slideshow/source/engine/shapes/viewshape.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_SHAPES_VIEWSHAPE_HXX
  21 #define INCLUDED_SLIDESHOW_SOURCE_ENGINE_SHAPES_VIEWSHAPE_HXX
  22
  23 #include <cppcanvas/renderer.hxx>
  24 #include <cppcanvas/bitmap.hxx>
  25
  26 #include <basegfx/range/b2drectangle.hxx>
  27 #include <o3tl/typed_flags_set.hxx>
  28
  29 #include <tools.hxx>
  30 #include <shapeattributelayer.hxx>
  31 #include <animatedsprite.hxx>
  32 #include <viewlayer.hxx>
  33 #include <doctreenode.hxx>
  34
  35 #include <vector>
  36 #include <memory>
  37
  38 enum class UpdateFlags
  39 {
  40     NONE           = 0x00,
  41     Transformation = 0x01,
  42     Clip           = 0x02,
  43     Alpha          = 0x04,
  44     Position       = 0x08,
  45     Content        = 0x10,
  46     Force          = 0x20,
  47 };
  48 namespace o3tl {
  49     template<> struct typed_flags<UpdateFlags> : is_typed_flags<UpdateFlags, 0x3f> {};
  50 }
  51
  52
  53
  54 namespace slideshow::internal
  55     {
  56         /** This class is the viewable representation of a draw
  57             document's XShape, associated to a specific View
  58
  59             The class is able to render the associated XShape on
  60             View implementations.
  61          */
  62         class ViewShape
  63         {
  64         public:
  65             /** Create a ViewShape for the given View
  66
  67                 @param rView
  68                 The associated View object.
  69              */
  70             explicit ViewShape( ViewLayerSharedPtr xViewLayer );
  71
  72             ///Forbid copy construction
  73             ViewShape(const ViewShape&) = delete;
  74             /// Forbid copy assignment
  75             ViewShape& operator=(const ViewShape&) = delete;
  76
  77             /** Query the associated view layer of this shape
  78              */
  79             const ViewLayerSharedPtr& getViewLayer() const;
  80
  81             /** Query dimension of a safety border around the shape for AA
  82
  83                 If the view performs antialiasing, this method
  84                 calculates a safety border around the shape, in the
  85                 shape coordinate system, which is guaranteed to
  86                 include every pixel touched when rendering the shape.
  87              */
  88             ::basegfx::B2DSize getAntialiasingBorder() const;
  89
  90
  91             // animation methods
  92
  93
  94             /** Notify the ViewShape that an animation starts now
  95
  96                 This method enters animation mode on the associate
  97                 target view. The shape can be animated in parallel on
  98                 different views.
  99              */
 100             void enterAnimationMode();
 101
 102             /** Notify the ViewShape that it is no longer animated
 103
 104                 This methods ends animation mode on the associate
 105                 target view
 106              */
 107             void leaveAnimationMode();
 108
 109
 110             // render methods
 111
 112
 113             struct RenderArgs
 114             {
 115                 /** Create render argument struct
 116
 117                     @param rOrigBounds
 118                     The initial shape bounds
 119
 120                     @param rUpdateBounds
 121                     The area covered by the shape
 122
 123                     @param rBounds
 124                     The current shape bounds
 125
 126                     @param rAttr
 127                     The current shape attribute set. Can be NULL, for
 128                     default attributes. Attention: stored as a reference,
 129                     thus, parameter object must stay valid!
 130
 131                     @param rSubsets
 132                     Vector of subset rendering ranges. Attention:
 133                     stored as a reference, thus, parameter object must
 134                     stay valid!
 135
 136                     @param nPrio
 137                     Shape priority
 138                 */
 139                 RenderArgs( const ::basegfx::B2DRectangle&      rOrigBounds,
 140                             const ::basegfx::B2DRectangle&      rUpdateBounds,
 141                             const ::basegfx::B2DRectangle&      rBounds,
 142                             const ::basegfx::B2DRectangle&      rUnitBounds,
 143                             const ShapeAttributeLayerSharedPtr& rAttr,
 144                             const VectorOfDocTreeNodes&         rSubsets,
 145                             double                              nPrio ) :
 146                     maOrigBounds( rOrigBounds ),
 147                     maUpdateBounds( rUpdateBounds ),
 148                     maBounds( rBounds ),
 149                     maUnitBounds( rUnitBounds ),
 150                     mrAttr( rAttr ),
 151                     mrSubsets( rSubsets ),
 152                     mnShapePriority( nPrio )
 153                 {
 154                 }
 155
 156                 const ::basegfx::B2DRectangle       maOrigBounds;
 157                 const ::basegfx::B2DRectangle       maUpdateBounds;
 158                 const ::basegfx::B2DRectangle       maBounds;
 159                 const ::basegfx::B2DRectangle       maUnitBounds;
 160                 const ShapeAttributeLayerSharedPtr& mrAttr;
 161                 const VectorOfDocTreeNodes&         mrSubsets;
 162                 const double                        mnShapePriority;
 163             };
 164
 165             /** Update the ViewShape
 166
 167                 This method updates the ViewShape on the associated
 168                 view. If the shape is currently animated, the render
 169                 target is the sprite, otherwise the view's
 170                 canvas. This method does not render anything, if the
 171                 update flags are 0.
 172
 173                 @param rMtf
 174                 The metafile representation of the shape
 175
 176                 @param rArgs
 177                 Parameter structure, containing all necessary arguments
 178
 179                 @param nUpdateFlags
 180                 Bitmask of things to update. Use FORCE to force a repaint.
 181
 182                 @param bIsVisible
 183                 When false, the shape is fully invisible (and possibly
 184                 don't need to be painted)
 185
 186                 @return whether the rendering finished successfully.
 187             */
 188             bool update( const GDIMetaFileSharedPtr&    rMtf,
 189                          const RenderArgs&              rArgs,
 190                          UpdateFlags                    nUpdateFlags,
 191                          bool                           bIsVisible ) const;
 192
 193             /** Retrieve renderer for given canvas and metafile.
 194
 195                 If necessary, the renderer is created or updated for
 196                 the metafile and attribute layer.
 197
 198                 @return a renderer that renders to the given
 199                 destination canvas
 200              */
 201             ::cppcanvas::RendererSharedPtr getRenderer( const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas,
 202                                                         const GDIMetaFileSharedPtr&         rMtf,
 203                                                         const ShapeAttributeLayerSharedPtr& rAttr ) const;
 204
 205
 206         private:
 207             struct RendererCacheEntry
 208             {
 209                 RendererCacheEntry() :
 210                     mpDestinationCanvas(),
 211                     mpRenderer(),
 212                     mpMtf(),
 213                     mpLastBitmap(),
 214                     mpLastBitmapCanvas()
 215                 {
 216                 }
 217
 218                 const ::cppcanvas::CanvasSharedPtr& getDestinationCanvas() const
 219                 {
 220                     return mpDestinationCanvas;
 221                 }
 222
 223                 ::cppcanvas::CanvasSharedPtr        mpDestinationCanvas;
 224                 ::cppcanvas::RendererSharedPtr      mpRenderer;
 225                 GDIMetaFileSharedPtr                mpMtf;
 226                 ::cppcanvas::BitmapSharedPtr        mpLastBitmap;
 227                 ::cppcanvas::BitmapCanvasSharedPtr  mpLastBitmapCanvas;
 228             };
 229
 230             typedef ::std::vector< RendererCacheEntry > RendererCacheVector;
 231
 232
 233             /** Prefetch Renderer for given canvas
 234              */
 235             static bool prefetch( RendererCacheEntry&                  io_rCacheEntry,
 236                            const ::cppcanvas::CanvasSharedPtr&  rDestinationCanvas,
 237                            const GDIMetaFileSharedPtr&          rMtf,
 238                            const ShapeAttributeLayerSharedPtr&  rAttr );
 239
 240             /** Draw with prefetched Renderer to stored canvas
 241
 242                 This method draws prefetched Renderer to its
 243                 associated canvas (which happens to be mpLastCanvas).
 244              */
 245             bool draw( const ::cppcanvas::CanvasSharedPtr&  rDestinationCanvas,
 246                        const GDIMetaFileSharedPtr&          rMtf,
 247                        const ShapeAttributeLayerSharedPtr&  rAttr,
 248                        const ::basegfx::B2DHomMatrix&       rTransform,
 249                        const ::basegfx::B2DPolyPolygon*     pClip,
 250                        const VectorOfDocTreeNodes&          rSubsets ) const;
 251
 252             /** Render shape to an active sprite
 253              */
 254             bool renderSprite( const ViewLayerSharedPtr&            rViewLayer,
 255                                const GDIMetaFileSharedPtr&          rMtf,
 256                                const ::basegfx::B2DRectangle&       rOrigBounds,
 257                                const ::basegfx::B2DRectangle&       rBounds,
 258                                const ::basegfx::B2DRectangle&       rUnitBounds,
 259                                UpdateFlags                          nUpdateFlags,
 260                                const ShapeAttributeLayerSharedPtr&  pAttr,
 261                                const VectorOfDocTreeNodes&          rSubsets,
 262                                double                               nPrio,
 263                                bool                                 bIsVisible ) const;
 264
 265             /** Render shape to given canvas
 266              */
 267             bool render( const ::cppcanvas::CanvasSharedPtr&    rDestinationCanvas,
 268                          const GDIMetaFileSharedPtr&            rMtf,
 269                          const ::basegfx::B2DRectangle&         rBounds,
 270                          const ::basegfx::B2DRectangle&         rUpdateBounds,
 271                          UpdateFlags                            nUpdateFlags,
 272                          const ShapeAttributeLayerSharedPtr&    pAttr,
 273                          const VectorOfDocTreeNodes&            rSubsets,
 274                          bool                                   bIsVisible ) const;
 275
 276             enum{ MAX_RENDER_CACHE_ENTRIES=2 };
 277
 278             /** Retrieve a valid iterator to renderer cache entry
 279
 280                 This method ensures that an internal limit of
 281                 MAX_RENDER_CACHE_ENTRIES is not exceeded.
 282
 283                 @param rDestinationCanvas
 284                 Destination canvas to retrieve cache entry for
 285
 286                 @return a valid iterator to a renderer cache entry for
 287                 the given canvas. The entry might be
 288                 default-constructed (if newly added)
 289              */
 290             RendererCacheVector::iterator getCacheEntry( const ::cppcanvas::CanvasSharedPtr& rDestinationCanvas ) const;
 291
 292             void invalidateRenderer() const;
 293
 294             /** The view layer this object is part of.
 295
 296                 Needed for sprite creation
 297             */
 298             ViewLayerSharedPtr                          mpViewLayer;
 299
 300             /// A set of cached mtf/canvas combinations
 301             mutable RendererCacheVector                 maRenderers;
 302
 303             /// The sprite object
 304             mutable AnimatedSpriteSharedPtr             mpSprite;
 305
 306             /// If true, render() calls go to the sprite
 307             mutable bool                                mbAnimationMode;
 308
 309             /// If true, shape needs full repaint (and the sprite a setup, if any)
 310             mutable bool                                mbForceUpdate;
 311         };
 312
 313         typedef ::std::shared_ptr< ViewShape > ViewShapeSharedPtr;
 314
 315 }
 316
 317 #endif // INCLUDED_SLIDESHOW_SOURCE_ENGINE_SHAPES_VIEWSHAPE_HXX
 318
 319 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */