slideshow/source/engine/slide/layermanager.hxx

   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 #ifndef INCLUDED_SLIDESHOW_SOURCE_ENGINE_SLIDE_LAYERMANAGER_HXX
  21 #define INCLUDED_SLIDESHOW_SOURCE_ENGINE_SLIDE_LAYERMANAGER_HXX
  22
  23 #include <boost/shared_ptr.hpp>
  24 #include <boost/noncopyable.hpp>
  25
  26 #include <cppcanvas/spritecanvas.hxx>
  27
  28 #include "unoview.hxx"
  29 #include "unoviewcontainer.hxx"
  30 #include "attributableshape.hxx"
  31 #include "layer.hxx"
  32 #include "tools.hxx"
  33
  34 #include <algorithm>
  35 #include <functional>
  36 #include <map>
  37 #include <unordered_map>
  38 #include <vector>
  39
  40 namespace basegfx {
  41     class B2DRange;
  42 }
  43
  44 namespace slideshow
  45 {
  46     namespace internal
  47     {
  48         /* Definition of Layermanager class */
  49
  50         /** This class manages all of a slide's layers (and shapes)
  51
  52             Since layer content changes when animations start or end,
  53             the layer manager keeps track of this and also handles
  54             starting/stopping of Shape animations. Note that none of
  55             the methods actually perform a screen update, this is
  56             always delayed until the ActivitiesQueue explicitly
  57             performs it.
  58
  59             @see Layer
  60             @see Shape
  61          */
  62         class LayerManager : private boost::noncopyable
  63         {
  64         public:
  65             /** Create a new layer manager for the given page bounds
  66
  67                 @param rViews
  68                 Views currently registered
  69
  70                 @param rPageBounds
  71                 Overall page bounds, in user space coordinates
  72
  73                 @param bDisableAnimationZOrder
  74                 When true, all sprite animations run in the
  75                 foreground.  That is, no extra layers are created, and
  76                 the slideshow runs potentially faster.
  77              */
  78             LayerManager( const UnoViewContainer&    rViews,
  79                           const ::basegfx::B2DRange& rPageBounds,
  80                           bool                       bDisableAnimationZOrder );
  81
  82             /** Activate the LayerManager
  83
  84                 This method activates the LayerManager. Prior to
  85                 activation, this instance will be passive, i.e. won't
  86                 render anything to any view.
  87
  88                 @param bSlideBackgoundPainted
  89                 When true, the initial slide content on the background
  90                 layer is already rendered (e.g. from a previous slide
  91                 transition). When false, LayerManager also renders
  92                 initial content of background layer on next update()
  93                 call.
  94              */
  95             void activate( bool bSlideBackgoundPainted );
  96
  97             /** Deactivate the LayerManager
  98
  99                 This method deactivates the LayerManager. After
 100                 deactivation, this instance will be passive,
 101                 i.e. don't render anything to any view.  Furthermore,
 102                 if there's currently more than one Layer active, this
 103                 method also removes all but one.
 104              */
 105             void deactivate();
 106
 107             // From ViewEventHandler, forwarded by SlideImpl
 108             /// Notify new view added to UnoViewContainer
 109             void viewAdded( const UnoViewSharedPtr& rView );
 110             /// Notify view removed from UnoViewContainer
 111             void viewRemoved( const UnoViewSharedPtr& rView );
 112             void viewChanged( const UnoViewSharedPtr& rView );
 113             void viewsChanged();
 114
 115             /** Add the shape to this object
 116
 117                 This method adds a shape to the page.
 118              */
 119             void addShape( const ShapeSharedPtr& rShape );
 120
 121             /** Lookup a Shape from an XShape model object
 122
 123                 This method looks up the internal shape map for one
 124                 representing the given XShape.
 125
 126                 @param xShape
 127                 The XShape object, for which the representing Shape
 128                 should be looked up.
 129              */
 130             ShapeSharedPtr lookupShape( const ::com::sun::star::uno::Reference<
 131                                            ::com::sun::star::drawing::XShape >& xShape ) const;
 132
 133             /** Query a subset of the given original shape
 134
 135                 This method queries a new (but not necessarily unique)
 136                 shape, which displays only the given subset of the
 137                 original one.
 138              */
 139             AttributableShapeSharedPtr getSubsetShape( const AttributableShapeSharedPtr&    rOrigShape,
 140                                                        const DocTreeNode&                   rTreeNode );
 141
 142             /** Revoke a previously queried subset shape.
 143
 144                 With this method, a previously requested subset shape
 145                 is revoked again. If the last client revokes a given
 146                 subset, it will cease to be displayed, and the
 147                 original shape will again show the subset data.
 148
 149                 @param rOrigShape
 150                 The shape the subset was created from
 151
 152                 @param rSubsetShape
 153                 The subset created from rOrigShape
 154              */
 155             void revokeSubset( const AttributableShapeSharedPtr& rOrigShape,
 156                                const AttributableShapeSharedPtr& rSubsetShape );
 157
 158             /** Notify the LayerManager that the given Shape starts an
 159                 animation now.
 160
 161                 This method enters animation mode for the Shape on all
 162                 registered views.
 163              */
 164             void enterAnimationMode( const AnimatableShapeSharedPtr& rShape );
 165
 166             /** Notify the LayerManager that the given Shape is no
 167                 longer animated.
 168
 169                 This methods ends animation mode for the given Shape
 170                 on all registered views.
 171              */
 172             void leaveAnimationMode( const AnimatableShapeSharedPtr& rShape );
 173
 174             /** Notify that a shape needs an update
 175
 176                 This method notifies the layer manager that a shape
 177                 update is necessary. This is useful if, during
 178                 animation playback, changes occur to shapes which make
 179                 an update necessary on an update() call. Otherwise,
 180                 update() will not render anything, which is not
 181                 triggered by calling one of the other LayerManager
 182                 methods.
 183
 184                 @param rShape
 185                 Shape which needs an update
 186              */
 187             void notifyShapeUpdate( const ShapeSharedPtr& rShape);
 188
 189             /** Check whether any update operations  are pending.
 190
 191                 @return true, if this LayerManager has any updates
 192                 pending, i.e. needs to repaint something for the next
 193                 frame.
 194              */
 195             bool isUpdatePending() const;
 196
 197             /** Update the content
 198
 199                 This method updates the content on all layers on all
 200                 registered views. It does not issues a
 201                 View::updateScreen() call on registered views. Please
 202                 note that this method only takes into account changes
 203                 to shapes induced directly by calling methods of the
 204                 LayerManager. If a shape needs an update, because of
 205                 some external event unknown to the LayerManager (most
 206                 notably running animations), you have to notify the
 207                 LayerManager via notifyShapeUpdate().
 208
 209                 @see LayerManager::updateScreen()
 210
 211                 @return whether the update finished successfully.
 212             */
 213             bool update();
 214
 215             /** Render the content to given canvas
 216
 217                 This is a one-shot operation, which simply draws all
 218                 shapes onto the given canvas, without any caching or
 219                 other fuzz. Don't use that for repeated output onto
 220                 the same canvas, the View concept is more optimal
 221                 then.
 222
 223                 @param rTargetCanvas
 224                 Target canvas to output onto.
 225              */
 226             bool renderTo( const ::cppcanvas::CanvasSharedPtr& rTargetCanvas ) const;
 227
 228         private:
 229             /** A hash map which maps the XShape to the corresponding Shape object.
 230
 231                 Provides quicker lookup than ShapeSet for simple mappings
 232              */
 233             typedef std::unordered_map<
 234                 ::com::sun::star::uno::Reference<
 235                     ::com::sun::star::drawing::XShape >,
 236                 ShapeSharedPtr,
 237                 hash< ::com::sun::star::uno::Reference<
 238                       ::com::sun::star::drawing::XShape > > > XShapeHash;
 239
 240             class ShapeComparator
 241             {
 242             public:
 243                 bool operator() (const ShapeSharedPtr& rpS1, const ShapeSharedPtr& rpS2 ) const
 244                 {
 245                     return Shape::lessThanShape::compare(rpS1.get(), rpS2.get());
 246                 }
 247             };
 248             /** Set of all shapes
 249              */
 250         private:
 251             typedef ::std::map< ShapeSharedPtr, LayerWeakPtr, ShapeComparator > LayerShapeMap;
 252             typedef ::std::set< ShapeSharedPtr > ShapeUpdateSet;
 253
 254
 255
 256
 257
 258             /// Adds shape area to containing layer's damage area
 259             void addUpdateArea( ShapeSharedPtr const& rShape );
 260
 261             LayerSharedPtr createForegroundLayer() const;
 262
 263             /** Push changes from updateShapeLayerAssociations() to current layer
 264
 265                 Factored-out method that resizes layer, if necessary,
 266                 assigns correct layer priority, and repaints contained shapes.
 267
 268                 @param nCurrLayerIndex
 269                 Index of current layer in maLayers
 270
 271                 @param aFirstLayerShape
 272                 Valid iterator out of maAllShapes, denoting the first
 273                 shape from nCurrLayerIndex
 274
 275                 @param aEndLayerShapes
 276                 Valid iterator or end iterator out of maAllShapes,
 277                 denoting one-behind-the-last shape of nCurrLayerIndex
 278              */
 279             void           commitLayerChanges( std::size_t                    nCurrLayerIndex,
 280                                                LayerShapeMap::const_iterator  aFirstLayerShape,
 281                                                LayerShapeMap::const_iterator  aEndLayerShapes );
 282
 283             /** Init Shape layers with background layer.
 284              */
 285             void          putShape2BackgroundLayer( LayerShapeMap::value_type& rShapeEntry );
 286
 287             /** Commits any pending layer reorg, due to shapes either
 288                 entering or leaving animation mode
 289
 290                 @param bBackgroundLayerPainted
 291                 When true, LayerManager does not render anything on
 292                 the background layer. Use this, if background has been
 293                 updated by other means (e.g. slide transition)
 294             */
 295             void          updateShapeLayers( bool bBackgroundLayerPainted );
 296
 297             /** Common stuff when adding a shape
 298              */
 299             void          implAddShape( const ShapeSharedPtr& rShape );
 300
 301             /** Common stuff when removing a shape
 302              */
 303             void          implRemoveShape( const ShapeSharedPtr& rShape );
 304
 305             /** Add or remove views
 306
 307                 Sharing duplicate code from viewAdded and viewRemoved
 308                 method. The only point of variation at those places
 309                 are removal vs. adding.
 310              */
 311             template<typename LayerFunc,
 312                      typename ShapeFunc> void manageViews( LayerFunc layerFunc,
 313                                                            ShapeFunc shapeFunc );
 314
 315             bool updateSprites();
 316
 317             /// Registered views
 318             const UnoViewContainer&  mrViews;
 319
 320             /// All layers of this object. Vector owns the layers
 321             LayerVector              maLayers;
 322
 323             /** Contains all shapes with their XShape reference as the key
 324              */
 325             XShapeHash               maXShapeHash;
 326
 327             /** Set of shapes this LayerManager own
 328
 329                 Contains the same set of shapes as XShapeHash, but is
 330                 sorted in z order, for painting and layer
 331                 association. Set entries are enriched with two flags
 332                 for buffering animation enable/disable changes, and
 333                 shape update requests.
 334             */
 335             LayerShapeMap            maAllShapes;
 336
 337             /** Set of shapes that have requested an update
 338
 339                 When a shape is member of this set, its maShapes entry
 340                 has bNeedsUpdate set to true. We maintain this
 341                 redundant information for faster update processing.
 342              */
 343             ShapeUpdateSet           maUpdateShapes;
 344
 345             /** Overall slide bounds (in user coordinate
 346                 system). shapes that exceed this boundary are clipped,
 347                 thus, layers only need to be of this size.
 348              */
 349             const basegfx::B2DRange  maPageBounds;
 350
 351             /// Number of shape sprites currently active on this LayerManager
 352             sal_Int32                mnActiveSprites;
 353
 354             /// sal_True, if shapes might need to move to different layer
 355             bool                     mbLayerAssociationDirty;
 356
 357             /// sal_False when deactivated
 358             bool                     mbActive;
 359
 360             /** When true, all sprite animations run in the foreground.  That
 361                 is, no extra layers are created, and the slideshow runs
 362                 potentially faster.
 363              */
 364             bool                     mbDisableAnimationZOrder;
 365         };
 366
 367         typedef ::boost::shared_ptr< LayerManager > LayerManagerSharedPtr;
 368     }
 369 }
 370
 371 #endif // INCLUDED_SLIDESHOW_SOURCE_ENGINE_SLIDE_LAYERMANAGER_HXX
 372
 373 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */