?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / canvas / source / cairo / cairo_canvashelper.cxx
blob22280fe82dbdf32a16685e4977292c957155c72e
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: cairo_canvashelper.cxx,v $
10 * $Revision: 1.17 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_canvas.hxx"
33
34 #include <canvas/debug.hxx>
35 #include <tools/diagnose_ex.h>
36
37 #include <rtl/logfile.hxx>
38 #include <rtl/math.hxx>
39 #include <rtl/instance.hxx>
40
41 #include <com/sun/star/util/Endianness.hpp>
42 #include <com/sun/star/rendering/TexturingMode.hpp>
43 #include <com/sun/star/rendering/CompositeOperation.hpp>
44 #include <com/sun/star/rendering/RepaintResult.hpp>
45 #include <com/sun/star/rendering/PathCapType.hpp>
46 #include <com/sun/star/rendering/PathJoinType.hpp>
47 #include <com/sun/star/rendering/XIntegerBitmapColorSpace.hpp>
48 #include <com/sun/star/rendering/IntegerBitmapLayout.hpp>
49 #include <com/sun/star/rendering/ColorSpaceType.hpp>
50 #include <com/sun/star/rendering/ColorComponentTag.hpp>
51 #include <com/sun/star/rendering/RenderingIntent.hpp>
52
53 #include <basegfx/matrix/b2dhommatrix.hxx>
54 #include <basegfx/point/b2dpoint.hxx>
55 #include <basegfx/polygon/b2dpolygon.hxx>
56 #include <basegfx/polygon/b2dpolypolygon.hxx>
57 #include <basegfx/polygon/b2dpolygontools.hxx>
58 #include <basegfx/tools/canvastools.hxx>
59
60 #include <comphelper/sequence.hxx>
61 #include <cppuhelper/compbase1.hxx>
62
63 #include <canvas/canvastools.hxx>
64 #include <canvas/parametricpolypolygon.hxx>
65
66 #include <vcl/canvastools.hxx>
67 #include <vcl/bitmapex.hxx>
68 #include <vcl/bmpacc.hxx>
69 #include <vcl/virdev.hxx>
70
71 #include "cairo_spritecanvas.hxx"
72 #include "cairo_cachedbitmap.hxx"
73 #include "cairo_canvashelper.hxx"
74 #include "cairo_canvasbitmap.hxx"
75
76 #include <algorithm>
77
78 using namespace ::cairo;
79 using namespace ::com::sun::star;
80
81 namespace cairocanvas
82 {
83 CanvasHelper::CanvasHelper() :
84 mpSurfaceProvider(NULL),
85 mpDevice(NULL),
86 mpVirtualDevice(),
87 mbHaveAlpha(),
88 mpCairo(),
89 mpSurface(),
90 maSize()
91 {
92 }
93
94 void CanvasHelper::disposing()
95 {
96 mpSurface.reset();
97 mpCairo.reset();
98 mpVirtualDevice.reset();
99 mpDevice = NULL;
100 mpSurfaceProvider = NULL;
101 }
102
103 void CanvasHelper::init( const ::basegfx::B2ISize& rSizePixel,
104 SurfaceProvider& rSurfaceProvider,
105 rendering::XGraphicDevice* pDevice )
106 {
107 maSize = rSizePixel;
108 mpSurfaceProvider = &rSurfaceProvider;
109 mpDevice = pDevice;
110 }
111
112 void CanvasHelper::setSize( const ::basegfx::B2ISize& rSize )
113 {
114 maSize = rSize;
115 }
116
117 void CanvasHelper::setSurface( const SurfaceSharedPtr& pSurface, bool bHasAlpha )
118 {
119 mbHaveAlpha = bHasAlpha;
120 mpVirtualDevice.reset();
121 mpSurface = pSurface;
122 mpCairo = pSurface->getCairo();
123 }
124
125 void CanvasHelper::useStates( const rendering::ViewState& viewState,
126 const rendering::RenderState& renderState,
127 bool setColor )
128 {
129 Matrix aViewMatrix;
130 Matrix aRenderMatrix;
131 Matrix aCombinedMatrix;
132
133 cairo_matrix_init( &aViewMatrix,
134 viewState.AffineTransform.m00, viewState.AffineTransform.m10, viewState.AffineTransform.m01,
135 viewState.AffineTransform.m11, viewState.AffineTransform.m02, viewState.AffineTransform.m12);
136 cairo_matrix_init( &aRenderMatrix,
137 renderState.AffineTransform.m00, renderState.AffineTransform.m10, renderState.AffineTransform.m01,
138 renderState.AffineTransform.m11, renderState.AffineTransform.m02, renderState.AffineTransform.m12);
139 cairo_matrix_multiply( &aCombinedMatrix, &aRenderMatrix, &aViewMatrix);
140
141 if( viewState.Clip.is() ) {
142 OSL_TRACE ("view clip");
143
144 aViewMatrix.x0 = basegfx::fround( aViewMatrix.x0 );
145 aViewMatrix.y0 = basegfx::fround( aViewMatrix.y0 );
146 cairo_set_matrix( mpCairo.get(), &aViewMatrix );
147 doPolyPolygonPath( viewState.Clip, Clip );
148 }
149
150 aCombinedMatrix.x0 = basegfx::fround( aCombinedMatrix.x0 );
151 aCombinedMatrix.y0 = basegfx::fround( aCombinedMatrix.y0 );
152 cairo_set_matrix( mpCairo.get(), &aCombinedMatrix );
153
154 if( renderState.Clip.is() ) {
155 OSL_TRACE ("render clip BEGIN");
156
157 doPolyPolygonPath( renderState.Clip, Clip );
158 OSL_TRACE ("render clip END");
159 }
160
161 if( setColor ) {
162 if( renderState.DeviceColor.getLength() > 3 )
163 cairo_set_source_rgba( mpCairo.get(),
164 renderState.DeviceColor [0],
165 renderState.DeviceColor [1],
166 renderState.DeviceColor [2],
167 renderState.DeviceColor [3] );
168 else if (renderState.DeviceColor.getLength() == 3)
169 cairo_set_source_rgb( mpCairo.get(),
170 renderState.DeviceColor [0],
171 renderState.DeviceColor [1],
172 renderState.DeviceColor [2] );
173 }
174
175 cairo_operator_t compositingMode( CAIRO_OPERATOR_OVER );
176 switch( renderState.CompositeOperation )
177 {
178 case rendering::CompositeOperation::CLEAR:
179 compositingMode = CAIRO_OPERATOR_CLEAR;
180 break;
181 case rendering::CompositeOperation::SOURCE:
182 compositingMode = CAIRO_OPERATOR_SOURCE;
183 break;
184 case rendering::CompositeOperation::DESTINATION:
185 compositingMode = CAIRO_OPERATOR_DEST;
186 break;
187 case rendering::CompositeOperation::OVER:
188 compositingMode = CAIRO_OPERATOR_OVER;
189 break;
190 case rendering::CompositeOperation::UNDER:
191 compositingMode = CAIRO_OPERATOR_DEST;
192 break;
193 case rendering::CompositeOperation::INSIDE:
194 compositingMode = CAIRO_OPERATOR_IN;
195 break;
196 case rendering::CompositeOperation::INSIDE_REVERSE:
197 compositingMode = CAIRO_OPERATOR_OUT;
198 break;
199 case rendering::CompositeOperation::OUTSIDE:
200 compositingMode = CAIRO_OPERATOR_DEST_OVER;
201 break;
202 case rendering::CompositeOperation::OUTSIDE_REVERSE:
203 compositingMode = CAIRO_OPERATOR_DEST_OUT;
204 break;
205 case rendering::CompositeOperation::ATOP:
206 compositingMode = CAIRO_OPERATOR_ATOP;
207 break;
208 case rendering::CompositeOperation::ATOP_REVERSE:
209 compositingMode = CAIRO_OPERATOR_DEST_ATOP;
210 break;
211 case rendering::CompositeOperation::XOR:
212 compositingMode = CAIRO_OPERATOR_XOR;
213 break;
214 case rendering::CompositeOperation::ADD:
215 compositingMode = CAIRO_OPERATOR_ADD;
216 break;
217 case rendering::CompositeOperation::SATURATE:
218 compositingMode = CAIRO_OPERATOR_SATURATE;
219 break;
220 }
221 cairo_set_operator( mpCairo.get(), compositingMode );
222 }
223
224 void CanvasHelper::clear()
225 {
226 OSL_TRACE ("clear whole area: %d x %d", maSize.getX(), maSize.getY() );
227
228 if( mpCairo )
229 {
230 cairo_save( mpCairo.get() );
231
232 cairo_identity_matrix( mpCairo.get() );
233 // this does not really differ from all-zero, as cairo
234 // internally converts to premultiplied alpha. but anyway,
235 // this keeps it consistent with the other canvas impls
236 if( mbHaveAlpha )
237 cairo_set_source_rgba( mpCairo.get(), 1.0, 1.0, 1.0, 0.0 );
238 else
239 cairo_set_source_rgb( mpCairo.get(), 1.0, 1.0, 1.0 );
240 cairo_set_operator( mpCairo.get(), CAIRO_OPERATOR_SOURCE );
241
242 cairo_rectangle( mpCairo.get(), 0, 0, maSize.getX(), maSize.getY() );
243 cairo_fill( mpCairo.get() );
244
245 cairo_restore( mpCairo.get() );
246 }
247 }
248
249 void CanvasHelper::drawPoint( const rendering::XCanvas* ,
250 const geometry::RealPoint2D& ,
251 const rendering::ViewState& ,
252 const rendering::RenderState& )
253 {
254 }
255
256 void CanvasHelper::drawLine( const rendering::XCanvas* /*pCanvas*/,
257 const geometry::RealPoint2D& aStartPoint,
258 const geometry::RealPoint2D& aEndPoint,
259 const rendering::ViewState& viewState,
260 const rendering::RenderState& renderState )
261 {
262 if( mpCairo ) {
263 cairo_save( mpCairo.get() );
264
265 cairo_set_line_width( mpCairo.get(), 1 );
266
267 useStates( viewState, renderState, true );
268
269 cairo_move_to( mpCairo.get(), aStartPoint.X + 0.5, aStartPoint.Y + 0.5 );
270 cairo_line_to( mpCairo.get(), aEndPoint.X + 0.5, aEndPoint.Y + 0.5 );
271 cairo_stroke( mpCairo.get() );
272
273 cairo_restore( mpCairo.get() );
274 }
275 }
276
277 void CanvasHelper::drawBezier( const rendering::XCanvas* ,
278 const geometry::RealBezierSegment2D& aBezierSegment,
279 const geometry::RealPoint2D& aEndPoint,
280 const rendering::ViewState& viewState,
281 const rendering::RenderState& renderState )
282 {
283 if( mpCairo ) {
284 cairo_save( mpCairo.get() );
285
286 cairo_set_line_width( mpCairo.get(), 1 );
287
288 useStates( viewState, renderState, true );
289
290 cairo_move_to( mpCairo.get(), aBezierSegment.Px + 0.5, aBezierSegment.Py + 0.5 );
291 cairo_curve_to( mpCairo.get(),
292 aBezierSegment.C1x + 0.5, aBezierSegment.C1y + 0.5,
293 aBezierSegment.C2x + 0.5, aBezierSegment.C2y + 0.5,
294 aEndPoint.X + 0.5, aEndPoint.Y + 0.5 );
295 cairo_stroke( mpCairo.get() );
296
297 cairo_restore( mpCairo.get() );
298 }
299 }
300
301 #define CANVASBITMAP_IMPLEMENTATION_NAME "CairoCanvas::CanvasBitmap"
302 #define PARAMETRICPOLYPOLYGON_IMPLEMENTATION_NAME "Canvas::ParametricPolyPolygon"
303
304
305 /** surfaceFromXBitmap Create a surface from XBitmap
306 * @param xBitmap bitmap image that will be used for the surface
307 * @param bHasAlpha will be set to true if resulting surface has alpha
308 *
309 * This is a helper function for the other surfaceFromXBitmap().
310 * This function tries to create surface from xBitmap by checking if xBitmap is CanvasBitmap or SpriteCanvas.
311 *
312 * @return created surface or NULL
313 **/
314 static SurfaceSharedPtr surfaceFromXBitmap( const uno::Reference< rendering::XBitmap >& xBitmap )
315 {
316 CanvasBitmap* pBitmapImpl = dynamic_cast< CanvasBitmap* >( xBitmap.get() );
317 if( pBitmapImpl )
318 return pBitmapImpl->getSurface();
319
320 SurfaceProvider* pSurfaceProvider = dynamic_cast<SurfaceProvider*>( xBitmap.get() );
321 if( pSurfaceProvider )
322 return pSurfaceProvider->getSurface();
323
324 return SurfaceSharedPtr();
325 }
326
327 static ::BitmapEx bitmapExFromXBitmap( const uno::Reference< rendering::XBitmap >& xBitmap )
328 {
329 // TODO(F1): Add support for floating point bitmap formats
330 uno::Reference<rendering::XIntegerReadOnlyBitmap> xIntBmp(xBitmap,
331 uno::UNO_QUERY_THROW);
332 ::BitmapEx aBmpEx = ::vcl::unotools::bitmapExFromXBitmap(xIntBmp);
333 if( !!aBmpEx )
334 return aBmpEx;
335
336 // TODO(F1): extract pixel from XBitmap interface
337 ENSURE_OR_THROW( false,
338 "bitmapExFromXBitmap(): could not extract BitmapEx" );
339
340 return ::BitmapEx();
341 }
342
343 static bool readAlpha( BitmapReadAccess* pAlphaReadAcc, long nY, const long nWidth, unsigned char* data, long nOff )
344 {
345 bool bIsAlpha = false;
346 long nX;
347 int nAlpha;
348 Scanline pReadScan;
349
350 nOff += 3;
351
352 switch( pAlphaReadAcc->GetScanlineFormat() ) {
353 case BMP_FORMAT_8BIT_TC_MASK:
354 pReadScan = pAlphaReadAcc->GetScanline( nY );
355 for( nX = 0; nX < nWidth; nX++ ) {
356 nAlpha = data[ nOff ] = 255 - ( *pReadScan++ );
357 if( nAlpha != 255 )
358 bIsAlpha = true;
359 nOff += 4;
360 }
361 break;
362 case BMP_FORMAT_8BIT_PAL:
363 pReadScan = pAlphaReadAcc->GetScanline( nY );
364 for( nX = 0; nX < nWidth; nX++ ) {
365 nAlpha = data[ nOff ] = 255 - ( pAlphaReadAcc->GetPaletteColor( *pReadScan++ ).GetBlue() );
366 if( nAlpha != 255 )
367 bIsAlpha = true;
368 nOff += 4;
369 }
370 break;
371 default:
372 OSL_TRACE( "fallback to GetColor for alpha - slow, format: %d", pAlphaReadAcc->GetScanlineFormat() );
373 for( nX = 0; nX < nWidth; nX++ ) {
374 nAlpha = data[ nOff ] = 255 - pAlphaReadAcc->GetColor( nY, nX ).GetBlue();
375 if( nAlpha != 255 )
376 bIsAlpha = true;
377 nOff += 4;
378 }
379 }
380
381 return bIsAlpha;
382 }
383
384
385 /** surfaceFromXBitmap Create a surface from XBitmap
386 * @param xBitmap bitmap image that will be used for the surface
387 * @param rDevice reference to the device into which we want to draw
388 * @param data will be filled with alpha data, if xBitmap is alpha/transparent image
389 * @param bHasAlpha will be set to true if resulting surface has alpha
390 *
391 * This function tries various methods for creating a surface from xBitmap. It also uses
392 * the helper function surfaceFromXBitmap( xBitmap, bHasAlpha )
393 *
394 * @return created surface or NULL
395 **/
396 static SurfaceSharedPtr surfaceFromXBitmap( const uno::Reference< rendering::XBitmap >& xBitmap, const SurfaceProviderRef& rSurfaceProvider, unsigned char*& data, bool& bHasAlpha )
397 {
398 bHasAlpha = xBitmap->hasAlpha();
399 SurfaceSharedPtr pSurface = surfaceFromXBitmap( xBitmap );
400 if( pSurface )
401 data = NULL;
402 else
403 {
404 ::BitmapEx aBmpEx = bitmapExFromXBitmap(xBitmap);
405 ::Bitmap aBitmap = aBmpEx.GetBitmap();
406
407 // there's no pixmap for alpha bitmap. we might still
408 // use rgb pixmap and only access alpha pixels the
409 // slow way. now we just speedup rgb bitmaps
410 if( !aBmpEx.IsTransparent() && !aBmpEx.IsAlpha() ) {
411 pSurface = rSurfaceProvider->createSurface( aBitmap );
412 data = NULL;
413 bHasAlpha = false;
414 }
415
416 if( !pSurface ) {
417 AlphaMask aAlpha = aBmpEx.GetAlpha();
418
419 ::BitmapReadAccess* pBitmapReadAcc = aBitmap.AcquireReadAccess();
420 ::BitmapReadAccess* pAlphaReadAcc = NULL;
421 const long nWidth = pBitmapReadAcc->Width();
422 const long nHeight = pBitmapReadAcc->Height();
423 long nX, nY;
424 bool bIsAlpha = false;
425
426 if( aBmpEx.IsTransparent() || aBmpEx.IsAlpha() )
427 pAlphaReadAcc = aAlpha.AcquireReadAccess();
428
429 data = (unsigned char*) malloc( nWidth*nHeight*4 );
430
431 long nOff = 0;
432 ::Color aColor;
433 unsigned int nAlpha = 255;
434
435 for( nY = 0; nY < nHeight; nY++ ) {
436 ::Scanline pReadScan;
437
438 switch( pBitmapReadAcc->GetScanlineFormat() ) {
439 case BMP_FORMAT_8BIT_PAL:
440 pReadScan = pBitmapReadAcc->GetScanline( nY );
441 if( pAlphaReadAcc )
442 if( readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
443 bIsAlpha = true;
444
445 for( nX = 0; nX < nWidth; nX++ ) {
446 #ifdef OSL_BIGENDIAN
447 if( pAlphaReadAcc )
448 nAlpha = data[ nOff++ ];
449 else
450 nAlpha = data[ nOff++ ] = 255;
451 #else
452 if( pAlphaReadAcc )
453 nAlpha = data[ nOff + 3 ];
454 else
455 nAlpha = data[ nOff + 3 ] = 255;
456 #endif
457 aColor = pBitmapReadAcc->GetPaletteColor( *pReadScan++ );
458
459 #ifdef OSL_BIGENDIAN
460 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( aColor.GetRed() ) )/255 );
461 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( aColor.GetGreen() ) )/255 );
462 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( aColor.GetBlue() ) )/255 );
463 #else
464 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( aColor.GetBlue() ) )/255 );
465 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( aColor.GetGreen() ) )/255 );
466 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( aColor.GetRed() ) )/255 );
467 nOff++;
468 #endif
469 }
470 break;
471 case BMP_FORMAT_24BIT_TC_BGR:
472 pReadScan = pBitmapReadAcc->GetScanline( nY );
473 if( pAlphaReadAcc )
474 if( readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
475 bIsAlpha = true;
476
477 for( nX = 0; nX < nWidth; nX++ ) {
478 #ifdef OSL_BIGENDIAN
479 if( pAlphaReadAcc )
480 nAlpha = data[ nOff ];
481 else
482 nAlpha = data[ nOff ] = 255;
483 data[ nOff + 3 ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
484 data[ nOff + 2 ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
485 data[ nOff + 1 ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
486 nOff += 4;
487 #else
488 if( pAlphaReadAcc )
489 nAlpha = data[ nOff + 3 ];
490 else
491 nAlpha = data[ nOff + 3 ] = 255;
492 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
493 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
494 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
495 nOff++;
496 #endif
497 }
498 break;
499 case BMP_FORMAT_24BIT_TC_RGB:
500 pReadScan = pBitmapReadAcc->GetScanline( nY );
501 if( pAlphaReadAcc )
502 if( readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
503 bIsAlpha = true;
504
505 for( nX = 0; nX < nWidth; nX++ ) {
506 #ifdef OSL_BIGENDIAN
507 if( pAlphaReadAcc )
508 nAlpha = data[ nOff++ ];
509 else
510 nAlpha = data[ nOff++ ] = 255;
511 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
512 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
513 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
514 #else
515 if( pAlphaReadAcc )
516 nAlpha = data[ nOff + 3 ];
517 else
518 nAlpha = data[ nOff + 3 ] = 255;
519 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( pReadScan[ 2 ] ) )/255 );
520 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( pReadScan[ 1 ] ) )/255 );
521 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( pReadScan[ 0 ] ) )/255 );
522 pReadScan += 3;
523 nOff++;
524 #endif
525 }
526 break;
527 case BMP_FORMAT_32BIT_TC_BGRA:
528 pReadScan = pBitmapReadAcc->GetScanline( nY );
529 if( pAlphaReadAcc )
530 if( readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
531 bIsAlpha = true;
532
533 for( nX = 0; nX < nWidth; nX++ ) {
534 #ifdef OSL_BIGENDIAN
535 if( pAlphaReadAcc )
536 nAlpha = data[ nOff++ ];
537 else
538 nAlpha = data[ nOff++ ] = pReadScan[ 3 ];
539 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( pReadScan[ 2 ] ) )/255 );
540 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( pReadScan[ 1 ] ) )/255 );
541 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( pReadScan[ 0 ] ) )/255 );
542 pReadScan += 4;
543 #else
544 if( pAlphaReadAcc )
545 nAlpha = data[ nOff + 3 ];
546 else
547 nAlpha = data[ nOff + 3 ] = pReadScan[ 3 ];
548 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
549 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
550 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
551 pReadScan++;
552 nOff++;
553 #endif
554 }
555 break;
556 case BMP_FORMAT_32BIT_TC_RGBA:
557 pReadScan = pBitmapReadAcc->GetScanline( nY );
558 if( pAlphaReadAcc )
559 if( readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
560 bIsAlpha = true;
561
562 for( nX = 0; nX < nWidth; nX++ ) {
563 #ifdef OSL_BIGENDIAN
564 if( pAlphaReadAcc )
565 nAlpha = data[ nOff ++ ];
566 else
567 nAlpha = data[ nOff ++ ] = 255;
568 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
569 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
570 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( *pReadScan++ ) )/255 );
571 pReadScan++;
572 #else
573 if( pAlphaReadAcc )
574 nAlpha = data[ nOff + 3 ];
575 else
576 nAlpha = data[ nOff + 3 ] = 255;
577 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( pReadScan[ 2 ] ) )/255 );
578 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( pReadScan[ 1 ] ) )/255 );
579 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*( pReadScan[ 0 ] ) )/255 );
580 pReadScan += 4;
581 nOff++;
582 #endif
583 }
584 break;
585 default:
586 OSL_TRACE( "fallback to GetColor - slow, format: %d", pBitmapReadAcc->GetScanlineFormat() );
587
588 if( pAlphaReadAcc )
589 if( readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
590 bIsAlpha = true;
591
592 for( nX = 0; nX < nWidth; nX++ ) {
593 aColor = pBitmapReadAcc->GetColor( nY, nX );
594
595 // cairo need premultiplied color values
596 // TODO(rodo) handle endianess
597 #ifdef OSL_BIGENDIAN
598 if( pAlphaReadAcc )
599 nAlpha = data[ nOff++ ];
600 else
601 nAlpha = data[ nOff++ ] = 255;
602 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*aColor.GetRed() )/255 );
603 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*aColor.GetGreen() )/255 );
604 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*aColor.GetBlue() )/255 );
605 #else
606 if( pAlphaReadAcc )
607 nAlpha = data[ nOff + 3 ];
608 else
609 nAlpha = data[ nOff + 3 ] = 255;
610 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*aColor.GetBlue() )/255 );
611 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*aColor.GetGreen() )/255 );
612 data[ nOff++ ] = sal::static_int_cast<unsigned char>(( nAlpha*aColor.GetRed() )/255 );
613 nOff ++;
614 #endif
615 }
616 }
617 }
618
619 aBitmap.ReleaseAccess( pBitmapReadAcc );
620 if( pAlphaReadAcc )
621 aAlpha.ReleaseAccess( pAlphaReadAcc );
622
623 SurfaceSharedPtr pImageSurface = createSurface(
624 CairoSurfaceSharedPtr(
625 cairo_image_surface_create_for_data(
626 data,
627 bIsAlpha ? CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24,
628 nWidth, nHeight, nWidth*4 ),
629 &cairo_surface_destroy) );
630
631 // pSurface = rSurfaceProvider->getSurface( ::basegfx::B2ISize( nWidth, nHeight ), bIsAlpha ? CAIRO_CONTENT_COLOR_ALPHA : CAIRO_CONTENT_COLOR );
632 // Cairo* pTargetCairo = cairo_create( pSurface );
633 // cairo_set_source_surface( pTargetCairo, pImageSurface, 0, 0 );
634
635 // //if( !bIsAlpha )
636 // //cairo_set_operator( pTargetCairo, CAIRO_OPERATOR_SOURCE );
637
638 // cairo_paint( pTargetCairo );
639 // cairo_destroy( pTargetCairo );
640 // cairo_surface_destroy( pImageSurface );
641 pSurface = pImageSurface;
642
643 bHasAlpha = bIsAlpha;
644
645 OSL_TRACE("image: %d x %d alpha: %d alphaRead %p", nWidth, nHeight, bIsAlpha, pAlphaReadAcc);
646 }
647 }
648
649 return pSurface;
650 }
651
652 static void addColorStops( Pattern* pPattern, const uno::Sequence< uno::Sequence< double > >& rColors, const uno::Sequence< double >& rStops, bool bReverseStops = false )
653 {
654 float stop;
655 int i;
656
657 OSL_ASSERT( rColors.getLength() == rStops.getLength() );
658
659 for( i = 0; i < rColors.getLength(); i++ ) {
660 const uno::Sequence< double >& rColor( rColors[i] );
661 stop = bReverseStops ? 1 - rStops[i] : rStops[i];
662 if( rColor.getLength() == 3 )
663 cairo_pattern_add_color_stop_rgb( pPattern, stop, rColor[0], rColor[1], rColor[2] );
664 else if( rColor.getLength() == 4 ) {
665 double alpha = rColor[3];
666 // cairo expects premultiplied alpha
667 cairo_pattern_add_color_stop_rgba( pPattern, stop, rColor[0]*alpha, rColor[1]*alpha, rColor[2]*alpha, alpha );
668 //cairo_pattern_add_color_stop_rgba( pPattern, stop, rColor[0], rColor[1], rColor[2], alpha );
669 }
670 }
671 }
672
673 static Pattern* patternFromParametricPolyPolygon( ::canvas::ParametricPolyPolygon& rPolygon )
674 {
675 Pattern* pPattern = NULL;
676 const ::canvas::ParametricPolyPolygon::Values aValues = rPolygon.getValues();
677 double x0, x1, y0, y1, cx, cy, r0, r1;
678
679 // undef macros from vclenum.hxx which conflicts with GradientType enum values
680 #undef GRADIENT_LINEAR
681 #undef GRADIENT_AXIAL
682 #undef GRADIENT_ELLIPTICAL
683
684 switch( aValues.meType ) {
685 case ::canvas::ParametricPolyPolygon::GRADIENT_LINEAR:
686 x0 = 0;
687 y0 = 0;
688 x1 = 1;
689 y1 = 0;
690 pPattern = cairo_pattern_create_linear( x0, y0, x1, y1 );
691 addColorStops( pPattern, aValues.maColors, aValues.maStops );
692 break;
693
694 // FIXME: NYI
695 case ::canvas::ParametricPolyPolygon::GRADIENT_RECTANGULAR:
696 case ::canvas::ParametricPolyPolygon::GRADIENT_AXIAL:
697 x0 = 0;
698 y0 = 0;
699 x1 = 1;
700 y1 = 0;
701 pPattern = cairo_pattern_create_linear( x0, y0, x1, y1 );
702 addColorStops( pPattern, aValues.maColors, aValues.maStops );
703 break;
704
705 case ::canvas::ParametricPolyPolygon::GRADIENT_ELLIPTICAL:
706 cx = 0.5;
707 cy = 0.5;
708 r0 = 0;
709 r1 = 0.5;
710
711 pPattern = cairo_pattern_create_radial( cx, cy, r0, cx, cy, r1 );
712 addColorStops( pPattern, aValues.maColors, aValues.maStops, true );
713 break;
714 }
715
716 return pPattern;
717 }
718
719 static void doOperation( Operation aOperation,
720 Cairo* pCairo,
721 const uno::Sequence< rendering::Texture >* pTextures,
722 const SurfaceProviderRef& pDevice )
723 {
724 switch( aOperation ) {
725 case Fill:
726 /* TODO: multitexturing */
727 if( pTextures ) {
728 const ::com::sun::star::rendering::Texture& aTexture ( (*pTextures)[0] );
729 if( aTexture.Bitmap.is() ) {
730 unsigned char* data = NULL;
731 bool bHasAlpha = false;
732 SurfaceSharedPtr pSurface = surfaceFromXBitmap( (*pTextures)[0].Bitmap, pDevice, data, bHasAlpha );
733
734 if( pSurface ) {
735 cairo_pattern_t* pPattern;
736
737 cairo_save( pCairo );
738
739 ::com::sun::star::geometry::AffineMatrix2D aTransform( aTexture.AffineTransform );
740 Matrix aScaleMatrix, aTextureMatrix, aScaledTextureMatrix;
741
742 cairo_matrix_init( &aTextureMatrix,
743 aTransform.m00, aTransform.m10, aTransform.m01,
744 aTransform.m11, aTransform.m02, aTransform.m12);
745
746 geometry::IntegerSize2D aSize = aTexture.Bitmap->getSize();
747
748 cairo_matrix_init_scale( &aScaleMatrix, 1.0/aSize.Width, 1.0/aSize.Height );
749 cairo_matrix_multiply( &aScaledTextureMatrix, &aTextureMatrix, &aScaleMatrix );
750 cairo_matrix_invert( &aScaledTextureMatrix );
751
752 // we don't care about repeat mode yet, so the workaround is disabled for now
753 pPattern = cairo_pattern_create_for_surface( pSurface->getCairoSurface().get() );
754
755 if( aTexture.RepeatModeX == rendering::TexturingMode::REPEAT &&
756 aTexture.RepeatModeY == rendering::TexturingMode::REPEAT )
757 cairo_pattern_set_extend( pPattern, CAIRO_EXTEND_REPEAT );
758 aScaledTextureMatrix.x0 = basegfx::fround( aScaledTextureMatrix.x0 );
759 aScaledTextureMatrix.y0 = basegfx::fround( aScaledTextureMatrix.y0 );
760 cairo_pattern_set_matrix( pPattern, &aScaledTextureMatrix );
761
762 cairo_set_source( pCairo, pPattern );
763 if( !bHasAlpha )
764 cairo_set_operator( pCairo, CAIRO_OPERATOR_SOURCE );
765 cairo_fill( pCairo );
766
767 cairo_restore( pCairo );
768
769 cairo_pattern_destroy( pPattern );
770 }
771
772 if( data )
773 free( data );
774 } else if( aTexture.Gradient.is() ) {
775 uno::Reference< lang::XServiceInfo > xRef( aTexture.Gradient, uno::UNO_QUERY );
776
777 OSL_TRACE( "gradient fill" );
778 if( xRef.is() &&
779 xRef->getImplementationName().equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( PARAMETRICPOLYPOLYGON_IMPLEMENTATION_NAME ) ) ) ) {
780 // TODO(Q1): Maybe use dynamic_cast here
781
782 // TODO(E1): Return value
783 // TODO(F1): FillRule
784 OSL_TRACE( "known implementation" );
785
786 ::canvas::ParametricPolyPolygon* pPolyImpl = static_cast< ::canvas::ParametricPolyPolygon* >( aTexture.Gradient.get() );
787 ::com::sun::star::geometry::AffineMatrix2D aTransform( aTexture.AffineTransform );
788 Matrix aTextureMatrix;
789
790 cairo_matrix_init( &aTextureMatrix,
791 aTransform.m00, aTransform.m10, aTransform.m01,
792 aTransform.m11, aTransform.m02, aTransform.m12);
793 Pattern* pPattern = patternFromParametricPolyPolygon( *pPolyImpl );
794
795 if( pPattern ) {
796 OSL_TRACE( "filling with pattern" );
797
798 cairo_save( pCairo );
799
800 cairo_transform( pCairo, &aTextureMatrix );
801 cairo_set_source( pCairo, pPattern );
802 cairo_fill( pCairo );
803 cairo_restore( pCairo );
804
805 cairo_pattern_destroy( pPattern );
806 }
807 }
808 }
809 } else
810 cairo_fill( pCairo );
811 OSL_TRACE("fill");
812 break;
813 case Stroke:
814 cairo_stroke( pCairo );
815 OSL_TRACE("stroke");
816 break;
817 case Clip:
818 cairo_clip( pCairo );
819 OSL_TRACE("clip");
820 break;
821 }
822 }
823
824 static void clipNULL( Cairo *pCairo )
825 {
826 OSL_TRACE("clipNULL");
827 Matrix aOrigMatrix, aIdentityMatrix;
828
829 /* we set identity matrix here to overcome bug in cairo 0.9.2
830 where XCreatePixmap is called with zero width and height.
831
832 it also reaches faster path in cairo clipping code.
833 */
834 cairo_matrix_init_identity( &aIdentityMatrix );
835 cairo_get_matrix( pCairo, &aOrigMatrix );
836 cairo_set_matrix( pCairo, &aIdentityMatrix );
837
838 cairo_reset_clip( pCairo );
839 cairo_rectangle( pCairo, 0, 0, 1, 1 );
840 cairo_clip( pCairo );
841 cairo_rectangle( pCairo, 2, 0, 1, 1 );
842 cairo_clip( pCairo );
843
844 /* restore the original matrix */
845 cairo_set_matrix( pCairo, &aOrigMatrix );
846 }
847
848 void doPolyPolygonImplementation( ::basegfx::B2DPolyPolygon aPolyPolygon,
849 Operation aOperation,
850 Cairo* pCairo,
851 const uno::Sequence< rendering::Texture >* pTextures,
852 const SurfaceProviderRef& pDevice,
853 rendering::FillRule eFillrule )
854 {
855 if( pTextures )
856 ENSURE_ARG_OR_THROW( pTextures->getLength(),
857 "CanvasHelper::fillTexturedPolyPolygon: empty texture sequence");
858
859 bool bOpToDo = false;
860 Matrix aOrigMatrix, aIdentityMatrix;
861 double nX, nY, nBX, nBY, nAX, nAY;
862
863 cairo_get_matrix( pCairo, &aOrigMatrix );
864 cairo_matrix_init_identity( &aIdentityMatrix );
865 cairo_set_matrix( pCairo, &aIdentityMatrix );
866
867 cairo_set_fill_rule( pCairo,
868 eFillrule == rendering::FillRule_EVEN_ODD ?
869 CAIRO_FILL_RULE_EVEN_ODD : CAIRO_FILL_RULE_WINDING );
870
871 for( sal_uInt32 nPolygonIndex = 0; nPolygonIndex < aPolyPolygon.count(); nPolygonIndex++ ) {
872 ::basegfx::B2DPolygon aPolygon( aPolyPolygon.getB2DPolygon( nPolygonIndex ) );
873 const sal_uInt32 nPointCount( aPolygon.count() );
874 // to correctly render closed curves, need to output first
875 // point twice (so output one additional point)
876 const sal_uInt32 nExtendedPointCount( nPointCount +
877 aPolygon.isClosed()*aPolygon.areControlPointsUsed() );
878
879 if( nPointCount > 1) {
880 bool bIsBezier = aPolygon.areControlPointsUsed();
881 bool bIsRectangle = ::basegfx::tools::isRectangle( aPolygon );
882 ::basegfx::B2DPoint aA, aB, aP;
883
884 for( sal_uInt32 j=0; j < nExtendedPointCount; j++ ) {
885 aP = aPolygon.getB2DPoint( j % nPointCount );
886
887 nX = aP.getX();
888 nY = aP.getY();
889 cairo_matrix_transform_point( &aOrigMatrix, &nX, &nY );
890
891 if( ! bIsBezier && (bIsRectangle || aOperation == Clip) ) {
892 nX = basegfx::fround( nX );
893 nY = basegfx::fround( nY );
894 }
895
896 if( aOperation == Stroke ) {
897 nX += 0.5;
898 nY += 0.5;
899 }
900
901 if( j==0 )
902 {
903 cairo_move_to( pCairo, nX, nY );
904 OSL_TRACE( "move to %f,%f", nX, nY );
905 }
906 else {
907 if( bIsBezier ) {
908 aA = aPolygon.getNextControlPoint( (j-1) % nPointCount );
909 aB = aPolygon.getPrevControlPoint( j % nPointCount );
910
911 nAX = aA.getX();
912 nAY = aA.getY();
913 nBX = aB.getX();
914 nBY = aB.getY();
915
916 if( aOperation == Stroke ) {
917 nAX += 0.5;
918 nAY += 0.5;
919 nBX += 0.5;
920 nBY += 0.5;
921 }
922 cairo_matrix_transform_point( &aOrigMatrix, &nAX, &nAY );
923 cairo_matrix_transform_point( &aOrigMatrix, &nBX, &nBY );
924 cairo_curve_to( pCairo, nAX, nAY, nBX, nBY, nX, nY );
925 } else {
926 cairo_line_to( pCairo, nX, nY );
927 OSL_TRACE( "line to %f,%f", nX, nY );
928 }
929 bOpToDo = true;
930 }
931 }
932
933 if( aPolygon.isClosed() )
934 cairo_close_path( pCairo );
935
936 if( aOperation == Fill && pTextures ) {
937 cairo_set_matrix( pCairo, &aOrigMatrix );
938 doOperation( aOperation, pCairo, pTextures, pDevice );
939 cairo_set_matrix( pCairo, &aIdentityMatrix );
940 }
941 } else {
942 OSL_TRACE( "empty polygon for op: %d\n", aOperation );
943 if( aOperation == Clip ) {
944 clipNULL( pCairo );
945
946 return;
947 }
948 }
949 }
950 if( bOpToDo && ( aOperation != Fill || !pTextures ) )
951 doOperation( aOperation, pCairo, pTextures, pDevice );
952
953 cairo_set_matrix( pCairo, &aOrigMatrix );
954
955 if( aPolyPolygon.count() == 0 && aOperation == Clip )
956 clipNULL( pCairo );
957 }
958
959 void CanvasHelper::doPolyPolygonPath( const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
960 Operation aOperation,
961 const uno::Sequence< rendering::Texture >* pTextures,
962 Cairo* pCairo ) const
963 {
964 const ::basegfx::B2DPolyPolygon& rPolyPoly(
965 ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(xPolyPolygon) );
966
967 if( !pCairo )
968 pCairo = mpCairo.get();
969
970 doPolyPolygonImplementation( rPolyPoly, aOperation,
971 pCairo, pTextures,
972 mpSurfaceProvider,
973 xPolyPolygon->getFillRule() );
974 }
975
976 uno::Reference< rendering::XCachedPrimitive > CanvasHelper::drawPolyPolygon( const rendering::XCanvas* ,
977 const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
978 const rendering::ViewState& viewState,
979 const rendering::RenderState& renderState )
980 {
981 #ifdef CAIRO_CANVAS_PERF_TRACE
982 struct timespec aTimer;
983 mxDevice->startPerfTrace( &aTimer );
984 #endif
985
986 if( mpCairo ) {
987 cairo_save( mpCairo.get() );
988
989 cairo_set_line_width( mpCairo.get(), 1 );
990
991 useStates( viewState, renderState, true );
992 doPolyPolygonPath( xPolyPolygon, Stroke );
993
994 cairo_restore( mpCairo.get() );
995 } else
996 OSL_TRACE ("CanvasHelper called after it was disposed");
997
998 #ifdef CAIRO_CANVAS_PERF_TRACE
999 mxDevice->stopPerfTrace( &aTimer, "drawPolyPolygon" );
1000 #endif
1001
1002 return uno::Reference< rendering::XCachedPrimitive >(NULL);
1003 }
1004
1005 uno::Reference< rendering::XCachedPrimitive > CanvasHelper::strokePolyPolygon( const rendering::XCanvas* ,
1006 const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
1007 const rendering::ViewState& viewState,
1008 const rendering::RenderState& renderState,
1009 const rendering::StrokeAttributes& strokeAttributes )
1010 {
1011 #ifdef CAIRO_CANVAS_PERF_TRACE
1012 struct timespec aTimer;
1013 mxDevice->startPerfTrace( &aTimer );
1014 #endif
1015
1016 if( mpCairo ) {
1017 cairo_save( mpCairo.get() );
1018
1019 useStates( viewState, renderState, true );
1020
1021 Matrix aMatrix;
1022 double w = strokeAttributes.StrokeWidth, h = 0;
1023 cairo_get_matrix( mpCairo.get(), &aMatrix );
1024 cairo_matrix_transform_distance( &aMatrix, &w, &h );
1025 cairo_set_line_width( mpCairo.get(), w );
1026
1027 cairo_set_miter_limit( mpCairo.get(), strokeAttributes.MiterLimit );
1028
1029 // FIXME: cairo doesn't handle end cap so far (rodo)
1030 switch( strokeAttributes.StartCapType ) {
1031 case rendering::PathCapType::BUTT:
1032 cairo_set_line_cap( mpCairo.get(), CAIRO_LINE_CAP_BUTT );
1033 break;
1034 case rendering::PathCapType::ROUND:
1035 cairo_set_line_cap( mpCairo.get(), CAIRO_LINE_CAP_ROUND );
1036 break;
1037 case rendering::PathCapType::SQUARE:
1038 cairo_set_line_cap( mpCairo.get(), CAIRO_LINE_CAP_SQUARE );
1039 break;
1040 }
1041
1042 switch( strokeAttributes.JoinType ) {
1043 // cairo doesn't have join type NONE so we use MITER as it's pretty close
1044 case rendering::PathJoinType::NONE:
1045 case rendering::PathJoinType::MITER:
1046 cairo_set_line_join( mpCairo.get(), CAIRO_LINE_JOIN_MITER );
1047 break;
1048 case rendering::PathJoinType::ROUND:
1049 cairo_set_line_join( mpCairo.get(), CAIRO_LINE_JOIN_ROUND );
1050 break;
1051 case rendering::PathJoinType::BEVEL:
1052 cairo_set_line_join( mpCairo.get(), CAIRO_LINE_JOIN_BEVEL );
1053 break;
1054 }
1055
1056 if( strokeAttributes.DashArray.getLength() > 0 ) {
1057 double* pDashArray = new double[ strokeAttributes.DashArray.getLength() ];
1058 for( sal_Int32 i=0; i<strokeAttributes.DashArray.getLength(); i++ )
1059 pDashArray[i]=strokeAttributes.DashArray[i];
1060 cairo_set_dash( mpCairo.get(), pDashArray, strokeAttributes.DashArray.getLength(), 0 );
1061 delete[] pDashArray;
1062 }
1063
1064 // TODO(rodo) use LineArray of strokeAttributes
1065
1066 doPolyPolygonPath( xPolyPolygon, Stroke );
1067
1068 cairo_restore( mpCairo.get() );
1069 } else
1070 OSL_TRACE ("CanvasHelper called after it was disposed");
1071
1072 #ifdef CAIRO_CANVAS_PERF_TRACE
1073 mxDevice->stopPerfTrace( &aTimer, "strokePolyPolygon" );
1074 #endif
1075
1076 // TODO(P1): Provide caching here.
1077 return uno::Reference< rendering::XCachedPrimitive >(NULL);
1078 }
1079
1080 uno::Reference< rendering::XCachedPrimitive > CanvasHelper::strokeTexturedPolyPolygon( const rendering::XCanvas* ,
1081 const uno::Reference< rendering::XPolyPolygon2D >& /*xPolyPolygon*/,
1082 const rendering::ViewState& /*viewState*/,
1083 const rendering::RenderState& /*renderState*/,
1084 const uno::Sequence< rendering::Texture >& /*textures*/,
1085 const rendering::StrokeAttributes& /*strokeAttributes*/ )
1086 {
1087 // TODO
1088 return uno::Reference< rendering::XCachedPrimitive >(NULL);
1089 }
1090
1091 uno::Reference< rendering::XCachedPrimitive > CanvasHelper::strokeTextureMappedPolyPolygon( const rendering::XCanvas* ,
1092 const uno::Reference< rendering::XPolyPolygon2D >& /*xPolyPolygon*/,
1093 const rendering::ViewState& /*viewState*/,
1094 const rendering::RenderState& /*renderState*/,
1095 const uno::Sequence< rendering::Texture >& /*textures*/,
1096 const uno::Reference< geometry::XMapping2D >& /*xMapping*/,
1097 const rendering::StrokeAttributes& /*strokeAttributes*/ )
1098 {
1099 // TODO
1100 return uno::Reference< rendering::XCachedPrimitive >(NULL);
1101 }
1102
1103 uno::Reference< rendering::XPolyPolygon2D > CanvasHelper::queryStrokeShapes( const rendering::XCanvas* ,
1104 const uno::Reference< rendering::XPolyPolygon2D >& /*xPolyPolygon*/,
1105 const rendering::ViewState& /*viewState*/,
1106 const rendering::RenderState& /*renderState*/,
1107 const rendering::StrokeAttributes& /*strokeAttributes*/ )
1108 {
1109 // TODO
1110 return uno::Reference< rendering::XPolyPolygon2D >(NULL);
1111 }
1112
1113 uno::Reference< rendering::XCachedPrimitive > CanvasHelper::fillPolyPolygon( const rendering::XCanvas* ,
1114 const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
1115 const rendering::ViewState& viewState,
1116 const rendering::RenderState& renderState )
1117 {
1118 #ifdef CAIRO_CANVAS_PERF_TRACE
1119 struct timespec aTimer;
1120 mxDevice->startPerfTrace( &aTimer );
1121 #endif
1122
1123 if( mpCairo ) {
1124 cairo_save( mpCairo.get() );
1125
1126 useStates( viewState, renderState, true );
1127 doPolyPolygonPath( xPolyPolygon, Fill );
1128
1129 cairo_restore( mpCairo.get() );
1130 } else
1131 OSL_TRACE ("CanvasHelper called after it was disposed");
1132
1133 #ifdef CAIRO_CANVAS_PERF_TRACE
1134 mxDevice->stopPerfTrace( &aTimer, "fillPolyPolygon" );
1135 #endif
1136
1137 return uno::Reference< rendering::XCachedPrimitive >(NULL);
1138 }
1139
1140 uno::Reference< rendering::XCachedPrimitive > CanvasHelper::fillTexturedPolyPolygon( const rendering::XCanvas* ,
1141 const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
1142 const rendering::ViewState& viewState,
1143 const rendering::RenderState& renderState,
1144 const uno::Sequence< rendering::Texture >& textures )
1145 {
1146 if( mpCairo ) {
1147 cairo_save( mpCairo.get() );
1148
1149 useStates( viewState, renderState, true );
1150 doPolyPolygonPath( xPolyPolygon, Fill, &textures );
1151
1152 cairo_restore( mpCairo.get() );
1153 }
1154
1155 return uno::Reference< rendering::XCachedPrimitive >(NULL);
1156 }
1157
1158 uno::Reference< rendering::XCachedPrimitive > CanvasHelper::fillTextureMappedPolyPolygon( const rendering::XCanvas* ,
1159 const uno::Reference< rendering::XPolyPolygon2D >& /*xPolyPolygon*/,
1160 const rendering::ViewState& /*viewState*/,
1161 const rendering::RenderState& /*renderState*/,
1162 const uno::Sequence< rendering::Texture >& /*textures*/,
1163 const uno::Reference< geometry::XMapping2D >& /*xMapping*/ )
1164 {
1165 // TODO
1166 return uno::Reference< rendering::XCachedPrimitive >(NULL);
1167 }
1168
1169 uno::Reference< rendering::XCachedPrimitive > CanvasHelper::implDrawBitmapSurface( const rendering::XCanvas* pCanvas,
1170 const SurfaceSharedPtr& pInputSurface,
1171 const rendering::ViewState& viewState,
1172 const rendering::RenderState& renderState,
1173 const geometry::IntegerSize2D& rSize,
1174 bool /*bModulateColors*/,
1175 bool bHasAlpha )
1176 {
1177 SurfaceSharedPtr pSurface=pInputSurface;
1178 uno::Reference< rendering::XCachedPrimitive > rv = uno::Reference< rendering::XCachedPrimitive >(NULL);
1179 geometry::IntegerSize2D aBitmapSize = rSize;
1180
1181 if( mpCairo ) {
1182 cairo_save( mpCairo.get() );
1183
1184 cairo_rectangle( mpCairo.get(), 0, 0, maSize.getX(), maSize.getY() );
1185 cairo_clip( mpCairo.get() );
1186
1187 useStates( viewState, renderState, true );
1188
1189 // if( !bHasAlpha )
1190 // cairo_set_operator( mpCairo.get(), CAIRO_OPERATOR_SOURCE );
1191
1192 Matrix aMatrix;
1193
1194 cairo_get_matrix( mpCairo.get(), &aMatrix );
1195 if( ! ::rtl::math::approxEqual( aMatrix.xx, 1 ) &&
1196 ! ::rtl::math::approxEqual( aMatrix.yy, 1 ) &&
1197 ::rtl::math::approxEqual( aMatrix.x0, 0 ) &&
1198 ::rtl::math::approxEqual( aMatrix.y0, 0 ) &&
1199 basegfx::fround( rSize.Width * aMatrix.xx ) > 8 &&
1200 basegfx::fround( rSize.Height* aMatrix.yy ) > 8 )
1201 {
1202 double dWidth, dHeight;
1203
1204 dWidth = basegfx::fround( rSize.Width * aMatrix.xx );
1205 dHeight = basegfx::fround( rSize.Height* aMatrix.yy );
1206 aBitmapSize.Width = static_cast<sal_Int32>( dWidth );
1207 aBitmapSize.Height = static_cast<sal_Int32>( dHeight );
1208
1209 SurfaceSharedPtr pScaledSurface = mpSurfaceProvider->createSurface(
1210 ::basegfx::B2ISize( aBitmapSize.Width, aBitmapSize.Height ),
1211 bHasAlpha ? CAIRO_CONTENT_COLOR_ALPHA : CAIRO_CONTENT_COLOR );
1212 CairoSharedPtr pCairo = pScaledSurface->getCairo();
1213
1214 cairo_set_operator( pCairo.get(), CAIRO_OPERATOR_SOURCE );
1215 // add 0.5px to size to avoid rounding errors in cairo, leading sometimes to random data on the image right/bottom borders
1216 cairo_scale( pCairo.get(), (dWidth+0.5)/rSize.Width, (dHeight+0.5)/rSize.Height );
1217 cairo_set_source_surface( pCairo.get(), pSurface->getCairoSurface().get(), 0, 0 );
1218 cairo_paint( pCairo.get() );
1219
1220 pSurface = pScaledSurface;
1221
1222 aMatrix.xx = aMatrix.yy = 1;
1223 cairo_set_matrix( mpCairo.get(), &aMatrix );
1224
1225 rv = uno::Reference< rendering::XCachedPrimitive >(
1226 new CachedBitmap( pSurface, viewState, renderState,
1227 // cast away const, need to
1228 // change refcount (as this is
1229 // ~invisible to client code,
1230 // still logically const)
1231 const_cast< rendering::XCanvas* >(pCanvas)) );
1232 }
1233
1234 if( !bHasAlpha && mbHaveAlpha )
1235 {
1236 double x, y, width, height;
1237
1238 x = y = 0;
1239 width = aBitmapSize.Width;
1240 height = aBitmapSize.Height;
1241 cairo_matrix_transform_point( &aMatrix, &x, &y );
1242 cairo_matrix_transform_distance( &aMatrix, &width, &height );
1243
1244 // in case the bitmap doesn't have alpha and covers whole area
1245 // we try to change surface to plain rgb
1246 OSL_TRACE ("chance to change surface to rgb, %f, %f, %f x %f (%d x %d)", x, y, width, height, maSize.getX(), maSize.getY() );
1247 if( x <= 0 && y <= 0 && x + width >= maSize.getX() && y + height >= maSize.getY() )
1248 {
1249 OSL_TRACE ("trying to change surface to rgb");
1250 if( mpSurfaceProvider ) {
1251 SurfaceSharedPtr pNewSurface = mpSurfaceProvider->changeSurface( false, false );
1252
1253 if( pNewSurface )
1254 setSurface( pNewSurface, false );
1255
1256 // set state to new mpCairo.get()
1257 useStates( viewState, renderState, true );
1258 // use the possibly modified matrix
1259 cairo_set_matrix( mpCairo.get(), &aMatrix );
1260 }
1261 }
1262 }
1263
1264 cairo_set_source_surface( mpCairo.get(), pSurface->getCairoSurface().get(), 0, 0 );
1265 if( !bHasAlpha &&
1266 ::rtl::math::approxEqual( aMatrix.xx, 1 ) &&
1267 ::rtl::math::approxEqual( aMatrix.yy, 1 ) &&
1268 ::rtl::math::approxEqual( aMatrix.x0, 0 ) &&
1269 ::rtl::math::approxEqual( aMatrix.y0, 0 ) )
1270 cairo_set_operator( mpCairo.get(), CAIRO_OPERATOR_SOURCE );
1271 cairo_rectangle( mpCairo.get(), 0, 0, aBitmapSize.Width, aBitmapSize.Height );
1272 cairo_clip( mpCairo.get() );
1273 cairo_paint( mpCairo.get() );
1274 cairo_restore( mpCairo.get() );
1275 } else
1276 OSL_TRACE ("CanvasHelper called after it was disposed");
1277
1278 return rv; // uno::Reference< rendering::XCachedPrimitive >(NULL);
1279 }
1280
1281 uno::Reference< rendering::XCachedPrimitive > CanvasHelper::drawBitmap( const rendering::XCanvas* pCanvas,
1282 const uno::Reference< rendering::XBitmap >& xBitmap,
1283 const rendering::ViewState& viewState,
1284 const rendering::RenderState& renderState )
1285 {
1286 #ifdef CAIRO_CANVAS_PERF_TRACE
1287 struct timespec aTimer;
1288 mxDevice->startPerfTrace( &aTimer );
1289 #endif
1290
1291 uno::Reference< rendering::XCachedPrimitive > rv;
1292 unsigned char* data = NULL;
1293 bool bHasAlpha = false;
1294 SurfaceSharedPtr pSurface = surfaceFromXBitmap( xBitmap, mpSurfaceProvider, data, bHasAlpha );
1295 geometry::IntegerSize2D aSize = xBitmap->getSize();
1296
1297 if( pSurface ) {
1298 rv = implDrawBitmapSurface( pCanvas, pSurface, viewState, renderState, aSize, false, bHasAlpha );
1299
1300 if( data )
1301 free( data );
1302 } else
1303 rv = uno::Reference< rendering::XCachedPrimitive >(NULL);
1304
1305 #ifdef CAIRO_CANVAS_PERF_TRACE
1306 mxDevice->stopPerfTrace( &aTimer, "drawBitmap" );
1307 #endif
1308
1309 return rv;
1310 }
1311
1312 uno::Reference< rendering::XCachedPrimitive > CanvasHelper::drawBitmapModulated( const rendering::XCanvas* ,
1313 const uno::Reference< rendering::XBitmap >& /*xBitmap*/,
1314 const rendering::ViewState& /*viewState*/,
1315 const rendering::RenderState& /*renderState*/ )
1316 {
1317 // TODO(F3): Implement modulated bitmap!
1318
1319 // TODO(P1): Provide caching here.
1320 return uno::Reference< rendering::XCachedPrimitive >(NULL);
1321 }
1322
1323 uno::Reference< rendering::XGraphicDevice > CanvasHelper::getDevice()
1324 {
1325 return uno::Reference< rendering::XGraphicDevice >(mpDevice);
1326 }
1327
1328 void CanvasHelper::copyRect( const rendering::XCanvas* ,
1329 const uno::Reference< rendering::XBitmapCanvas >& /*sourceCanvas*/,
1330 const geometry::RealRectangle2D& /*sourceRect*/,
1331 const rendering::ViewState& /*sourceViewState*/,
1332 const rendering::RenderState& /*sourceRenderState*/,
1333 const geometry::RealRectangle2D& /*destRect*/,
1334 const rendering::ViewState& /*destViewState*/,
1335 const rendering::RenderState& /*destRenderState*/ )
1336 {
1337 // TODO(F2): copyRect NYI
1338 }
1339
1340 geometry::IntegerSize2D CanvasHelper::getSize()
1341 {
1342 if( !mpSurfaceProvider )
1343 geometry::IntegerSize2D(1, 1); // we're disposed
1344
1345 return ::basegfx::unotools::integerSize2DFromB2ISize( maSize );
1346 }
1347
1348 uno::Reference< rendering::XBitmap > CanvasHelper::getScaledBitmap( const geometry::RealSize2D& newSize,
1349 sal_Bool /*beFast*/ )
1350 {
1351 #ifdef CAIRO_CANVAS_PERF_TRACE
1352 struct timespec aTimer;
1353 mxDevice->startPerfTrace( &aTimer );
1354 #endif
1355
1356 if( mpCairo ) {
1357 return uno::Reference< rendering::XBitmap >( new CanvasBitmap( ::basegfx::B2ISize( ::canvas::tools::roundUp( newSize.Width ),
1358 ::canvas::tools::roundUp( newSize.Height ) ),
1359 mpSurfaceProvider, mpDevice, false ) );
1360 } else
1361 OSL_TRACE ("CanvasHelper called after it was disposed");
1362
1363 #ifdef CAIRO_CANVAS_PERF_TRACE
1364 mxDevice->stopPerfTrace( &aTimer, "getScaledBitmap" );
1365 #endif
1366
1367 return uno::Reference< rendering::XBitmap >();
1368 }
1369
1370 uno::Sequence< sal_Int8 > CanvasHelper::getData( rendering::IntegerBitmapLayout& aLayout,
1371 const geometry::IntegerRectangle2D& rect )
1372 {
1373 if( mpCairo ) {
1374 aLayout = getMemoryLayout();
1375
1376 const sal_Int32 nWidth( rect.X2 - rect.X1 );
1377 const sal_Int32 nHeight( rect.Y2 - rect.Y1 );
1378 uno::Sequence< sal_Int8 > aRes( 4*nWidth*nHeight );
1379 sal_Int8* pData = aRes.getArray();
1380 cairo_surface_t* pImageSurface = cairo_image_surface_create_for_data( (unsigned char *) pData,
1381 CAIRO_FORMAT_ARGB32,
1382 nWidth, nHeight, 4*nWidth );
1383 cairo_t* pCairo = cairo_create( pImageSurface );
1384 cairo_set_source_surface( pCairo, mpSurface->getCairoSurface().get(), -rect.X1, -rect.Y1);
1385 cairo_paint( pCairo );
1386 cairo_destroy( pCairo );
1387 cairo_surface_destroy( pImageSurface );
1388
1389 aLayout.ScanLines = nHeight;
1390 aLayout.ScanLineBytes = nWidth*4;
1391 aLayout.ScanLineStride = aLayout.ScanLineBytes;
1392
1393 return aRes;
1394 }
1395
1396 return uno::Sequence< sal_Int8 >();
1397 }
1398
1399 void CanvasHelper::setData( const uno::Sequence< sal_Int8 >& /*data*/,
1400 const rendering::IntegerBitmapLayout& /*bitmapLayout*/,
1401 const geometry::IntegerRectangle2D& /*rect*/ )
1402 {
1403 }
1404
1405 void CanvasHelper::setPixel( const uno::Sequence< sal_Int8 >& /*color*/,
1406 const rendering::IntegerBitmapLayout& /*bitmapLayout*/,
1407 const geometry::IntegerPoint2D& /*pos*/ )
1408 {
1409 }
1410
1411 uno::Sequence< sal_Int8 > CanvasHelper::getPixel( rendering::IntegerBitmapLayout& /*bitmapLayout*/,
1412 const geometry::IntegerPoint2D& /*pos*/ )
1413 {
1414 return uno::Sequence< sal_Int8 >();
1415 }
1416
1417 uno::Reference< rendering::XBitmapPalette > CanvasHelper::getPalette()
1418 {
1419 // TODO(F1): Palette bitmaps NYI
1420 return uno::Reference< rendering::XBitmapPalette >();
1421 }
1422
1423 namespace
1424 {
1425 class CairoColorSpace : public cppu::WeakImplHelper1< com::sun::star::rendering::XIntegerBitmapColorSpace >
1426 {
1427 private:
1428 uno::Sequence< sal_Int8 > maComponentTags;
1429 uno::Sequence< sal_Int32 > maBitCounts;
1430
1431 virtual ::sal_Int8 SAL_CALL getType( ) throw (uno::RuntimeException)
1432 {
1433 return rendering::ColorSpaceType::RGB;
1434 }
1435 virtual uno::Sequence< ::sal_Int8 > SAL_CALL getComponentTags( ) throw (uno::RuntimeException)
1436 {
1437 return maComponentTags;
1438 }
1439 virtual ::sal_Int8 SAL_CALL getRenderingIntent( ) throw (uno::RuntimeException)
1440 {
1441 return rendering::RenderingIntent::PERCEPTUAL;
1442 }
1443 virtual uno::Sequence< beans::PropertyValue > SAL_CALL getProperties( ) throw (uno::RuntimeException)
1444 {
1445 return uno::Sequence< beans::PropertyValue >();
1446 }
1447 virtual uno::Sequence< double > SAL_CALL convertColorSpace( const uno::Sequence< double >& deviceColor,
1448 const uno::Reference< rendering::XColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,
1449 uno::RuntimeException)
1450 {
1451 // TODO(P3): if we know anything about target
1452 // colorspace, this can be greatly sped up
1453 uno::Sequence<rendering::ARGBColor> aIntermediate(
1454 convertToARGB(deviceColor));
1455 return targetColorSpace->convertFromARGB(aIntermediate);
1456 }
1457 virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1458 {
1459 const double* pIn( deviceColor.getConstArray() );
1460 const sal_Size nLen( deviceColor.getLength() );
1461 ENSURE_ARG_OR_THROW2(nLen%4==0,
1462 "number of channels no multiple of 4",
1463 static_cast<rendering::XColorSpace*>(this), 0);
1464
1465 uno::Sequence< rendering::RGBColor > aRes(nLen/4);
1466 rendering::RGBColor* pOut( aRes.getArray() );
1467 for( sal_Size i=0; i<nLen; i+=4 )
1468 {
1469 const double fAlpha(pIn[3]);
1470 if( fAlpha == 0.0 )
1471 *pOut++ = rendering::RGBColor(0.0, 0.0, 0.0);
1472 else
1473 *pOut++ = rendering::RGBColor(pIn[2]/fAlpha,pIn[1]/fAlpha,pIn[0]/fAlpha);
1474 pIn += 4;
1475 }
1476 return aRes;
1477 }
1478 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1479 {
1480 const double* pIn( deviceColor.getConstArray() );
1481 const sal_Size nLen( deviceColor.getLength() );
1482 ENSURE_ARG_OR_THROW2(nLen%4==0,
1483 "number of channels no multiple of 4",
1484 static_cast<rendering::XColorSpace*>(this), 0);
1485
1486 uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
1487 rendering::ARGBColor* pOut( aRes.getArray() );
1488 for( sal_Size i=0; i<nLen; i+=4 )
1489 {
1490 const double fAlpha(pIn[3]);
1491 if( fAlpha == 0.0 )
1492 *pOut++ = rendering::ARGBColor(0.0, 0.0, 0.0, 0.0);
1493 else
1494 *pOut++ = rendering::ARGBColor(fAlpha,pIn[2]/fAlpha,pIn[1]/fAlpha,pIn[0]/fAlpha);
1495 pIn += 4;
1496 }
1497 return aRes;
1498 }
1499 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1500 {
1501 const double* pIn( deviceColor.getConstArray() );
1502 const sal_Size nLen( deviceColor.getLength() );
1503 ENSURE_ARG_OR_THROW2(nLen%4==0,
1504 "number of channels no multiple of 4",
1505 static_cast<rendering::XColorSpace*>(this), 0);
1506
1507 uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
1508 rendering::ARGBColor* pOut( aRes.getArray() );
1509 for( sal_Size i=0; i<nLen; i+=4 )
1510 {
1511 *pOut++ = rendering::ARGBColor(pIn[3],pIn[2],pIn[1],pIn[1]);
1512 pIn += 4;
1513 }
1514 return aRes;
1515 }
1516 virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1517 {
1518 const rendering::RGBColor* pIn( rgbColor.getConstArray() );
1519 const sal_Size nLen( rgbColor.getLength() );
1520
1521 uno::Sequence< double > aRes(nLen*4);
1522 double* pColors=aRes.getArray();
1523 for( sal_Size i=0; i<nLen; ++i )
1524 {
1525 *pColors++ = pIn->Blue;
1526 *pColors++ = pIn->Green;
1527 *pColors++ = pIn->Red;
1528 *pColors++ = 1.0;
1529 ++pIn;
1530 }
1531 return aRes;
1532 }
1533 virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1534 {
1535 const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
1536 const sal_Size nLen( rgbColor.getLength() );
1537
1538 uno::Sequence< double > aRes(nLen*4);
1539 double* pColors=aRes.getArray();
1540 for( sal_Size i=0; i<nLen; ++i )
1541 {
1542 *pColors++ = pIn->Alpha*pIn->Blue;
1543 *pColors++ = pIn->Alpha*pIn->Green;
1544 *pColors++ = pIn->Alpha*pIn->Red;
1545 *pColors++ = pIn->Alpha;
1546 ++pIn;
1547 }
1548 return aRes;
1549 }
1550 virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1551 {
1552 const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
1553 const sal_Size nLen( rgbColor.getLength() );
1554
1555 uno::Sequence< double > aRes(nLen*4);
1556 double* pColors=aRes.getArray();
1557 for( sal_Size i=0; i<nLen; ++i )
1558 {
1559 *pColors++ = pIn->Blue;
1560 *pColors++ = pIn->Green;
1561 *pColors++ = pIn->Red;
1562 *pColors++ = pIn->Alpha;
1563 ++pIn;
1564 }
1565 return aRes;
1566 }
1567
1568 // XIntegerBitmapColorSpace
1569 virtual ::sal_Int32 SAL_CALL getBitsPerPixel( ) throw (uno::RuntimeException)
1570 {
1571 return 32;
1572 }
1573 virtual uno::Sequence< ::sal_Int32 > SAL_CALL getComponentBitCounts( ) throw (uno::RuntimeException)
1574 {
1575 return maBitCounts;
1576 }
1577 virtual ::sal_Int8 SAL_CALL getEndianness( ) throw (uno::RuntimeException)
1578 {
1579 return util::Endianness::LITTLE;
1580 }
1581 virtual uno::Sequence<double> SAL_CALL convertFromIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& deviceColor,
1582 const uno::Reference< rendering::XColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,
1583 uno::RuntimeException)
1584 {
1585 if( dynamic_cast<CairoColorSpace*>(targetColorSpace.get()) )
1586 {
1587 const sal_Int8* pIn( deviceColor.getConstArray() );
1588 const sal_Size nLen( deviceColor.getLength() );
1589 ENSURE_ARG_OR_THROW2(nLen%4==0,
1590 "number of channels no multiple of 4",
1591 static_cast<rendering::XColorSpace*>(this), 0);
1592
1593 uno::Sequence<double> aRes(nLen);
1594 double* pOut( aRes.getArray() );
1595 for( sal_Size i=0; i<nLen; i+=4 )
1596 {
1597 *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
1598 *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
1599 *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
1600 *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
1601 }
1602 return aRes;
1603 }
1604 else
1605 {
1606 // TODO(P3): if we know anything about target
1607 // colorspace, this can be greatly sped up
1608 uno::Sequence<rendering::ARGBColor> aIntermediate(
1609 convertIntegerToARGB(deviceColor));
1610 return targetColorSpace->convertFromARGB(aIntermediate);
1611 }
1612 }
1613 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertToIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& deviceColor,
1614 const uno::Reference< rendering::XIntegerBitmapColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,
1615 uno::RuntimeException)
1616 {
1617 if( dynamic_cast<CairoColorSpace*>(targetColorSpace.get()) )
1618 {
1619 // it's us, so simply pass-through the data
1620 return deviceColor;
1621 }
1622 else
1623 {
1624 // TODO(P3): if we know anything about target
1625 // colorspace, this can be greatly sped up
1626 uno::Sequence<rendering::ARGBColor> aIntermediate(
1627 convertIntegerToARGB(deviceColor));
1628 return targetColorSpace->convertIntegerFromARGB(aIntermediate);
1629 }
1630 }
1631 virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertIntegerToRGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1632 {
1633 const sal_Int8* pIn( deviceColor.getConstArray() );
1634 const sal_Size nLen( deviceColor.getLength() );
1635 ENSURE_ARG_OR_THROW2(nLen%4==0,
1636 "number of channels no multiple of 4",
1637 static_cast<rendering::XColorSpace*>(this), 0);
1638
1639 uno::Sequence< rendering::RGBColor > aRes(nLen/4);
1640 rendering::RGBColor* pOut( aRes.getArray() );
1641 for( sal_Size i=0; i<nLen; i+=4 )
1642 {
1643 const double fAlpha((sal_uInt8)pIn[3]);
1644 if( fAlpha )
1645 *pOut++ = rendering::RGBColor(
1646 pIn[2]/fAlpha,
1647 pIn[1]/fAlpha,
1648 pIn[0]/fAlpha);
1649 else
1650 *pOut++ = rendering::RGBColor(0,0,0);
1651 pIn += 4;
1652 }
1653 return aRes;
1654 }
1655
1656 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1657 {
1658 const sal_Int8* pIn( deviceColor.getConstArray() );
1659 const sal_Size nLen( deviceColor.getLength() );
1660 ENSURE_ARG_OR_THROW2(nLen%4==0,
1661 "number of channels no multiple of 4",
1662 static_cast<rendering::XColorSpace*>(this), 0);
1663
1664 uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
1665 rendering::ARGBColor* pOut( aRes.getArray() );
1666 for( sal_Size i=0; i<nLen; i+=4 )
1667 {
1668 const double fAlpha((sal_uInt8)pIn[3]);
1669 if( fAlpha )
1670 *pOut++ = rendering::ARGBColor(
1671 fAlpha/255.0,
1672 pIn[2]/fAlpha,
1673 pIn[1]/fAlpha,
1674 pIn[0]/fAlpha);
1675 else
1676 *pOut++ = rendering::ARGBColor(0,0,0,0);
1677 pIn += 4;
1678 }
1679 return aRes;
1680 }
1681 virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToPARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1682 {
1683 const sal_Int8* pIn( deviceColor.getConstArray() );
1684 const sal_Size nLen( deviceColor.getLength() );
1685 ENSURE_ARG_OR_THROW2(nLen%4==0,
1686 "number of channels no multiple of 4",
1687 static_cast<rendering::XColorSpace*>(this), 0);
1688
1689 uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
1690 rendering::ARGBColor* pOut( aRes.getArray() );
1691 for( sal_Size i=0; i<nLen; i+=4 )
1692 {
1693 *pOut++ = rendering::ARGBColor(
1694 vcl::unotools::toDoubleColor(pIn[3]),
1695 vcl::unotools::toDoubleColor(pIn[2]),
1696 vcl::unotools::toDoubleColor(pIn[1]),
1697 vcl::unotools::toDoubleColor(pIn[0]));
1698 pIn += 4;
1699 }
1700 return aRes;
1701 }
1702
1703 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1704 {
1705 const rendering::RGBColor* pIn( rgbColor.getConstArray() );
1706 const sal_Size nLen( rgbColor.getLength() );
1707
1708 uno::Sequence< sal_Int8 > aRes(nLen*4);
1709 sal_Int8* pColors=aRes.getArray();
1710 for( sal_Size i=0; i<nLen; ++i )
1711 {
1712 *pColors++ = vcl::unotools::toByteColor(pIn->Blue);
1713 *pColors++ = vcl::unotools::toByteColor(pIn->Green);
1714 *pColors++ = vcl::unotools::toByteColor(pIn->Red);
1715 *pColors++ = 255;
1716 ++pIn;
1717 }
1718 return aRes;
1719 }
1720
1721 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1722 {
1723 const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
1724 const sal_Size nLen( rgbColor.getLength() );
1725
1726 uno::Sequence< sal_Int8 > aRes(nLen*4);
1727 sal_Int8* pColors=aRes.getArray();
1728 for( sal_Size i=0; i<nLen; ++i )
1729 {
1730 const double fAlpha(pIn->Alpha);
1731 *pColors++ = vcl::unotools::toByteColor(fAlpha*pIn->Blue);
1732 *pColors++ = vcl::unotools::toByteColor(fAlpha*pIn->Green);
1733 *pColors++ = vcl::unotools::toByteColor(fAlpha*pIn->Red);
1734 *pColors++ = vcl::unotools::toByteColor(fAlpha);
1735 ++pIn;
1736 }
1737 return aRes;
1738 }
1739 virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1740 {
1741 const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
1742 const sal_Size nLen( rgbColor.getLength() );
1743
1744 uno::Sequence< sal_Int8 > aRes(nLen*4);
1745 sal_Int8* pColors=aRes.getArray();
1746 for( sal_Size i=0; i<nLen; ++i )
1747 {
1748 *pColors++ = vcl::unotools::toByteColor(pIn->Blue);
1749 *pColors++ = vcl::unotools::toByteColor(pIn->Green);
1750 *pColors++ = vcl::unotools::toByteColor(pIn->Red);
1751 *pColors++ = vcl::unotools::toByteColor(pIn->Alpha);
1752 ++pIn;
1753 }
1754 return aRes;
1755 }
1756
1757 public:
1758 CairoColorSpace() :
1759 maComponentTags(4),
1760 maBitCounts(4)
1761 {
1762 sal_Int8* pTags = maComponentTags.getArray();
1763 sal_Int32* pBitCounts = maBitCounts.getArray();
1764 pTags[0] = rendering::ColorComponentTag::RGB_BLUE;
1765 pTags[1] = rendering::ColorComponentTag::RGB_GREEN;
1766 pTags[2] = rendering::ColorComponentTag::RGB_RED;
1767 pTags[3] = rendering::ColorComponentTag::PREMULTIPLIED_ALPHA;
1768
1769 pBitCounts[0] =
1770 pBitCounts[1] =
1771 pBitCounts[2] =
1772 pBitCounts[3] = 8;
1773 }
1774 };
1775
1776 struct CairoColorSpaceHolder : public rtl::StaticWithInit<uno::Reference<rendering::XIntegerBitmapColorSpace>,
1777 CairoColorSpaceHolder>
1778 {
1779 uno::Reference<rendering::XIntegerBitmapColorSpace> operator()()
1780 {
1781 return new CairoColorSpace();
1782 }
1783 };
1784 }
1785
1786 rendering::IntegerBitmapLayout CanvasHelper::getMemoryLayout()
1787 {
1788 if( !mpCairo )
1789 return rendering::IntegerBitmapLayout(); // we're disposed
1790
1791 const geometry::IntegerSize2D aSize(getSize());
1792 rendering::IntegerBitmapLayout aLayout;
1793
1794 aLayout.ScanLines = aSize.Height;
1795 aLayout.ScanLineBytes = aSize.Width*4;
1796 aLayout.ScanLineStride = aLayout.ScanLineBytes;
1797 aLayout.PlaneStride = 0;
1798 aLayout.ColorSpace = CairoColorSpaceHolder::get();
1799 aLayout.Palette.clear();
1800 aLayout.IsMsbFirst = sal_False;
1801
1802 return aLayout;
1803 }
1804
1805 void CanvasHelper::flush() const
1806 {
1807 }
1808
1809 bool CanvasHelper::hasAlpha() const
1810 {
1811 return mbHaveAlpha;
1812 }
1813
1814 bool CanvasHelper::repaint( const SurfaceSharedPtr& pSurface,
1815 const rendering::ViewState& viewState,
1816 const rendering::RenderState& renderState )
1817 {
1818 OSL_TRACE("CanvasHelper::repaint");
1819
1820 if( mpCairo ) {
1821 cairo_save( mpCairo.get() );
1822
1823 cairo_rectangle( mpCairo.get(), 0, 0, maSize.getX(), maSize.getY() );
1824 cairo_clip( mpCairo.get() );
1825
1826 useStates( viewState, renderState, true );
1827
1828 Matrix aMatrix;
1829
1830 cairo_get_matrix( mpCairo.get(), &aMatrix );
1831 aMatrix.xx = aMatrix.yy = 1;
1832 cairo_set_matrix( mpCairo.get(), &aMatrix );
1833
1834 // if( !bHasAlpha )
1835 // cairo_set_operator( mpCairo.get(), CAIRO_OPERATOR_SOURCE );
1836
1837 cairo_set_source_surface( mpCairo.get(), pSurface->getCairoSurface().get(), 0, 0 );
1838 cairo_paint( mpCairo.get() );
1839 cairo_restore( mpCairo.get() );
1840 }
1841
1842 return true;
1843 }
1844 }
vba interoperability for OOo