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 : // must be first
22 : #include <canvas/debug.hxx>
23 : #include <tools/diagnose_ex.h>
24 :
25 : #include <math.h>
26 :
27 : #include <rtl/logfile.hxx>
28 : #include <rtl/math.hxx>
29 :
30 : #include <com/sun/star/rendering/XCanvas.hpp>
31 : #include <com/sun/star/rendering/XIntegerBitmap.hpp>
32 : #include <com/sun/star/rendering/PanoseLetterForm.hpp>
33 : #include <com/sun/star/awt/FontSlant.hpp>
34 :
35 : #include <cppuhelper/exc_hlp.hxx>
36 : #include <comphelper/anytostring.hxx>
37 :
38 : #include <basegfx/polygon/b2dpolygontools.hxx>
39 : #include <basegfx/numeric/ftools.hxx>
40 : #include <basegfx/matrix/b2dhommatrix.hxx>
41 : #include <basegfx/matrix/b2dhommatrixtools.hxx>
42 :
43 : #include <canvas/verbosetrace.hxx>
44 : #include <canvas/canvastools.hxx>
45 : #include <cppcanvas/vclfactory.hxx>
46 : #include <cppcanvas/basegfxfactory.hxx>
47 :
48 : #include "viewshape.hxx"
49 : #include "tools.hxx"
50 :
51 : #include <boost/bind.hpp>
52 :
53 :
54 : using namespace ::com::sun::star;
55 :
56 : namespace slideshow
57 : {
58 : namespace internal
59 : {
60 :
61 : // TODO(F2): Provide sensible setup for mtf-related attributes (fill mode,
62 : // char rotation etc.). Do that via mtf argument at this object
63 :
64 0 : bool ViewShape::prefetch( RendererCacheEntry& io_rCacheEntry,
65 : const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
66 : const GDIMetaFileSharedPtr& rMtf,
67 : const ShapeAttributeLayerSharedPtr& rAttr ) const
68 : {
69 : RTL_LOGFILE_CONTEXT( aLog, "::presentation::internal::ViewShape::prefetch()" );
70 0 : ENSURE_OR_RETURN_FALSE( rMtf,
71 : "ViewShape::prefetch(): no valid metafile!" );
72 :
73 0 : if( rMtf != io_rCacheEntry.mpMtf ||
74 0 : rDestinationCanvas != io_rCacheEntry.getDestinationCanvas() )
75 : {
76 : // buffered renderer invalid, re-create
77 0 : ::cppcanvas::Renderer::Parameters aParms;
78 :
79 : // rendering attribute override parameter struct. For
80 : // every valid attribute, the corresponding struct
81 : // member is filled, which in the metafile renderer
82 : // forces rendering with the given attribute.
83 0 : if( rAttr )
84 : {
85 0 : if( rAttr->isFillColorValid() )
86 : {
87 : // convert RGBColor to RGBA32 integer. Note
88 : // that getIntegerColor() also truncates
89 : // out-of-range values appropriately
90 : aParms.maFillColor =
91 0 : rAttr->getFillColor().getIntegerColor();
92 : }
93 0 : if( rAttr->isLineColorValid() )
94 : {
95 : // convert RGBColor to RGBA32 integer. Note
96 : // that getIntegerColor() also truncates
97 : // out-of-range values appropriately
98 : aParms.maLineColor =
99 0 : rAttr->getLineColor().getIntegerColor();
100 : }
101 0 : if( rAttr->isCharColorValid() )
102 : {
103 : // convert RGBColor to RGBA32 integer. Note
104 : // that getIntegerColor() also truncates
105 : // out-of-range values appropriately
106 : aParms.maTextColor =
107 0 : rAttr->getCharColor().getIntegerColor();
108 : }
109 0 : if( rAttr->isDimColorValid() )
110 : {
111 : // convert RGBColor to RGBA32 integer. Note
112 : // that getIntegerColor() also truncates
113 : // out-of-range values appropriately
114 :
115 : // dim color overrides all other colors
116 : aParms.maFillColor =
117 : aParms.maLineColor =
118 : aParms.maTextColor =
119 0 : rAttr->getDimColor().getIntegerColor();
120 : }
121 0 : if( rAttr->isFontFamilyValid() )
122 : {
123 : aParms.maFontName =
124 0 : rAttr->getFontFamily();
125 : }
126 0 : if( rAttr->isCharScaleValid() )
127 : {
128 0 : ::basegfx::B2DHomMatrix aMatrix;
129 :
130 : // enlarge text by given scale factor. Do that
131 : // with the middle of the shape as the center
132 : // of scaling.
133 0 : aMatrix.translate( -0.5, -0.5 );
134 : aMatrix.scale( rAttr->getCharScale(),
135 0 : rAttr->getCharScale() );
136 0 : aMatrix.translate( 0.5, 0.5 );
137 :
138 0 : aParms.maTextTransformation = aMatrix;
139 : }
140 0 : if( rAttr->isCharWeightValid() )
141 : {
142 : aParms.maFontWeight =
143 : static_cast< sal_Int8 >(
144 : ::basegfx::fround(
145 : ::std::max( 0.0,
146 : ::std::min( 11.0,
147 0 : rAttr->getCharWeight() / 20.0 ) ) ) );
148 : }
149 0 : if( rAttr->isCharPostureValid() )
150 : {
151 : aParms.maFontLetterForm =
152 0 : rAttr->getCharPosture() == awt::FontSlant_NONE ?
153 : rendering::PanoseLetterForm::ANYTHING :
154 0 : rendering::PanoseLetterForm::OBLIQUE_CONTACT;
155 : }
156 0 : if( rAttr->isUnderlineModeValid() )
157 : {
158 : aParms.maFontUnderline =
159 0 : rAttr->getUnderlineMode();
160 : }
161 : }
162 :
163 0 : io_rCacheEntry.mpRenderer = ::cppcanvas::VCLFactory::getInstance().createRenderer( rDestinationCanvas,
164 0 : *rMtf.get(),
165 0 : aParms );
166 :
167 0 : io_rCacheEntry.mpMtf = rMtf;
168 0 : io_rCacheEntry.mpDestinationCanvas = rDestinationCanvas;
169 :
170 : // also invalidate alpha compositing bitmap (created
171 : // new renderer, which possibly generates different
172 : // output). Do NOT invalidate, if we're incidentally
173 : // rendering INTO it.
174 0 : if( rDestinationCanvas != io_rCacheEntry.mpLastBitmapCanvas )
175 : {
176 0 : io_rCacheEntry.mpLastBitmapCanvas.reset();
177 0 : io_rCacheEntry.mpLastBitmap.reset();
178 0 : }
179 : }
180 :
181 0 : return io_rCacheEntry.mpRenderer;
182 : }
183 :
184 0 : bool ViewShape::draw( const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
185 : const GDIMetaFileSharedPtr& rMtf,
186 : const ShapeAttributeLayerSharedPtr& rAttr,
187 : const ::basegfx::B2DHomMatrix& rTransform,
188 : const ::basegfx::B2DPolyPolygon* pClip,
189 : const VectorOfDocTreeNodes& rSubsets ) const
190 : {
191 : RTL_LOGFILE_CONTEXT( aLog, "::presentation::internal::ViewShape::draw()" );
192 :
193 : ::cppcanvas::RendererSharedPtr pRenderer(
194 0 : getRenderer( rDestinationCanvas, rMtf, rAttr ) );
195 :
196 0 : ENSURE_OR_RETURN_FALSE( pRenderer, "ViewShape::draw(): Invalid renderer" );
197 :
198 0 : pRenderer->setTransformation( rTransform );
199 : #if OSL_DEBUG_LEVEL >= 2
200 : rendering::RenderState aRenderState;
201 : ::canvas::tools::initRenderState(aRenderState);
202 : ::canvas::tools::setRenderStateTransform(aRenderState,
203 : rTransform);
204 : aRenderState.DeviceColor.realloc(4);
205 : aRenderState.DeviceColor[0] = 1.0;
206 : aRenderState.DeviceColor[1] = 0.0;
207 : aRenderState.DeviceColor[2] = 0.0;
208 : aRenderState.DeviceColor[3] = 1.0;
209 :
210 : try
211 : {
212 : rDestinationCanvas->getUNOCanvas()->drawLine( geometry::RealPoint2D(0.0,0.0),
213 : geometry::RealPoint2D(1.0,1.0),
214 : rDestinationCanvas->getViewState(),
215 : aRenderState );
216 : rDestinationCanvas->getUNOCanvas()->drawLine( geometry::RealPoint2D(1.0,0.0),
217 : geometry::RealPoint2D(0.0,1.0),
218 : rDestinationCanvas->getViewState(),
219 : aRenderState );
220 : }
221 : catch( uno::Exception& )
222 : {
223 : DBG_UNHANDLED_EXCEPTION();
224 : }
225 : #endif
226 0 : if( pClip )
227 0 : pRenderer->setClip( *pClip );
228 : else
229 0 : pRenderer->setClip();
230 :
231 0 : if( rSubsets.empty() )
232 : {
233 0 : return pRenderer->draw();
234 : }
235 : else
236 : {
237 : // render subsets of whole metafile
238 : // --------------------------------
239 :
240 0 : bool bRet(true);
241 0 : VectorOfDocTreeNodes::const_iterator aIter( rSubsets.begin() );
242 0 : const VectorOfDocTreeNodes::const_iterator aEnd ( rSubsets.end() );
243 0 : while( aIter != aEnd )
244 : {
245 0 : if( !pRenderer->drawSubset( aIter->getStartIndex(),
246 0 : aIter->getEndIndex() ) )
247 0 : bRet = false;
248 :
249 0 : ++aIter;
250 : }
251 :
252 0 : return bRet;
253 0 : }
254 : }
255 :
256 : namespace
257 : {
258 : /// Convert untransformed shape update area to device pixel.
259 0 : ::basegfx::B2DRectangle shapeArea2AreaPixel( const ::basegfx::B2DHomMatrix& rCanvasTransformation,
260 : const ::basegfx::B2DRectangle& rUntransformedArea )
261 : {
262 : // convert area to pixel, and add anti-aliasing border
263 :
264 : // TODO(P1): Should the view transform some
265 : // day contain rotation/shear, transforming
266 : // the original bounds with the total
267 : // transformation might result in smaller
268 : // overall bounds.
269 :
270 0 : ::basegfx::B2DRectangle aBoundsPixel;
271 : ::canvas::tools::calcTransformedRectBounds( aBoundsPixel,
272 : rUntransformedArea,
273 0 : rCanvasTransformation );
274 :
275 : // add antialiasing border around the shape (AA
276 : // touches pixel _outside_ the nominal bound rect)
277 0 : aBoundsPixel.grow( ::cppcanvas::Canvas::ANTIALIASING_EXTRA_SIZE );
278 :
279 0 : return aBoundsPixel;
280 : }
281 :
282 : /// Convert shape unit rect to device pixel.
283 0 : ::basegfx::B2DRectangle calcUpdateAreaPixel( const ::basegfx::B2DRectangle& rUnitBounds,
284 : const ::basegfx::B2DHomMatrix& rShapeTransformation,
285 : const ::basegfx::B2DHomMatrix& rCanvasTransformation,
286 : const ShapeAttributeLayerSharedPtr& pAttr )
287 : {
288 : // calc update area for whole shape (including
289 : // character scaling)
290 : return shapeArea2AreaPixel( rCanvasTransformation,
291 : getShapeUpdateArea( rUnitBounds,
292 : rShapeTransformation,
293 0 : pAttr ) );
294 : }
295 : }
296 :
297 0 : bool ViewShape::renderSprite( const ViewLayerSharedPtr& rViewLayer,
298 : const GDIMetaFileSharedPtr& rMtf,
299 : const ::basegfx::B2DRectangle& rOrigBounds,
300 : const ::basegfx::B2DRectangle& rBounds,
301 : const ::basegfx::B2DRectangle& rUnitBounds,
302 : int nUpdateFlags,
303 : const ShapeAttributeLayerSharedPtr& pAttr,
304 : const VectorOfDocTreeNodes& rSubsets,
305 : double nPrio,
306 : bool bIsVisible ) const
307 : {
308 : RTL_LOGFILE_CONTEXT( aLog, "::presentation::internal::ViewShape::renderSprite()" );
309 :
310 : // TODO(P1): For multiple views, it might pay off to reorg Shape and ViewShape,
311 : // in that all the common setup steps here are refactored to Shape (would then
312 : // have to be performed only _once_ per Shape paint).
313 :
314 0 : if( !bIsVisible ||
315 0 : rUnitBounds.isEmpty() ||
316 0 : rOrigBounds.isEmpty() ||
317 0 : rBounds.isEmpty() )
318 : {
319 : // shape is invisible or has zero size, no need to
320 : // update anything.
321 0 : if( mpSprite )
322 0 : mpSprite->hide();
323 :
324 0 : return true;
325 : }
326 :
327 :
328 : // calc sprite position, size and content transformation
329 : // =====================================================
330 :
331 : // the shape transformation for a sprite is always a
332 : // simple scale-up to the nominal shape size. Everything
333 : // else is handled via the sprite transformation
334 0 : ::basegfx::B2DHomMatrix aNonTranslationalShapeTransformation;
335 : aNonTranslationalShapeTransformation.scale( rOrigBounds.getWidth(),
336 0 : rOrigBounds.getHeight() );
337 0 : ::basegfx::B2DHomMatrix aShapeTransformation( aNonTranslationalShapeTransformation );
338 : aShapeTransformation.translate( rOrigBounds.getMinX(),
339 0 : rOrigBounds.getMinY() );
340 :
341 : const ::basegfx::B2DHomMatrix& rCanvasTransform(
342 0 : rViewLayer->getSpriteTransformation() );
343 :
344 : // area actually needed for the sprite
345 : const ::basegfx::B2DRectangle& rSpriteBoundsPixel(
346 : calcUpdateAreaPixel( rUnitBounds,
347 : aShapeTransformation,
348 : rCanvasTransform,
349 0 : pAttr ) );
350 :
351 : // actual area for the shape (without subsetting, but
352 : // including char scaling)
353 : const ::basegfx::B2DRectangle& rShapeBoundsPixel(
354 : calcUpdateAreaPixel( ::basegfx::B2DRectangle(0.0,0.0,1.0,1.0),
355 : aShapeTransformation,
356 : rCanvasTransform,
357 0 : pAttr ) );
358 :
359 : // nominal area for the shape (without subsetting, without
360 : // char scaling). NOTE: to cancel the shape translation,
361 : // contained in rSpriteBoundsPixel, this is _without_ any
362 : // translational component.
363 0 : ::basegfx::B2DRectangle aLogShapeBounds;
364 : const ::basegfx::B2DRectangle& rNominalShapeBoundsPixel(
365 : shapeArea2AreaPixel( rCanvasTransform,
366 : ::canvas::tools::calcTransformedRectBounds(
367 : aLogShapeBounds,
368 : ::basegfx::B2DRectangle(0.0,0.0,1.0,1.0),
369 0 : aNonTranslationalShapeTransformation ) ) );
370 :
371 : // create (or resize) sprite with sprite's pixel size, if
372 : // not done already
373 0 : const ::basegfx::B2DSize& rSpriteSizePixel(rSpriteBoundsPixel.getRange());
374 0 : if( !mpSprite )
375 : {
376 : mpSprite.reset(
377 : new AnimatedSprite( mpViewLayer,
378 : rSpriteSizePixel,
379 0 : nPrio ));
380 : }
381 : else
382 : {
383 : // TODO(F2): when the sprite _actually_ gets resized,
384 : // content needs a repaint!
385 0 : mpSprite->resize( rSpriteSizePixel );
386 : }
387 :
388 0 : ENSURE_OR_RETURN_FALSE( mpSprite, "ViewShape::renderSprite(): No sprite" );
389 :
390 : VERBOSE_TRACE( "ViewShape::renderSprite(): Rendering sprite 0x%X",
391 : mpSprite.get() );
392 :
393 :
394 : // always show the sprite (might have been hidden before)
395 0 : mpSprite->show();
396 :
397 : // determine center of sprite output position in pixel
398 : // (assumption here: all shape transformations have the
399 : // shape center as the pivot point). From that, subtract
400 : // distance of rSpriteBoundsPixel's left, top edge from
401 : // rShapeBoundsPixel's center. This moves the sprite at
402 : // the appropriate output position within the virtual
403 : // rShapeBoundsPixel area.
404 0 : ::basegfx::B2DPoint aSpritePosPixel( rBounds.getCenter() );
405 0 : aSpritePosPixel *= rCanvasTransform;
406 0 : aSpritePosPixel -= rShapeBoundsPixel.getCenter() - rSpriteBoundsPixel.getMinimum();
407 :
408 : // the difference between rShapeBoundsPixel and
409 : // rSpriteBoundsPixel upper, left corner is: the offset we
410 : // have to move sprite output to the right, top (to make
411 : // the desired subset content visible at all)
412 : const ::basegfx::B2DSize& rSpriteCorrectionOffset(
413 0 : rSpriteBoundsPixel.getMinimum() - rNominalShapeBoundsPixel.getMinimum() );
414 :
415 : // offset added top, left for anti-aliasing (otherwise,
416 : // shapes fully filling the sprite will have anti-aliased
417 : // pixel cut off)
418 : const ::basegfx::B2DSize aAAOffset(
419 : ::cppcanvas::Canvas::ANTIALIASING_EXTRA_SIZE,
420 0 : ::cppcanvas::Canvas::ANTIALIASING_EXTRA_SIZE );
421 :
422 : // set pixel output offset to sprite: we always leave
423 : // ANTIALIASING_EXTRA_SIZE room atop and to the left, and,
424 : // what's more, for subsetted shapes, we _have_ to cancel
425 : // the effect of the shape renderer outputting the subset
426 : // at its absolute position inside the shape, instead of
427 : // at the origin.
428 : // NOTE: As for now, sprites are always positioned on
429 : // integer pixel positions on screen, have to round to
430 : // nearest integer here, too
431 : mpSprite->setPixelOffset(
432 : aAAOffset - ::basegfx::B2DSize(
433 0 : ::basegfx::fround( rSpriteCorrectionOffset.getX() ),
434 0 : ::basegfx::fround( rSpriteCorrectionOffset.getY() ) ) );
435 :
436 : // always set sprite position and transformation, since
437 : // they do not relate directly to the update flags
438 : // (e.g. sprite position changes when sprite size changes)
439 0 : mpSprite->movePixel( aSpritePosPixel );
440 : mpSprite->transform( getSpriteTransformation( rSpriteSizePixel,
441 : rOrigBounds.getRange(),
442 0 : pAttr ) );
443 :
444 :
445 : // process flags
446 : // =============
447 :
448 0 : bool bRedrawRequired( mbForceUpdate || (nUpdateFlags & FORCE) );
449 :
450 0 : if( mbForceUpdate || (nUpdateFlags & ALPHA) )
451 : {
452 0 : mpSprite->setAlpha( (pAttr && pAttr->isAlphaValid()) ?
453 0 : ::basegfx::clamp(pAttr->getAlpha(),
454 : 0.0,
455 0 : 1.0) :
456 0 : 1.0 );
457 : }
458 0 : if( mbForceUpdate || (nUpdateFlags & CLIP) )
459 : {
460 0 : if( pAttr && pAttr->isClipValid() )
461 : {
462 0 : ::basegfx::B2DPolyPolygon aClipPoly( pAttr->getClip() );
463 :
464 : // extract linear part of canvas view transformation
465 : // (linear means: without translational components)
466 : ::basegfx::B2DHomMatrix aViewTransform(
467 0 : mpViewLayer->getTransformation() );
468 0 : aViewTransform.set( 0, 2, 0.0 );
469 0 : aViewTransform.set( 1, 2, 0.0 );
470 :
471 : // make the clip 2*ANTIALIASING_EXTRA_SIZE larger
472 : // such that it's again centered over the sprite.
473 0 : aViewTransform.scale(rSpriteSizePixel.getX()/
474 0 : (rSpriteSizePixel.getX()-2*::cppcanvas::Canvas::ANTIALIASING_EXTRA_SIZE),
475 0 : rSpriteSizePixel.getY()/
476 0 : (rSpriteSizePixel.getY()-2*::cppcanvas::Canvas::ANTIALIASING_EXTRA_SIZE));
477 :
478 : // transform clip polygon from view to device
479 : // coordinate space
480 0 : aClipPoly.transform( aViewTransform );
481 :
482 0 : mpSprite->clip( aClipPoly );
483 : }
484 : else
485 0 : mpSprite->clip();
486 : }
487 0 : if( mbForceUpdate || (nUpdateFlags & CONTENT) )
488 : {
489 0 : bRedrawRequired = true;
490 :
491 : // TODO(P1): maybe provide some appearance change methods at
492 : // the Renderer interface
493 :
494 : // force the renderer to be regenerated below, for the
495 : // different attributes to take effect
496 0 : invalidateRenderer();
497 : }
498 :
499 0 : mbForceUpdate = false;
500 :
501 0 : if( !bRedrawRequired )
502 0 : return true;
503 :
504 :
505 : // sprite needs repaint - output to sprite canvas
506 : // ==============================================
507 :
508 0 : ::cppcanvas::CanvasSharedPtr pContentCanvas( mpSprite->getContentCanvas() );
509 :
510 : return draw( pContentCanvas,
511 : rMtf,
512 : pAttr,
513 : aShapeTransformation,
514 : NULL, // clipping is done via Sprite::clip()
515 0 : rSubsets );
516 : }
517 :
518 0 : bool ViewShape::render( const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
519 : const GDIMetaFileSharedPtr& rMtf,
520 : const ::basegfx::B2DRectangle& rBounds,
521 : const ::basegfx::B2DRectangle& rUpdateBounds,
522 : int nUpdateFlags,
523 : const ShapeAttributeLayerSharedPtr& pAttr,
524 : const VectorOfDocTreeNodes& rSubsets,
525 : bool bIsVisible ) const
526 : {
527 : RTL_LOGFILE_CONTEXT( aLog, "::presentation::internal::ViewShape::render()" );
528 :
529 : // TODO(P1): For multiple views, it might pay off to reorg Shape and ViewShape,
530 : // in that all the common setup steps here are refactored to Shape (would then
531 : // have to be performed only _once_ per Shape paint).
532 :
533 0 : if( !bIsVisible )
534 : {
535 : VERBOSE_TRACE( "ViewShape::render(): skipping shape %X", this );
536 :
537 : // shape is invisible, no need to update anything.
538 0 : return true;
539 : }
540 :
541 : // since we have no sprite here, _any_ update request
542 : // translates into a required redraw.
543 0 : bool bRedrawRequired( mbForceUpdate || nUpdateFlags != 0 );
544 :
545 0 : if( (nUpdateFlags & CONTENT) )
546 : {
547 : // TODO(P1): maybe provide some appearance change methods at
548 : // the Renderer interface
549 :
550 : // force the renderer to be regenerated below, for the
551 : // different attributes to take effect
552 0 : invalidateRenderer();
553 : }
554 :
555 0 : mbForceUpdate = false;
556 :
557 0 : if( !bRedrawRequired )
558 0 : return true;
559 :
560 : VERBOSE_TRACE( "ViewShape::render(): rendering shape %X at position (%f,%f)",
561 : this,
562 : rBounds.getMinX(),
563 : rBounds.getMinY() );
564 :
565 :
566 : // shape needs repaint - setup all that's needed
567 : // ---------------------------------------------
568 :
569 0 : boost::optional<basegfx::B2DPolyPolygon> aClip;
570 :
571 0 : if( pAttr )
572 : {
573 : // setup clip poly
574 0 : if( pAttr->isClipValid() )
575 0 : aClip.reset( pAttr->getClip() );
576 :
577 : // emulate global shape alpha by first rendering into
578 : // a temp bitmap, and then to screen (this would have
579 : // been much easier if we'd be currently a sprite -
580 : // see above)
581 0 : if( pAttr->isAlphaValid() )
582 : {
583 0 : const double nAlpha( pAttr->getAlpha() );
584 :
585 0 : if( !::basegfx::fTools::equalZero( nAlpha ) &&
586 0 : !::rtl::math::approxEqual(nAlpha, 1.0) )
587 : {
588 : // render with global alpha - have to prepare
589 : // a bitmap, and render that with modulated
590 : // alpha
591 : // -------------------------------------------
592 :
593 : const ::basegfx::B2DHomMatrix aTransform(
594 : getShapeTransformation( rBounds,
595 0 : pAttr ) );
596 :
597 : // TODO(P1): Should the view transform some
598 : // day contain rotation/shear, transforming
599 : // the original bounds with the total
600 : // transformation might result in smaller
601 : // overall bounds.
602 :
603 : // determine output rect of _shape update
604 : // area_ in device pixel
605 : const ::basegfx::B2DHomMatrix aCanvasTransform(
606 0 : rDestinationCanvas->getTransformation() );
607 0 : ::basegfx::B2DRectangle aTmpRect;
608 : ::canvas::tools::calcTransformedRectBounds( aTmpRect,
609 : rUpdateBounds,
610 0 : aCanvasTransform );
611 :
612 : // pixel size of cache bitmap: round up to
613 : // nearest int
614 0 : const ::basegfx::B2ISize aBmpSize( static_cast<sal_Int32>( aTmpRect.getWidth() )+1,
615 0 : static_cast<sal_Int32>( aTmpRect.getHeight() )+1 );
616 :
617 : // try to fetch temporary surface for alpha
618 : // compositing (to achieve the global alpha
619 : // blend effect, have to first render shape as
620 : // a whole, then blit that surface with global
621 : // alpha to the destination)
622 : const RendererCacheVector::iterator aCompositingSurface(
623 0 : getCacheEntry( rDestinationCanvas ) );
624 :
625 0 : if( !aCompositingSurface->mpLastBitmapCanvas ||
626 0 : aCompositingSurface->mpLastBitmapCanvas->getSize() != aBmpSize )
627 : {
628 : // create a bitmap of appropriate size
629 : ::cppcanvas::BitmapSharedPtr pBitmap(
630 0 : ::cppcanvas::BaseGfxFactory::getInstance().createAlphaBitmap(
631 : rDestinationCanvas,
632 0 : aBmpSize ) );
633 :
634 0 : ENSURE_OR_THROW(pBitmap,
635 : "ViewShape::render(): Could not create compositing surface");
636 :
637 0 : aCompositingSurface->mpDestinationCanvas = rDestinationCanvas;
638 0 : aCompositingSurface->mpLastBitmap = pBitmap;
639 0 : aCompositingSurface->mpLastBitmapCanvas = pBitmap->getBitmapCanvas();
640 : }
641 :
642 : // buffer aCompositingSurface iterator content
643 : // - said one might get invalidated during
644 : // draw() below.
645 : ::cppcanvas::BitmapCanvasSharedPtr pBitmapCanvas(
646 0 : aCompositingSurface->mpLastBitmapCanvas );
647 :
648 : ::cppcanvas::BitmapSharedPtr pBitmap(
649 0 : aCompositingSurface->mpLastBitmap);
650 :
651 : // setup bitmap canvas transformation -
652 : // which happens to be the destination
653 : // canvas transformation without any
654 : // translational components.
655 : //
656 : // But then, the render transformation as
657 : // calculated by getShapeTransformation()
658 : // above outputs the shape at its real
659 : // destination position. Thus, we have to
660 : // offset the output back to the origin,
661 : // for which we simply plug in the
662 : // negative position of the left, top edge
663 : // of the shape's bound rect in device
664 : // pixel into aLinearTransform below.
665 0 : ::basegfx::B2DHomMatrix aAdjustedCanvasTransform( aCanvasTransform );
666 0 : aAdjustedCanvasTransform.translate( -aTmpRect.getMinX(),
667 0 : -aTmpRect.getMinY() );
668 :
669 0 : pBitmapCanvas->setTransformation( aAdjustedCanvasTransform );
670 :
671 : // TODO(P2): If no update flags, or only
672 : // alpha_update is set, we can save us the
673 : // rendering into the bitmap (uh, it's not
674 : // _that_ easy - for a forced redraw,
675 : // e.g. when ending an animation, we always
676 : // get UPDATE_FORCE here).
677 :
678 : // render into this bitmap
679 0 : if( !draw( pBitmapCanvas,
680 : rMtf,
681 : pAttr,
682 : aTransform,
683 0 : !aClip ? NULL : &(*aClip),
684 0 : rSubsets ) )
685 : {
686 0 : return false;
687 : }
688 :
689 : // render bitmap to screen, with given global
690 : // alpha. Since the bitmap already contains
691 : // pixel-equivalent output, we have to use the
692 : // inverse view transformation, adjusted with
693 : // the final shape output position (note:
694 : // cannot simply change the view
695 : // transformation here, as that would affect a
696 : // possibly set clip!)
697 0 : ::basegfx::B2DHomMatrix aBitmapTransform( aCanvasTransform );
698 : OSL_ENSURE( aBitmapTransform.isInvertible(),
699 : "ViewShape::render(): View transformation is singular!" );
700 :
701 0 : aBitmapTransform.invert();
702 :
703 : const basegfx::B2DHomMatrix aTranslation(basegfx::tools::createTranslateB2DHomMatrix(
704 0 : aTmpRect.getMinX(), aTmpRect.getMinY()));
705 :
706 0 : aBitmapTransform = aBitmapTransform * aTranslation;
707 0 : pBitmap->setTransformation( aBitmapTransform );
708 :
709 : // finally, render bitmap alpha-modulated
710 0 : pBitmap->drawAlphaModulated( nAlpha );
711 :
712 0 : return true;
713 : }
714 : }
715 : }
716 :
717 : // retrieve shape transformation, _with_ shape translation
718 : // to actual page position.
719 : const ::basegfx::B2DHomMatrix aTransform(
720 : getShapeTransformation( rBounds,
721 0 : pAttr ) );
722 :
723 : return draw( rDestinationCanvas,
724 : rMtf,
725 : pAttr,
726 : aTransform,
727 0 : !aClip ? NULL : &(*aClip),
728 0 : rSubsets );
729 : }
730 :
731 :
732 : // -------------------------------------------------------------------------------------
733 :
734 0 : ViewShape::ViewShape( const ViewLayerSharedPtr& rViewLayer ) :
735 : mpViewLayer( rViewLayer ),
736 : maRenderers(),
737 : mpSprite(),
738 : mbAnimationMode( false ),
739 0 : mbForceUpdate( true )
740 : {
741 0 : ENSURE_OR_THROW( mpViewLayer, "ViewShape::ViewShape(): Invalid View" );
742 0 : }
743 :
744 0 : ViewLayerSharedPtr ViewShape::getViewLayer() const
745 : {
746 0 : return mpViewLayer;
747 : }
748 :
749 0 : ViewShape::RendererCacheVector::iterator ViewShape::getCacheEntry( const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas ) const
750 : {
751 : // lookup destination canvas - is there already a renderer
752 : // created for that target?
753 0 : RendererCacheVector::iterator aIter;
754 0 : const RendererCacheVector::iterator aEnd( maRenderers.end() );
755 :
756 : // already there?
757 0 : if( (aIter=::std::find_if( maRenderers.begin(),
758 : aEnd,
759 : ::boost::bind(
760 : ::std::equal_to< ::cppcanvas::CanvasSharedPtr >(),
761 : ::boost::cref( rDestinationCanvas ),
762 : ::boost::bind(
763 : &RendererCacheEntry::getDestinationCanvas,
764 0 : _1 ) ) ) ) == aEnd )
765 : {
766 0 : if( maRenderers.size() >= MAX_RENDER_CACHE_ENTRIES )
767 : {
768 : // cache size exceeded - prune entries. For now,
769 : // simply remove the first one, which of course
770 : // breaks for more complex access schemes. But in
771 : // general, this leads to most recently used
772 : // entries to reside at the end of the vector.
773 0 : maRenderers.erase( maRenderers.begin() );
774 :
775 : // ATTENTION: after this, both aIter and aEnd are
776 : // invalid!
777 : }
778 :
779 : // not yet in cache - add default-constructed cache
780 : // entry, to have something to return
781 0 : maRenderers.push_back( RendererCacheEntry() );
782 0 : aIter = maRenderers.end()-1;
783 : }
784 :
785 0 : return aIter;
786 : }
787 :
788 0 : ::cppcanvas::RendererSharedPtr ViewShape::getRenderer( const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
789 : const GDIMetaFileSharedPtr& rMtf,
790 : const ShapeAttributeLayerSharedPtr& rAttr ) const
791 : {
792 : // lookup destination canvas - is there already a renderer
793 : // created for that target?
794 : const RendererCacheVector::iterator aIter(
795 0 : getCacheEntry( rDestinationCanvas ) );
796 :
797 : // now we have a valid entry, either way. call prefetch()
798 : // on it, nevertheless - maybe the metafile changed, and
799 : // the renderer still needs an update (prefetch() will
800 : // detect that)
801 0 : if( prefetch( *aIter,
802 : rDestinationCanvas,
803 : rMtf,
804 : rAttr ) )
805 : {
806 0 : return aIter->mpRenderer;
807 : }
808 : else
809 : {
810 : // prefetch failed - renderer is invalid
811 0 : return ::cppcanvas::RendererSharedPtr();
812 : }
813 : }
814 :
815 0 : void ViewShape::invalidateRenderer() const
816 : {
817 : // simply clear the cache. Subsequent getRenderer() calls
818 : // will regenerate the Renderers.
819 0 : maRenderers.clear();
820 0 : }
821 :
822 0 : ::basegfx::B2DSize ViewShape::getAntialiasingBorder() const
823 : {
824 0 : ENSURE_OR_THROW( mpViewLayer->getCanvas(),
825 : "ViewShape::getAntialiasingBorder(): Invalid ViewLayer canvas" );
826 :
827 : const ::basegfx::B2DHomMatrix& rViewTransform(
828 0 : mpViewLayer->getTransformation() );
829 :
830 : // TODO(F1): As a quick shortcut (did not want to invert
831 : // whole matrix here), taking only scale components of
832 : // view transformation matrix. This will be wrong when
833 : // e.g. shearing is involved.
834 0 : const double nXBorder( ::cppcanvas::Canvas::ANTIALIASING_EXTRA_SIZE / rViewTransform.get(0,0) );
835 0 : const double nYBorder( ::cppcanvas::Canvas::ANTIALIASING_EXTRA_SIZE / rViewTransform.get(1,1) );
836 :
837 : return ::basegfx::B2DSize( nXBorder,
838 0 : nYBorder );
839 : }
840 :
841 0 : bool ViewShape::enterAnimationMode()
842 : {
843 0 : mbForceUpdate = true;
844 0 : mbAnimationMode = true;
845 :
846 0 : return true;
847 : }
848 :
849 0 : void ViewShape::leaveAnimationMode()
850 : {
851 0 : mpSprite.reset();
852 0 : mbAnimationMode = false;
853 0 : mbForceUpdate = true;
854 0 : }
855 :
856 0 : bool ViewShape::update( const GDIMetaFileSharedPtr& rMtf,
857 : const RenderArgs& rArgs,
858 : int nUpdateFlags,
859 : bool bIsVisible ) const
860 : {
861 : RTL_LOGFILE_CONTEXT( aLog, "::presentation::internal::ViewShape::update()" );
862 0 : ENSURE_OR_RETURN_FALSE( mpViewLayer->getCanvas(), "ViewShape::update(): Invalid layer canvas" );
863 :
864 : // Shall we render to a sprite, or to a plain canvas?
865 0 : if( isBackgroundDetached() )
866 : return renderSprite( mpViewLayer,
867 : rMtf,
868 : rArgs.maOrigBounds,
869 : rArgs.maBounds,
870 : rArgs.maUnitBounds,
871 : nUpdateFlags,
872 : rArgs.mrAttr,
873 : rArgs.mrSubsets,
874 : rArgs.mnShapePriority,
875 0 : bIsVisible );
876 : else
877 0 : return render( mpViewLayer->getCanvas(),
878 : rMtf,
879 : rArgs.maBounds,
880 : rArgs.maUpdateBounds,
881 : nUpdateFlags,
882 : rArgs.mrAttr,
883 : rArgs.mrSubsets,
884 0 : bIsVisible );
885 : }
886 :
887 : }
888 0 : }
889 :
890 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
