oleobjw.hxx

Go to the documentation of this file.

/* -*- 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 .
 */
 
#pragma once
 
#include "ole2uno.hxx"
#include "wincrap.hxx"
 
#include <string_view>
#include <unordered_map>
#include <vector>
 
#include <cppuhelper/implbase.hxx>
 
#include <com/sun/star/lang/XInitialization.hpp>
#include <com/sun/star/bridge/oleautomation/XAutomationObject.hpp>
#include <com/sun/star/script/XAutomationInvocation.hpp>
#include <rtl/ustring.hxx>
 
#include <com/sun/star/script/XDefaultProperty.hpp>
#include <com/sun/star/script/XDefaultMethod.hpp>
#include <com/sun/star/script/XDirectInvocation.hpp>
 
#include <typelib/typedescription.hxx>
#include "unoconversionutilities.hxx"
#include "windata.hxx"
using namespace cppu;
using namespace com::sun::star::lang;
using namespace com::sun::star::bridge;
using namespace com::sun::star::bridge::oleautomation;
 
typedef std::unordered_map<OUString, std::pair<DISPID, unsigned short>> DispIdMap;
 
typedef std::unordered_multimap<OUString, unsigned int> TLBFuncIndexMap;
 
// This class wraps an IDispatch and maps XInvocation calls to IDispatch calls on the wrapped object.
// If m_TypeDescription is set then this class represents a UNO interface implemented in a COM component.
// The interface is not a real interface in terms of an abstract class but is realized through IDispatch.
class IUnknownWrapper : public WeakImplHelper< XBridgeSupplier2, XInitialization, XAutomationObject, XDefaultProperty, XDefaultMethod, XDirectInvocation, XAutomationInvocation >,
 
                             public UnoConversionUtilities<IUnknownWrapper>
 
