?  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 / bmpacc.cxx
blob2e7982f07a68fd999f65125f43db97a760a03fb3
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 <vcl/salbtype.hxx>
21 #include <vcl/bitmap.hxx>
22 #include <vcl/bmpacc.hxx>
23
24 #include <impbmp.hxx>
25
26 #include <osl/diagnose.h>
27
28 #include <string.h>
29
30 BitmapInfoAccess::BitmapInfoAccess( Bitmap& rBitmap, BitmapAccessMode nMode ) :
31 mpBuffer ( NULL ),
32 mnAccessMode ( nMode )
33 {
34 ImplCreate( rBitmap );
35 }
36
37 BitmapInfoAccess::BitmapInfoAccess( Bitmap& rBitmap ) :
38 mpBuffer ( NULL ),
39 mnAccessMode ( BITMAP_INFO_ACCESS )
40 {
41 ImplCreate( rBitmap );
42 }
43
44 BitmapInfoAccess::~BitmapInfoAccess()
45 {
46 ImplDestroy();
47 }
48
49 void BitmapInfoAccess::ImplCreate( Bitmap& rBitmap )
50 {
51 ImpBitmap* pImpBmp = rBitmap.ImplGetImpBitmap();
52
53 DBG_ASSERT( pImpBmp, "Forbidden Access to empty bitmap!" );
54
55 if( pImpBmp )
56 {
57 if( mnAccessMode == BITMAP_WRITE_ACCESS && !maBitmap.ImplGetImpBitmap() )
58 {
59 rBitmap.ImplMakeUnique();
60 pImpBmp = rBitmap.ImplGetImpBitmap();
61 }
62 else
63 {
64 DBG_ASSERT( mnAccessMode != BITMAP_WRITE_ACCESS ||
65 pImpBmp->ImplGetRefCount() == 2,
66 "Unpredictable results: bitmap is referenced more than once!" );
67 }
68
69 mpBuffer = pImpBmp->ImplAcquireBuffer( mnAccessMode );
70
71 if( !mpBuffer )
72 {
73 ImpBitmap* pNewImpBmp = new ImpBitmap;
74
75 if( pNewImpBmp->ImplCreate( *pImpBmp, rBitmap.GetBitCount() ) )
76 {
77 pImpBmp = pNewImpBmp;
78 rBitmap.ImplSetImpBitmap( pImpBmp );
79 mpBuffer = pImpBmp->ImplAcquireBuffer( mnAccessMode );
80 }
81 else
82 delete pNewImpBmp;
83 }
84
85 maBitmap = rBitmap;
86 }
87 }
88
89 void BitmapInfoAccess::ImplDestroy()
90 {
91 ImpBitmap* pImpBmp = maBitmap.ImplGetImpBitmap();
92
93 if( mpBuffer && pImpBmp )
94 {
95 pImpBmp->ImplReleaseBuffer( mpBuffer, mnAccessMode );
96 mpBuffer = NULL;
97 }
98 }
99
100 sal_uInt16 BitmapInfoAccess::GetBestPaletteIndex( const BitmapColor& rBitmapColor ) const
101 {
102 return( HasPalette() ? mpBuffer->maPalette.GetBestIndex( rBitmapColor ) : 0 );
103 }
104
105 BitmapReadAccess::BitmapReadAccess( Bitmap& rBitmap, BitmapAccessMode nMode ) :
106 BitmapInfoAccess( rBitmap, nMode ),
107 mpScanBuf ( NULL ),
108 mFncGetPixel ( NULL ),
109 mFncSetPixel ( NULL )
110 {
111 ImplInitScanBuffer( rBitmap );
112 }
113
114 BitmapReadAccess::BitmapReadAccess( Bitmap& rBitmap ) :
115 BitmapInfoAccess( rBitmap, BITMAP_READ_ACCESS ),
116 mpScanBuf ( NULL ),
117 mFncGetPixel ( NULL ),
118 mFncSetPixel ( NULL )
119 {
120 ImplInitScanBuffer( rBitmap );
121 }
122
123 BitmapReadAccess::~BitmapReadAccess()
124 {
125 ImplClearScanBuffer();
126 }
127
128 void BitmapReadAccess::ImplInitScanBuffer( Bitmap& rBitmap )
129 {
130 ImpBitmap* pImpBmp = rBitmap.ImplGetImpBitmap();
131
132 if( pImpBmp && mpBuffer )
133 {
134 const long nHeight = mpBuffer->mnHeight;
135 Scanline pTmpLine = mpBuffer->mpBits;
136
137 mpScanBuf = new Scanline[ nHeight ];
138 maColorMask = mpBuffer->maColorMask;
139
140 if( BMP_SCANLINE_ADJUSTMENT( mpBuffer->mnFormat ) == BMP_FORMAT_TOP_DOWN )
141 {
142 for( long nY = 0L; nY < nHeight; nY++, pTmpLine += mpBuffer->mnScanlineSize )
143 mpScanBuf[ nY ] = pTmpLine;
144 }
145 else
146 {
147 for( long nY = nHeight - 1; nY >= 0; nY--, pTmpLine += mpBuffer->mnScanlineSize )
148 mpScanBuf[ nY ] = pTmpLine;
149 }
150
151 if( !ImplSetAccessPointers( BMP_SCANLINE_FORMAT( mpBuffer->mnFormat ) ) )
152 {
153 delete[] mpScanBuf;
154 mpScanBuf = NULL;
155
156 pImpBmp->ImplReleaseBuffer( mpBuffer, mnAccessMode );
157 mpBuffer = NULL;
158 }
159 }
160 }
161
162 void BitmapReadAccess::ImplClearScanBuffer()
163 {
164 delete[] mpScanBuf;
165 mpScanBuf = NULL;
166 }
167
168 bool BitmapReadAccess::ImplSetAccessPointers( sal_uLong nFormat )
169 {
170 bool bRet = true;
171
172 switch( nFormat )
173 {
174 case BMP_FORMAT_1BIT_MSB_PAL:
175 {
176 mFncGetPixel = GetPixelFor_1BIT_MSB_PAL;
177 mFncSetPixel = SetPixelFor_1BIT_MSB_PAL;
178 }
179 break;
180 case BMP_FORMAT_1BIT_LSB_PAL:
181 {
182 mFncGetPixel = GetPixelFor_1BIT_LSB_PAL;
183 mFncSetPixel = SetPixelFor_1BIT_LSB_PAL;
184 }
185 break;
186 case BMP_FORMAT_4BIT_MSN_PAL:
187 {
188 mFncGetPixel = GetPixelFor_4BIT_MSN_PAL;
189 mFncSetPixel = SetPixelFor_4BIT_MSN_PAL;
190 }
191 break;
192 case BMP_FORMAT_4BIT_LSN_PAL:
193 {
194 mFncGetPixel = GetPixelFor_4BIT_LSN_PAL;
195 mFncSetPixel = SetPixelFor_4BIT_LSN_PAL;
196 }
197 break;
198 case BMP_FORMAT_8BIT_PAL:
199 {
200 mFncGetPixel = GetPixelFor_8BIT_PAL;
201 mFncSetPixel = SetPixelFor_8BIT_PAL;
202 }
203 break;
204 case BMP_FORMAT_8BIT_TC_MASK:
205 {
206 mFncGetPixel = GetPixelFor_8BIT_TC_MASK;
207 mFncSetPixel = SetPixelFor_8BIT_TC_MASK;
208 }
209 break;
210 case BMP_FORMAT_16BIT_TC_MSB_MASK:
211 {
212 mFncGetPixel = GetPixelFor_16BIT_TC_MSB_MASK;
213 mFncSetPixel = SetPixelFor_16BIT_TC_MSB_MASK;
214 }
215 break;
216 case BMP_FORMAT_16BIT_TC_LSB_MASK:
217 {
218 mFncGetPixel = GetPixelFor_16BIT_TC_LSB_MASK;
219 mFncSetPixel = SetPixelFor_16BIT_TC_LSB_MASK;
220 }
221 break;
222 case BMP_FORMAT_24BIT_TC_BGR:
223 {
224 mFncGetPixel = GetPixelFor_24BIT_TC_BGR;
225 mFncSetPixel = SetPixelFor_24BIT_TC_BGR;
226 }
227 break;
228 case BMP_FORMAT_24BIT_TC_RGB:
229 {
230 mFncGetPixel = GetPixelFor_24BIT_TC_RGB;
231 mFncSetPixel = SetPixelFor_24BIT_TC_RGB;
232 }
233 break;
234 case BMP_FORMAT_24BIT_TC_MASK:
235 {
236 mFncGetPixel = GetPixelFor_24BIT_TC_MASK;
237 mFncSetPixel = SetPixelFor_24BIT_TC_MASK;
238 }
239 break;
240 case BMP_FORMAT_32BIT_TC_ABGR:
241 {
242 mFncGetPixel = GetPixelFor_32BIT_TC_ABGR;
243 mFncSetPixel = SetPixelFor_32BIT_TC_ABGR;
244 }
245 break;
246 case BMP_FORMAT_32BIT_TC_ARGB:
247 {
248 mFncGetPixel = GetPixelFor_32BIT_TC_ARGB;
249 mFncSetPixel = SetPixelFor_32BIT_TC_ARGB;
250 }
251 break;
252 case BMP_FORMAT_32BIT_TC_BGRA:
253 {
254 mFncGetPixel = GetPixelFor_32BIT_TC_BGRA;
255 mFncSetPixel = SetPixelFor_32BIT_TC_BGRA;
256 }
257 break;
258 case BMP_FORMAT_32BIT_TC_RGBA:
259 {
260 mFncGetPixel = GetPixelFor_32BIT_TC_RGBA;
261 mFncSetPixel = SetPixelFor_32BIT_TC_RGBA;
262 }
263 break;
264 case BMP_FORMAT_32BIT_TC_MASK:
265 {
266 mFncGetPixel = GetPixelFor_32BIT_TC_MASK;
267 mFncSetPixel = SetPixelFor_32BIT_TC_MASK;
268 }
269 break;
270
271 default:
272 bRet = false;
273 break;
274 }
275
276 return bRet;
277 }
278
279 void BitmapReadAccess::ImplZeroInitUnusedBits()
280 {
281 const sal_uInt32 nWidth = Width(), nHeight = Height(), nScanSize = GetScanlineSize();
282
283 if( nWidth && nHeight && nScanSize && GetBuffer() )
284 {
285 sal_uInt32 nBits;
286 bool bMsb;
287
288 const sal_uLong nScanlineFormat = GetScanlineFormat();
289 switch( nScanlineFormat )
290 {
291 case( BMP_FORMAT_1BIT_MSB_PAL ):
292 nBits = 1;
293 bMsb = true;
294 break;
295
296 case( BMP_FORMAT_1BIT_LSB_PAL ):
297 nBits = 1;
298 bMsb = false;
299 break;
300
301 case( BMP_FORMAT_4BIT_MSN_PAL ):
302 nBits = 4;
303 bMsb = true;
304 break;
305
306 case( BMP_FORMAT_4BIT_LSN_PAL ):
307 nBits = 4;
308 bMsb = false;
309 break;
310
311 case( BMP_FORMAT_8BIT_PAL ):
312 case( BMP_FORMAT_8BIT_TC_MASK ):
313 bMsb = true;
314 nBits = 8;
315 break;
316
317 case( BMP_FORMAT_16BIT_TC_MSB_MASK ):
318 case( BMP_FORMAT_16BIT_TC_LSB_MASK ):
319 bMsb = true;
320 nBits = 16;
321 break;
322
323 case( BMP_FORMAT_24BIT_TC_BGR ):
324 case( BMP_FORMAT_24BIT_TC_RGB ):
325 case( BMP_FORMAT_24BIT_TC_MASK ):
326 bMsb = true;
327 nBits = 24;
328 break;
329
330 case( BMP_FORMAT_32BIT_TC_ABGR ):
331 case( BMP_FORMAT_32BIT_TC_ARGB ):
332 case( BMP_FORMAT_32BIT_TC_BGRA ):
333 case( BMP_FORMAT_32BIT_TC_RGBA ):
334 case( BMP_FORMAT_32BIT_TC_MASK ):
335 bMsb = true;
336 nBits = 32;
337 break;
338
339 default:
340 {
341 OSL_FAIL( "BitmapWriteAccess::ZeroInitUnusedBits: Unsupported pixel format");
342 nBits = 0;
343 bMsb = true;
344 }
345 break;
346 }
347
348 nBits *= nWidth;
349 if( nScanSize % 4 || !bMsb )
350 {
351 DBG_ASSERT( 8*nScanSize >= nBits,
352 "BitmapWriteAccess::ZeroInitUnusedBits: span size smaller than width?!");
353 const sal_uInt32 nLeftOverBits = 8*sizeof(sal_uInt8)*nScanSize - nBits;
354 if( nLeftOverBits != 0 ) // else there is really nothing to do
355 {
356 const sal_uInt32 nBytes = (nLeftOverBits + 7U) >> 3U;
357 sal_uInt8 nMask;
358
359 if( bMsb )
360 nMask = static_cast<sal_uInt8>(0xffU << (nLeftOverBits & 3UL));
361 else
362 nMask = static_cast<sal_uInt8>(0xffU >> (nLeftOverBits & 3UL));
363
364 sal_uInt8* pLastBytes = (sal_uInt8*)GetBuffer() + ( nScanSize - nBytes );
365 for( sal_uInt32 i = 0; i < nHeight; i++, pLastBytes += nScanSize )
366 {
367 *pLastBytes &= nMask;
368 for( sal_uInt32 j = 1; j < nBytes; j++ )
369 pLastBytes[j] = 0;
370 }
371 }
372 }
373 else if( nBits & 0x1f )
374 {
375 sal_uInt32 nMask = 0xffffffff << ( ( nScanSize << 3 ) - nBits );
376 sal_uInt8* pLast4Bytes = (sal_uInt8*) GetBuffer() + ( nScanSize - 4 );
377
378 #ifdef OSL_LITENDIAN
379 nMask = OSL_SWAPDWORD( nMask );
380 #endif
381 for( sal_uInt32 i = 0; i < nHeight; i++, pLast4Bytes += nScanSize )
382 *reinterpret_cast<sal_uInt32*>(pLast4Bytes) &= nMask;
383 }
384 }
385 }
386
387 BitmapColor BitmapReadAccess::GetInterpolatedColorWithFallback( double fY, double fX, const BitmapColor& rFallback ) const
388 {
389 // ask directly doubles >= 0.0 here to avoid rounded values of 0 at small negative
390 // double values, e.g. static_cast< sal_Int32 >(-0.25) is 0, not -1, but *has* to be outside (!)
391 if(mpBuffer && fX >= 0.0 && fY >= 0.0)
392 {
393 const sal_Int32 nX(static_cast< sal_Int32 >(fX));
394 const sal_Int32 nY(static_cast< sal_Int32 >(fY));
395
396 if(nX < mpBuffer->mnWidth && nY < mpBuffer->mnHeight)
397 {
398 // get base-return value from inside pixel
399 BitmapColor aRetval(GetColor(nY, nX));
400
401 // calculate deltas and indices for neighbour accesses
402 sal_Int16 nDeltaX((fX - (nX + 0.5)) * 255.0); // [-255 .. 255]
403 sal_Int16 nDeltaY((fY - (nY + 0.5)) * 255.0); // [-255 .. 255]
404 sal_Int16 nIndX(0);
405 sal_Int16 nIndY(0);
406
407 if(nDeltaX > 0)
408 {
409 nIndX = nX + 1;
410 }
411 else
412 {
413 nIndX = nX - 1;
414 nDeltaX = -nDeltaX;
415 }
416
417 if(nDeltaY > 0)
418 {
419 nIndY = nY + 1;
420 }
421 else
422 {
423 nIndY = nY - 1;
424 nDeltaY = -nDeltaY;
425 }
426
427 // get right/left neighbour
428 BitmapColor aXCol(rFallback);
429
430 if(nDeltaX && nIndX >= 0 && nIndX < mpBuffer->mnWidth)
431 {
432 aXCol = GetColor(nY, nIndX);
433 }
434
435 // get top/bottom neighbour
436 BitmapColor aYCol(rFallback);
437
438 if(nDeltaY && nIndY >= 0 && nIndY < mpBuffer->mnHeight)
439 {
440 aYCol = GetColor(nIndY, nX);
441 }
442
443 // get one of four edge neighbours
444 BitmapColor aXYCol(rFallback);
445
446 if(nDeltaX && nDeltaY && nIndX >=0 && nIndY >= 0 && nIndX < mpBuffer->mnWidth && nIndY < mpBuffer->mnHeight)
447 {
448 aXYCol = GetColor(nIndY, nIndX);
449 }
450
451 // merge return value with right/left neighbour
452 if(aXCol != aRetval)
453 {
454 aRetval.Merge(aXCol, 255 - nDeltaX);
455 }
456
457 // merge top/bottom neighbour with edge
458 if(aYCol != aXYCol)
459 {
460 aYCol.Merge(aXYCol, 255 - nDeltaX);
461 }
462
463 // merge return value with already merged top/bottom neighbour
464 if(aRetval != aYCol)
465 {
466 aRetval.Merge(aYCol, 255 - nDeltaY);
467 }
468
469 return aRetval;
470 }
471 }
472
473 return rFallback;
474 }
475
476 BitmapColor BitmapReadAccess::GetColorWithFallback( double fY, double fX, const BitmapColor& rFallback ) const
477 {
478 // ask directly doubles >= 0.0 here to avoid rounded values of 0 at small negative
479 // double values, e.g. static_cast< sal_Int32 >(-0.25) is 0, not -1, but *has* to be outside (!)
480 if(mpBuffer && fX >= 0.0 && fY >= 0.0)
481 {
482 const sal_Int32 nX(static_cast< sal_Int32 >(fX));
483 const sal_Int32 nY(static_cast< sal_Int32 >(fY));
484
485 if(nX < mpBuffer->mnWidth && nY < mpBuffer->mnHeight)
486 {
487 return GetColor(nY, nX);
488 }
489 }
490
491 return rFallback;
492 }
493
494 BitmapWriteAccess::BitmapWriteAccess(Bitmap& rBitmap)
495 : BitmapReadAccess(rBitmap, BITMAP_WRITE_ACCESS)
496 , mpLineColor()
497 , mpFillColor()
498 {
499 }
500
501 BitmapWriteAccess::~BitmapWriteAccess()
502 {
503 }
504
505 void BitmapWriteAccess::CopyScanline( long nY, const BitmapReadAccess& rReadAcc )
506 {
507 assert(nY >= 0 && nY < mpBuffer->mnHeight && "y-coordinate in destination out of range!");
508 DBG_ASSERT( nY < rReadAcc.Height(), "y-coordinate in source out of range!" );
509 DBG_ASSERT( ( HasPalette() && rReadAcc.HasPalette() ) || ( !HasPalette() && !rReadAcc.HasPalette() ), "No copying possible between palette bitmap and TC bitmap!" );
510
511 if( ( GetScanlineFormat() == rReadAcc.GetScanlineFormat() ) &&
512 ( GetScanlineSize() >= rReadAcc.GetScanlineSize() ) )
513 {
514 memcpy( mpScanBuf[ nY ], rReadAcc.GetScanline( nY ), rReadAcc.GetScanlineSize() );
515 }
516 else
517 // TODO: use fastbmp infrastructure
518 for( long nX = 0L, nWidth = std::min( mpBuffer->mnWidth, rReadAcc.Width() ); nX < nWidth; nX++ )
519 SetPixel( nY, nX, rReadAcc.GetPixel( nY, nX ) );
520 }
521
522 void BitmapWriteAccess::CopyScanline( long nY, ConstScanline aSrcScanline,
523 sal_uLong nSrcScanlineFormat, sal_uLong nSrcScanlineSize )
524 {
525 const sal_uLong nFormat = BMP_SCANLINE_FORMAT( nSrcScanlineFormat );
526
527 assert(nY >= 0 && nY < mpBuffer->mnHeight && "y-coordinate in destination out of range!");
528 DBG_ASSERT( ( HasPalette() && nFormat <= BMP_FORMAT_8BIT_PAL ) ||
529 ( !HasPalette() && nFormat > BMP_FORMAT_8BIT_PAL ),
530 "No copying possible between palette and non palette scanlines!" );
531
532 const sal_uLong nCount = std::min( GetScanlineSize(), nSrcScanlineSize );
533
534 if( nCount )
535 {
536 if( GetScanlineFormat() == BMP_SCANLINE_FORMAT( nSrcScanlineFormat ) )
537 memcpy( mpScanBuf[ nY ], aSrcScanline, nCount );
538 else
539 {
540 DBG_ASSERT( nFormat != BMP_FORMAT_8BIT_TC_MASK &&
541 nFormat != BMP_FORMAT_16BIT_TC_MSB_MASK && nFormat != BMP_FORMAT_16BIT_TC_LSB_MASK &&
542 nFormat != BMP_FORMAT_24BIT_TC_MASK && nFormat != BMP_FORMAT_32BIT_TC_MASK,
543 "No support for pixel formats with color masks yet!" );
544
545 // TODO: use fastbmp infrastructure
546 FncGetPixel pFncGetPixel;
547
548 switch( nFormat )
549 {
550 case( BMP_FORMAT_1BIT_MSB_PAL ): pFncGetPixel = GetPixelFor_1BIT_MSB_PAL; break;
551 case( BMP_FORMAT_1BIT_LSB_PAL ): pFncGetPixel = GetPixelFor_1BIT_LSB_PAL; break;
552 case( BMP_FORMAT_4BIT_MSN_PAL ): pFncGetPixel = GetPixelFor_4BIT_MSN_PAL; break;
553 case( BMP_FORMAT_4BIT_LSN_PAL ): pFncGetPixel = GetPixelFor_4BIT_LSN_PAL; break;
554 case( BMP_FORMAT_8BIT_PAL ): pFncGetPixel = GetPixelFor_8BIT_PAL; break;
555 case( BMP_FORMAT_8BIT_TC_MASK ): pFncGetPixel = GetPixelFor_8BIT_TC_MASK; break;
556 case( BMP_FORMAT_16BIT_TC_MSB_MASK ): pFncGetPixel = GetPixelFor_16BIT_TC_MSB_MASK; break;
557 case( BMP_FORMAT_16BIT_TC_LSB_MASK ): pFncGetPixel = GetPixelFor_16BIT_TC_LSB_MASK; break;
558 case( BMP_FORMAT_24BIT_TC_BGR ): pFncGetPixel = GetPixelFor_24BIT_TC_BGR; break;
559 case( BMP_FORMAT_24BIT_TC_RGB ): pFncGetPixel = GetPixelFor_24BIT_TC_RGB; break;
560 case( BMP_FORMAT_24BIT_TC_MASK ): pFncGetPixel = GetPixelFor_24BIT_TC_MASK; break;
561 case( BMP_FORMAT_32BIT_TC_ABGR ): pFncGetPixel = GetPixelFor_32BIT_TC_ABGR; break;
562 case( BMP_FORMAT_32BIT_TC_ARGB ): pFncGetPixel = GetPixelFor_32BIT_TC_ARGB; break;
563 case( BMP_FORMAT_32BIT_TC_BGRA ): pFncGetPixel = GetPixelFor_32BIT_TC_BGRA; break;
564 case( BMP_FORMAT_32BIT_TC_RGBA ): pFncGetPixel = GetPixelFor_32BIT_TC_RGBA; break;
565 case( BMP_FORMAT_32BIT_TC_MASK ): pFncGetPixel = GetPixelFor_32BIT_TC_MASK; break;
566
567 default:
568 pFncGetPixel = NULL;
569 break;
570 }
571
572 if( pFncGetPixel )
573 {
574 const ColorMask aDummyMask;
575
576 for( long nX = 0L, nWidth = mpBuffer->mnWidth; nX < nWidth; nX++ )
577 SetPixel( nY, nX, pFncGetPixel( aSrcScanline, nX, aDummyMask ) );
578 }
579 }
580 }
581 }
582
583 void BitmapWriteAccess::CopyBuffer( const BitmapReadAccess& rReadAcc )
584 {
585 DBG_ASSERT( ( HasPalette() && rReadAcc.HasPalette() ) || ( !HasPalette() && !rReadAcc.HasPalette() ), "No copying possible between palette bitmap and TC bitmap!" );
586
587 if( ( GetScanlineFormat() == rReadAcc.GetScanlineFormat() ) &&
588 ( GetScanlineSize() == rReadAcc.GetScanlineSize() ) )
589 {
590 const long nHeight = std::min( mpBuffer->mnHeight, rReadAcc.Height() );
591 const sal_uLong nCount = nHeight * mpBuffer->mnScanlineSize;
592
593 memcpy( mpBuffer->mpBits, rReadAcc.GetBuffer(), nCount );
594 }
595 else
596 for( long nY = 0L, nHeight = std::min( mpBuffer->mnHeight, rReadAcc.Height() ); nY < nHeight; nY++ )
597 CopyScanline( nY, rReadAcc );
598 }
599
600 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE