summaryrefslogtreecommitdiffstats
path: root/include/oox/vml/vmldrawing.hxx
blob: 9181b73566133a554706e01d3be8ef04f37e4dfa (plain)
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
208
/* -*- 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::sun::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.
    bool         mbTextContentShape; ///< Whether this control shape will be imported to Writer or not (has AnchorType property or not).

    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: */