slideshow/source/engine/shapes/drawshapesubsetting.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_DRAWSHAPESUBSETTING_HXX
  21 #define INCLUDED_SLIDESHOW_SOURCE_ENGINE_SHAPES_DRAWSHAPESUBSETTING_HXX
  22
  23 #include <doctreenode.hxx>
  24 #include <attributableshape.hxx>
  25
  26
  27 class GDIMetaFile;
  28 typedef ::std::shared_ptr< GDIMetaFile > GDIMetaFileSharedPtr;
  29
  30 namespace slideshow
  31 {
  32     namespace internal
  33     {
  34         /** This class encapsulates the subsetting aspects of a
  35             DrawShape.
  36          */
  37         class DrawShapeSubsetting
  38         {
  39         public:
  40             /** Create empty shape subset handling.
  41
  42                 This method creates a subset handler which contains no
  43                 subset information. All methods will return default
  44                 values.
  45
  46                 @param rMtf
  47                 Metafile to retrieve subset info from (must have been
  48                 generated with verbose text comments switched on).
  49              */
  50             DrawShapeSubsetting();
  51
  52             /** Create new shape subset handling.
  53
  54                 @param rShapeSubset
  55                 The subset this object represents (can be empty, then
  56                 denoting 'represents a whole shape')
  57
  58                 @param rMtf
  59                 Metafile to retrieve subset info from (must have been
  60                 generated with verbose text comments switched on).
  61              */
  62             DrawShapeSubsetting( const DocTreeNode&     rShapeSubset,
  63                                  GDIMetaFileSharedPtr   rMtf );
  64
  65             /// Forbid copy construction
  66             DrawShapeSubsetting(const DrawShapeSubsetting&) = delete;
  67
  68             /// Forbid copy assignment
  69             DrawShapeSubsetting& operator=(const DrawShapeSubsetting&) = delete;
  70
  71             /** Reset metafile.
  72
  73                 Use this method to completely reset the
  74                 ShapeSubsetting, with a new metafile. Note that any
  75                 information previously set will be lost, including
  76                 added subset shapes!
  77
  78                 @param rMtf
  79                 Metafile to retrieve subset info from (must have been
  80                 generated with verbose text comments switched on).
  81              */
  82             void reset( const ::std::shared_ptr< GDIMetaFile >&   rMtf );
  83
  84             // Shape subsetting methods
  85
  86
  87             /// Return subset node for this shape
  88             const DocTreeNode&          getSubsetNode       () const;
  89
  90             /// Get subset shape for given node, if any
  91             AttributableShapeSharedPtr  getSubsetShape      ( const DocTreeNode& rTreeNode ) const;
  92
  93             /// Add child subset shape (or increase use count, if already existent)
  94             void                        addSubsetShape      ( const AttributableShapeSharedPtr& rShape );
  95
  96             /** Revoke subset shape
  97
  98                 This method revokes a subset shape, decrementing the
  99                 use count for this subset by one. If the use count
 100                 reaches zero (i.e. when the number of addSubsetShape()
 101                 matches the number of revokeSubsetShape() calls for
 102                 the same subset), the subset entry is removed from the
 103                 internal list, and subsequent getSubsetShape() calls
 104                 will return the empty pointer for this subset.
 105
 106                 @return true, if the subset shape was physically
 107                 removed from the list (false is returned, when nothing
 108                 was removed, either because only the use count was
 109                 decremented, or there was no such subset found, in the
 110                 first place).
 111              */
 112             bool                        revokeSubsetShape   ( const AttributableShapeSharedPtr& rShape );
 113
 114
 115             // Doc tree methods
 116
 117
 118             /// Return overall number of nodes for given type
 119             sal_Int32   getNumberOfTreeNodes        ( DocTreeNode::NodeType eNodeType ) const;
 120
 121             /// Return tree node of given index and given type
 122             DocTreeNode getTreeNode                 ( sal_Int32             nNodeIndex,
 123                                                       DocTreeNode::NodeType eNodeType ) const;
 124
 125             /// Return number of nodes of given type, below parent node
 126             sal_Int32   getNumberOfSubsetTreeNodes  ( const DocTreeNode&    rParentNode,
 127                                                       DocTreeNode::NodeType eNodeType ) const;
 128
 129             /// Return tree node of given index and given type, relative to parent node
 130             DocTreeNode getSubsetTreeNode           ( const DocTreeNode&    rParentNode,
 131                                                       sal_Int32             nNodeIndex,
 132                                                       DocTreeNode::NodeType eNodeType ) const;
 133
 134             // Helper
 135
 136
 137             /** Return a vector of currently active subsets.
 138
 139                 Needed when rendering a shape, this method provides a
 140                 vector of subsets currently visible (the range as
 141                 returned by getEffectiveSubset(), minus the parts that
 142                 are currently hidden, because displayed by child
 143                 shapes).
 144              */
 145             const VectorOfDocTreeNodes& getActiveSubsets() const {  return maCurrentSubsets; }
 146
 147             /** This enum classifies each action index in the
 148                 metafile.
 149
 150                 Of interest are, of course, the places where
 151                 structural shape and/or text elements end. The
 152                 remainder of the action gets classified as 'noop'
 153              */
 154             enum IndexClassificator
 155             {
 156                 CLASS_NOOP,
 157                 CLASS_SHAPE_START,
 158                 CLASS_SHAPE_END,
 159
 160                 CLASS_LINE_END,
 161                 CLASS_PARAGRAPH_END,
 162                 CLASS_SENTENCE_END,
 163                 CLASS_WORD_END,
 164                 CLASS_CHARACTER_CELL_END
 165             };
 166
 167             typedef ::std::vector< IndexClassificator > IndexClassificatorVector;
 168
 169         private:
 170             /** Entry for subset shape
 171
 172                 This struct contains data for every subset shape
 173                 generated. Note that for a given start/end action
 174                 index combination, only one subset instance is
 175                 generated (and reused for subsequent queries).
 176              */
 177             struct SubsetEntry
 178             {
 179                 AttributableShapeSharedPtr  mpShape;
 180                 sal_Int32                   mnStartActionIndex;
 181                 sal_Int32                   mnEndActionIndex;
 182
 183                 /// Number of times this subset was queried, and not yet revoked
 184                 int                         mnSubsetQueriedCount;
 185
 186                 sal_Int32 getHashValue() const
 187                 {
 188                     // TODO(Q3): That's a hack. We assume that start
 189                     // index will always be less than 65535 (if this
 190                     // assumption is violated, hash map performance
 191                     // will degrade severely)
 192                     return mnStartActionIndex*SAL_MAX_INT16 + mnEndActionIndex;
 193                 }
 194
 195                 /// The shape set is ordered according to this method
 196                 bool operator<(const SubsetEntry& rOther) const
 197                 {
 198                     return getHashValue() < rOther.getHashValue();
 199                 }
 200
 201             };
 202
 203             typedef ::std::set< SubsetEntry >       ShapeSet;
 204
 205             void ensureInitializedNodeTree() const;
 206             void excludeSubset(sal_Int32 nExcludedStart, sal_Int32 nExcludedEnd);
 207             void updateSubsets();
 208             void initCurrentSubsets();
 209             void reset();
 210
 211             static sal_Int32   implGetNumberOfTreeNodes( const IndexClassificatorVector::const_iterator&   rBegin,
 212                                                   const IndexClassificatorVector::const_iterator&   rEnd,
 213                                                   DocTreeNode::NodeType                             eNodeType );
 214             DocTreeNode implGetTreeNode( const IndexClassificatorVector::const_iterator&    rBegin,
 215                                          const IndexClassificatorVector::const_iterator&    rEnd,
 216                                          sal_Int32                                          nNodeIndex,
 217                                          DocTreeNode::NodeType                              eNodeType ) const;
 218
 219             mutable IndexClassificatorVector    maActionClassVector;
 220
 221             /// Metafile to retrieve subset info from
 222             ::std::shared_ptr< GDIMetaFile >  mpMtf;
 223
 224             /// Subset of the metafile represented by this object
 225             DocTreeNode                         maSubset;
 226
 227             /// the list of subset shapes spawned from this one.
 228             ShapeSet                            maSubsetShapes;
 229
 230             /** Current number of subsets to render (calculated from
 231                 maSubset and mnMin/MaxSubsetActionIndex).
 232
 233                 Note that this is generally _not_ equivalent to
 234                 maSubset, as it excludes all active subset children!
 235              */
 236             mutable VectorOfDocTreeNodes        maCurrentSubsets;
 237
 238             /// Whether the shape's doc tree has been initialized successfully, or not
 239             mutable bool                        mbNodeTreeInitialized;
 240         };
 241
 242     }
 243 }
 244
 245 #endif // INCLUDED_SLIDESHOW_SOURCE_ENGINE_SHAPES_DRAWSHAPESUBSETTING_HXX
 246
 247 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */