?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fdo#74697 Add Bluez 5 support for impress remote.
[LibreOffice.git] / vcl / test / canvasbitmaptest.cxx
blob5816244c13725200d2bf61219e985fc0e47a82bd
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
21 // bootstrap stuff
22 #include <sal/main.h>
23 #include <rtl/bootstrap.hxx>
24 #include <rtl/ref.hxx>
25 #include <comphelper/processfactory.hxx>
26 #include <cppuhelper/servicefactory.hxx>
27 #include <cppuhelper/bootstrap.hxx>
28 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
29 #include <com/sun/star/lang/XInitialization.hpp>
30 #include <com/sun/star/registry/XSimpleRegistry.hpp>
31 #include <com/sun/star/util/Endianness.hpp>
32 #include <com/sun/star/rendering/ColorComponentTag.hpp>
33 #include <com/sun/star/rendering/ColorSpaceType.hpp>
34 #include <com/sun/star/rendering/RenderingIntent.hpp>
35 #include <com/sun/star/rendering/XIntegerReadOnlyBitmap.hpp>
36 #include <com/sun/star/rendering/XIntegerBitmapColorSpace.hpp>
37 #include <com/sun/star/rendering/XBitmapPalette.hpp>
38
39 #include <cppuhelper/compbase3.hxx>
40
41 #include <tools/diagnose_ex.h>
42 #include <tools/extendapplicationenvironment.hxx>
43
44 #include "vcl/svapp.hxx"
45 #include "vcl/canvastools.hxx"
46 #include "vcl/canvasbitmap.hxx"
47 #include "vcl/dialog.hxx"
48 #include "vcl/outdev.hxx"
49 #include "vcl/bmpacc.hxx"
50 #include "vcl/virdev.hxx"
51 #include "vcl/bitmapex.hxx"
52
53
54 using namespace ::com::sun::star;
55 using namespace ::vcl::unotools;
56
57 // -----------------------------------------------------------------------
58
59 void Main();
60
61 // -----------------------------------------------------------------------
62
63 SAL_IMPLEMENT_MAIN()
64 {
65 tools::extendApplicationEnvironment();
66
67 uno::Reference< lang::XMultiServiceFactory > xMS;
68 xMS = cppu::createRegistryServiceFactory(
69 OUString( "applicat.rdb" ),
70 sal_True );
71
72 comphelper::setProcessServiceFactory( xMS );
73
74 InitVCL();
75 ::Main();
76 DeInitVCL();
77
78 return 0;
79 }
80
81 // -----------------------------------------------------------------------
82
83 namespace com { namespace sun { namespace star { namespace rendering
84 {
85
86 bool operator==( const RGBColor& rLHS, const ARGBColor& rRHS )
87 {
88 return rLHS.Red == rRHS.Red && rLHS.Green == rRHS.Green && rLHS.Blue == rRHS.Blue;
89 }
90 bool operator==( const ARGBColor& rLHS, const RGBColor& rRHS )
91 {
92 return rLHS.Red == rRHS.Red && rLHS.Green == rRHS.Green && rLHS.Blue == rRHS.Blue;
93 }
94
95 } } } }
96
97 //----------------------------------------------------------------------------------
98
99 namespace
100 {
101
102 class TestApp : public Application
103 {
104 public:
105 virtual void Main();
106 virtual sal_uInt16 Exception( sal_uInt16 nError );
107 };
108
109 class TestWindow : public Dialog
110 {
111 public:
112 TestWindow() : Dialog( (Window *) NULL )
113 {
114 SetText( OUString("CanvasBitmap test harness") );
115 SetSizePixel( Size( 1024, 1024 ) );
116 EnablePaint( true );
117 Show();
118 }
119
120 virtual ~TestWindow() {}
121 virtual void Paint( const Rectangle& rRect );
122 };
123
124 //----------------------------------------------------------------------------------
125
126 static bool g_failure=false;
127
128 void test( bool bResult, const char* msg )
129 {
130 if( bResult )
131 {
132 OSL_TRACE("Testing: %s - PASSED", msg);
133 }
134 else
135 {
136 g_failure = true;
137 OSL_TRACE("Testing: %s - FAILED", msg);
138 }
139 }
140
141 //----------------------------------------------------------------------------------
142
143 bool rangeCheck( const rendering::RGBColor& rColor )
144 {
145 return rColor.Red < 0.0 || rColor.Red > 1.0 ||
146 rColor.Green < 0.0 || rColor.Green > 1.0 ||
147 rColor.Blue < 0.0 || rColor.Blue > 1.0;
148 }
149
150 //----------------------------------------------------------------------------------
151
152 void checkCanvasBitmap( const rtl::Reference<VclCanvasBitmap>& xBmp,
153 const char* msg,
154 int nOriginalDepth )
155 {
156 OSL_TRACE("-------------------------");
157 OSL_TRACE("Testing %s, with depth %d", msg, nOriginalDepth);
158
159 BitmapEx aContainedBmpEx( xBmp->getBitmapEx() );
160 Bitmap aContainedBmp( aContainedBmpEx.GetBitmap() );
161 int nDepth = nOriginalDepth;
162
163 {
164 Bitmap::ScopedReadAccess pAcc( aContainedBmp );
165 nDepth = pAcc->GetBitCount();
166 }
167
168 test( aContainedBmp.GetSizePixel() == Size(200,200),
169 "Original bitmap size" );
170
171 test( xBmp->getSize().Width == 200 && xBmp->getSize().Height == 200,
172 "Original bitmap size via API" );
173
174 test( xBmp->hasAlpha() == aContainedBmpEx.IsTransparent(),
175 "Correct alpha state" );
176
177 test( xBmp->getScaledBitmap( geometry::RealSize2D(500,500), sal_False ).is(),
178 "getScaledBitmap()" );
179
180 rendering::IntegerBitmapLayout aLayout;
181 uno::Sequence<sal_Int8> aPixelData = xBmp->getData(aLayout, geometry::IntegerRectangle2D(0,0,1,1));
182
183 const sal_Int32 nExpectedBitsPerPixel(
184 aContainedBmpEx.IsTransparent() ? std::max(8,nDepth)+8 : nDepth);
185 test( aLayout.ScanLines == 1,
186 "# scanlines" );
187 test( aLayout.ScanLineBytes == (nExpectedBitsPerPixel+7)/8,
188 "# scanline bytes" );
189 test( aLayout.ScanLineStride == (nExpectedBitsPerPixel+7)/8 ||
190 aLayout.ScanLineStride == -(nExpectedBitsPerPixel+7)/8,
191 "# scanline stride" );
192 test( aLayout.PlaneStride == 0,
193 "# plane stride" );
194
195 test( aLayout.ColorSpace.is(),
196 "Color space there" );
197
198 test( aLayout.Palette.is() == (nDepth <= 8),
199 "Palette existance conforms to bitmap" );
200
201 uno::Sequence<sal_Int8> aPixelData2 = xBmp->getPixel( aLayout, geometry::IntegerPoint2D(0,0) );
202
203 test( aPixelData2.getLength() == aPixelData.getLength(),
204 "getData and getPixel return same amount of data" );
205
206 aPixelData = xBmp->getData(aLayout, geometry::IntegerRectangle2D(0,0,200,1));
207 test( aLayout.ScanLines == 1,
208 "# scanlines" );
209 test( aLayout.ScanLineBytes == (200*nExpectedBitsPerPixel+7)/8,
210 "# scanline bytes" );
211 test( aLayout.ScanLineStride == (200*nExpectedBitsPerPixel+7)/8 ||
212 aLayout.ScanLineStride == -(200*nExpectedBitsPerPixel+7)/8,
213 "# scanline stride" );
214
215 uno::Sequence< rendering::RGBColor > aRGBColors = xBmp->convertIntegerToRGB( aPixelData );
216 uno::Sequence< rendering::ARGBColor > aARGBColors = xBmp->convertIntegerToARGB( aPixelData );
217
218 const rendering::RGBColor* pRGBStart ( aRGBColors.getConstArray() );
219 const rendering::RGBColor* pRGBEnd ( aRGBColors.getConstArray()+aRGBColors.getLength() );
220 const rendering::ARGBColor* pARGBStart( aARGBColors.getConstArray() );
221 std::pair<const rendering::RGBColor*,
222 const rendering::ARGBColor*> aRes = std::mismatch( pRGBStart, pRGBEnd, pARGBStart );
223 test( aRes.first == pRGBEnd,
224 "argb and rgb colors are equal" );
225
226 test( std::find_if(pRGBStart,pRGBEnd,&rangeCheck) == pRGBEnd,
227 "rgb colors are within [0,1] range" );
228
229 test( pRGBStart[0].Red == 1.0 && pRGBStart[0].Green == 1.0 && pRGBStart[0].Blue == 1.0,
230 "First pixel is white" );
231 test( pARGBStart[1].Alpha == 1.0,
232 "Second pixel is opaque" );
233 if( aContainedBmpEx.IsTransparent() )
234 {
235 test( pARGBStart[0].Alpha == 0.0,
236 "First pixel is fully transparent" );
237 }
238
239 test( pRGBStart[1].Red == 0.0 && pRGBStart[1].Green == 0.0 && pRGBStart[1].Blue == 0.0,
240 "Second pixel is black" );
241
242 if( nOriginalDepth > 8 )
243 {
244 const Color aCol(COL_GREEN);
245 test( pRGBStart[5].Red == vcl::unotools::toDoubleColor(aCol.GetRed()) &&
246 pRGBStart[5].Green == vcl::unotools::toDoubleColor(aCol.GetGreen()) &&
247 pRGBStart[5].Blue == vcl::unotools::toDoubleColor(aCol.GetBlue()),
248 "Sixth pixel is green" );
249 }
250 else if( nDepth <= 8 )
251 {
252 uno::Reference<rendering::XBitmapPalette> xPal = xBmp->getPalette();
253 test( xPal.is(),
254 "8bit or less: needs palette" );
255 test( xPal->getNumberOfEntries() == 1L << nOriginalDepth,
256 "Palette has correct entry count" );
257 uno::Sequence<double> aIndex;
258 test( xPal->setIndex(aIndex,sal_True,0) == sal_False,
259 "Palette is read-only" );
260 test( xPal->getIndex(aIndex,0),
261 "Palette entry 0 is opaque" );
262 test( xPal->getColorSpace().is(),
263 "Palette has a valid color space" );
264 }
265
266 test( pRGBStart[150].Red == 1.0 && pRGBStart[150].Green == 1.0 && pRGBStart[150].Blue == 1.0,
267 "150th pixel is white" );
268
269 if( nOriginalDepth > 8 )
270 {
271 const uno::Sequence<sal_Int8> aComponentTags( xBmp->getComponentTags() );
272 uno::Sequence<rendering::ARGBColor> aARGBColor(1);
273 uno::Sequence<rendering::RGBColor> aRGBColor(1);
274 uno::Sequence<sal_Int8> aPixel3, aPixel4;
275
276 const Color aCol(COL_GREEN);
277 aARGBColor[0].Red = vcl::unotools::toDoubleColor(aCol.GetRed());
278 aARGBColor[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
279 aARGBColor[0].Blue = vcl::unotools::toDoubleColor(aCol.GetBlue());
280 aARGBColor[0].Alpha = 1.0;
281
282 aRGBColor[0].Red = vcl::unotools::toDoubleColor(aCol.GetRed());
283 aRGBColor[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
284 aRGBColor[0].Blue = vcl::unotools::toDoubleColor(aCol.GetBlue());
285
286 aPixel3 = xBmp->convertIntegerFromARGB( aARGBColor );
287 aPixel4 = xBmp->getPixel( aLayout, geometry::IntegerPoint2D(5,0) );
288 test( aPixel3 == aPixel4,
289 "Green pixel from bitmap matches with manually converted green pixel" );
290
291 if( !aContainedBmpEx.IsTransparent() )
292 {
293 aPixel3 = xBmp->convertIntegerFromRGB( aRGBColor );
294 test( aPixel3 == aPixel4,
295 "Green pixel from bitmap matches with manually RGB-converted green pixel" );
296 }
297 }
298 }
299
300 //----------------------------------------------------------------------------------
301
302 void checkBitmapImport( const rtl::Reference<VclCanvasBitmap>& xBmp,
303 const char* msg,
304 int nOriginalDepth )
305 {
306 OSL_TRACE("-------------------------");
307 OSL_TRACE("Testing %s, with depth %d", msg, nOriginalDepth);
308
309 BitmapEx aContainedBmpEx( xBmp->getBitmapEx() );
310 Bitmap aContainedBmp( aContainedBmpEx.GetBitmap() );
311 int nDepth = nOriginalDepth;
312
313 {
314 Bitmap::ScopedReadAccess pAcc( aContainedBmp );
315 nDepth = pAcc->GetBitCount();
316 }
317
318 test( aContainedBmp.GetSizePixel() == Size(200,200),
319 "Original bitmap size" );
320
321 test( xBmp->getSize().Width == 200 && xBmp->getSize().Height == 200,
322 "Original bitmap size via API" );
323
324 test( xBmp->hasAlpha() == aContainedBmpEx.IsTransparent(),
325 "Correct alpha state" );
326
327 test( xBmp->getScaledBitmap( geometry::RealSize2D(500,500), sal_False ).is(),
328 "getScaledBitmap()" );
329
330 rendering::IntegerBitmapLayout aLayout;
331 uno::Sequence<sal_Int8> aPixelData = xBmp->getData(aLayout, geometry::IntegerRectangle2D(0,0,1,1));
332
333 const sal_Int32 nExpectedBitsPerPixel(
334 aContainedBmpEx.IsTransparent() ? std::max(8,nDepth)+8 : nDepth);
335 test( aLayout.ScanLines == 1,
336 "# scanlines" );
337 test( aLayout.ScanLineBytes == (nExpectedBitsPerPixel+7)/8,
338 "# scanline bytes" );
339 test( aLayout.ScanLineStride == (nExpectedBitsPerPixel+7)/8 ||
340 aLayout.ScanLineStride == -(nExpectedBitsPerPixel+7)/8,
341 "# scanline stride" );
342 test( aLayout.PlaneStride == 0,
343 "# plane stride" );
344
345 test( aLayout.ColorSpace.is(),
346 "Color space there" );
347
348 test( aLayout.Palette.is() == (nDepth <= 8),
349 "Palette existance conforms to bitmap" );
350
351 uno::Sequence<sal_Int8> aPixelData2 = xBmp->getPixel( aLayout, geometry::IntegerPoint2D(0,0) );
352
353 test( aPixelData2.getLength() == aPixelData.getLength(),
354 "getData and getPixel return same amount of data" );
355
356 aPixelData = xBmp->getData(aLayout, geometry::IntegerRectangle2D(0,0,200,1));
357 test( aLayout.ScanLines == 1,
358 "# scanlines" );
359 test( aLayout.ScanLineBytes == (200*nExpectedBitsPerPixel+7)/8,
360 "# scanline bytes" );
361 test( aLayout.ScanLineStride == (200*nExpectedBitsPerPixel+7)/8 ||
362 aLayout.ScanLineStride == -(200*nExpectedBitsPerPixel+7)/8,
363 "# scanline stride" );
364
365 uno::Sequence< rendering::RGBColor > aRGBColors = xBmp->convertIntegerToRGB( aPixelData );
366 uno::Sequence< rendering::ARGBColor > aARGBColors = xBmp->convertIntegerToARGB( aPixelData );
367
368 const rendering::RGBColor* pRGBStart ( aRGBColors.getConstArray() );
369 const rendering::RGBColor* pRGBEnd ( aRGBColors.getConstArray()+aRGBColors.getLength() );
370 const rendering::ARGBColor* pARGBStart( aARGBColors.getConstArray() );
371 std::pair<const rendering::RGBColor*,
372 const rendering::ARGBColor*> aRes = std::mismatch( pRGBStart, pRGBEnd, pARGBStart );
373 test( aRes.first == pRGBEnd,
374 "argb and rgb colors are equal" );
375
376 test( std::find_if(pRGBStart,pRGBEnd,&rangeCheck) == pRGBEnd,
377 "rgb colors are within [0,1] range" );
378
379 test( pRGBStart[0].Red == 1.0 && pRGBStart[0].Green == 1.0 && pRGBStart[0].Blue == 1.0,
380 "First pixel is white" );
381 test( pARGBStart[1].Alpha == 1.0,
382 "Second pixel is opaque" );
383 if( aContainedBmpEx.IsTransparent() )
384 {
385 test( pARGBStart[0].Alpha == 0.0,
386 "First pixel is fully transparent" );
387 }
388
389 test( pRGBStart[1].Red == 0.0 && pRGBStart[1].Green == 0.0 && pRGBStart[1].Blue == 0.0,
390 "Second pixel is black" );
391
392 if( nOriginalDepth > 8 )
393 {
394 const Color aCol(COL_GREEN);
395 test( pRGBStart[5].Red == vcl::unotools::toDoubleColor(aCol.GetRed()) &&
396 pRGBStart[5].Green == vcl::unotools::toDoubleColor(aCol.GetGreen()) &&
397 pRGBStart[5].Blue == vcl::unotools::toDoubleColor(aCol.GetBlue()),
398 "Sixth pixel is green" );
399 }
400 else if( nDepth <= 8 )
401 {
402 uno::Reference<rendering::XBitmapPalette> xPal = xBmp->getPalette();
403 test( xPal.is(),
404 "8bit or less: needs palette" );
405 test( xPal->getNumberOfEntries() == 1L << nOriginalDepth,
406 "Palette has correct entry count" );
407 uno::Sequence<double> aIndex;
408 test( xPal->setIndex(aIndex,sal_True,0) == sal_False,
409 "Palette is read-only" );
410 test( xPal->getIndex(aIndex,0),
411 "Palette entry 0 is opaque" );
412 test( xPal->getColorSpace().is(),
413 "Palette has a valid color space" );
414 }
415
416 test( pRGBStart[150].Red == 1.0 && pRGBStart[150].Green == 1.0 && pRGBStart[150].Blue == 1.0,
417 "150th pixel is white" );
418
419 if( nOriginalDepth > 8 )
420 {
421 const uno::Sequence<sal_Int8> aComponentTags( xBmp->getComponentTags() );
422 uno::Sequence<rendering::ARGBColor> aARGBColor(1);
423 uno::Sequence<rendering::RGBColor> aRGBColor(1);
424 uno::Sequence<sal_Int8> aPixel3, aPixel4;
425
426 const Color aCol(COL_GREEN);
427 aARGBColor[0].Red = vcl::unotools::toDoubleColor(aCol.GetRed());
428 aARGBColor[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
429 aARGBColor[0].Blue = vcl::unotools::toDoubleColor(aCol.GetBlue());
430 aARGBColor[0].Alpha = 1.0;
431
432 aRGBColor[0].Red = vcl::unotools::toDoubleColor(aCol.GetRed());
433 aRGBColor[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
434 aRGBColor[0].Blue = vcl::unotools::toDoubleColor(aCol.GetBlue());
435
436 aPixel3 = xBmp->convertIntegerFromARGB( aARGBColor );
437 aPixel4 = xBmp->getPixel( aLayout, geometry::IntegerPoint2D(5,0) );
438 test( aPixel3 == aPixel4,
439 "Green pixel from bitmap matches with manually converted green pixel" );
440
441 if( !aContainedBmpEx.IsTransparent() )
442 {
443 aPixel3 = xBmp->convertIntegerFromRGB( aRGBColor );
444 test( aPixel3 == aPixel4,
445 "Green pixel from bitmap matches with manually RGB-converted green pixel" );
446 }
447 }
448 }
449
450 //----------------------------------------------------------------------------------
451
452 class TestBitmap : public cppu::WeakImplHelper3< rendering::XIntegerReadOnlyBitmap,
453 rendering::XBitmapPalette,
454 rendering::XIntegerBitmapColorSpace >
455 {
456 private:
457 geometry::IntegerSize2D maSize;
458 uno::Sequence<sal_Int8> maComponentTags;
459 uno::Sequence<sal_Int32> maComponentBitCounts;
460 rendering::IntegerBitmapLayout maLayout;
461 const sal_Int32 mnBitsPerPixel;
462
463 // XBitmap
464 virtual geometry::IntegerSize2D SAL_CALL getSize() throw (uno::RuntimeException) { return maSize; }
465 virtual ::sal_Bool SAL_CALL hasAlpha( ) throw (uno::RuntimeException) { return mnBitsPerPixel != 8; }
466 virtual uno::Reference< rendering::XBitmap > SAL_CALL getScaledBitmap( const geometry::RealSize2D&,
467 sal_Bool ) throw (uno::RuntimeException) { return this; }
468
469 // XIntegerReadOnlyBitmap
470 virtual uno::Sequence< ::sal_Int8 > SAL_CALL getData( rendering::IntegerBitmapLayout& bitmapLayout,
471 const geometry::IntegerRectangle2D& rect ) throw (lang::IndexOutOfBoundsException,
472 rendering::VolatileContentDestroyedException, uno::RuntimeException)
473 {
474 test( rect.X1 >= 0, "X1 within bounds" );
475 test( rect.Y1 >= 0, "Y1 within bounds" );
476 test( rect.X2 <= maSize.Width, "X2 within bounds" );
477 test( rect.Y2 <= maSize.Height, "Y2 within bounds" );
478
479 bitmapLayout = getMemoryLayout();
480
481 const sal_Int32 nWidth = rect.X2-rect.X1;
482 const sal_Int32 nHeight = rect.Y2-rect.Y1;
483 const sal_Int32 nScanlineLen = (nWidth * mnBitsPerPixel + 7)/8;
484 uno::Sequence<sal_Int8> aRes( nScanlineLen * nHeight );
485 sal_Int8* pOut = aRes.getArray();
486
487 bitmapLayout.ScanLines = nHeight;
488 bitmapLayout.ScanLineBytes =
489 bitmapLayout.ScanLineStride= nScanlineLen;
490
491 if( mnBitsPerPixel == 8 )
492 {
493 for( sal_Int32 y=0; y<nHeight; ++y )
494 {
495 for( sal_Int32 x=0; x<nWidth; ++x )
496 pOut[ y*nScanlineLen + x ] = sal_Int8(x);
497 }
498 }
499 else
500 {
501 for( sal_Int32 y=0; y<nHeight; ++y )
502 {
503 for( sal_Int32 x=0; x<nWidth; ++x )
504 {
505 pOut[ y*nScanlineLen + 4*x ] = sal_Int8(rect.X1);
506 pOut[ y*nScanlineLen + 4*x + 1 ] = sal_Int8(rect.Y2);
507 pOut[ y*nScanlineLen + 4*x + 2 ] = sal_Int8(x);
508 pOut[ y*nScanlineLen + 4*x + 3 ] = sal_Int8(rect.Y1);
509 }
510 }
511 }
512
513 return aRes;
514 }
515
516 virtual uno::Sequence< ::sal_Int8 > SAL_CALL getPixel( rendering::IntegerBitmapLayout&,
517 const geometry::IntegerPoint2D& ) throw (lang::IndexOutOfBoundsException,
518 rendering::VolatileContentDestroyedException, uno::RuntimeException)
519 {
520 test(false, "Method not implemented");
521 return uno::Sequence< sal_Int8 >();
522 }
523
524 virtual uno::Reference< rendering::XBitmapPalette > SAL_CALL getPalette( ) throw (uno::RuntimeException)
525 {
526 uno::Reference< XBitmapPalette > aRet;
527 if( mnBitsPerPixel == 8 )
528 aRet.set(this);
529 return aRet;
530 }
531
532 virtual rendering::IntegerBitmapLayout SAL_CALL getMemoryLayout( ) throw (uno::RuntimeException)
533 {
534 rendering::IntegerBitmapLayout aLayout( maLayout );
535
536 const sal_Int32 nScanlineLen = (maSize.Width * mnBitsPerPixel + 7)/8;
537
538 aLayout.ScanLines = maSize.Height;
539 aLayout.ScanLineBytes =
540 aLayout.ScanLineStride= nScanlineLen;
541 aLayout.Palette = getPalette();
542 aLayout.ColorSpace.set( this );
543
544 return aLayout;
545 }
546
547 // XBitmapPalette
548 virtual sal_Int32 SAL_CALL getNumberOfEntries() throw (uno::RuntimeException)
549 {
550 test( getPalette().is(),
551 "Got palette interface call without handing out palette?!" );
552
553 return 255;
554 }
555
556 virtual ::sal_Bool SAL_CALL getIndex( uno::Sequence< double >& entry,
557 ::sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException,
558 uno::RuntimeException)
559 {
560 test( getPalette().is(),
561 "Got palette interface call without handing out palette?!" );
562 test( nIndex >= 0 && nIndex < 256,
563 "Index out of range" );
564 entry = colorToStdColorSpaceSequence(
565 Color(UINT8(nIndex),
566 UINT8(nIndex),
567 UINT8(nIndex)) );
568
569 return sal_True; // no palette transparency here.
570 }
571
572 virtual ::sal_Bool SAL_CALL setIndex( const uno::Sequence< double >&,
573 ::sal_Bool,
574 ::sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException,
575 lang::IllegalArgumentException,
576 uno::RuntimeException)
577 {
578 test( getPalette().is(),
579 "Got palette interface call without handing out palette?!" );
580 test( nIndex >= 0 && nIndex < 256,
581 "Index out of range" );
582 return sal_False;
583 }
584
585 struct PaletteColorSpaceHolder: public rtl::StaticWithInit<uno::Reference<rendering::XColorSpace>,
586 PaletteColorSpaceHolder>
587 {
588 uno::Reference<rendering::XColorSpace> operator()()
589 {
590 return vcl::unotools::createStandardColorSpace();
591 }
592 };
593
594 virtual uno::Reference< rendering::XColorSpace > SAL_CALL getColorSpace( ) throw (uno::RuntimeException)
595 {
596 // this is the method from XBitmapPalette. Return palette color
597 // space here
598 return PaletteColorSpaceHolder::get();
599 }
600
601 // XIntegerBitmapColorSpace
602 virtual ::sal_Int8 SAL_CALL getType( ) throw (uno::RuntimeException)
603 {
604 return rendering::ColorSpaceType::RGB;
605 }
606
607 virtual uno::Sequence< sal_Int8 > SAL_CALL getComponentTags( ) throw (uno::RuntimeException)
608 {
609 return maComponentTags;
610 }
611
612 virtual ::sal_Int8 SAL_CALL getRenderingIntent( ) throw (uno::RuntimeException)
613 {
614 return rendering::RenderingIntent::PERCEPTUAL;
615 }
616
617 virtual uno::Sequence< beans::PropertyValue > SAL_CALL getProperties( ) throw (uno::RuntimeException)
618 {
619 test(false, "Method not implemented");
620 return uno::Sequence< ::beans::PropertyValue >();
621 }
622
623 virtual uno::Sequence< double > SAL_CALL convertColorSpace( const uno::Sequence< double >&,
624 const uno::Reference< rendering::XColorSpace >& ) throw (uno::RuntimeException)
625 {
626 test(false, "Method not implemented");
627 return uno::Sequence< double >();
628 }
629
630 virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& ) throw (lang::IllegalArgumentException,
631 uno::RuntimeException)
632 {
633 test(false, "Method not implemented");
634 return uno::Sequence< rendering::RGBColor >();
635 }
636
637 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToARGB( const uno::Sequence< double >& ) throw (lang::IllegalArgumentException,
638 uno::RuntimeException)
639 {
640 test(false, "Method not implemented");
641 return uno::Sequence< rendering::ARGBColor >();
642 }
643
644 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& ) throw (lang::IllegalArgumentException,
645 uno::RuntimeException)
646 {
647 test(false, "Method not implemented");
648 return uno::Sequence< rendering::ARGBColor >();
649 }
650
651 virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& ) throw (lang::IllegalArgumentException,
652 uno::RuntimeException)
653 {
654 test(false, "Method not implemented");
655 return uno::Sequence< double >();
656 }
657
658 virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& ) throw (lang::IllegalArgumentException,
659 uno::RuntimeException)
660 {
661 test(false, "This method is not expected to be called!");
662 return uno::Sequence< double >();
663 }
664
665 virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& ) throw (lang::IllegalArgumentException,
666 uno::RuntimeException)
667 {
668 test(false, "This method is not expected to be called!");
669 return uno::Sequence< double >();
670 }
671
672 virtual ::sal_Int32 SAL_CALL getBitsPerPixel( ) throw (uno::RuntimeException)
673 {
674 return mnBitsPerPixel;
675 }
676
677 virtual uno::Sequence< ::sal_Int32 > SAL_CALL getComponentBitCounts( ) throw (uno::RuntimeException)
678 {
679 return maComponentBitCounts;
680 }
681
682 virtual ::sal_Int8 SAL_CALL getEndianness( ) throw (uno::RuntimeException)
683 {
684 return util::Endianness::LITTLE;
685 }
686
687 virtual uno::Sequence< double > SAL_CALL convertFromIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& ,
688 const uno::Reference< rendering::XColorSpace >& ) throw (lang::IllegalArgumentException,
689 uno::RuntimeException)
690 {
691 test(false, "Method not implemented");
692 return uno::Sequence< double >();
693 }
694
695 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertToIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& ,
696 const uno::Reference< rendering::XIntegerBitmapColorSpace >& ) throw (lang::IllegalArgumentException,
697 uno::RuntimeException)
698 {
699 test(false, "Method not implemented");
700 return uno::Sequence< sal_Int8 >();
701 }
702
703 virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertIntegerToRGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,
704 uno::RuntimeException)
705 {
706 const uno::Sequence< rendering::ARGBColor > aTemp( convertIntegerToARGB(deviceColor) );
707 const sal_Size nLen(aTemp.getLength());
708 uno::Sequence< rendering::RGBColor > aRes( nLen );
709 rendering::RGBColor* pOut = aRes.getArray();
710 for( sal_Size i=0; i<nLen; ++i )
711 {
712 *pOut++ = rendering::RGBColor(aTemp[i].Red,
713 aTemp[i].Green,
714 aTemp[i].Blue);
715 }
716
717 return aRes;
718 }
719
720 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,
721 uno::RuntimeException)
722 {
723 const sal_Size nLen( deviceColor.getLength() );
724 const sal_Int32 nBytesPerPixel(mnBitsPerPixel == 8 ? 1 : 4);
725 test(nLen%nBytesPerPixel==0,
726 "number of channels no multiple of pixel element count");
727
728 uno::Sequence< rendering::ARGBColor > aRes( nLen / nBytesPerPixel );
729 rendering::ARGBColor* pOut( aRes.getArray() );
730
731 if( getPalette().is() )
732 {
733 for( sal_Size i=0; i<nLen; ++i )
734 {
735 *pOut++ = rendering::ARGBColor(
736 1.0,
737 vcl::unotools::toDoubleColor(deviceColor[i]),
738 vcl::unotools::toDoubleColor(deviceColor[i]),
739 vcl::unotools::toDoubleColor(deviceColor[i]));
740 }
741 }
742 else
743 {
744 for( sal_Size i=0; i<nLen; i+=4 )
745 {
746 *pOut++ = rendering::ARGBColor(
747 vcl::unotools::toDoubleColor(deviceColor[i+3]),
748 vcl::unotools::toDoubleColor(deviceColor[i+0]),
749 vcl::unotools::toDoubleColor(deviceColor[i+1]),
750 vcl::unotools::toDoubleColor(deviceColor[i+2]));
751 }
752 }
753
754 return aRes;
755 }
756
757 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToPARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,
758 uno::RuntimeException)
759 {
760 const sal_Size nLen( deviceColor.getLength() );
761 const sal_Int32 nBytesPerPixel(mnBitsPerPixel == 8 ? 1 : 4);
762 test(nLen%nBytesPerPixel==0,
763 "number of channels no multiple of pixel element count");
764
765 uno::Sequence< rendering::ARGBColor > aRes( nLen / nBytesPerPixel );
766 rendering::ARGBColor* pOut( aRes.getArray() );
767
768 if( getPalette().is() )
769 {
770 for( sal_Size i=0; i<nLen; ++i )
771 {
772 *pOut++ = rendering::ARGBColor(
773 1.0,
774 vcl::unotools::toDoubleColor(deviceColor[i]),
775 vcl::unotools::toDoubleColor(deviceColor[i]),
776 vcl::unotools::toDoubleColor(deviceColor[i]));
777 }
778 }
779 else
780 {
781 for( sal_Size i=0; i<nLen; i+=4 )
782 {
783 const double fAlpha=vcl::unotools::toDoubleColor(deviceColor[i+3]);
784 *pOut++ = rendering::ARGBColor(
785 fAlpha,
786 fAlpha*vcl::unotools::toDoubleColor(deviceColor[i+0]),
787 fAlpha*vcl::unotools::toDoubleColor(deviceColor[i+1]),
788 fAlpha*vcl::unotools::toDoubleColor(deviceColor[i+2]));
789 }
790 }
791
792 return aRes;
793 }
794
795 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromRGB( const uno::Sequence< rendering::RGBColor >& ) throw (lang::IllegalArgumentException,
796 uno::RuntimeException)
797 {
798 test(false, "Method not implemented");
799 return uno::Sequence< sal_Int8 >();
800 }
801
802 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromARGB( const uno::Sequence< rendering::ARGBColor >& ) throw (lang::IllegalArgumentException,
803 uno::RuntimeException)
804 {
805 test(false, "Method not implemented");
806 return uno::Sequence< sal_Int8 >();
807 }
808
809 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromPARGB( const uno::Sequence< rendering::ARGBColor >& ) throw (lang::IllegalArgumentException,
810 uno::RuntimeException)
811 {
812 test(false, "Method not implemented");
813 return uno::Sequence< sal_Int8 >();
814 }
815
816 public:
817 TestBitmap( const geometry::IntegerSize2D& rSize, bool bPalette ) :
818 maSize(rSize),
819 maComponentTags(),
820 maComponentBitCounts(),
821 maLayout(),
822 mnBitsPerPixel( bPalette ? 8 : 32 )
823 {
824 if( bPalette )
825 {
826 maComponentTags.realloc(1);
827 maComponentTags[0] = rendering::ColorComponentTag::INDEX;
828
829 maComponentBitCounts.realloc(1);
830 maComponentBitCounts[0] = 8;
831 }
832 else
833 {
834 maComponentTags.realloc(4);
835 sal_Int8* pTags = maComponentTags.getArray();
836 pTags[0] = rendering::ColorComponentTag::RGB_BLUE;
837 pTags[1] = rendering::ColorComponentTag::RGB_GREEN;
838 pTags[2] = rendering::ColorComponentTag::RGB_RED;
839 pTags[3] = rendering::ColorComponentTag::ALPHA;
840
841 maComponentBitCounts.realloc(4);
842 sal_Int32* pCounts = maComponentBitCounts.getArray();
843 pCounts[0] = 8;
844 pCounts[1] = 8;
845 pCounts[2] = 8;
846 pCounts[3] = 8;
847 }
848
849 maLayout.ScanLines = 0;
850 maLayout.ScanLineBytes = 0;
851 maLayout.ScanLineStride = 0;
852 maLayout.PlaneStride = 0;
853 maLayout.ColorSpace.clear();
854 maLayout.Palette.clear();
855 maLayout.IsMsbFirst = sal_False;
856 }
857 };
858
859
860 //----------------------------------------------------------------------------------
861
862 void TestWindow::Paint( const Rectangle& )
863 {
864 static sal_Int8 lcl_depths[]={1,4,8,16,24};
865
866 try
867 {
868 // Testing VclCanvasBitmap wrapper
869 // ===============================
870
871 for( unsigned int i=0; i<SAL_N_ELEMENTS(lcl_depths); ++i )
872 {
873 const sal_Int8 nDepth( lcl_depths[i] );
874 Bitmap aBitmap(Size(200,200),nDepth);
875 aBitmap.Erase(COL_WHITE);
876 {
877 Bitmap::ScopedWriteAccess pAcc(aBitmap);
878 if( pAcc.get() )
879 {
880 BitmapColor aBlack(0);
881 BitmapColor aWhite(0);
882 if( pAcc->HasPalette() )
883 {
884 aBlack.SetIndex( sal::static_int_cast<BYTE>(pAcc->GetBestPaletteIndex(BitmapColor(0,0,0))) );
885 aWhite.SetIndex( sal::static_int_cast<BYTE>(pAcc->GetBestPaletteIndex(BitmapColor(255,255,255))) );
886 }
887 else
888 {
889 aBlack = Color(COL_BLACK);
890 aWhite = Color(COL_WHITE);
891 }
892 pAcc->SetFillColor(COL_GREEN);
893 pAcc->FillRect(Rectangle(0,0,100,100));
894 pAcc->SetPixel(0,0,aWhite);
895 pAcc->SetPixel(0,1,aBlack);
896 pAcc->SetPixel(0,2,aWhite);
897 }
898 }
899
900 rtl::Reference<VclCanvasBitmap> xBmp( new VclCanvasBitmap(aBitmap) );
901
902 checkCanvasBitmap( xBmp, "single bitmap", nDepth );
903
904 Bitmap aMask(Size(200,200),1);
905 aMask.Erase(COL_WHITE);
906 {
907 Bitmap::ScopedWriteAccess pAcc(aMask);
908 if( pAcc.get() )
909 {
910 pAcc->SetFillColor(COL_BLACK);
911 pAcc->FillRect(Rectangle(0,0,100,100));
912 pAcc->SetPixel(0,0,BitmapColor(1));
913 pAcc->SetPixel(0,1,BitmapColor(0));
914 pAcc->SetPixel(0,2,BitmapColor(1));
915 }
916 }
917
918 xBmp.set( new VclCanvasBitmap(BitmapEx(aBitmap,aMask)) );
919
920 checkCanvasBitmap( xBmp, "masked bitmap", nDepth );
921
922 AlphaMask aAlpha(Size(200,200));
923 aAlpha.Erase(255);
924 {
925 BitmapWriteAccess* pAcc = aAlpha.AcquireWriteAccess();
926 if( pAcc )
927 {
928 pAcc->SetFillColor(COL_BLACK);
929 pAcc->FillRect(Rectangle(0,0,100,100));
930 pAcc->SetPixel(0,0,BitmapColor(255));
931 pAcc->SetPixel(0,1,BitmapColor(0));
932 pAcc->SetPixel(0,2,BitmapColor(255));
933 aAlpha.ReleaseAccess(pAcc);
934 }
935 }
936
937 xBmp.set( new VclCanvasBitmap(BitmapEx(aBitmap,aAlpha)) );
938
939 checkCanvasBitmap( xBmp, "alpha bitmap", nDepth );
940 }
941
942 // Testing XBitmap import
943 // ======================
944 uno::Reference< rendering::XIntegerReadOnlyBitmap > xTestBmp(
945 new TestBitmap( geometry::IntegerSize2D(10,10), true ));
946
947 BitmapEx aBmp = vcl::unotools::bitmapExFromXBitmap(xTestBmp);
948 test( aBmp.IsTransparent() == false,
949 "Palette bitmap is not transparent" );
950 test( aBmp.GetSizePixel() == Size(10,10),
951 "Bitmap has size (10,10)" );
952 test( aBmp.GetBitCount() == 8,
953 "Bitmap has bitcount of 8" );
954 {
955 BitmapReadAccess* pBmpAcc = aBmp.GetBitmap().AcquireReadAccess();
956
957 test( pBmpAcc,
958 "Bitmap has valid BitmapReadAccess" );
959
960 test(pBmpAcc->GetPixel(0,0) == BitmapColor(0),
961 "(0,0) correct content");
962 test(pBmpAcc->GetPixel(2,2) == BitmapColor(2),
963 "(2,2) correct content");
964 test(pBmpAcc->GetPixel(2,9) == BitmapColor(9),
965 "(9,2) correct content");
966
967 aBmp.GetBitmap().ReleaseAccess(pBmpAcc);
968 }
969
970 xTestBmp.set( new TestBitmap( geometry::IntegerSize2D(10,10), false ));
971
972 aBmp = vcl::unotools::bitmapExFromXBitmap(xTestBmp);
973 test( aBmp.IsTransparent() == TRUE,
974 "Palette bitmap is transparent" );
975 test( aBmp.IsAlpha() == TRUE,
976 "Palette bitmap has alpha" );
977 test( aBmp.GetSizePixel() == Size(10,10),
978 "Bitmap has size (10,10)" );
979 test( aBmp.GetBitCount() == 24,
980 "Bitmap has bitcount of 24" );
981 {
982 BitmapReadAccess* pBmpAcc = aBmp.GetBitmap().AcquireReadAccess();
983 BitmapReadAccess* pAlphaAcc = aBmp.GetAlpha().AcquireReadAccess();
984
985 test( pBmpAcc,
986 "Bitmap has valid BitmapReadAccess" );
987 test( pAlphaAcc,
988 "Bitmap has valid alpha BitmapReadAccess" );
989
990 test(pBmpAcc->GetPixel(0,0) == BitmapColor(0,1,0),
991 "(0,0) correct content");
992 test(pAlphaAcc->GetPixel(0,0) == BitmapColor(255),
993 "(0,0) correct alpha content");
994 test(pBmpAcc->GetPixel(2,2) == BitmapColor(0,3,2),
995 "(2,2) correct content");
996 test(pAlphaAcc->GetPixel(2,2) == BitmapColor(253),
997 "(2,2) correct alpha content");
998 test(pBmpAcc->GetPixel(2,9) == BitmapColor(0,3,9),
999 "(9,2) correct content");
1000 test(pAlphaAcc->GetPixel(2,9) == BitmapColor(253),
1001 "(9,2) correct alpha content");
1002
1003 aBmp.GetAlpha().ReleaseAccess(pAlphaAcc);
1004 aBmp.GetBitmap().ReleaseAccess(pBmpAcc);
1005 }
1006 }
1007 catch( uno::Exception& )
1008 {
1009 DBG_UNHANDLED_EXCEPTION();
1010 exit(2);
1011 }
1012 catch( std::exception& )
1013 {
1014 OSL_TRACE( "Caught std exception!" );
1015 }
1016
1017 if( g_failure )
1018 exit(2);
1019 }
1020
1021 } // namespace
1022
1023 void Main()
1024 {
1025 TestWindow aWindow;
1026 aWindow.Execute();
1027 aWindow.SetText( OUString( "VCL - canvasbitmaptest" ) );
1028
1029 Application::Execute();
1030 }
1031
1032 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE