include/oox/ole/vbaproject.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_OLE_VBAPROJECT_HXX
  21 #define INCLUDED_OOX_OLE_VBAPROJECT_HXX
  22
  23 #include <functional>
  24 #include <map>
  25
  26 #include <com/sun/star/uno/Reference.hxx>
  27 #include <oox/dllapi.h>
  28 #include <oox/helper/refmap.hxx>
  29 #include <oox/helper/refvector.hxx>
  30 #include <rtl/ustring.hxx>
  31 #include <sal/types.h>
  32
  33 namespace com { namespace sun { namespace star {
  34     namespace container { class XNameContainer; }
  35     namespace frame { class XModel; }
  36     namespace script { class XLibraryContainer; }
  37     namespace script { namespace vba { class XVBAMacroResolver; } }
  38     namespace uno { class XComponentContext; }
  39     namespace uno { class XInterface; }
  40     namespace io { class XInputStream; }
  41 } } }
  42
  43 namespace oox {
  44     class GraphicHelper;
  45     class StorageBase;
  46 }
  47
  48 namespace oox {
  49 namespace ole {
  50
  51 class VbaModule;
  52
  53 class OOX_DLLPUBLIC VbaFilterConfig
  54 {
  55 public:
  56     explicit            VbaFilterConfig(
  57                             const css::uno::Reference< css::uno::XComponentContext >& rxContext,
  58                             const OUString& rConfigCompName );
  59                         ~VbaFilterConfig();
  60
  61     /** Returns true, if the VBA source code and forms should be imported. */
  62     bool                isImportVba() const;
  63     /** Returns true, if the VBA source code should be imported executable. */
  64     bool                isImportVbaExecutable() const;
  65     /** Returns true, if the VBA source code and forms should be exported. */
  66     bool                isExportVba() const;
  67
  68 private:
  69     css::uno::Reference< css::uno::XInterface >
  70                         mxConfigAccess;
  71 };
  72
  73
  74 /** Base class for objects that attach a macro to a specific action.
  75
  76     Purpose is to collect objects that need to attach a VBA macro to an action.
  77     The VBA project will be loaded at a very late point of the document import
  78     process, because it depends on an initialized core document model (e.g.
  79     spreadsheet codenames). Some objects that want to attach a VBA macro to an
  80     action (e.g. mouse click action for drawing shapes) are loaded long before
  81     the VBA project. The drawback is that in most cases macros are specified
  82     without module name, or the VBA project name is part of the macro name.
  83     In the former case, all code modules have to be scanned for the macro to be
  84     able to create a valid script URL.
  85
  86     The import code will register these requests to attach a VBA macro with an
  87     instance of a class derived from this base class. The derived class will
  88     store all information needed to finally attach the macro to the action,
  89     once the VBA project has been imported.
  90  */
  91 class OOX_DLLPUBLIC VbaMacroAttacherBase
  92 {
  93 public:
  94     explicit            VbaMacroAttacherBase( const OUString& rMacroName );
  95     virtual             ~VbaMacroAttacherBase();
  96
  97     /** Resolves the internal macro name to the related macro URL, and attaches
  98         the macro to the object. */
  99     void                resolveAndAttachMacro(
 100                             const css::uno::Reference< css::script::vba::XVBAMacroResolver >& rxResolver );
 101
 102 private:
 103     /** Called after the VBA project has been imported. Derived classes will
 104         attach the passed script to the object represented by this instance. */
 105     virtual void        attachMacro( const OUString& rScriptUrl ) = 0;
 106
 107 private:
 108     OUString     maMacroName;
 109 };
 110
 111 typedef std::shared_ptr< VbaMacroAttacherBase > VbaMacroAttacherRef;
 112
 113
 114 class OOX_DLLPUBLIC VbaProject : public VbaFilterConfig
 115 {
 116 public:
 117     explicit            VbaProject(
 118                             const css::uno::Reference< css::uno::XComponentContext >& rxContext,
 119                             const css::uno::Reference< css::frame::XModel >& rxDocModel,
 120                             const OUString& rConfigCompName );
 121     virtual             ~VbaProject();
 122
 123     /** Imports the entire VBA project from the passed storage.
 124
 125         @param rVbaPrjStrg  The root storage of the entire VBA project.
 126      */
 127     void                importVbaProject(
 128                             StorageBase& rVbaPrjStrg,
 129                             const GraphicHelper& rGraphicHelper );
 130
 131     bool                importVbaProject(
 132                             StorageBase& rVbaPrjStrg );
 133
 134     /// Imports VBA data for a VBA project, e.g. word/vbaData.xml.
 135     void                importVbaData(const css::uno::Reference<css::io::XInputStream>& xInputStream);
 136
 137     /** Reads vba module related information from the project streams */
 138     void                readVbaModules( StorageBase& rVbaPrjStrg );
 139     /** Imports (and creates) vba modules and user forms from the vba project records previously read.
 140       Note: ( expects that readVbaModules was already called ) */
 141     void                importModulesAndForms( StorageBase& rVbaPrjStrg, const GraphicHelper& rGraphicHelper );
 142     /** Registers a macro attacher object. For details, see description of the
 143         VbaMacroAttacherBase class. */
 144     void                registerMacroAttacher( const VbaMacroAttacherRef& rxAttacher );
 145
 146     /** Attaches VBA macros to objects registered via registerMacroAttacher(). */
 147     void                attachMacros();
 148
 149     void                setOleOverridesSink( css::uno::Reference< css::container::XNameContainer >&  rxOleOverridesSink ){ mxOleOverridesSink = rxOleOverridesSink; }
 150
 151 protected:
 152     /** Registers a dummy module that will be created when the VBA project is
 153         imported. */
 154     void                addDummyModule( const OUString& rName, sal_Int32 nType );
 155
 156     /** Called when the import process of the VBA project has been started. */
 157     virtual void        prepareImport();
 158
 159 private:
 160                         VbaProject( const VbaProject& ) = delete;
 161     VbaProject&         operator=( const VbaProject& ) = delete;
 162
 163     /** Returns the Basic or dialog library container. */
 164     css::uno::Reference< css::script::XLibraryContainer >
 165                         getLibraryContainer( sal_Int32 nPropId );
 166     /** Opens a Basic or dialog library, creates missing if not found. */
 167     css::uno::Reference< css::container::XNameContainer >
 168                         openLibrary( sal_Int32 nPropId );
 169     /** Creates and returns the Basic library of the document used for import. */
 170     css::uno::Reference< css::container::XNameContainer > const &
 171                         createBasicLibrary();
 172     /** Creates and returns the dialog library of the document used for import. */
 173     css::uno::Reference< css::container::XNameContainer > const &
 174                         createDialogLibrary();
 175
 176     /** Imports the VBA code modules and forms. */
 177     void                importVba(
 178                             StorageBase& rVbaPrjStrg,
 179                             const GraphicHelper& rGraphicHelper );
 180
 181     /** Copies the entire VBA project storage to the passed document model. */
 182     void                copyStorage( StorageBase& rVbaPrjStrg );
 183
 184 private:
 185     typedef RefVector< VbaMacroAttacherBase >           MacroAttacherVector;
 186     typedef ::std::map< OUString, sal_Int32 >    DummyModuleMap;
 187
 188     css::uno::Reference< css::uno::XComponentContext >
 189                         mxContext;          ///< Component context with service manager.
 190     css::uno::Reference< css::frame::XModel >
 191                         mxDocModel;         ///< Document model used to import/export the VBA project.
 192     css::uno::Reference< css::container::XNameContainer >
 193                         mxBasicLib;         ///< The Basic library of the document used for import.
 194     css::uno::Reference< css::container::XNameContainer >
 195                         mxDialogLib;        ///< The dialog library of the document used for import.
 196     MacroAttacherVector maMacroAttachers;   ///< Objects that want to attach a VBA macro to an action.
 197     DummyModuleMap      maDummyModules;     ///< Additional empty modules created on import.
 198     OUString            maPrjName;          ///< Name of the VBA project.
 199     css::uno::Reference< css::container::XNameContainer >
 200                         mxOleOverridesSink;
 201     typedef RefMap< rtl::OUString, VbaModule > VbaModuleMap;
 202     VbaModuleMap        maModules;
 203     VbaModuleMap        maModulesByStrm;
 204 };
 205
 206
 207 } // namespace ole
 208 } // namespace oox
 209
 210 #endif
 211
 212 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */