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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
/* -*- 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_VMLDRAWING_HXX
#define INCLUDED_OOX_VML_VMLDRAWING_HXX
#include <map>
#include <memory>
#include <vector>
#include <com/sun/star/uno/Reference.hxx>
#include <oox/dllapi.h>
#include <oox/ole/oleobjecthelper.hxx>
#include <rtl/ustring.hxx>
#include <sal/types.h>
namespace com { namespace sun { namespace star {
namespace awt { struct Rectangle; }
namespace drawing { class XDrawPage; }
namespace drawing { class XShape; }
namespace drawing { class XShapes; }
} } }
namespace oox {
namespace core { class XmlFilterBase; }
namespace ole { class EmbeddedControl; }
namespace ole { class EmbeddedForm; }
namespace vml { class ShapeContainer; }
}
namespace oox {
namespace vml {
class ShapeBase;
/** Enumerates different types of VML drawings. */
enum DrawingType
{
VMLDRAWING_WORD, ///< Word: One shape per drawing.
VMLDRAWING_EXCEL, ///< Excel: OLE objects are part of VML.
VMLDRAWING_POWERPOINT ///< PowerPoint: OLE objects are part of DrawingML.
};
/** Contains information about an OLE object embedded in a draw page. */
struct OOX_DLLPUBLIC OleObjectInfo : public ::oox::ole::OleObjectInfo
{
OUString maShapeId; ///< Shape identifier for shape lookup.
OUString maName; ///< Programmatical name of the OLE object.
bool mbAutoLoad;
const bool mbDmlShape; ///< True = DrawingML shape (PowerPoint), false = VML shape (Excel/Word).
explicit OleObjectInfo( bool bDmlShape = false );
/** Sets the string representation of the passed numeric shape identifier. */
void setShapeId( sal_Int32 nShapeId );
};
// =========================================/===================================
/** Contains information about a form control embedded in a draw page. */
struct OOX_DLLPUBLIC ControlInfo
{
OUString maShapeId; ///< Shape identifier for shape lookup.
OUString maFragmentPath; ///< Path to the fragment describing the form control properties.
OUString maName; ///< Programmatical name of the form control.
explicit ControlInfo();
/** Sets the string representation of the passed numeric shape identifier. */
void setShapeId( sal_Int32 nShapeId );
};
/** Represents the collection of VML shapes for a complete draw page. */
class OOX_DLLPUBLIC Drawing
{
public:
explicit Drawing(
::oox::core::XmlFilterBase& rFilter,
const css::uno::Reference< css::drawing::XDrawPage >& rxDrawPage,
DrawingType eType );
virtual ~Drawing();
/** Returns the filter object that imports/exports this VML drawing. */
::oox::core::XmlFilterBase& getFilter() const { return mrFilter; }
/** Returns the application type containing the drawing. */
DrawingType getType() const { return meType; }
/** Returns read/write access to the container of shapes and templates. */
ShapeContainer& getShapes() { return *mxShapes; }
/** Returns read access to the container of shapes and templates. */
const ShapeContainer& getShapes() const { return *mxShapes; }
/** Returns the form object used to process ActiveX form controls. */
::oox::ole::EmbeddedForm& getControlForm() const;
/** Registers a block of shape identifiers reserved by this drawing. Block
size is 1024, shape identifiers are one-based (block 1 => 1025-2048). */
void registerBlockId( sal_Int32 nBlockId );
/** Registers the passed embedded OLE object. The related shape will then
load the OLE object data from the specified fragment. */
void registerOleObject( const OleObjectInfo& rOleObject );
/** Registers the passed embedded form control. The related shape will then
load the control properties from the specified fragment. */
void registerControl( const ControlInfo& rControl );
/** Final processing after import of the fragment. */
void finalizeFragmentImport();
/** Creates and inserts all UNO shapes into the draw page. The virtual
function notifyXShapeInserted() will be called for each new shape. */
void convertAndInsert() const;
/** Returns the local shape index from the passed global shape identifier. */
sal_Int32 getLocalShapeIndex( const OUString& rShapeId ) const;
/** Returns the registered info structure for an OLE object, if extant. */
const OleObjectInfo* getOleObjectInfo( const OUString& rShapeId ) const;
/** Returns the registered info structure for a form control, if extant. */
const ControlInfo* getControlInfo( const OUString& rShapeId ) const;
/** Creates a new UNO shape object, inserts it into the passed UNO shape
container, and sets the shape position and size. */
css::uno::Reference< css::drawing::XShape >
createAndInsertXShape(
const OUString& rService,
const css::uno::Reference< css::drawing::XShapes >& rxShapes,
const css::awt::Rectangle& rShapeRect ) const;
/** Creates a new UNO shape object for a form control, inserts the control
model into the form, and the shape into the passed UNO shape container. */
css::uno::Reference< css::drawing::XShape >
createAndInsertXControlShape(
const ::oox::ole::EmbeddedControl& rControl,
const css::uno::Reference< css::drawing::XShapes >& rxShapes,
const css::awt::Rectangle& rShapeRect,
sal_Int32& rnCtrlIndex ) const;
/** Derived classes may disable conversion of specific shapes. */
virtual bool isShapeSupported( const ShapeBase& rShape ) const;
/** Derived classes may return additional base names for automatic shape
name creation. */
virtual OUString getShapeBaseName( const ShapeBase& rShape ) const;
/** Derived classes may calculate the shape rectangle from a non-standard
anchor information string. */
virtual bool convertClientAnchor(
css::awt::Rectangle& orShapeRect,
const OUString& rShapeAnchor ) const;
/** Derived classes create a UNO shape according to the passed shape model.
Called for shape models that specify being under host control. */
virtual css::uno::Reference< css::drawing::XShape >
createAndInsertClientXShape(
const ShapeBase& rShape,
const css::uno::Reference< css::drawing::XShapes >& rxShapes,
const css::awt::Rectangle& rShapeRect ) const;
/** Derived classes may want to know that a UNO shape has been inserted.
Will be called from the convertAndInsert() implementation.
@param bGroupChild True = inserted into a group shape,
false = inserted directly into this drawing. */
virtual void notifyXShapeInserted(
const css::uno::Reference< css::drawing::XShape >& rxShape,
const css::awt::Rectangle& rShapeRect,
const ShapeBase& rShape, bool bGroupChild );
private:
typedef ::std::vector< sal_Int32 > BlockIdVector;
typedef ::std::map< OUString, OleObjectInfo > OleObjectInfoMap;
typedef ::std::map< OUString, ControlInfo > ControlInfoMap;
::oox::core::XmlFilterBase& mrFilter; ///< Filter object that imports/exports the VML drawing.
css::uno::Reference< css::drawing::XDrawPage >
mxDrawPage; ///< UNO draw page used to insert the shapes.
mutable std::unique_ptr<::oox::ole::EmbeddedForm> mxCtrlForm; ///< The control form used to process embedded controls.
mutable BlockIdVector maBlockIds; ///< Block identifiers used by this drawing.
std::unique_ptr<ShapeContainer> mxShapes; ///< All shapes and shape templates.
OleObjectInfoMap maOleObjects; ///< Info about all embedded OLE objects, mapped by shape id.
ControlInfoMap maControls; ///< Info about all embedded form controls, mapped by control name.
const DrawingType meType; ///< Application type containing the drawing.
};
} // namespace vml
} // namespace oox
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
