include/oox/vml/vmlshapecontainer.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_OOX_VML_VMLSHAPECONTAINER_HXX
  21 #define INCLUDED_OOX_VML_VMLSHAPECONTAINER_HXX
  22
  23 #include <cstddef>
  24 #include <functional>
  25 #include <memory>
  26 #include <stack>
  27
  28 #include <com/sun/star/awt/Rectangle.hpp>
  29 #include <com/sun/star/uno/Reference.hxx>
  30 #include <oox/helper/refmap.hxx>
  31 #include <oox/helper/refvector.hxx>
  32 #include <rtl/ustring.hxx>
  33
  34 namespace com::sun::star {
  35     namespace drawing { class XShapes; }
  36 }
  37
  38 namespace oox::vml {
  39
  40 class Drawing;
  41 class ShapeType;
  42 class ShapeBase;
  43
  44
  45 struct ShapeParentAnchor
  46 {
  47     css::awt::Rectangle maShapeRect;
  48     css::awt::Rectangle maCoordSys;
  49 };
  50
  51
  52 /** Container that holds a list of shapes and shape templates. */
  53 class ShapeContainer
  54 {
  55 public:
  56     explicit            ShapeContainer( Drawing& rDrawing );
  57                         ~ShapeContainer();
  58
  59     /** Returns the drawing this shape container is part of. */
  60     Drawing&     getDrawing() { return mrDrawing; }
  61
  62     /** Creates and returns a new shape template object. */
  63     std::shared_ptr<ShapeType> createShapeType();
  64     /** Creates and returns a new shape object of the specified type. */
  65     template< typename ShapeT >
  66     std::shared_ptr<ShapeT> createShape();
  67
  68     /** Final processing after import of the drawing fragment. */
  69     void                finalizeFragmentImport();
  70
  71     /** Returns true, if this container does not contain any shapes. */
  72     bool         empty() const { return maShapes.empty(); }
  73
  74     /** Returns the shape template with the passed identifier.
  75         Searches in all group shapes too. */
  76     const ShapeType*    getShapeTypeById( const OUString& rShapeId ) const;
  77     /** Returns the shape with the passed identifier.
  78         Searches in all group shapes too. */
  79     const ShapeBase*    getShapeById( const OUString& rShapeId ) const;
  80
  81     /** Searches for a shape by using the passed functor that takes a constant
  82         reference of a ShapeBase object. */
  83     template< typename Functor >
  84     const ShapeBase*    findShape( const Functor& rFunctor ) const;
  85
  86     /**
  87       (Word only) Returns the last shape in the collection, if it is after the last
  88       mark from pushMark(), and removes it.
  89     */
  90     std::shared_ptr< ShapeBase > takeLastShape();
  91     /**
  92       Adds a recursion mark to the stack. It is possible that a shape contains <w:txbxContent>
  93       which contains another shape, and writerfilter needs to know which shape is from the inner
  94       ooxml context and which from the outer ooxml context, while it is necessary to keep
  95       at least shape types across such blocks. Therefore this function marks beginning
  96       of each shape xml block, and takeLastShape() returns only shapes from this block.
  97     */
  98     void pushMark();
  99     /**
 100       Removes a recursion mark.
 101     */
 102     void popMark();
 103
 104     /** Creates and inserts all UNO shapes into the passed container. */
 105     void                convertAndInsert(
 106                             const css::uno::Reference< css::drawing::XShapes >& rxShapes,
 107                             const ShapeParentAnchor* pParentAnchor = nullptr ) const;
 108
 109 private:
 110     typedef RefVector< ShapeType >                  ShapeTypeVector;
 111     typedef RefVector< ShapeBase >                  ShapeVector;
 112     typedef RefMap< OUString, ShapeType >    ShapeTypeMap;
 113     typedef RefMap< OUString, ShapeBase >    ShapeMap;
 114
 115     Drawing&            mrDrawing;          ///< The VML drawing page that contains this shape.
 116     ShapeTypeVector     maTypes;            ///< All shape templates.
 117     ShapeVector         maShapes;           ///< All shape definitions.
 118     ShapeTypeMap        maTypesById;        ///< All shape templates mapped by identifier.
 119     ShapeMap            maShapesById;       ///< All shape definitions mapped by identifier.
 120     std::stack< size_t > markStack;         ///< Recursion marks from pushMark()/popMark().
 121 };
 122
 123
 124 template< typename ShapeT >
 125 std::shared_ptr<ShapeT> ShapeContainer::createShape()
 126 {
 127     auto xShape = std::make_shared<ShapeT>( mrDrawing );
 128     xShape->setContainer(this);
 129     maShapes.push_back( xShape );
 130     return xShape;
 131 }
 132
 133 template< typename Functor >
 134 const ShapeBase* ShapeContainer::findShape( const Functor& rFunctor ) const
 135 {
 136     return maShapes.findIf( rFunctor ).get();
 137 }
 138
 139
 140 } // namespace oox::vml
 141
 142 #endif
 143
 144 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */