Branch data 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 : : #include <canvas/debug.hxx>
21 : : #include <tools/diagnose_ex.h>
22 : : #include <canvas/canvastools.hxx>
23 : :
24 : : #include "eventqueue.hxx"
25 : : #include "eventmultiplexer.hxx"
26 : : #include "slideview.hxx"
27 : : #include "delayevent.hxx"
28 : : #include "unoview.hxx"
29 : :
30 : : #include <rtl/instance.hxx>
31 : : #include <cppuhelper/basemutex.hxx>
32 : : #include <cppuhelper/compbase2.hxx>
33 : : #include <cppuhelper/implementationentry.hxx>
34 : : #include <cppuhelper/interfacecontainer.h>
35 : : #include <comphelper/make_shared_from_uno.hxx>
36 : :
37 : : #include <cppcanvas/spritecanvas.hxx>
38 : : #include <cppcanvas/customsprite.hxx>
39 : : #include <cppcanvas/vclfactory.hxx>
40 : : #include <cppcanvas/basegfxfactory.hxx>
41 : :
42 : : #include <tools/debug.hxx>
43 : :
44 : : #include <basegfx/range/b1drange.hxx>
45 : : #include <basegfx/range/b2drange.hxx>
46 : : #include <basegfx/range/b2irange.hxx>
47 : : #include <basegfx/point/b2dpoint.hxx>
48 : : #include <basegfx/polygon/b2dpolygon.hxx>
49 : : #include <basegfx/matrix/b2dhommatrix.hxx>
50 : : #include <basegfx/polygon/b2dpolygontools.hxx>
51 : : #include <basegfx/polygon/b2dpolypolygontools.hxx>
52 : : #include <basegfx/tools/canvastools.hxx>
53 : : #include <basegfx/polygon/b2dpolygonclipper.hxx>
54 : : #include <basegfx/polygon/b2dpolypolygoncutter.hxx>
55 : :
56 : : #include <com/sun/star/presentation/XSlideShow.hpp>
57 : :
58 : : #include <boost/noncopyable.hpp>
59 : : #include <boost/bind.hpp>
60 : : #include <boost/weak_ptr.hpp>
61 : :
62 : : #include <vector>
63 : : #include <iterator>
64 : : #include <algorithm>
65 : :
66 : : using namespace com::sun::star;
67 : :
68 : : namespace slideshow {
69 : : namespace internal {
70 : :
71 : : namespace {
72 : :
73 : : struct StaticUnitRectPoly : public rtl::StaticWithInit<basegfx::B2DPolygon, StaticUnitRectPoly>
74 : : {
75 : : basegfx::B2DPolygon operator()()
76 : : {
77 : : return basegfx::tools::createUnitPolygon();
78 : : }
79 : : };
80 : :
81 : : /** Sprite entry, to store sprite plus priority
82 : :
83 : : The operator<() defines a strict weak ordering of sprites, sort
84 : : key is the sprite priority.
85 : : */
86 : 0 : struct SpriteEntry
87 : : {
88 : 0 : SpriteEntry( const cppcanvas::CustomSpriteSharedPtr& rSprite,
89 : : double nPrio ) :
90 : : mpSprite( rSprite ),
91 : 0 : mnPriority( nPrio )
92 : : {
93 : 0 : }
94 : :
95 : 0 : bool operator<(const SpriteEntry& rRHS) const
96 : : {
97 : 0 : return mnPriority < rRHS.mnPriority;
98 : : }
99 : :
100 : : boost::weak_ptr< cppcanvas::CustomSprite > mpSprite;
101 : : double mnPriority;
102 : : };
103 : :
104 : : typedef std::vector< SpriteEntry > SpriteVector;
105 : :
106 : :
107 : : /** Create a clip polygon for slide views
108 : :
109 : : @param rClip
110 : : Clip to set (can be empty)
111 : :
112 : : @param rCanvas
113 : : Canvas to create the clip polygon for
114 : :
115 : : @param rUserSize
116 : : The size of the view. Note that the returned clip will
117 : : <em>always</em> clip to at least the rect defined herein.
118 : :
119 : : @return the view clip polygon, in view coordinates, which is
120 : : guaranteed to at least clip to the view size.
121 : : */
122 : 0 : basegfx::B2DPolyPolygon createClipPolygon( const basegfx::B2DPolyPolygon& rClip,
123 : : const cppcanvas::CanvasSharedPtr& /*rCanvas*/,
124 : : const basegfx::B2DSize& rUserSize )
125 : : {
126 : : // setup canvas clipping
127 : : // =====================
128 : :
129 : : // AW: Simplified
130 : 0 : const basegfx::B2DRange aClipRange(0, 0, rUserSize.getX(), rUserSize.getY());
131 : :
132 : 0 : if(rClip.count())
133 : : {
134 : 0 : return basegfx::tools::clipPolyPolygonOnRange(rClip, aClipRange, true, false);
135 : : }
136 : : else
137 : : {
138 : 0 : return basegfx::B2DPolyPolygon(basegfx::tools::createPolygonFromRect(aClipRange));
139 : : }
140 : : }
141 : :
142 : : /** Prepare given clip polygon to be stored as the current clip
143 : :
144 : : Note that this is separate from createClipPolygon(), to allow
145 : : SlideView implementations to store this intermediate result
146 : : (createClipPolygon() has to be called every time the view size
147 : : changes)
148 : : */
149 : 0 : basegfx::B2DPolyPolygon prepareClip( const basegfx::B2DPolyPolygon& rClip )
150 : : {
151 : 0 : basegfx::B2DPolyPolygon aClip( rClip );
152 : :
153 : : // TODO(P2): unnecessary, once XCanvas is correctly handling this
154 : : // AW: Should be no longer necessary; tools are now bezier-safe
155 : 0 : if( aClip.areControlPointsUsed() )
156 : 0 : aClip = basegfx::tools::adaptiveSubdivideByAngle( aClip );
157 : :
158 : : // normalize polygon, preparation for clipping
159 : : // in updateCanvas()
160 : 0 : aClip = basegfx::tools::correctOrientations(aClip);
161 : 0 : aClip = basegfx::tools::solveCrossovers(aClip);
162 : 0 : aClip = basegfx::tools::stripNeutralPolygons(aClip);
163 : 0 : aClip = basegfx::tools::stripDispensablePolygons(aClip, false);
164 : :
165 : 0 : return aClip;
166 : : }
167 : :
168 : :
169 : 0 : void clearRect( ::cppcanvas::CanvasSharedPtr const& pCanvas,
170 : : basegfx::B2IRange const& rArea )
171 : : {
172 : : // convert clip polygon to device coordinate system
173 : 0 : ::basegfx::B2DPolyPolygon const* pClipPoly( pCanvas->getClip() );
174 : 0 : if( pClipPoly )
175 : : {
176 : 0 : ::basegfx::B2DPolyPolygon aClipPoly( *pClipPoly );
177 : 0 : aClipPoly.transform( pCanvas->getTransformation() );
178 : 0 : pCanvas->setClip( aClipPoly );
179 : : }
180 : :
181 : : // set transformation to identitiy (->device pixel)
182 : 0 : pCanvas->setTransformation( ::basegfx::B2DHomMatrix() );
183 : :
184 : : // #i42440# Fill the _full_ background in
185 : : // black. Since we had to extend the bitmap by one
186 : : // pixel, and the bitmap is initialized white,
187 : : // depending on the slide content a one pixel wide
188 : : // line will show to the bottom and the right.
189 : : const ::basegfx::B2DPolygon aPoly(
190 : : ::basegfx::tools::createPolygonFromRect(
191 : 0 : basegfx::B2DRange(rArea)));
192 : :
193 : : ::cppcanvas::PolyPolygonSharedPtr pPolyPoly(
194 : 0 : ::cppcanvas::BaseGfxFactory::getInstance().createPolyPolygon( pCanvas,
195 : 0 : aPoly ) );
196 : :
197 : 0 : if( pPolyPoly )
198 : : {
199 : 0 : pPolyPoly->setCompositeOp( cppcanvas::CanvasGraphic::SOURCE );
200 : 0 : pPolyPoly->setRGBAFillColor( 0xFFFFFF00U );
201 : 0 : pPolyPoly->draw();
202 : 0 : }
203 : :
204 : : #if OSL_DEBUG_LEVEL >= 2 && defined(DBG_UTIL)
205 : : ::cppcanvas::CanvasSharedPtr pCliplessCanvas( pCanvas->clone() );
206 : : pCliplessCanvas->setClip();
207 : :
208 : : if( pCanvas->getClip() )
209 : : {
210 : : ::cppcanvas::PolyPolygonSharedPtr pPolyPoly2(
211 : : ::cppcanvas::BaseGfxFactory::getInstance().createPolyPolygon( pCliplessCanvas,
212 : : aPoly ));
213 : : if( pPolyPoly2 )
214 : : {
215 : : pPolyPoly2->setRGBALineColor( 0x008000FFU );
216 : : pPolyPoly2->draw();
217 : : }
218 : : }
219 : : #endif
220 : 0 : }
221 : :
222 : : /** Get bounds in pixel
223 : :
224 : : @param rLayerBounds
225 : : Bound rect, in user space coordinates
226 : :
227 : : @param rTransformation
228 : : User space to device pixel transformation
229 : :
230 : : @return the layer bounds in pixel, extended by one pixel to the
231 : : right and bottom
232 : : */
233 : 0 : basegfx::B2IRange getLayerBoundsPixel( basegfx::B2DRange const& rLayerBounds,
234 : : basegfx::B2DHomMatrix const& rTransformation )
235 : : {
236 : 0 : ::basegfx::B2DRange aTmpRect;
237 : : ::canvas::tools::calcTransformedRectBounds( aTmpRect,
238 : : rLayerBounds,
239 : 0 : rTransformation );
240 : :
241 : 0 : if( aTmpRect.isEmpty() )
242 : 0 : return ::basegfx::B2IRange();
243 : :
244 : : // #i42440# Returned layer size is one pixel too small, as
245 : : // rendering happens one pixel to the right and below the
246 : : // actual bound rect.
247 : : return ::basegfx::B2IRange( ::basegfx::fround(aTmpRect.getMinX()),
248 : : ::basegfx::fround(aTmpRect.getMinY()),
249 : 0 : ::basegfx::fround(aTmpRect.getMaxX()) + 1,
250 : 0 : ::basegfx::fround(aTmpRect.getMaxY()) + 1 );
251 : : }
252 : :
253 : :
254 : : // ----------------------------------------------------------------
255 : :
256 : : /** Container class for sprites issued by a ViewLayer
257 : :
258 : : This class handles the sprite prioritization issues, that are
259 : : needed for layer sprites (e.g. the need to re-prioritize sprites
260 : : when the layer changes prio).
261 : : */
262 : 0 : class LayerSpriteContainer
263 : : {
264 : : /** Max fill level of maSprites, before we try to prune it from
265 : : deceased sprites
266 : : */
267 : : enum{ SPRITE_ULLAGE=256 };
268 : :
269 : : /** All sprites that have been issued by this container (pruned
270 : : from time to time, for invalid references). This vector is
271 : : kept sorted with increasing sprite priority.
272 : : */
273 : : SpriteVector maSprites;
274 : :
275 : : /// Priority of this layer, relative to other view layers
276 : : basegfx::B1DRange maLayerPrioRange;
277 : :
278 : 0 : double getSpritePriority( std::size_t nSpriteNum ) const
279 : : {
280 : : // divide the available layer range equally between all
281 : : // sprites, assign upper bound of individual sprite range as
282 : : // sprite prio (the layer itself gets assigned the lower bound
283 : : // of sprite 0's individual range):
284 : : //
285 : : // | layer 0 | layer 1 | ...
286 : : // | sprite 0 | sprite 1 | sprite 0 | sprite 1 | ...
287 : 0 : return maLayerPrioRange.getMinimum() + maLayerPrioRange.getRange()*(nSpriteNum+1)/(maSprites.size()+1);
288 : : }
289 : :
290 : : /** Rescan sprite vector, and remove deceased sprites (and reset
291 : : sprite prio)
292 : :
293 : : @param aBegin
294 : : Iterator to the first entry to rescan
295 : : */
296 : 0 : void updateSprites()
297 : : {
298 : 0 : SpriteVector aValidSprites;
299 : :
300 : : // check all sprites for validity and set new priority
301 : 0 : SpriteVector::iterator aCurrSprite( maSprites.begin() );
302 : 0 : const SpriteVector::iterator aEnd( maSprites.end() );
303 : 0 : while( aCurrSprite != aEnd )
304 : : {
305 : 0 : cppcanvas::CustomSpriteSharedPtr pCurrSprite( aCurrSprite->mpSprite.lock() );
306 : :
307 : 0 : if( pCurrSprite )
308 : : {
309 : : // only copy still valid sprites over to the refreshed
310 : : // sprite vector.
311 : 0 : aValidSprites.push_back( *aCurrSprite );
312 : :
313 : 0 : pCurrSprite->setPriority(
314 : 0 : getSpritePriority( aValidSprites.size()-1 ));
315 : : }
316 : :
317 : 0 : ++aCurrSprite;
318 : 0 : }
319 : :
320 : : // replace sprite list with pruned one
321 : 0 : maSprites.swap( aValidSprites );
322 : 0 : }
323 : :
324 : : public:
325 : 0 : LayerSpriteContainer() :
326 : : maSprites(),
327 : 0 : maLayerPrioRange()
328 : : {
329 : 0 : }
330 : :
331 : 0 : basegfx::B1DRange getLayerPriority() const
332 : : {
333 : 0 : return maLayerPrioRange;
334 : : }
335 : :
336 : 0 : void setLayerPriority( const basegfx::B1DRange& rRange )
337 : : {
338 : 0 : if( rRange != maLayerPrioRange )
339 : : {
340 : 0 : maLayerPrioRange = rRange;
341 : :
342 : : // prune and recalc sprite prios
343 : 0 : updateSprites();
344 : : }
345 : 0 : }
346 : :
347 : 0 : void addSprite( const cppcanvas::CustomSpriteSharedPtr& pSprite,
348 : : double nPriority )
349 : : {
350 : 0 : if( !pSprite )
351 : 0 : return;
352 : :
353 : 0 : SpriteEntry aEntry( pSprite,nPriority );
354 : :
355 : : // insert new sprite, such that vector stays sorted
356 : : SpriteVector::iterator aInsertPos(
357 : : maSprites.insert(
358 : : std::lower_bound( maSprites.begin(),
359 : : maSprites.end(),
360 : : aEntry ),
361 : 0 : aEntry ));
362 : :
363 : 0 : const std::size_t nNumSprites( maSprites.size() );
364 : 0 : if( nNumSprites > SPRITE_ULLAGE ||
365 : 0 : maSprites.end() - aInsertPos > 1 )
366 : : {
367 : : // updateSprites() also updates all sprite prios
368 : 0 : updateSprites();
369 : : }
370 : : else
371 : : {
372 : : // added sprite to the end, and not too many sprites in
373 : : // vector - perform optimized update (only need to set
374 : : // prio). This basically caters for the common case of
375 : : // iterated character animations, which generate lots of
376 : : // sprites, all added to the end.
377 : 0 : pSprite->setPriority(
378 : 0 : getSpritePriority( nNumSprites-1 ));
379 : 0 : }
380 : : }
381 : :
382 : 0 : void clear()
383 : : {
384 : 0 : maSprites.clear();
385 : 0 : }
386 : : };
387 : :
388 : :
389 : : // ----------------------------------------------------------------
390 : :
391 : :
392 : : /** This class provides layers for a slide view
393 : :
394 : : Layers are used to render animations with the correct z order -
395 : : because sprites are always in front of the static canvas
396 : : background, shapes that must appear <em<before</em> an animation
397 : : must also be displayed as a sprite.
398 : :
399 : : Each layer has a priority assigned to it (valid range [0,1]), which
400 : : also affects all sprites created for this specific layer - i.e. if
401 : : the layer priority changes, the sprites change z order together
402 : : with their parent.
403 : : */
404 : 0 : class SlideViewLayer : public ViewLayer,
405 : : private boost::noncopyable
406 : : {
407 : : /// Smart container for all sprites issued by this layer
408 : : mutable LayerSpriteContainer maSpriteContainer;
409 : :
410 : : /// Bounds of this layer in user space coordinates
411 : : basegfx::B2DRange maLayerBounds;
412 : :
413 : : /// Bounds of this layer in device pixel
414 : : mutable basegfx::B2IRange maLayerBoundsPixel;
415 : :
416 : : /// Current clip polygon in user coordinates
417 : : basegfx::B2DPolyPolygon maClip;
418 : :
419 : : /// Current size of the view in user coordinates
420 : : basegfx::B2DSize maUserSize;
421 : :
422 : : /// Current overall view transformation
423 : : basegfx::B2DHomMatrix maTransformation;
424 : :
425 : : /// 'parent' canvas, this viewlayer is associated with
426 : : const cppcanvas::SpriteCanvasSharedPtr mpSpriteCanvas;
427 : :
428 : : /** output surface (necessarily a sprite, won't otherwise be able
429 : : to display anything <em>before</em> other sprites)
430 : : */
431 : : mutable cppcanvas::CustomSpriteSharedPtr mpSprite;
432 : :
433 : : /// actual output canvas retrieved from a sprite
434 : : mutable cppcanvas::CanvasSharedPtr mpOutputCanvas;
435 : :
436 : : /// ptr back to owning view. needed for isOnView() method
437 : : View const* const mpParentView;
438 : :
439 : : public:
440 : : /** Create a new layer
441 : :
442 : : @param pCanvas
443 : : Sprite canvas to create the layer on
444 : :
445 : : @param rTransform
446 : : Initial overall canvas transformation
447 : :
448 : : @param rLayerBounds
449 : : Initial layer bounds, in view coordinate system
450 : : */
451 : 0 : SlideViewLayer( const cppcanvas::SpriteCanvasSharedPtr& pCanvas,
452 : : const basegfx::B2DHomMatrix& rTransform,
453 : : const basegfx::B2DRange& rLayerBounds,
454 : : const basegfx::B2DSize& rUserSize,
455 : : View const* const pParentView) :
456 : : maSpriteContainer(),
457 : : maLayerBounds(rLayerBounds),
458 : : maLayerBoundsPixel(),
459 : : maClip(),
460 : : maUserSize(rUserSize),
461 : : maTransformation(rTransform),
462 : : mpSpriteCanvas(pCanvas),
463 : : mpSprite(),
464 : : mpOutputCanvas(),
465 : 0 : mpParentView(pParentView)
466 : : {
467 : 0 : }
468 : :
469 : 0 : void updateView( const basegfx::B2DHomMatrix& rMatrix,
470 : : const basegfx::B2DSize& rUserSize )
471 : : {
472 : 0 : maTransformation = rMatrix;
473 : 0 : maUserSize = rUserSize;
474 : :
475 : : // limit layer bounds to visible screen
476 : : maLayerBounds.intersect( basegfx::B2DRange(0.0,
477 : : 0.0,
478 : : maUserSize.getX(),
479 : 0 : maUserSize.getY()) );
480 : :
481 : : basegfx::B2IRange const& rNewLayerPixel(
482 : : getLayerBoundsPixel(maLayerBounds,
483 : 0 : maTransformation) );
484 : 0 : if( rNewLayerPixel != maLayerBoundsPixel )
485 : : {
486 : : // re-gen sprite with new size
487 : 0 : mpOutputCanvas.reset();
488 : 0 : mpSprite.reset();
489 : : }
490 : 0 : }
491 : :
492 : : private:
493 : : // ViewLayer interface
494 : : // ----------------------------------------------
495 : :
496 : 0 : virtual cppcanvas::CustomSpriteSharedPtr createSprite(
497 : : const ::basegfx::B2DSize& rSpriteSizePixel,
498 : : double nPriority ) const
499 : : {
500 : : cppcanvas::CustomSpriteSharedPtr pSprite(
501 : 0 : mpSpriteCanvas->createCustomSprite( rSpriteSizePixel ) );
502 : :
503 : : maSpriteContainer.addSprite( pSprite,
504 : 0 : nPriority );
505 : :
506 : 0 : return pSprite;
507 : : }
508 : :
509 : 0 : virtual void setPriority( const basegfx::B1DRange& rRange )
510 : : {
511 : : OSL_ENSURE( !rRange.isEmpty() &&
512 : : rRange.getMinimum() >= 1.0,
513 : : "SlideViewLayer::setPriority(): prio MUST be larger than 1.0 (because "
514 : : "the background layer already lies there)" );
515 : :
516 : 0 : maSpriteContainer.setLayerPriority( rRange );
517 : :
518 : 0 : if( mpSprite )
519 : 0 : mpSprite->setPriority( rRange.getMinimum() );
520 : 0 : }
521 : :
522 : 0 : virtual basegfx::B2DHomMatrix getTransformation() const
523 : : {
524 : : // Offset given transformation by left, top border of given
525 : : // range (after transformation through given transformation)
526 : 0 : basegfx::B2DRectangle aTmpRect;
527 : : canvas::tools::calcTransformedRectBounds( aTmpRect,
528 : : maLayerBounds,
529 : 0 : maTransformation );
530 : :
531 : 0 : basegfx::B2DHomMatrix aMatrix( maTransformation );
532 : :
533 : : // Add translation according to the origin of aTmpRect. Ignore the
534 : : // translation when aTmpRect was not properly initialized.
535 : 0 : if ( ! aTmpRect.isEmpty())
536 : : {
537 : 0 : aMatrix.translate( -basegfx::fround(aTmpRect.getMinX()),
538 : 0 : -basegfx::fround(aTmpRect.getMinY()) );
539 : : }
540 : :
541 : 0 : return aMatrix;
542 : : }
543 : :
544 : 0 : virtual basegfx::B2DHomMatrix getSpriteTransformation() const
545 : : {
546 : 0 : return maTransformation;
547 : : }
548 : :
549 : 0 : virtual void clear() const
550 : : {
551 : : // grab canvas - that also lazy-initializes maLayerBoundsPixel
552 : 0 : cppcanvas::CanvasSharedPtr pCanvas=getCanvas()->clone();
553 : :
554 : : // clear whole canvas
555 : 0 : const basegfx::B2I64Tuple& rSpriteSize(maLayerBoundsPixel.getRange());
556 : : clearRect(pCanvas,
557 : 0 : basegfx::B2IRange(0,0,rSpriteSize.getX(),rSpriteSize.getY()));
558 : 0 : }
559 : :
560 : 0 : virtual void clearAll() const
561 : : {
562 : : // grab canvas - that also lazy-initializes maLayerBoundsPixel
563 : 0 : ::cppcanvas::CanvasSharedPtr pCanvas( getCanvas()->clone() );
564 : :
565 : : // clear layer clip, to clear whole area
566 : 0 : pCanvas->setClip();
567 : :
568 : : // clear whole canvas
569 : 0 : const basegfx::B2I64Tuple& rSpriteSize(maLayerBoundsPixel.getRange());
570 : : clearRect(pCanvas,
571 : 0 : basegfx::B2IRange(0,0,rSpriteSize.getX(),rSpriteSize.getY()));
572 : 0 : }
573 : :
574 : 0 : virtual bool isOnView(boost::shared_ptr<View> const& rView) const
575 : : {
576 : 0 : return rView.get() == mpParentView;
577 : : }
578 : :
579 : 0 : virtual cppcanvas::CanvasSharedPtr getCanvas() const
580 : : {
581 : 0 : if( !mpOutputCanvas )
582 : : {
583 : 0 : if( !mpSprite )
584 : : {
585 : : maLayerBoundsPixel = getLayerBoundsPixel(maLayerBounds,
586 : 0 : maTransformation);
587 : :
588 : : // HACK: ensure at least 1x1 pixel size. clients might
589 : : // need an actual canvas (e.g. for bound rect
590 : : // calculations) without rendering anything. Better
591 : : // solution: introduce something like a reference
592 : : // canvas for ViewLayers, which is always available.
593 : 0 : if( maLayerBoundsPixel.isEmpty() )
594 : 0 : maLayerBoundsPixel = basegfx::B2IRange(0,0,1,1);
595 : :
596 : 0 : const basegfx::B2I64Tuple& rSpriteSize(maLayerBoundsPixel.getRange());
597 : 0 : mpSprite = mpSpriteCanvas->createCustomSprite(
598 : 0 : basegfx::B2DVector(sal::static_int_cast<sal_Int32>(rSpriteSize.getX()),
599 : 0 : sal::static_int_cast<sal_Int32>(rSpriteSize.getY())) );
600 : :
601 : 0 : mpSprite->setPriority(
602 : 0 : maSpriteContainer.getLayerPriority().getMinimum() );
603 : :
604 : : #if OSL_DEBUG_LEVEL >= 2 && defined(DBG_UTIL)
605 : : mpSprite->movePixel(
606 : : basegfx::B2DPoint(maLayerBoundsPixel.getMinimum()) +
607 : : basegfx::B2DPoint(10,10) );
608 : :
609 : : mpSprite->setAlpha(0.5);
610 : : #else
611 : 0 : mpSprite->movePixel(
612 : 0 : basegfx::B2DPoint(maLayerBoundsPixel.getMinimum()) );
613 : :
614 : 0 : mpSprite->setAlpha(1.0);
615 : : #endif
616 : 0 : mpSprite->show();
617 : : }
618 : :
619 : 0 : ENSURE_OR_THROW( mpSprite,
620 : : "SlideViewLayer::getCanvas(): no layer sprite" );
621 : :
622 : 0 : mpOutputCanvas = mpSprite->getContentCanvas();
623 : :
624 : 0 : ENSURE_OR_THROW( mpOutputCanvas,
625 : : "SlideViewLayer::getCanvas(): sprite doesn't yield a canvas" );
626 : :
627 : : // new canvas retrieved - setup transformation and clip
628 : 0 : mpOutputCanvas->setTransformation( getTransformation() );
629 : 0 : mpOutputCanvas->setClip(
630 : : createClipPolygon( maClip,
631 : : mpOutputCanvas,
632 : 0 : maUserSize ));
633 : : }
634 : :
635 : 0 : return mpOutputCanvas;
636 : : }
637 : :
638 : 0 : virtual void setClip( const basegfx::B2DPolyPolygon& rClip )
639 : : {
640 : 0 : basegfx::B2DPolyPolygon aNewClip = prepareClip( rClip );
641 : :
642 : 0 : if( aNewClip != maClip )
643 : : {
644 : 0 : maClip = aNewClip;
645 : :
646 : 0 : if(mpOutputCanvas )
647 : 0 : mpOutputCanvas->setClip(
648 : : createClipPolygon( maClip,
649 : : mpOutputCanvas,
650 : 0 : maUserSize ));
651 : 0 : }
652 : 0 : }
653 : :
654 : 0 : virtual bool resize( const ::basegfx::B2DRange& rArea )
655 : : {
656 : 0 : const bool bRet( maLayerBounds != rArea );
657 : 0 : maLayerBounds = rArea;
658 : : updateView( maTransformation,
659 : 0 : maUserSize );
660 : :
661 : 0 : return bRet;
662 : : }
663 : : };
664 : :
665 : :
666 : : // ---------------------------------------------------------
667 : :
668 : : typedef cppu::WeakComponentImplHelper2<
669 : : ::com::sun::star::util::XModifyListener,
670 : : ::com::sun::star::awt::XPaintListener> SlideViewBase;
671 : :
672 : : /** SlideView class
673 : :
674 : : This class implements the View interface, encapsulating
675 : : <em>one</em> view a slideshow is displayed on.
676 : : */
677 : 0 : class SlideView : private cppu::BaseMutex,
678 : : public SlideViewBase,
679 : : public UnoView
680 : : {
681 : : public:
682 : : SlideView( const uno::Reference<presentation::XSlideShowView>& xView,
683 : : EventQueue& rEventQueue,
684 : : EventMultiplexer& rEventMultiplexer );
685 : : void updateCanvas();
686 : :
687 : : private:
688 : : // View:
689 : : virtual ViewLayerSharedPtr createViewLayer( const basegfx::B2DRange& rLayerBounds ) const;
690 : : virtual bool updateScreen() const;
691 : : virtual bool paintScreen() const;
692 : : virtual void setViewSize( const ::basegfx::B2DSize& );
693 : : virtual void setCursorShape( sal_Int16 nPointerShape );
694 : :
695 : : // ViewLayer interface
696 : : virtual bool isOnView(boost::shared_ptr<View> const& rView) const;
697 : : virtual void clear() const;
698 : : virtual void clearAll() const;
699 : : virtual cppcanvas::CanvasSharedPtr getCanvas() const;
700 : : virtual cppcanvas::CustomSpriteSharedPtr createSprite( const ::basegfx::B2DSize& rSpriteSizePixel,
701 : : double nPriority ) const;
702 : : virtual void setPriority( const basegfx::B1DRange& rRange );
703 : : virtual ::basegfx::B2DHomMatrix getTransformation() const;
704 : : virtual basegfx::B2DHomMatrix getSpriteTransformation() const;
705 : : virtual void setClip( const ::basegfx::B2DPolyPolygon& rClip );
706 : : virtual bool resize( const ::basegfx::B2DRange& rArea );
707 : :
708 : : // UnoView:
709 : : virtual void _dispose();
710 : : virtual uno::Reference<presentation::XSlideShowView> getUnoView()const;
711 : : virtual void setIsSoundEnabled (const bool bValue);
712 : : virtual bool isSoundEnabled (void) const;
713 : :
714 : : // XEventListener:
715 : : virtual void SAL_CALL disposing( lang::EventObject const& evt )
716 : : throw (uno::RuntimeException);
717 : : // XModifyListener:
718 : : virtual void SAL_CALL modified( const lang::EventObject& aEvent )
719 : : throw (uno::RuntimeException);
720 : : // XPaintListener:
721 : : virtual void SAL_CALL windowPaint( const awt::PaintEvent& e )
722 : : throw (uno::RuntimeException);
723 : :
724 : : // WeakComponentImplHelperBase:
725 : : virtual void SAL_CALL disposing();
726 : :
727 : : void updateClip();
728 : :
729 : : private:
730 : : typedef std::vector< boost::weak_ptr<SlideViewLayer> > ViewLayerVector;
731 : :
732 : : /// Prune viewlayers from deceased ones, optionally update them
733 : : void pruneLayers( bool bWithViewLayerUpdate=false ) const;
734 : :
735 : : /** Max fill level of maViewLayers, before we try to prune it from
736 : : deceased layers
737 : : */
738 : : enum{ LAYER_ULLAGE=8 };
739 : :
740 : : uno::Reference<presentation::XSlideShowView> mxView;
741 : : cppcanvas::SpriteCanvasSharedPtr mpCanvas;
742 : :
743 : : EventMultiplexer& mrEventMultiplexer;
744 : : EventQueue& mrEventQueue;
745 : :
746 : : mutable LayerSpriteContainer maSprites;
747 : : mutable ViewLayerVector maViewLayers;
748 : :
749 : : basegfx::B2DPolyPolygon maClip;
750 : :
751 : : basegfx::B2DHomMatrix maViewTransform;
752 : : basegfx::B2DSize maUserSize;
753 : : bool mbIsSoundEnabled;
754 : : };
755 : :
756 : :
757 : 0 : SlideView::SlideView( const uno::Reference<presentation::XSlideShowView>& xView,
758 : : EventQueue& rEventQueue,
759 : : EventMultiplexer& rEventMultiplexer ) :
760 : : SlideViewBase( m_aMutex ),
761 : : mxView( xView ),
762 : : mpCanvas(),
763 : : mrEventMultiplexer( rEventMultiplexer ),
764 : : mrEventQueue( rEventQueue ),
765 : : maSprites(),
766 : : maViewLayers(),
767 : : maClip(),
768 : : maViewTransform(),
769 : : maUserSize( 1.0, 1.0 ), // default size: one-by-one rectangle
770 : 0 : mbIsSoundEnabled(true)
771 : : {
772 : : // take care not constructing any UNO references to this _inside_
773 : : // ctor, shift that code to createSlideView()!
774 : 0 : ENSURE_OR_THROW( mxView.is(),
775 : : "SlideView::SlideView(): Invalid view" );
776 : :
777 : 0 : mpCanvas = cppcanvas::VCLFactory::getInstance().createSpriteCanvas(
778 : 0 : xView->getCanvas() );
779 : 0 : ENSURE_OR_THROW( mpCanvas,
780 : : "Could not create cppcanvas" );
781 : :
782 : : geometry::AffineMatrix2D aViewTransform(
783 : 0 : xView->getTransformation() );
784 : :
785 : 0 : if( basegfx::fTools::equalZero(
786 : : basegfx::B2DVector(aViewTransform.m00,
787 : 0 : aViewTransform.m10).getLength()) ||
788 : : basegfx::fTools::equalZero(
789 : : basegfx::B2DVector(aViewTransform.m01,
790 : 0 : aViewTransform.m11).getLength()) )
791 : : {
792 : : OSL_FAIL( "SlideView::SlideView(): Singular matrix!" );
793 : :
794 : 0 : canvas::tools::setIdentityAffineMatrix2D(aViewTransform);
795 : : }
796 : :
797 : : basegfx::unotools::homMatrixFromAffineMatrix(
798 : 0 : maViewTransform, aViewTransform );
799 : :
800 : : // once and forever: set fixed prio to this 'layer' (we're always
801 : : // the background layer)
802 : 0 : maSprites.setLayerPriority( basegfx::B1DRange(0.0,1.0) );
803 : 0 : }
804 : :
805 : 0 : void SlideView::disposing()
806 : : {
807 : 0 : osl::MutexGuard aGuard( m_aMutex );
808 : :
809 : 0 : maViewLayers.clear();
810 : 0 : maSprites.clear();
811 : 0 : mpCanvas.reset();
812 : :
813 : : // additionally, also de-register from XSlideShowView
814 : 0 : if (mxView.is())
815 : : {
816 : 0 : mxView->removeTransformationChangedListener( this );
817 : 0 : mxView->removePaintListener( this );
818 : 0 : mxView.clear();
819 : 0 : }
820 : 0 : }
821 : :
822 : 0 : ViewLayerSharedPtr SlideView::createViewLayer( const basegfx::B2DRange& rLayerBounds ) const
823 : : {
824 : 0 : osl::MutexGuard aGuard( m_aMutex );
825 : :
826 : 0 : ENSURE_OR_THROW( mpCanvas,
827 : : "SlideView::createViewLayer(): Disposed" );
828 : :
829 : 0 : const std::size_t nNumLayers( maViewLayers.size() );
830 : :
831 : : // avoid filling up layer vector with lots of deceased layer weak
832 : : // ptrs
833 : 0 : if( nNumLayers > LAYER_ULLAGE )
834 : 0 : pruneLayers();
835 : :
836 : : boost::shared_ptr<SlideViewLayer> pViewLayer( new SlideViewLayer(mpCanvas,
837 : 0 : getTransformation(),
838 : : rLayerBounds,
839 : : maUserSize,
840 : 0 : this) );
841 : 0 : maViewLayers.push_back( pViewLayer );
842 : :
843 : 0 : return pViewLayer;
844 : : }
845 : :
846 : 0 : bool SlideView::updateScreen() const
847 : : {
848 : 0 : osl::MutexGuard aGuard( m_aMutex );
849 : :
850 : 0 : ENSURE_OR_RETURN_FALSE( mpCanvas.get(),
851 : : "SlideView::updateScreen(): Disposed" );
852 : :
853 : 0 : return mpCanvas->updateScreen( false );
854 : : }
855 : :
856 : 0 : bool SlideView::paintScreen() const
857 : : {
858 : 0 : osl::MutexGuard aGuard( m_aMutex );
859 : :
860 : 0 : ENSURE_OR_RETURN_FALSE( mpCanvas.get(),
861 : : "SlideView::paintScreen(): Disposed" );
862 : :
863 : 0 : return mpCanvas->updateScreen( true );
864 : : }
865 : :
866 : 0 : void SlideView::clear() const
867 : : {
868 : 0 : osl::MutexGuard aGuard( m_aMutex );
869 : :
870 : : OSL_ENSURE( mxView.is() && mpCanvas,
871 : : "SlideView::clear(): Disposed" );
872 : 0 : if( !mxView.is() || !mpCanvas )
873 : 0 : return;
874 : :
875 : : // keep layer clip
876 : 0 : clearRect(getCanvas()->clone(),
877 : : getLayerBoundsPixel(
878 : : basegfx::B2DRange(0,0,
879 : : maUserSize.getX(),
880 : : maUserSize.getY()),
881 : 0 : getTransformation()));
882 : : }
883 : :
884 : 0 : void SlideView::clearAll() const
885 : : {
886 : 0 : osl::MutexGuard aGuard( m_aMutex );
887 : :
888 : : OSL_ENSURE( mxView.is() && mpCanvas,
889 : : "SlideView::clear(): Disposed" );
890 : 0 : if( !mxView.is() || !mpCanvas )
891 : 0 : return;
892 : :
893 : : // clear whole view
894 : 0 : mxView->clear();
895 : : }
896 : :
897 : 0 : void SlideView::setViewSize( const basegfx::B2DSize& rSize )
898 : : {
899 : 0 : osl::MutexGuard aGuard( m_aMutex );
900 : :
901 : 0 : maUserSize = rSize;
902 : 0 : updateCanvas();
903 : 0 : }
904 : :
905 : 0 : void SlideView::setCursorShape( sal_Int16 nPointerShape )
906 : : {
907 : 0 : osl::MutexGuard const guard( m_aMutex );
908 : :
909 : 0 : if (mxView.is())
910 : 0 : mxView->setMouseCursor( nPointerShape );
911 : 0 : }
912 : :
913 : 0 : bool SlideView::isOnView(boost::shared_ptr<View> const& rView) const
914 : : {
915 : 0 : return rView.get() == this;
916 : : }
917 : :
918 : 0 : cppcanvas::CanvasSharedPtr SlideView::getCanvas() const
919 : : {
920 : 0 : osl::MutexGuard aGuard( m_aMutex );
921 : :
922 : 0 : ENSURE_OR_THROW( mpCanvas,
923 : : "SlideView::getCanvas(): Disposed" );
924 : :
925 : 0 : return mpCanvas;
926 : : }
927 : :
928 : 0 : cppcanvas::CustomSpriteSharedPtr SlideView::createSprite(
929 : : const basegfx::B2DSize& rSpriteSizePixel,
930 : : double nPriority ) const
931 : : {
932 : 0 : osl::MutexGuard aGuard( m_aMutex );
933 : :
934 : 0 : ENSURE_OR_THROW( mpCanvas, "SlideView::createSprite(): Disposed" );
935 : :
936 : : cppcanvas::CustomSpriteSharedPtr pSprite(
937 : 0 : mpCanvas->createCustomSprite( rSpriteSizePixel ) );
938 : :
939 : : maSprites.addSprite( pSprite,
940 : 0 : nPriority );
941 : :
942 : 0 : return pSprite;
943 : : }
944 : :
945 : 0 : void SlideView::setPriority( const basegfx::B1DRange& /*rRange*/ )
946 : : {
947 : 0 : osl::MutexGuard aGuard( m_aMutex );
948 : :
949 : : OSL_FAIL( "SlideView::setPriority() is a NOOP for slide view - "
950 : 0 : "content will always be shown in the background" );
951 : 0 : }
952 : :
953 : 0 : basegfx::B2DHomMatrix SlideView::getTransformation() const
954 : : {
955 : 0 : osl::MutexGuard aGuard( m_aMutex );
956 : :
957 : 0 : basegfx::B2DHomMatrix aMatrix;
958 : 0 : aMatrix.scale( 1.0/maUserSize.getX(), 1.0/maUserSize.getY() );
959 : :
960 : 0 : return maViewTransform * aMatrix;
961 : : }
962 : :
963 : 0 : basegfx::B2DHomMatrix SlideView::getSpriteTransformation() const
964 : : {
965 : 0 : return getTransformation();
966 : : }
967 : :
968 : 0 : void SlideView::setClip( const basegfx::B2DPolyPolygon& rClip )
969 : : {
970 : 0 : osl::MutexGuard aGuard( m_aMutex );
971 : :
972 : 0 : basegfx::B2DPolyPolygon aNewClip = prepareClip( rClip );
973 : :
974 : 0 : if( aNewClip != maClip )
975 : : {
976 : 0 : maClip = aNewClip;
977 : :
978 : 0 : updateClip();
979 : 0 : }
980 : 0 : }
981 : :
982 : 0 : bool SlideView::resize( const ::basegfx::B2DRange& /*rArea*/ )
983 : : {
984 : 0 : osl::MutexGuard aGuard( m_aMutex );
985 : :
986 : : OSL_FAIL( "SlideView::resize(): ignored for the View, can't change size "
987 : : "effectively, anyway" );
988 : :
989 : 0 : return false;
990 : : }
991 : :
992 : 0 : uno::Reference<presentation::XSlideShowView> SlideView::getUnoView() const
993 : : {
994 : 0 : osl::MutexGuard aGuard( m_aMutex );
995 : 0 : return mxView;
996 : : }
997 : :
998 : 0 : void SlideView::setIsSoundEnabled (const bool bValue)
999 : : {
1000 : 0 : mbIsSoundEnabled = bValue;
1001 : 0 : }
1002 : :
1003 : 0 : bool SlideView::isSoundEnabled (void) const
1004 : : {
1005 : 0 : return mbIsSoundEnabled;
1006 : : }
1007 : :
1008 : 0 : void SlideView::_dispose()
1009 : : {
1010 : 0 : dispose();
1011 : 0 : }
1012 : :
1013 : : // XEventListener
1014 : 0 : void SlideView::disposing( lang::EventObject const& evt )
1015 : : throw (uno::RuntimeException)
1016 : : {
1017 : : (void)evt;
1018 : :
1019 : : // no deregistration necessary anymore, XView has left:
1020 : 0 : osl::MutexGuard const guard( m_aMutex );
1021 : :
1022 : 0 : if (mxView.is())
1023 : : {
1024 : : OSL_ASSERT( evt.Source == mxView );
1025 : 0 : mxView.clear();
1026 : : }
1027 : :
1028 : 0 : dispose();
1029 : 0 : }
1030 : :
1031 : : // XModifyListener
1032 : 0 : void SlideView::modified( const lang::EventObject& /*aEvent*/ )
1033 : : throw (uno::RuntimeException)
1034 : : {
1035 : 0 : osl::MutexGuard const guard( m_aMutex );
1036 : :
1037 : : OSL_ENSURE( mxView.is(), "SlideView::modified(): "
1038 : : "Disposed, but event received from XSlideShowView?!");
1039 : :
1040 : 0 : if( !mxView.is() )
1041 : : return;
1042 : :
1043 : : geometry::AffineMatrix2D aViewTransform(
1044 : 0 : mxView->getTransformation() );
1045 : :
1046 : 0 : if( basegfx::fTools::equalZero(
1047 : : basegfx::B2DVector(aViewTransform.m00,
1048 : 0 : aViewTransform.m10).getLength()) ||
1049 : : basegfx::fTools::equalZero(
1050 : : basegfx::B2DVector(aViewTransform.m01,
1051 : 0 : aViewTransform.m11).getLength()) )
1052 : : {
1053 : : OSL_FAIL( "SlideView::modified(): Singular matrix!" );
1054 : :
1055 : 0 : canvas::tools::setIdentityAffineMatrix2D(aViewTransform);
1056 : : }
1057 : :
1058 : : // view transformation really changed?
1059 : 0 : basegfx::B2DHomMatrix aNewTransform;
1060 : : basegfx::unotools::homMatrixFromAffineMatrix(
1061 : : aNewTransform,
1062 : 0 : aViewTransform );
1063 : :
1064 : 0 : if( aNewTransform == maViewTransform )
1065 : : return; // No change, nothing to do
1066 : :
1067 : 0 : maViewTransform = aNewTransform;
1068 : :
1069 : 0 : updateCanvas();
1070 : :
1071 : : // notify view change. Don't call EventMultiplexer directly, this
1072 : : // might not be the main thread!
1073 : : mrEventQueue.addEvent(
1074 : : makeEvent( boost::bind( (bool (EventMultiplexer::*)(
1075 : : const uno::Reference<presentation::XSlideShowView>&))
1076 : : &EventMultiplexer::notifyViewChanged,
1077 : : boost::ref(mrEventMultiplexer), mxView ),
1078 : 0 : "EventMultiplexer::notifyViewChanged"));
1079 : : }
1080 : :
1081 : : // XPaintListener
1082 : 0 : void SlideView::windowPaint( const awt::PaintEvent& /*e*/ )
1083 : : throw (uno::RuntimeException)
1084 : : {
1085 : 0 : osl::MutexGuard aGuard( m_aMutex );
1086 : :
1087 : : OSL_ENSURE( mxView.is() && mpCanvas, "Disposed, but event received?!" );
1088 : :
1089 : : // notify view clobbering. Don't call EventMultiplexer directly,
1090 : : // this might not be the main thread!
1091 : : mrEventQueue.addEvent(
1092 : : makeEvent( boost::bind( &EventMultiplexer::notifyViewClobbered,
1093 : : boost::ref(mrEventMultiplexer), mxView ),
1094 : 0 : "EventMultiplexer::notifyViewClobbered") );
1095 : 0 : }
1096 : :
1097 : 0 : void SlideView::updateCanvas()
1098 : : {
1099 : : OSL_ENSURE( mpCanvas,
1100 : : "SlideView::updateCanvasTransform(): Disposed" );
1101 : :
1102 : 0 : if( !mpCanvas || !mxView.is())
1103 : 0 : return;
1104 : :
1105 : 0 : mpCanvas->clear(); // this is unnecessary, strictly speaking. but
1106 : : // it makes the SlideView behave exactly like a
1107 : : // sprite-based SlideViewLayer, because those
1108 : : // are created from scratch after a resize
1109 : 0 : clearAll();
1110 : 0 : mpCanvas->setTransformation( getTransformation() );
1111 : 0 : mpCanvas->setClip(
1112 : : createClipPolygon( maClip,
1113 : : mpCanvas,
1114 : 0 : maUserSize ));
1115 : :
1116 : : // forward update to viewlayers
1117 : 0 : pruneLayers( true );
1118 : : }
1119 : :
1120 : 0 : void SlideView::updateClip()
1121 : : {
1122 : : OSL_ENSURE( mpCanvas,
1123 : : "SlideView::updateClip(): Disposed" );
1124 : :
1125 : 0 : if( !mpCanvas )
1126 : 0 : return;
1127 : :
1128 : 0 : mpCanvas->setClip(
1129 : : createClipPolygon( maClip,
1130 : : mpCanvas,
1131 : 0 : maUserSize ));
1132 : :
1133 : 0 : pruneLayers( false );
1134 : : }
1135 : :
1136 : 0 : void SlideView::pruneLayers( bool bWithViewLayerUpdate ) const
1137 : : {
1138 : 0 : ViewLayerVector aValidLayers;
1139 : :
1140 : : const basegfx::B2DHomMatrix& rCurrTransform(
1141 : 0 : getTransformation() );
1142 : :
1143 : : // check all layers for validity, and retain only the live ones
1144 : 0 : ViewLayerVector::const_iterator aCurr( maViewLayers.begin() );
1145 : 0 : const ViewLayerVector::const_iterator aEnd( maViewLayers.end() );
1146 : 0 : while( aCurr != aEnd )
1147 : : {
1148 : 0 : boost::shared_ptr< SlideViewLayer > pCurrLayer( aCurr->lock() );
1149 : :
1150 : 0 : if( pCurrLayer )
1151 : : {
1152 : 0 : aValidLayers.push_back( pCurrLayer );
1153 : :
1154 : 0 : if( bWithViewLayerUpdate )
1155 : : pCurrLayer->updateView( rCurrTransform,
1156 : 0 : maUserSize );
1157 : : }
1158 : :
1159 : 0 : ++aCurr;
1160 : 0 : }
1161 : :
1162 : : // replace layer list with pruned one
1163 : 0 : maViewLayers.swap( aValidLayers );
1164 : 0 : }
1165 : :
1166 : : } // anonymous namespace
1167 : :
1168 : 0 : UnoViewSharedPtr createSlideView( uno::Reference< presentation::XSlideShowView> const& xView,
1169 : : EventQueue& rEventQueue,
1170 : : EventMultiplexer& rEventMultiplexer )
1171 : : {
1172 : : boost::shared_ptr<SlideView> const that(
1173 : : comphelper::make_shared_from_UNO(
1174 : : new SlideView(xView,
1175 : : rEventQueue,
1176 : 0 : rEventMultiplexer)));
1177 : :
1178 : : // register listeners with XSlideShowView
1179 : 0 : xView->addTransformationChangedListener( that.get() );
1180 : 0 : xView->addPaintListener( that.get() );
1181 : :
1182 : : // set new transformation
1183 : 0 : that->updateCanvas();
1184 : :
1185 : 0 : return that;
1186 : : }
1187 : :
1188 : : } // namespace internal
1189 : 0 : } // namespace slideshow
1190 : :
1191 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
