Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 212 insertions, 0 deletions

diff --git a/include/oox/ole/vbaproject.hxx b/include/oox/ole/vbaproject.hxx
new file mode 100644
index 000000000..c3ad3a970
--- /dev/null
+++ b/include/oox/ole/vbaproject.hxx
@@ -0,0 +1,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::sun::star {
+    namespace container { class XNameContainer; }
+    namespace frame { class XModel; }
+    namespace script { class XLibraryContainer; }
+    namespace script::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 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     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: */