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