drawshapesubsetting.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#ifndef INCLUDED_SLIDESHOW_SOURCE_ENGINE_SHAPES_DRAWSHAPESUBSETTING_HXX
#define INCLUDED_SLIDESHOW_SOURCE_ENGINE_SHAPES_DRAWSHAPESUBSETTING_HXX
 
#include <doctreenode.hxx>
#include <attributableshape.hxx>
 
 
class GDIMetaFile;
typedef ::std::shared_ptr< GDIMetaFile > GDIMetaFileSharedPtr;
 
namespace slideshow::internal
    {
        class DrawShapeSubsetting
        {
        public:
            DrawShapeSubsetting();
 
            DrawShapeSubsetting( const DocTreeNode&     rShapeSubset,
                                 GDIMetaFileSharedPtr   rMtf );
 
            DrawShapeSubsetting(const DrawShapeSubsetting&) = delete;
 
            DrawShapeSubsetting& operator=(const DrawShapeSubsetting&) = delete;
 
            void reset( const ::std::shared_ptr< GDIMetaFile >&   rMtf );
 
            // Shape subsetting methods
 
 
            const DocTreeNode&          getSubsetNode       () const;
 
            AttributableShapeSharedPtr  getSubsetShape      ( const DocTreeNode& rTreeNode ) const;
 
            void                        addSubsetShape      ( const AttributableShapeSharedPtr& rShape );
 
            bool                        revokeSubsetShape   ( const AttributableShapeSharedPtr& rShape );
 
 
            // Doc tree methods
 
 
            sal_Int32   getNumberOfTreeNodes        ( DocTreeNode::NodeType eNodeType ) const;
 
            DocTreeNode getTreeNode                 ( sal_Int32             nNodeIndex,
                                                      DocTreeNode::NodeType eNodeType ) const;
 
            sal_Int32   getNumberOfSubsetTreeNodes  ( const DocTreeNode&    rParentNode,
                                                      DocTreeNode::NodeType eNodeType ) const;
 
            DocTreeNode getSubsetTreeNode           ( const DocTreeNode&    rParentNode,
                                                      sal_Int32             nNodeIndex,
                                                      DocTreeNode::NodeType eNodeType ) const;
 
            // Helper
 
 
            const VectorOfDocTreeNodes& getActiveSubsets() const {  return maCurrentSubsets; }
 
            enum IndexClassificator
            {
                CLASS_NOOP,
                CLASS_SHAPE_START,
                CLASS_SHAPE_END,
 
                CLASS_LINE_END,
                CLASS_PARAGRAPH_END,
                CLASS_SENTENCE_END,
                CLASS_WORD_END,
                CLASS_CHARACTER_CELL_END
            };
 
            typedef ::std::vector< IndexClassificator > IndexClassificatorVector;
 
        private:
            struct SubsetEntry
            {
                AttributableShapeSharedPtr  mpShape;
                sal_Int32                   mnStartActionIndex;
                sal_Int32                   mnEndActionIndex;
 
                int                         mnSubsetQueriedCount;
 
                sal_Int32 getHashValue() const
                {
                    // TODO(Q3): That's a hack. We assume that start
                    // index will always be less than 65535 (if this
                    // assumption is violated, hash map performance
                    // will degrade severely)
                    return mnStartActionIndex*SAL_MAX_INT16 + mnEndActionIndex;
                }
 
                bool operator<(const SubsetEntry& rOther) const
                {
                    return getHashValue() < rOther.getHashValue();
                }
 
            };
 
            typedef ::std::set< SubsetEntry >       ShapeSet;
 
            void ensureInitializedNodeTree() const;
            void excludeSubset(sal_Int32 nExcludedStart, sal_Int32 nExcludedEnd);
            void updateSubsets();
            void initCurrentSubsets();
            void reset();
 
            static sal_Int32   implGetNumberOfTreeNodes( const IndexClassificatorVector::const_iterator&   rBegin,
                                                  const IndexClassificatorVector::const_iterator&   rEnd,
                                                  DocTreeNode::NodeType                             eNodeType );
            DocTreeNode implGetTreeNode( const IndexClassificatorVector::const_iterator&    rBegin,
                                         const IndexClassificatorVector::const_iterator&    rEnd,
                                         sal_Int32                                          nNodeIndex,
                                         DocTreeNode::NodeType                              eNodeType ) const;
 
            mutable IndexClassificatorVector    maActionClassVector;
 
            ::std::shared_ptr< GDIMetaFile >  mpMtf;
 
            DocTreeNode                         maSubset;
 
            ShapeSet                            maSubsetShapes;
 
            mutable VectorOfDocTreeNodes        maCurrentSubsets;
 
            mutable bool                        mbNodeTreeInitialized;
        };
 
}
 
#endif // INCLUDED_SLIDESHOW_SOURCE_ENGINE_SHAPES_DRAWSHAPESUBSETTING_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */