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
209
210
211
212
|
/* -*- 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_OLE_VBAPROJECT_HXX
#define INCLUDED_OOX_OLE_VBAPROJECT_HXX
#include <functional>
#include <map>
#include <com/sun/star/uno/Reference.hxx>
#include <oox/dllapi.h>
#include <oox/helper/refmap.hxx>
#include <oox/helper/refvector.hxx>
#include <rtl/ustring.hxx>
#include <sal/types.h>
namespace com { namespace sun { namespace star {
namespace container { class XNameContainer; }
namespace frame { class XModel; }
namespace script { class XLibraryContainer; }
namespace script { namespace vba { class XVBAMacroResolver; } }
namespace uno { class XComponentContext; }
namespace uno { class XInterface; }
namespace io { class XInputStream; }
} } }
namespace oox {
class GraphicHelper;
class StorageBase;
}
namespace oox {
namespace ole {
class VbaModule;
class OOX_DLLPUBLIC VbaFilterConfig
{
public:
explicit VbaFilterConfig(
const css::uno::Reference< css::uno::XComponentContext >& rxContext,
const OUString& rConfigCompName );
~VbaFilterConfig();
/** Returns true, if the VBA source code and forms should be imported. */
bool isImportVba() const;
/** Returns true, if the VBA source code should be imported executable. */
bool isImportVbaExecutable() const;
/** Returns true, if the VBA source code and forms should be exported. */
bool isExportVba() const;
private:
css::uno::Reference< css::uno::XInterface >
mxConfigAccess;
};
/** Base class for objects that attach a macro to a specific action.
Purpose is to collect objects that need to attach a VBA macro to an action.
The VBA project will be loaded at a very late point of the document import
process, because it depends on an initialized core document model (e.g.
spreadsheet codenames). Some objects that want to attach a VBA macro to an
action (e.g. mouse click action for drawing shapes) are loaded long before
the VBA project. The drawback is that in most cases macros are specified
without module name, or the VBA project name is part of the macro name.
In the former case, all code modules have to be scanned for the macro to be
able to create a valid script URL.
The import code will register these requests to attach a VBA macro with an
instance of a class derived from this base class. The derived class will
store all information needed to finally attach the macro to the action,
once the VBA project has been imported.
*/
class OOX_DLLPUBLIC VbaMacroAttacherBase
{
public:
explicit VbaMacroAttacherBase( const OUString& rMacroName );
virtual ~VbaMacroAttacherBase();
/** Resolves the internal macro name to the related macro URL, and attaches
the macro to the object. */
void resolveAndAttachMacro(
const css::uno::Reference< css::script::vba::XVBAMacroResolver >& rxResolver );
private:
/** Called after the VBA project has been imported. Derived classes will
attach the passed script to the object represented by this instance. */
virtual void attachMacro( const OUString& rScriptUrl ) = 0;
private:
OUString const maMacroName;
};
typedef std::shared_ptr< VbaMacroAttacherBase > VbaMacroAttacherRef;
class OOX_DLLPUBLIC VbaProject : public VbaFilterConfig
{
public:
explicit VbaProject(
const css::uno::Reference< css::uno::XComponentContext >& rxContext,
const css::uno::Reference< css::frame::XModel >& rxDocModel,
const OUString& rConfigCompName );
virtual ~VbaProject();
/** Imports the entire VBA project from the passed storage.
@param rVbaPrjStrg The root storage of the entire VBA project.
*/
void importVbaProject(
StorageBase& rVbaPrjStrg,
const GraphicHelper& rGraphicHelper );
bool importVbaProject(
StorageBase& rVbaPrjStrg );
/// Imports VBA data for a VBA project, e.g. word/vbaData.xml.
void importVbaData(const css::uno::Reference<css::io::XInputStream>& xInputStream);
/** Reads vba module related information from the project streams */
void readVbaModules( StorageBase& rVbaPrjStrg );
/** Imports (and creates) vba modules and user forms from the vba project records previously read.
Note: ( expects that readVbaModules was already called ) */
void importModulesAndForms( StorageBase& rVbaPrjStrg, const GraphicHelper& rGraphicHelper );
/** Registers a macro attacher object. For details, see description of the
VbaMacroAttacherBase class. */
void registerMacroAttacher( const VbaMacroAttacherRef& rxAttacher );
/** Attaches VBA macros to objects registered via registerMacroAttacher(). */
void attachMacros();
void setOleOverridesSink( css::uno::Reference< css::container::XNameContainer > const & rxOleOverridesSink ){ mxOleOverridesSink = rxOleOverridesSink; }
protected:
/** Registers a dummy module that will be created when the VBA project is
imported. */
void addDummyModule( const OUString& rName, sal_Int32 nType );
/** Called when the import process of the VBA project has been started. */
virtual void prepareImport();
private:
VbaProject( const VbaProject& ) = delete;
VbaProject& operator=( const VbaProject& ) = delete;
/** Returns the Basic or dialog library container. */
css::uno::Reference< css::script::XLibraryContainer >
getLibraryContainer( sal_Int32 nPropId );
/** Opens a Basic or dialog library, creates missing if not found. */
css::uno::Reference< css::container::XNameContainer >
openLibrary( sal_Int32 nPropId );
/** Creates and returns the Basic library of the document used for import. */
css::uno::Reference< css::container::XNameContainer > const &
createBasicLibrary();
/** Creates and returns the dialog library of the document used for import. */
css::uno::Reference< css::container::XNameContainer > const &
createDialogLibrary();
/** Imports the VBA code modules and forms. */
void importVba(
StorageBase& rVbaPrjStrg,
const GraphicHelper& rGraphicHelper );
/** Copies the entire VBA project storage to the passed document model. */
void copyStorage( StorageBase& rVbaPrjStrg );
private:
typedef RefVector< VbaMacroAttacherBase > MacroAttacherVector;
typedef ::std::map< OUString, sal_Int32 > DummyModuleMap;
css::uno::Reference< css::uno::XComponentContext >
mxContext; ///< Component context with service manager.
css::uno::Reference< css::frame::XModel >
mxDocModel; ///< Document model used to import/export the VBA project.
css::uno::Reference< css::container::XNameContainer >
mxBasicLib; ///< The Basic library of the document used for import.
css::uno::Reference< css::container::XNameContainer >
mxDialogLib; ///< The dialog library of the document used for import.
MacroAttacherVector maMacroAttachers; ///< Objects that want to attach a VBA macro to an action.
DummyModuleMap maDummyModules; ///< Additional empty modules created on import.
OUString maPrjName; ///< Name of the VBA project.
css::uno::Reference< css::container::XNameContainer >
mxOleOverridesSink;
typedef RefMap< OUString, VbaModule > VbaModuleMap;
VbaModuleMap maModules;
VbaModuleMap maModulesByStrm;
};
} // namespace ole
} // namespace oox
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