{
public:
    IUnknownWrapper(Reference<XMultiServiceFactory> const &xFactory,
                    sal_uInt8 unoWrapperClass, sal_uInt8 comWrapperClass);
 
    ~IUnknownWrapper() override;
 
    //XInterface
    Any SAL_CALL queryInterface(const Type& t) override;
 
    // XInvokation
    virtual Reference< XIntrospectionAccess > SAL_CALL getIntrospection(  ) override;
    virtual Any SAL_CALL invoke( const OUString& aFunctionName,
                                 const Sequence< Any >& aParams,
                                 Sequence< sal_Int16 >& aOutParamIndex,
                                 Sequence< Any >& aOutParam ) override;
    virtual void SAL_CALL setValue( const OUString& aPropertyName,
                                    const Any& aValue ) override;
    virtual Any SAL_CALL getValue( const OUString& aPropertyName ) override;
    virtual sal_Bool SAL_CALL hasMethod( const OUString& aName ) override;
    virtual sal_Bool SAL_CALL hasProperty( const OUString& aName ) override;
 
    // XBridgeSupplier2
    // This interface is implemented to provide a safe way to obtain the original
    // IUnknown or IDispatch within the function anyToVariant. The function asks
    // every UNO object for its XBridgeSupplier2 and if it is available uses it to convert
    // the object with its own supplier.
    virtual Any SAL_CALL createBridge( const Any& modelDepObject,
                                       const Sequence< sal_Int8 >& aProcessId,
                                       sal_Int16 sourceModelType,
                                       sal_Int16 destModelType ) override;
 
    // XInitialization
    virtual void SAL_CALL initialize( const Sequence< Any >& aArguments ) override;
 
    // XDefaultProperty
    virtual OUString SAL_CALL getDefaultPropertyName(  ) override { return m_sDefaultMember; }
 
    // XDefaultMethod
    virtual OUString SAL_CALL getDefaultMethodName(  ) override { return m_sDefaultMember; }
 
    virtual css::uno::Any SAL_CALL invokeGetProperty( const OUString& aFunctionName, const css::uno::Sequence< css::uno::Any >& aParams, css::uno::Sequence< ::sal_Int16 >& aOutParamIndex, css::uno::Sequence< css::uno::Any >& aOutParam ) override;
    virtual css::uno::Any SAL_CALL invokePutProperty( const OUString& aFunctionName, const css::uno::Sequence< css::uno::Any >& aParams, css::uno::Sequence< ::sal_Int16 >& aOutParamIndex, css::uno::Sequence< css::uno::Any >& aOutParam ) override;
 
    // XDirectInvocation
    virtual css::uno::Any SAL_CALL directInvoke( const OUString& aName, const css::uno::Sequence< css::uno::Any >& aParams ) override;
    virtual sal_Bool SAL_CALL hasMember( const OUString& aName ) override;
 
 
    Any  invokeWithDispIdComTlb(FuncDesc& aFuncDesc,
                            const OUString& sFuncName,
                            const Sequence< Any >& Params,
                            Sequence< sal_Int16 >& OutParamIndex,
                            Sequence< Any >& OutParam);
 
 
protected:
 
    virtual Any invokeWithDispIdUnoTlb(const OUString& sFunctionName,
                                       const Sequence< Any >& Params,
                                       Sequence<sal_Int16 >& OutParamIndex,
                                       Sequence< Any >& OutParam);
    // Is used for OleObjectFactory service
    virtual Any invokeWithDispIdComTlb(const OUString& sFuncName,
                                       const Sequence< Any >& Params,
                                       Sequence< sal_Int16 >& OutParamIndex,
                                       Sequence< Any >& OutParam);
 
    // UnoConversionUtilities -------------------------------------------------------------------------------
    virtual Reference<XInterface> createUnoWrapperInstance() override;
    virtual Reference<XInterface> createComWrapperInstance() override;
 
    void getFuncDesc(const OUString & sFuncName, FUNCDESC ** pFuncDesc);
    void getPropDesc(const OUString & sFuncName, FUNCDESC ** pFuncDescGet,
                     FUNCDESC** pFuncDescPut, VARDESC ** pVarDesc);
    // These functions are for the case if an object of this class wraps an IDispatch
    // object that implements UNO interfaces. In that case the member m_seqTypes
    // is set through XInitialization::initialize.
    void getMethodInfo(std::u16string_view sName, TypeDescription& methodDescription);
    // After return attributInfo contains typelib_InterfaceAttributeTypeDescription::pAttributeTypeRef
    void getAttributeInfo(std::u16string_view sName, TypeDescription& attributeInfo);
    // used by get MethodInfo
    TypeDescription  getInterfaceMemberDescOfCurrentCall(std::u16string_view sName);
    ITypeInfo*  getTypeInfo();
 
    bool getDispid(const OUString& sFuncName, DISPID * id);
 
    VARTYPE getUserDefinedElementType( ITypeInfo* pTypeInfo, const DWORD nHrefType );
 
    VARTYPE getElementTypeDesc( const TYPEDESC *desc);
    void  buildComTlbIndex();
 
    void getFuncDescForInvoke(const OUString & sFuncName,
                              const Sequence<Any> & seqArgs, FUNCDESC** pFuncDesc);
 
    // Finds out whether the wrapped IDispatch is a JScript Object. This is
    // done by
    // asking for the property "_environment". If it has the value "JScript"
    // (case insensitive) then the IDispatch is considered a JScript object.
    bool isJScriptObject();
 
 
    // If UNO interfaces are implemented in JScript objects, VB or C++ COM objects
    // and those are passed as parameter to a UNO interface function, then
    // the IDispatch* are wrapped by objects of this class. Assuming that the functions
    // implemented by the IDispatch object returns another UNO interface then
    // it has to be wrapped to this type. But this is only possible if an object of this
    // wrapper class knows what type it is represting. The member m_TypeDescription holds this
    // information.
    // m_TypeDescription is only useful when an object wraps an IDispatch object that implements
    // a UNO interface. The value is set during a call to XInitialization::initialize.
    Sequence<Type> m_seqTypes;
    CComPtr<IUnknown> m_spUnknown;
    CComPtr<IDispatch> m_spDispatch;
        OUString m_sTypeName; // is "" ( not initialised ), "IDispatch" ( we have no idea ) or "SomeLibrary.SomeTypeName" if we managed to get a type
    bool  m_bOriginalDispatch;
    DispIdMap           m_dispIdMap;
    Reference<XIdlClass>*       m_pxIdlClass;
 
 
    // used by isJScriptObject
    enum JScriptDetermination{ JScriptUndefined=0, NoJScript, IsJScript};
    JScriptDetermination m_eJScript;
    // The map is filled by buildComTlbIndex
    // It maps Uno Function names to an index which is used in ITypeInfo::GetFuncDesc
    TLBFuncIndexMap m_mapComFunc;
    // used for synchronizing the computation of the content for m_mapComFunc
    bool m_bComTlbIndexInit;
    // Keeps the ITypeInfo obtained from IDispatch::GetTypeInfo
    CComPtr< ITypeInfo > m_spTypeInfo;
    OUString m_sDefaultMember;
    bool m_bHasDfltMethod;
    bool m_bHasDfltProperty;
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */