Line data Source code
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 : #include <canvas/debug.hxx>
22 : #include <tools/diagnose_ex.h>
23 :
24 : #include <com/sun/star/geometry/AffineMatrix2D.hpp>
25 : #include <com/sun/star/geometry/Matrix2D.hpp>
26 : #include <com/sun/star/awt/Rectangle.hpp>
27 : #include <com/sun/star/util/Endianness.hpp>
28 : #include <com/sun/star/rendering/XIntegerBitmapColorSpace.hpp>
29 : #include <com/sun/star/rendering/IntegerBitmapLayout.hpp>
30 : #include <com/sun/star/rendering/ColorSpaceType.hpp>
31 : #include <com/sun/star/rendering/ColorComponentTag.hpp>
32 : #include <com/sun/star/rendering/RenderingIntent.hpp>
33 : #include <com/sun/star/rendering/RenderState.hpp>
34 : #include <com/sun/star/rendering/ViewState.hpp>
35 : #include <com/sun/star/rendering/XCanvas.hpp>
36 : #include <com/sun/star/rendering/XColorSpace.hpp>
37 : #include <com/sun/star/rendering/CompositeOperation.hpp>
38 : #include <com/sun/star/beans/XPropertySet.hpp>
39 : #include <com/sun/star/lang/XServiceInfo.hpp>
40 :
41 : #include <basegfx/matrix/b2dhommatrix.hxx>
42 : #include <basegfx/range/b2drange.hxx>
43 : #include <basegfx/range/b2irange.hxx>
44 : #include <basegfx/range/b2drectangle.hxx>
45 : #include <basegfx/point/b2dpoint.hxx>
46 : #include <basegfx/point/b2ipoint.hxx>
47 : #include <basegfx/vector/b2ivector.hxx>
48 : #include <basegfx/polygon/b2dpolygon.hxx>
49 : #include <basegfx/polygon/b2dpolygontools.hxx>
50 : #include <basegfx/polygon/b2dpolypolygontools.hxx>
51 : #include <basegfx/tools/canvastools.hxx>
52 : #include <basegfx/numeric/ftools.hxx>
53 : #include <basegfx/matrix/b2dhommatrixtools.hxx>
54 :
55 : #include <cppuhelper/compbase1.hxx>
56 : #include <rtl/instance.hxx>
57 : #include <toolkit/helper/vclunohelper.hxx>
58 : #include <vcl/window.hxx>
59 : #include <vcl/canvastools.hxx>
60 :
61 : #include <canvas/canvastools.hxx>
62 :
63 : #include <limits>
64 :
65 :
66 : using namespace ::com::sun::star;
67 :
68 : namespace com { namespace sun { namespace star { namespace rendering
69 : {
70 0 : bool operator==( const RenderState& renderState1,
71 : const RenderState& renderState2 )
72 : {
73 0 : if( renderState1.Clip != renderState2.Clip )
74 0 : return false;
75 :
76 0 : if( renderState1.DeviceColor != renderState2.DeviceColor )
77 0 : return false;
78 :
79 0 : if( renderState1.CompositeOperation != renderState2.CompositeOperation )
80 0 : return false;
81 :
82 0 : ::basegfx::B2DHomMatrix mat1, mat2;
83 0 : ::canvas::tools::getRenderStateTransform( mat1, renderState1 );
84 0 : ::canvas::tools::getRenderStateTransform( mat2, renderState2 );
85 0 : if( mat1 != mat2 )
86 0 : return false;
87 :
88 0 : return true;
89 : }
90 :
91 0 : bool operator==( const ViewState& viewState1,
92 : const ViewState& viewState2 )
93 : {
94 0 : if( viewState1.Clip != viewState2.Clip )
95 0 : return false;
96 :
97 0 : ::basegfx::B2DHomMatrix mat1, mat2;
98 0 : ::canvas::tools::getViewStateTransform( mat1, viewState1 );
99 0 : ::canvas::tools::getViewStateTransform( mat2, viewState2 );
100 0 : if( mat1 != mat2 )
101 0 : return false;
102 :
103 0 : return true;
104 : }
105 : }}}}
106 :
107 : namespace canvas
108 : {
109 : namespace tools
110 : {
111 0 : geometry::RealSize2D createInfiniteSize2D()
112 : {
113 : return geometry::RealSize2D(
114 0 : ::std::numeric_limits<double>::infinity(),
115 0 : ::std::numeric_limits<double>::infinity() );
116 : }
117 :
118 0 : rendering::RenderState& initRenderState( rendering::RenderState& renderState )
119 : {
120 : // setup identity transform
121 0 : setIdentityAffineMatrix2D( renderState.AffineTransform );
122 0 : renderState.Clip = uno::Reference< rendering::XPolyPolygon2D >();
123 0 : renderState.DeviceColor = uno::Sequence< double >();
124 0 : renderState.CompositeOperation = rendering::CompositeOperation::OVER;
125 :
126 0 : return renderState;
127 : }
128 :
129 0 : rendering::ViewState& initViewState( rendering::ViewState& viewState )
130 : {
131 : // setup identity transform
132 0 : setIdentityAffineMatrix2D( viewState.AffineTransform );
133 0 : viewState.Clip = uno::Reference< rendering::XPolyPolygon2D >();
134 :
135 0 : return viewState;
136 : }
137 :
138 0 : ::basegfx::B2DHomMatrix& getViewStateTransform( ::basegfx::B2DHomMatrix& transform,
139 : const rendering::ViewState& viewState )
140 : {
141 0 : return ::basegfx::unotools::homMatrixFromAffineMatrix( transform, viewState.AffineTransform );
142 : }
143 :
144 0 : rendering::ViewState& setViewStateTransform( rendering::ViewState& viewState,
145 : const ::basegfx::B2DHomMatrix& transform )
146 : {
147 0 : ::basegfx::unotools::affineMatrixFromHomMatrix( viewState.AffineTransform, transform );
148 :
149 0 : return viewState;
150 : }
151 :
152 0 : ::basegfx::B2DHomMatrix& getRenderStateTransform( ::basegfx::B2DHomMatrix& transform,
153 : const rendering::RenderState& renderState )
154 : {
155 0 : return ::basegfx::unotools::homMatrixFromAffineMatrix( transform, renderState.AffineTransform );
156 : }
157 :
158 0 : rendering::RenderState& setRenderStateTransform( rendering::RenderState& renderState,
159 : const ::basegfx::B2DHomMatrix& transform )
160 : {
161 0 : ::basegfx::unotools::affineMatrixFromHomMatrix( renderState.AffineTransform, transform );
162 :
163 0 : return renderState;
164 : }
165 :
166 0 : rendering::RenderState& appendToRenderState( rendering::RenderState& renderState,
167 : const ::basegfx::B2DHomMatrix& rTransform )
168 : {
169 0 : ::basegfx::B2DHomMatrix transform;
170 :
171 0 : getRenderStateTransform( transform, renderState );
172 0 : return setRenderStateTransform( renderState, transform * rTransform );
173 : }
174 :
175 0 : rendering::RenderState& prependToRenderState( rendering::RenderState& renderState,
176 : const ::basegfx::B2DHomMatrix& rTransform )
177 : {
178 0 : ::basegfx::B2DHomMatrix transform;
179 :
180 0 : getRenderStateTransform( transform, renderState );
181 0 : return setRenderStateTransform( renderState, rTransform * transform );
182 : }
183 :
184 0 : ::basegfx::B2DHomMatrix& mergeViewAndRenderTransform( ::basegfx::B2DHomMatrix& combinedTransform,
185 : const rendering::ViewState& viewState,
186 : const rendering::RenderState& renderState )
187 : {
188 0 : ::basegfx::B2DHomMatrix viewTransform;
189 :
190 0 : ::basegfx::unotools::homMatrixFromAffineMatrix( combinedTransform, renderState.AffineTransform );
191 0 : ::basegfx::unotools::homMatrixFromAffineMatrix( viewTransform, viewState.AffineTransform );
192 :
193 : // this statement performs combinedTransform = viewTransform * combinedTransform
194 0 : combinedTransform *= viewTransform;
195 :
196 0 : return combinedTransform;
197 : }
198 :
199 0 : geometry::AffineMatrix2D& setIdentityAffineMatrix2D( geometry::AffineMatrix2D& matrix )
200 : {
201 0 : matrix.m00 = 1.0;
202 0 : matrix.m01 = 0.0;
203 0 : matrix.m02 = 0.0;
204 0 : matrix.m10 = 0.0;
205 0 : matrix.m11 = 1.0;
206 0 : matrix.m12 = 0.0;
207 :
208 0 : return matrix;
209 : }
210 :
211 0 : geometry::Matrix2D& setIdentityMatrix2D( geometry::Matrix2D& matrix )
212 : {
213 0 : matrix.m00 = 1.0;
214 0 : matrix.m01 = 0.0;
215 0 : matrix.m10 = 0.0;
216 0 : matrix.m11 = 1.0;
217 :
218 0 : return matrix;
219 : }
220 :
221 : namespace
222 : {
223 0 : class StandardColorSpace : public cppu::WeakImplHelper1< com::sun::star::rendering::XIntegerBitmapColorSpace >
224 : {
225 : private:
226 : uno::Sequence< sal_Int8 > maComponentTags;
227 : uno::Sequence< sal_Int32 > maBitCounts;
228 :
229 0 : virtual ::sal_Int8 SAL_CALL getType( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
230 : {
231 0 : return rendering::ColorSpaceType::RGB;
232 : }
233 0 : virtual uno::Sequence< ::sal_Int8 > SAL_CALL getComponentTags( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
234 : {
235 0 : return maComponentTags;
236 : }
237 0 : virtual ::sal_Int8 SAL_CALL getRenderingIntent( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
238 : {
239 0 : return rendering::RenderingIntent::PERCEPTUAL;
240 : }
241 0 : virtual uno::Sequence< beans::PropertyValue > SAL_CALL getProperties( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
242 : {
243 0 : return uno::Sequence< beans::PropertyValue >();
244 : }
245 0 : virtual uno::Sequence< double > SAL_CALL convertColorSpace( const uno::Sequence< double >& deviceColor,
246 : const uno::Reference< rendering::XColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,
247 : uno::RuntimeException, std::exception) SAL_OVERRIDE
248 : {
249 : // TODO(P3): if we know anything about target
250 : // colorspace, this can be greatly sped up
251 : uno::Sequence<rendering::ARGBColor> aIntermediate(
252 0 : convertToARGB(deviceColor));
253 0 : return targetColorSpace->convertFromARGB(aIntermediate);
254 : }
255 0 : virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
256 : {
257 0 : const double* pIn( deviceColor.getConstArray() );
258 0 : const sal_Size nLen( deviceColor.getLength() );
259 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
260 : "number of channels no multiple of 4",
261 : static_cast<rendering::XColorSpace*>(this), 0);
262 :
263 0 : uno::Sequence< rendering::RGBColor > aRes(nLen/4);
264 0 : rendering::RGBColor* pOut( aRes.getArray() );
265 0 : for( sal_Size i=0; i<nLen; i+=4 )
266 : {
267 0 : *pOut++ = rendering::RGBColor(pIn[0],pIn[1],pIn[2]);
268 0 : pIn += 4;
269 : }
270 0 : return aRes;
271 : }
272 0 : virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
273 : {
274 0 : const double* pIn( deviceColor.getConstArray() );
275 0 : const sal_Size nLen( deviceColor.getLength() );
276 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
277 : "number of channels no multiple of 4",
278 : static_cast<rendering::XColorSpace*>(this), 0);
279 :
280 0 : uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
281 0 : rendering::ARGBColor* pOut( aRes.getArray() );
282 0 : for( sal_Size i=0; i<nLen; i+=4 )
283 : {
284 0 : *pOut++ = rendering::ARGBColor(pIn[3],pIn[0],pIn[1],pIn[2]);
285 0 : pIn += 4;
286 : }
287 0 : return aRes;
288 : }
289 0 : virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
290 : {
291 0 : const double* pIn( deviceColor.getConstArray() );
292 0 : const sal_Size nLen( deviceColor.getLength() );
293 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
294 : "number of channels no multiple of 4",
295 : static_cast<rendering::XColorSpace*>(this), 0);
296 :
297 0 : uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
298 0 : rendering::ARGBColor* pOut( aRes.getArray() );
299 0 : for( sal_Size i=0; i<nLen; i+=4 )
300 : {
301 0 : *pOut++ = rendering::ARGBColor(pIn[3],pIn[3]*pIn[0],pIn[3]*pIn[1],pIn[3]*pIn[2]);
302 0 : pIn += 4;
303 : }
304 0 : return aRes;
305 : }
306 0 : virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
307 : {
308 0 : const rendering::RGBColor* pIn( rgbColor.getConstArray() );
309 0 : const sal_Size nLen( rgbColor.getLength() );
310 :
311 0 : uno::Sequence< double > aRes(nLen*4);
312 0 : double* pColors=aRes.getArray();
313 0 : for( sal_Size i=0; i<nLen; ++i )
314 : {
315 0 : *pColors++ = pIn->Red;
316 0 : *pColors++ = pIn->Green;
317 0 : *pColors++ = pIn->Blue;
318 0 : *pColors++ = 1.0;
319 0 : ++pIn;
320 : }
321 0 : return aRes;
322 : }
323 0 : virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
324 : {
325 0 : const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
326 0 : const sal_Size nLen( rgbColor.getLength() );
327 :
328 0 : uno::Sequence< double > aRes(nLen*4);
329 0 : double* pColors=aRes.getArray();
330 0 : for( sal_Size i=0; i<nLen; ++i )
331 : {
332 0 : *pColors++ = pIn->Red;
333 0 : *pColors++ = pIn->Green;
334 0 : *pColors++ = pIn->Blue;
335 0 : *pColors++ = pIn->Alpha;
336 0 : ++pIn;
337 : }
338 0 : return aRes;
339 : }
340 0 : virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
341 : {
342 0 : const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
343 0 : const sal_Size nLen( rgbColor.getLength() );
344 :
345 0 : uno::Sequence< double > aRes(nLen*4);
346 0 : double* pColors=aRes.getArray();
347 0 : for( sal_Size i=0; i<nLen; ++i )
348 : {
349 0 : *pColors++ = pIn->Red/pIn->Alpha;
350 0 : *pColors++ = pIn->Green/pIn->Alpha;
351 0 : *pColors++ = pIn->Blue/pIn->Alpha;
352 0 : *pColors++ = pIn->Alpha;
353 0 : ++pIn;
354 : }
355 0 : return aRes;
356 : }
357 :
358 : // XIntegerBitmapColorSpace
359 0 : virtual ::sal_Int32 SAL_CALL getBitsPerPixel( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
360 : {
361 0 : return 32;
362 : }
363 0 : virtual uno::Sequence< ::sal_Int32 > SAL_CALL getComponentBitCounts( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
364 : {
365 0 : return maBitCounts;
366 : }
367 0 : virtual ::sal_Int8 SAL_CALL getEndianness( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
368 : {
369 0 : return util::Endianness::LITTLE;
370 : }
371 0 : virtual uno::Sequence<double> SAL_CALL convertFromIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& deviceColor,
372 : const uno::Reference< rendering::XColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,
373 : uno::RuntimeException, std::exception) SAL_OVERRIDE
374 : {
375 0 : if( dynamic_cast<StandardColorSpace*>(targetColorSpace.get()) )
376 : {
377 0 : const sal_Int8* pIn( deviceColor.getConstArray() );
378 0 : const sal_Size nLen( deviceColor.getLength() );
379 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
380 : "number of channels no multiple of 4",
381 : static_cast<rendering::XColorSpace*>(this), 0);
382 :
383 0 : uno::Sequence<double> aRes(nLen);
384 0 : double* pOut( aRes.getArray() );
385 0 : for( sal_Size i=0; i<nLen; i+=4 )
386 : {
387 0 : *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
388 0 : *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
389 0 : *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
390 0 : *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
391 : }
392 0 : return aRes;
393 : }
394 : else
395 : {
396 : // TODO(P3): if we know anything about target
397 : // colorspace, this can be greatly sped up
398 : uno::Sequence<rendering::ARGBColor> aIntermediate(
399 0 : convertIntegerToARGB(deviceColor));
400 0 : return targetColorSpace->convertFromARGB(aIntermediate);
401 : }
402 : }
403 0 : virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertToIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& deviceColor,
404 : const uno::Reference< rendering::XIntegerBitmapColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,
405 : uno::RuntimeException, std::exception) SAL_OVERRIDE
406 : {
407 0 : if( dynamic_cast<StandardColorSpace*>(targetColorSpace.get()) )
408 : {
409 : // it's us, so simply pass-through the data
410 0 : return deviceColor;
411 : }
412 : else
413 : {
414 : // TODO(P3): if we know anything about target
415 : // colorspace, this can be greatly sped up
416 : uno::Sequence<rendering::ARGBColor> aIntermediate(
417 0 : convertIntegerToARGB(deviceColor));
418 0 : return targetColorSpace->convertIntegerFromARGB(aIntermediate);
419 : }
420 : }
421 0 : virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertIntegerToRGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
422 : {
423 0 : const sal_Int8* pIn( deviceColor.getConstArray() );
424 0 : const sal_Size nLen( deviceColor.getLength() );
425 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
426 : "number of channels no multiple of 4",
427 : static_cast<rendering::XColorSpace*>(this), 0);
428 :
429 0 : uno::Sequence< rendering::RGBColor > aRes(nLen/4);
430 0 : rendering::RGBColor* pOut( aRes.getArray() );
431 0 : for( sal_Size i=0; i<nLen; i+=4 )
432 : {
433 : *pOut++ = rendering::RGBColor(
434 0 : vcl::unotools::toDoubleColor(pIn[0]),
435 0 : vcl::unotools::toDoubleColor(pIn[1]),
436 0 : vcl::unotools::toDoubleColor(pIn[2]));
437 0 : pIn += 4;
438 : }
439 0 : return aRes;
440 : }
441 :
442 0 : virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
443 : {
444 0 : const sal_Int8* pIn( deviceColor.getConstArray() );
445 0 : const sal_Size nLen( deviceColor.getLength() );
446 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
447 : "number of channels no multiple of 4",
448 : static_cast<rendering::XColorSpace*>(this), 0);
449 :
450 0 : uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
451 0 : rendering::ARGBColor* pOut( aRes.getArray() );
452 0 : for( sal_Size i=0; i<nLen; i+=4 )
453 : {
454 : *pOut++ = rendering::ARGBColor(
455 0 : vcl::unotools::toDoubleColor(pIn[3]),
456 0 : vcl::unotools::toDoubleColor(pIn[0]),
457 0 : vcl::unotools::toDoubleColor(pIn[1]),
458 0 : vcl::unotools::toDoubleColor(pIn[2]));
459 0 : pIn += 4;
460 : }
461 0 : return aRes;
462 : }
463 :
464 0 : virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToPARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
465 : {
466 0 : const sal_Int8* pIn( deviceColor.getConstArray() );
467 0 : const sal_Size nLen( deviceColor.getLength() );
468 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
469 : "number of channels no multiple of 4",
470 : static_cast<rendering::XColorSpace*>(this), 0);
471 :
472 0 : uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
473 0 : rendering::ARGBColor* pOut( aRes.getArray() );
474 0 : for( sal_Size i=0; i<nLen; i+=4 )
475 : {
476 0 : const sal_Int8 nAlpha( pIn[3] );
477 : *pOut++ = rendering::ARGBColor(
478 0 : vcl::unotools::toDoubleColor(nAlpha),
479 0 : vcl::unotools::toDoubleColor(nAlpha*pIn[0]),
480 0 : vcl::unotools::toDoubleColor(nAlpha*pIn[1]),
481 0 : vcl::unotools::toDoubleColor(nAlpha*pIn[2]));
482 0 : pIn += 4;
483 : }
484 0 : return aRes;
485 : }
486 :
487 0 : virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
488 : {
489 0 : const rendering::RGBColor* pIn( rgbColor.getConstArray() );
490 0 : const sal_Size nLen( rgbColor.getLength() );
491 :
492 0 : uno::Sequence< sal_Int8 > aRes(nLen*4);
493 0 : sal_Int8* pColors=aRes.getArray();
494 0 : for( sal_Size i=0; i<nLen; ++i )
495 : {
496 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Red);
497 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Green);
498 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Blue);
499 0 : *pColors++ = 0;
500 0 : ++pIn;
501 : }
502 0 : return aRes;
503 : }
504 :
505 0 : virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
506 : {
507 0 : const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
508 0 : const sal_Size nLen( rgbColor.getLength() );
509 :
510 0 : uno::Sequence< sal_Int8 > aRes(nLen*4);
511 0 : sal_Int8* pColors=aRes.getArray();
512 0 : for( sal_Size i=0; i<nLen; ++i )
513 : {
514 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Red);
515 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Green);
516 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Blue);
517 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Alpha);
518 0 : ++pIn;
519 : }
520 0 : return aRes;
521 : }
522 :
523 0 : virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
524 : {
525 0 : const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
526 0 : const sal_Size nLen( rgbColor.getLength() );
527 :
528 0 : uno::Sequence< sal_Int8 > aRes(nLen*4);
529 0 : sal_Int8* pColors=aRes.getArray();
530 0 : for( sal_Size i=0; i<nLen; ++i )
531 : {
532 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Red/pIn->Alpha);
533 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Green/pIn->Alpha);
534 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Blue/pIn->Alpha);
535 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Alpha);
536 0 : ++pIn;
537 : }
538 0 : return aRes;
539 : }
540 :
541 : public:
542 0 : StandardColorSpace() :
543 : maComponentTags(4),
544 0 : maBitCounts(4)
545 : {
546 0 : sal_Int8* pTags = maComponentTags.getArray();
547 0 : sal_Int32* pBitCounts = maBitCounts.getArray();
548 0 : pTags[0] = rendering::ColorComponentTag::RGB_RED;
549 0 : pTags[1] = rendering::ColorComponentTag::RGB_GREEN;
550 0 : pTags[2] = rendering::ColorComponentTag::RGB_BLUE;
551 0 : pTags[3] = rendering::ColorComponentTag::ALPHA;
552 :
553 : pBitCounts[0] =
554 0 : pBitCounts[1] =
555 0 : pBitCounts[2] =
556 0 : pBitCounts[3] = 8;
557 0 : }
558 : };
559 :
560 0 : class StandardNoAlphaColorSpace : public cppu::WeakImplHelper1< com::sun::star::rendering::XIntegerBitmapColorSpace >
561 : {
562 : private:
563 : uno::Sequence< sal_Int8 > maComponentTags;
564 : uno::Sequence< sal_Int32 > maBitCounts;
565 :
566 0 : virtual ::sal_Int8 SAL_CALL getType( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
567 : {
568 0 : return rendering::ColorSpaceType::RGB;
569 : }
570 0 : virtual uno::Sequence< ::sal_Int8 > SAL_CALL getComponentTags( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
571 : {
572 0 : return maComponentTags;
573 : }
574 0 : virtual ::sal_Int8 SAL_CALL getRenderingIntent( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
575 : {
576 0 : return rendering::RenderingIntent::PERCEPTUAL;
577 : }
578 0 : virtual uno::Sequence< beans::PropertyValue > SAL_CALL getProperties( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
579 : {
580 0 : return uno::Sequence< beans::PropertyValue >();
581 : }
582 0 : virtual uno::Sequence< double > SAL_CALL convertColorSpace( const uno::Sequence< double >& deviceColor,
583 : const uno::Reference< rendering::XColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,
584 : uno::RuntimeException, std::exception) SAL_OVERRIDE
585 : {
586 : // TODO(P3): if we know anything about target
587 : // colorspace, this can be greatly sped up
588 : uno::Sequence<rendering::ARGBColor> aIntermediate(
589 0 : convertToARGB(deviceColor));
590 0 : return targetColorSpace->convertFromARGB(aIntermediate);
591 : }
592 0 : virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
593 : {
594 0 : const double* pIn( deviceColor.getConstArray() );
595 0 : const sal_Size nLen( deviceColor.getLength() );
596 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
597 : "number of channels no multiple of 4",
598 : static_cast<rendering::XColorSpace*>(this), 0);
599 :
600 0 : uno::Sequence< rendering::RGBColor > aRes(nLen/4);
601 0 : rendering::RGBColor* pOut( aRes.getArray() );
602 0 : for( sal_Size i=0; i<nLen; i+=4 )
603 : {
604 0 : *pOut++ = rendering::RGBColor(pIn[0],pIn[1],pIn[2]);
605 0 : pIn += 4;
606 : }
607 0 : return aRes;
608 : }
609 0 : virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
610 : {
611 0 : const double* pIn( deviceColor.getConstArray() );
612 0 : const sal_Size nLen( deviceColor.getLength() );
613 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
614 : "number of channels no multiple of 4",
615 : static_cast<rendering::XColorSpace*>(this), 0);
616 :
617 0 : uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
618 0 : rendering::ARGBColor* pOut( aRes.getArray() );
619 0 : for( sal_Size i=0; i<nLen; i+=4 )
620 : {
621 0 : *pOut++ = rendering::ARGBColor(1.0,pIn[0],pIn[1],pIn[2]);
622 0 : pIn += 4;
623 : }
624 0 : return aRes;
625 : }
626 0 : virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
627 : {
628 0 : const double* pIn( deviceColor.getConstArray() );
629 0 : const sal_Size nLen( deviceColor.getLength() );
630 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
631 : "number of channels no multiple of 4",
632 : static_cast<rendering::XColorSpace*>(this), 0);
633 :
634 0 : uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
635 0 : rendering::ARGBColor* pOut( aRes.getArray() );
636 0 : for( sal_Size i=0; i<nLen; i+=4 )
637 : {
638 0 : *pOut++ = rendering::ARGBColor(1.0,pIn[0],pIn[1],pIn[2]);
639 0 : pIn += 4;
640 : }
641 0 : return aRes;
642 : }
643 0 : virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
644 : {
645 0 : const rendering::RGBColor* pIn( rgbColor.getConstArray() );
646 0 : const sal_Size nLen( rgbColor.getLength() );
647 :
648 0 : uno::Sequence< double > aRes(nLen*4);
649 0 : double* pColors=aRes.getArray();
650 0 : for( sal_Size i=0; i<nLen; ++i )
651 : {
652 0 : *pColors++ = pIn->Red;
653 0 : *pColors++ = pIn->Green;
654 0 : *pColors++ = pIn->Blue;
655 0 : *pColors++ = 1.0; // the value does not matter
656 0 : ++pIn;
657 : }
658 0 : return aRes;
659 : }
660 0 : virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
661 : {
662 0 : const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
663 0 : const sal_Size nLen( rgbColor.getLength() );
664 :
665 0 : uno::Sequence< double > aRes(nLen*4);
666 0 : double* pColors=aRes.getArray();
667 0 : for( sal_Size i=0; i<nLen; ++i )
668 : {
669 0 : *pColors++ = pIn->Red;
670 0 : *pColors++ = pIn->Green;
671 0 : *pColors++ = pIn->Blue;
672 0 : *pColors++ = 1.0; // the value does not matter
673 0 : ++pIn;
674 : }
675 0 : return aRes;
676 : }
677 0 : virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
678 : {
679 0 : const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
680 0 : const sal_Size nLen( rgbColor.getLength() );
681 :
682 0 : uno::Sequence< double > aRes(nLen*4);
683 0 : double* pColors=aRes.getArray();
684 0 : for( sal_Size i=0; i<nLen; ++i )
685 : {
686 0 : *pColors++ = pIn->Red/pIn->Alpha;
687 0 : *pColors++ = pIn->Green/pIn->Alpha;
688 0 : *pColors++ = pIn->Blue/pIn->Alpha;
689 0 : *pColors++ = 1.0; // the value does not matter
690 0 : ++pIn;
691 : }
692 0 : return aRes;
693 : }
694 :
695 : // XIntegerBitmapColorSpace
696 0 : virtual ::sal_Int32 SAL_CALL getBitsPerPixel( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
697 : {
698 0 : return 32;
699 : }
700 0 : virtual uno::Sequence< ::sal_Int32 > SAL_CALL getComponentBitCounts( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
701 : {
702 0 : return maBitCounts;
703 : }
704 0 : virtual ::sal_Int8 SAL_CALL getEndianness( ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE
705 : {
706 0 : return util::Endianness::LITTLE;
707 : }
708 0 : virtual uno::Sequence<double> SAL_CALL convertFromIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& deviceColor,
709 : const uno::Reference< rendering::XColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,
710 : uno::RuntimeException, std::exception) SAL_OVERRIDE
711 : {
712 0 : if( dynamic_cast<StandardNoAlphaColorSpace*>(targetColorSpace.get()) )
713 : {
714 0 : const sal_Int8* pIn( deviceColor.getConstArray() );
715 0 : const sal_Size nLen( deviceColor.getLength() );
716 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
717 : "number of channels no multiple of 4",
718 : static_cast<rendering::XColorSpace*>(this), 0);
719 :
720 0 : uno::Sequence<double> aRes(nLen);
721 0 : double* pOut( aRes.getArray() );
722 0 : for( sal_Size i=0; i<nLen; i+=4 )
723 : {
724 0 : *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
725 0 : *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
726 0 : *pOut++ = vcl::unotools::toDoubleColor(*pIn++);
727 0 : *pOut++ = 1.0;
728 : }
729 0 : return aRes;
730 : }
731 : else
732 : {
733 : // TODO(P3): if we know anything about target
734 : // colorspace, this can be greatly sped up
735 : uno::Sequence<rendering::ARGBColor> aIntermediate(
736 0 : convertIntegerToARGB(deviceColor));
737 0 : return targetColorSpace->convertFromARGB(aIntermediate);
738 : }
739 : }
740 0 : virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertToIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& deviceColor,
741 : const uno::Reference< rendering::XIntegerBitmapColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,
742 : uno::RuntimeException, std::exception) SAL_OVERRIDE
743 : {
744 0 : if( dynamic_cast<StandardNoAlphaColorSpace*>(targetColorSpace.get()) )
745 : {
746 : // it's us, so simply pass-through the data
747 0 : return deviceColor;
748 : }
749 : else
750 : {
751 : // TODO(P3): if we know anything about target
752 : // colorspace, this can be greatly sped up
753 : uno::Sequence<rendering::ARGBColor> aIntermediate(
754 0 : convertIntegerToARGB(deviceColor));
755 0 : return targetColorSpace->convertIntegerFromARGB(aIntermediate);
756 : }
757 : }
758 0 : virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertIntegerToRGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
759 : {
760 0 : const sal_Int8* pIn( deviceColor.getConstArray() );
761 0 : const sal_Size nLen( deviceColor.getLength() );
762 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
763 : "number of channels no multiple of 4",
764 : static_cast<rendering::XColorSpace*>(this), 0);
765 :
766 0 : uno::Sequence< rendering::RGBColor > aRes(nLen/4);
767 0 : rendering::RGBColor* pOut( aRes.getArray() );
768 0 : for( sal_Size i=0; i<nLen; i+=4 )
769 : {
770 : *pOut++ = rendering::RGBColor(
771 0 : vcl::unotools::toDoubleColor(pIn[0]),
772 0 : vcl::unotools::toDoubleColor(pIn[1]),
773 0 : vcl::unotools::toDoubleColor(pIn[2]));
774 0 : pIn += 4;
775 : }
776 0 : return aRes;
777 : }
778 :
779 0 : virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
780 : {
781 0 : const sal_Int8* pIn( deviceColor.getConstArray() );
782 0 : const sal_Size nLen( deviceColor.getLength() );
783 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
784 : "number of channels no multiple of 4",
785 : static_cast<rendering::XColorSpace*>(this), 0);
786 :
787 0 : uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
788 0 : rendering::ARGBColor* pOut( aRes.getArray() );
789 0 : for( sal_Size i=0; i<nLen; i+=4 )
790 : {
791 : *pOut++ = rendering::ARGBColor(
792 : 1.0,
793 0 : vcl::unotools::toDoubleColor(pIn[0]),
794 0 : vcl::unotools::toDoubleColor(pIn[1]),
795 0 : vcl::unotools::toDoubleColor(pIn[2]));
796 0 : pIn += 4;
797 : }
798 0 : return aRes;
799 : }
800 :
801 0 : virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToPARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
802 : {
803 0 : const sal_Int8* pIn( deviceColor.getConstArray() );
804 0 : const sal_Size nLen( deviceColor.getLength() );
805 0 : ENSURE_ARG_OR_THROW2(nLen%4==0,
806 : "number of channels no multiple of 4",
807 : static_cast<rendering::XColorSpace*>(this), 0);
808 :
809 0 : uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
810 0 : rendering::ARGBColor* pOut( aRes.getArray() );
811 0 : for( sal_Size i=0; i<nLen; i+=4 )
812 : {
813 : *pOut++ = rendering::ARGBColor(
814 : 1.0,
815 0 : vcl::unotools::toDoubleColor(pIn[0]),
816 0 : vcl::unotools::toDoubleColor(pIn[1]),
817 0 : vcl::unotools::toDoubleColor(pIn[2]));
818 0 : pIn += 4;
819 : }
820 0 : return aRes;
821 : }
822 :
823 0 : virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
824 : {
825 0 : const rendering::RGBColor* pIn( rgbColor.getConstArray() );
826 0 : const sal_Size nLen( rgbColor.getLength() );
827 :
828 0 : uno::Sequence< sal_Int8 > aRes(nLen*4);
829 0 : sal_Int8* pColors=aRes.getArray();
830 0 : for( sal_Size i=0; i<nLen; ++i )
831 : {
832 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Red);
833 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Green);
834 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Blue);
835 0 : *pColors++ = 1.0;
836 0 : ++pIn;
837 : }
838 0 : return aRes;
839 : }
840 :
841 0 : virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
842 : {
843 0 : const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
844 0 : const sal_Size nLen( rgbColor.getLength() );
845 :
846 0 : uno::Sequence< sal_Int8 > aRes(nLen*4);
847 0 : sal_Int8* pColors=aRes.getArray();
848 0 : for( sal_Size i=0; i<nLen; ++i )
849 : {
850 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Red);
851 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Green);
852 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Blue);
853 0 : *pColors++ = -1;
854 0 : ++pIn;
855 : }
856 0 : return aRes;
857 : }
858 :
859 0 : virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception) SAL_OVERRIDE
860 : {
861 0 : const rendering::ARGBColor* pIn( rgbColor.getConstArray() );
862 0 : const sal_Size nLen( rgbColor.getLength() );
863 :
864 0 : uno::Sequence< sal_Int8 > aRes(nLen*4);
865 0 : sal_Int8* pColors=aRes.getArray();
866 0 : for( sal_Size i=0; i<nLen; ++i )
867 : {
868 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Red/pIn->Alpha);
869 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Green/pIn->Alpha);
870 0 : *pColors++ = vcl::unotools::toByteColor(pIn->Blue/pIn->Alpha);
871 0 : *pColors++ = -1;
872 0 : ++pIn;
873 : }
874 0 : return aRes;
875 : }
876 :
877 : public:
878 0 : StandardNoAlphaColorSpace() :
879 : maComponentTags(3),
880 0 : maBitCounts(3)
881 : {
882 0 : sal_Int8* pTags = maComponentTags.getArray();
883 0 : sal_Int32* pBitCounts = maBitCounts.getArray();
884 0 : pTags[0] = rendering::ColorComponentTag::RGB_RED;
885 0 : pTags[1] = rendering::ColorComponentTag::RGB_GREEN;
886 0 : pTags[2] = rendering::ColorComponentTag::RGB_BLUE;
887 :
888 : pBitCounts[0] =
889 0 : pBitCounts[1] =
890 0 : pBitCounts[2] = 8;
891 0 : }
892 : };
893 :
894 : struct StandardColorSpaceHolder : public rtl::StaticWithInit<uno::Reference<rendering::XIntegerBitmapColorSpace>,
895 : StandardColorSpaceHolder>
896 : {
897 0 : uno::Reference<rendering::XIntegerBitmapColorSpace> operator()()
898 : {
899 0 : return new StandardColorSpace();
900 : }
901 : };
902 :
903 : struct StandardNoAlphaColorSpaceHolder : public rtl::StaticWithInit<uno::Reference<rendering::XIntegerBitmapColorSpace>,
904 : StandardNoAlphaColorSpaceHolder>
905 : {
906 0 : uno::Reference<rendering::XIntegerBitmapColorSpace> operator()()
907 : {
908 0 : return new StandardNoAlphaColorSpace();
909 : }
910 : };
911 : }
912 :
913 0 : uno::Reference<rendering::XIntegerBitmapColorSpace> getStdColorSpace()
914 : {
915 0 : return StandardColorSpaceHolder::get();
916 : }
917 :
918 0 : uno::Reference<rendering::XIntegerBitmapColorSpace> getStdColorSpaceWithoutAlpha()
919 : {
920 0 : return StandardNoAlphaColorSpaceHolder::get();
921 : }
922 :
923 0 : rendering::IntegerBitmapLayout getStdMemoryLayout( const geometry::IntegerSize2D& rBmpSize )
924 : {
925 0 : rendering::IntegerBitmapLayout aLayout;
926 :
927 0 : aLayout.ScanLines = rBmpSize.Height;
928 0 : aLayout.ScanLineBytes = rBmpSize.Width*4;
929 0 : aLayout.ScanLineStride = aLayout.ScanLineBytes;
930 0 : aLayout.PlaneStride = 0;
931 0 : aLayout.ColorSpace = getStdColorSpace();
932 0 : aLayout.Palette.clear();
933 0 : aLayout.IsMsbFirst = sal_False;
934 :
935 0 : return aLayout;
936 : }
937 :
938 0 : ::Color stdIntSequenceToColor( const uno::Sequence<sal_Int8>& rColor )
939 : {
940 : #ifdef OSL_BIGENDIAN
941 : const sal_Int8* pCols( rColor.getConstArray() );
942 : return ::Color( pCols[3], pCols[0], pCols[1], pCols[2] );
943 : #else
944 0 : return ::Color( *reinterpret_cast< const ::ColorData* >(rColor.getConstArray()) );
945 : #endif
946 : }
947 :
948 0 : uno::Sequence<sal_Int8> colorToStdIntSequence( const ::Color& rColor )
949 : {
950 0 : uno::Sequence<sal_Int8> aRet(4);
951 0 : sal_Int8* pCols( aRet.getArray() );
952 : #ifdef OSL_BIGENDIAN
953 : pCols[0] = rColor.GetRed();
954 : pCols[1] = rColor.GetGreen();
955 : pCols[2] = rColor.GetBlue();
956 : pCols[3] = 255-rColor.GetTransparency();
957 : #else
958 0 : *reinterpret_cast<sal_Int32*>(pCols) = rColor.GetColor();
959 : #endif
960 0 : return aRet;
961 : }
962 :
963 : // Create a corrected view transformation out of the give one,
964 : // which ensures that the rectangle given by (0,0) and
965 : // rSpriteSize is mapped with its left,top corner to (0,0)
966 : // again. This is required to properly render sprite
967 : // animations to buffer bitmaps.
968 0 : ::basegfx::B2DHomMatrix& calcRectToOriginTransform( ::basegfx::B2DHomMatrix& o_transform,
969 : const ::basegfx::B2DRange& i_srcRect,
970 : const ::basegfx::B2DHomMatrix& i_transformation )
971 : {
972 0 : if( i_srcRect.isEmpty() )
973 0 : return o_transform=i_transformation;
974 :
975 : // transform by given transformation
976 0 : ::basegfx::B2DRectangle aTransformedRect;
977 :
978 : calcTransformedRectBounds( aTransformedRect,
979 : i_srcRect,
980 0 : i_transformation );
981 :
982 : // now move resulting left,top point of bounds to (0,0)
983 : const basegfx::B2DHomMatrix aCorrectedTransform(basegfx::tools::createTranslateB2DHomMatrix(
984 0 : -aTransformedRect.getMinX(), -aTransformedRect.getMinY()));
985 :
986 : // prepend to original transformation
987 0 : o_transform = aCorrectedTransform * i_transformation;
988 :
989 0 : return o_transform;
990 : }
991 :
992 0 : ::basegfx::B2DRange& calcTransformedRectBounds( ::basegfx::B2DRange& outRect,
993 : const ::basegfx::B2DRange& inRect,
994 : const ::basegfx::B2DHomMatrix& transformation )
995 : {
996 0 : outRect.reset();
997 :
998 0 : if( inRect.isEmpty() )
999 0 : return outRect;
1000 :
1001 : // transform all four extremal points of the rectangle,
1002 : // take bounding rect of those.
1003 :
1004 : // transform left-top point
1005 0 : outRect.expand( transformation * inRect.getMinimum() );
1006 :
1007 : // transform bottom-right point
1008 0 : outRect.expand( transformation * inRect.getMaximum() );
1009 :
1010 0 : ::basegfx::B2DPoint aPoint;
1011 :
1012 : // transform top-right point
1013 0 : aPoint.setX( inRect.getMaxX() );
1014 0 : aPoint.setY( inRect.getMinY() );
1015 :
1016 0 : aPoint *= transformation;
1017 0 : outRect.expand( aPoint );
1018 :
1019 : // transform bottom-left point
1020 0 : aPoint.setX( inRect.getMinX() );
1021 0 : aPoint.setY( inRect.getMaxY() );
1022 :
1023 0 : aPoint *= transformation;
1024 0 : outRect.expand( aPoint );
1025 :
1026 : // over and out.
1027 0 : return outRect;
1028 : }
1029 :
1030 0 : bool isInside( const ::basegfx::B2DRange& rContainedRect,
1031 : const ::basegfx::B2DRange& rTransformRect,
1032 : const ::basegfx::B2DHomMatrix& rTransformation )
1033 : {
1034 0 : if( rContainedRect.isEmpty() || rTransformRect.isEmpty() )
1035 0 : return false;
1036 :
1037 : ::basegfx::B2DPolygon aPoly(
1038 0 : ::basegfx::tools::createPolygonFromRect( rTransformRect ) );
1039 0 : aPoly.transform( rTransformation );
1040 :
1041 : return ::basegfx::tools::isInside( aPoly,
1042 : ::basegfx::tools::createPolygonFromRect(
1043 : rContainedRect ),
1044 0 : true );
1045 : }
1046 :
1047 : namespace
1048 : {
1049 0 : bool clipAreaImpl( ::basegfx::B2IRange* o_pDestArea,
1050 : ::basegfx::B2IRange& io_rSourceArea,
1051 : ::basegfx::B2IPoint& io_rDestPoint,
1052 : const ::basegfx::B2IRange& rSourceBounds,
1053 : const ::basegfx::B2IRange& rDestBounds )
1054 : {
1055 : const ::basegfx::B2IPoint aSourceTopLeft(
1056 0 : io_rSourceArea.getMinimum() );
1057 :
1058 0 : ::basegfx::B2IRange aLocalSourceArea( io_rSourceArea );
1059 :
1060 : // clip source area (which must be inside rSourceBounds)
1061 0 : aLocalSourceArea.intersect( rSourceBounds );
1062 :
1063 0 : if( aLocalSourceArea.isEmpty() )
1064 0 : return false;
1065 :
1066 : // calc relative new source area points (relative to orig
1067 : // source area)
1068 : const ::basegfx::B2IVector aUpperLeftOffset(
1069 0 : aLocalSourceArea.getMinimum()-aSourceTopLeft );
1070 : const ::basegfx::B2IVector aLowerRightOffset(
1071 0 : aLocalSourceArea.getMaximum()-aSourceTopLeft );
1072 :
1073 0 : ::basegfx::B2IRange aLocalDestArea( io_rDestPoint + aUpperLeftOffset,
1074 0 : io_rDestPoint + aLowerRightOffset );
1075 :
1076 : // clip dest area (which must be inside rDestBounds)
1077 0 : aLocalDestArea.intersect( rDestBounds );
1078 :
1079 0 : if( aLocalDestArea.isEmpty() )
1080 0 : return false;
1081 :
1082 : // calc relative new dest area points (relative to orig
1083 : // source area)
1084 : const ::basegfx::B2IVector aDestUpperLeftOffset(
1085 0 : aLocalDestArea.getMinimum()-io_rDestPoint );
1086 : const ::basegfx::B2IVector aDestLowerRightOffset(
1087 0 : aLocalDestArea.getMaximum()-io_rDestPoint );
1088 :
1089 0 : io_rSourceArea = ::basegfx::B2IRange( aSourceTopLeft + aDestUpperLeftOffset,
1090 0 : aSourceTopLeft + aDestLowerRightOffset );
1091 0 : io_rDestPoint = aLocalDestArea.getMinimum();
1092 :
1093 0 : if( o_pDestArea )
1094 0 : *o_pDestArea = aLocalDestArea;
1095 :
1096 0 : return true;
1097 : }
1098 : }
1099 :
1100 0 : bool clipScrollArea( ::basegfx::B2IRange& io_rSourceArea,
1101 : ::basegfx::B2IPoint& io_rDestPoint,
1102 : ::std::vector< ::basegfx::B2IRange >& o_ClippedAreas,
1103 : const ::basegfx::B2IRange& rBounds )
1104 : {
1105 0 : ::basegfx::B2IRange aResultingDestArea;
1106 :
1107 : // compute full destination area (to determine uninitialized
1108 : // areas below)
1109 0 : const ::basegfx::B2I64Tuple& rRange( io_rSourceArea.getRange() );
1110 : ::basegfx::B2IRange aInputDestArea( io_rDestPoint.getX(),
1111 : io_rDestPoint.getY(),
1112 0 : (io_rDestPoint.getX()
1113 0 : + static_cast<sal_Int32>(rRange.getX())),
1114 0 : (io_rDestPoint.getY()
1115 0 : + static_cast<sal_Int32>(rRange.getY())) );
1116 : // limit to output area (no point updating outside of it)
1117 0 : aInputDestArea.intersect( rBounds );
1118 :
1119 : // clip to rBounds
1120 0 : if( !clipAreaImpl( &aResultingDestArea,
1121 : io_rSourceArea,
1122 : io_rDestPoint,
1123 : rBounds,
1124 0 : rBounds ) )
1125 0 : return false;
1126 :
1127 : // finally, compute all areas clipped off the total
1128 : // destination area.
1129 : ::basegfx::computeSetDifference( o_ClippedAreas,
1130 : aInputDestArea,
1131 0 : aResultingDestArea );
1132 :
1133 0 : return true;
1134 : }
1135 :
1136 0 : ::basegfx::B2IRange spritePixelAreaFromB2DRange( const ::basegfx::B2DRange& rRange )
1137 : {
1138 0 : if( rRange.isEmpty() )
1139 0 : return ::basegfx::B2IRange();
1140 :
1141 : const ::basegfx::B2IPoint aTopLeft( ::basegfx::fround( rRange.getMinX() ),
1142 0 : ::basegfx::fround( rRange.getMinY() ) );
1143 : return ::basegfx::B2IRange( aTopLeft,
1144 0 : aTopLeft + ::basegfx::B2IPoint(
1145 : ::basegfx::fround( rRange.getWidth() ),
1146 0 : ::basegfx::fround( rRange.getHeight() ) ) );
1147 : }
1148 :
1149 0 : uno::Sequence< uno::Any >& getDeviceInfo( const uno::Reference< rendering::XCanvas >& i_rxCanvas,
1150 : uno::Sequence< uno::Any >& o_rxParams )
1151 : {
1152 0 : o_rxParams.realloc( 0 );
1153 :
1154 0 : if( i_rxCanvas.is() )
1155 : {
1156 : try
1157 : {
1158 0 : uno::Reference< rendering::XGraphicDevice > xDevice( i_rxCanvas->getDevice(),
1159 0 : uno::UNO_QUERY_THROW );
1160 :
1161 : uno::Reference< lang::XServiceInfo > xServiceInfo( xDevice,
1162 0 : uno::UNO_QUERY_THROW );
1163 : uno::Reference< beans::XPropertySet > xPropSet( xDevice,
1164 0 : uno::UNO_QUERY_THROW );
1165 :
1166 0 : o_rxParams.realloc( 2 );
1167 :
1168 0 : o_rxParams[ 0 ] = uno::makeAny( xServiceInfo->getImplementationName() );
1169 0 : o_rxParams[ 1 ] = uno::makeAny( xPropSet->getPropertyValue( "DeviceHandle" ) );
1170 : }
1171 0 : catch( const uno::Exception& )
1172 : {
1173 : // ignore, but return empty sequence
1174 : }
1175 : }
1176 :
1177 0 : return o_rxParams;
1178 : }
1179 :
1180 0 : awt::Rectangle getAbsoluteWindowRect( const awt::Rectangle& rRect,
1181 : const uno::Reference< awt::XWindow2 >& xWin )
1182 : {
1183 0 : awt::Rectangle aRetVal( rRect );
1184 :
1185 0 : ::Window* pWindow = VCLUnoHelper::GetWindow(xWin);
1186 0 : if( pWindow )
1187 : {
1188 : ::Point aPoint( aRetVal.X,
1189 0 : aRetVal.Y );
1190 :
1191 0 : aPoint = pWindow->OutputToScreenPixel( aPoint );
1192 :
1193 0 : aRetVal.X = aPoint.X();
1194 0 : aRetVal.Y = aPoint.Y();
1195 : }
1196 :
1197 0 : return aRetVal;
1198 : }
1199 :
1200 0 : ::basegfx::B2DPolyPolygon getBoundMarksPolyPolygon( const ::basegfx::B2DRange& rRange )
1201 : {
1202 0 : ::basegfx::B2DPolyPolygon aPolyPoly;
1203 0 : ::basegfx::B2DPolygon aPoly;
1204 :
1205 0 : const double nX0( rRange.getMinX() );
1206 0 : const double nY0( rRange.getMinY() );
1207 0 : const double nX1( rRange.getMaxX() );
1208 0 : const double nY1( rRange.getMaxY() );
1209 :
1210 : aPoly.append( ::basegfx::B2DPoint( nX0+4,
1211 0 : nY0 ) );
1212 : aPoly.append( ::basegfx::B2DPoint( nX0,
1213 0 : nY0 ) );
1214 : aPoly.append( ::basegfx::B2DPoint( nX0,
1215 0 : nY0+4 ) );
1216 0 : aPolyPoly.append( aPoly ); aPoly.clear();
1217 :
1218 : aPoly.append( ::basegfx::B2DPoint( nX1-4,
1219 0 : nY0 ) );
1220 : aPoly.append( ::basegfx::B2DPoint( nX1,
1221 0 : nY0 ) );
1222 : aPoly.append( ::basegfx::B2DPoint( nX1,
1223 0 : nY0+4 ) );
1224 0 : aPolyPoly.append( aPoly ); aPoly.clear();
1225 :
1226 : aPoly.append( ::basegfx::B2DPoint( nX0+4,
1227 0 : nY1 ) );
1228 : aPoly.append( ::basegfx::B2DPoint( nX0,
1229 0 : nY1 ) );
1230 : aPoly.append( ::basegfx::B2DPoint( nX0,
1231 0 : nY1-4 ) );
1232 0 : aPolyPoly.append( aPoly ); aPoly.clear();
1233 :
1234 : aPoly.append( ::basegfx::B2DPoint( nX1-4,
1235 0 : nY1 ) );
1236 : aPoly.append( ::basegfx::B2DPoint( nX1,
1237 0 : nY1 ) );
1238 : aPoly.append( ::basegfx::B2DPoint( nX1,
1239 0 : nY1-4 ) );
1240 0 : aPolyPoly.append( aPoly );
1241 :
1242 0 : return aPolyPoly;
1243 : }
1244 :
1245 0 : int calcGradientStepCount( ::basegfx::B2DHomMatrix& rTotalTransform,
1246 : const rendering::ViewState& viewState,
1247 : const rendering::RenderState& renderState,
1248 : const rendering::Texture& texture,
1249 : int nColorSteps )
1250 : {
1251 : // calculate overall texture transformation (directly from
1252 : // texture to device space).
1253 0 : ::basegfx::B2DHomMatrix aMatrix;
1254 :
1255 0 : rTotalTransform.identity();
1256 : ::basegfx::unotools::homMatrixFromAffineMatrix( rTotalTransform,
1257 0 : texture.AffineTransform );
1258 : ::canvas::tools::mergeViewAndRenderTransform(aMatrix,
1259 : viewState,
1260 0 : renderState);
1261 0 : rTotalTransform *= aMatrix; // prepend total view/render transformation
1262 :
1263 : // determine size of gradient in device coordinate system
1264 : // (to e.g. determine sensible number of gradient steps)
1265 0 : ::basegfx::B2DPoint aLeftTop( 0.0, 0.0 );
1266 0 : ::basegfx::B2DPoint aLeftBottom( 0.0, 1.0 );
1267 0 : ::basegfx::B2DPoint aRightTop( 1.0, 0.0 );
1268 0 : ::basegfx::B2DPoint aRightBottom( 1.0, 1.0 );
1269 :
1270 0 : aLeftTop *= rTotalTransform;
1271 0 : aLeftBottom *= rTotalTransform;
1272 0 : aRightTop *= rTotalTransform;
1273 0 : aRightBottom*= rTotalTransform;
1274 :
1275 : // longest line in gradient bound rect
1276 : const int nGradientSize(
1277 : static_cast<int>(
1278 : ::std::max(
1279 0 : ::basegfx::B2DVector(aRightBottom-aLeftTop).getLength(),
1280 0 : ::basegfx::B2DVector(aRightTop-aLeftBottom).getLength() ) + 1.0 ) );
1281 :
1282 : // typical number for pixel of the same color (strip size)
1283 0 : const int nStripSize( nGradientSize < 50 ? 2 : 4 );
1284 :
1285 : // use at least three steps, and at utmost the number of color
1286 : // steps
1287 : return ::std::max( 3,
1288 : ::std::min(
1289 0 : nGradientSize / nStripSize,
1290 0 : nColorSteps ) );
1291 : }
1292 :
1293 : } // namespace tools
1294 :
1295 : } // namespace canvas
1296 :
1297 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
