Re: Calling COM functions using IDispatch->Invoke(...

* Alex:


Don't know. Looks OK, including the backwards indexing. But then, it isn't
always necessary to know what the problem is in order to fix it! :-)


Happily I hadn't yet thrown away the code I posted last time (it's an
all-purpose VC project I use for examples in e.g. Usenet postings), and with a
little added functionality -- destructor and an "addParam" function in
DispatchParameters class, I think it deals with your current problem.

Before blindly using this, though, see the comment in ~DispatchParameters.

Sorry about the linebreaks if they're broken in the Usenet posting.

<code file="OleAutomationObject.hpp">
#ifndef OLE_AUTOMATION_OBJECT
#define OLE_AUTOMATION_OBJECT

#include "wrapper/windows_h.h"
#include <ole2.h> // IDispatch
#include <comdef.h> // _com_ptr_t, _variant_t, _bstr_t
#include <vector>

#include <stdexcept>
#include <string>

namespace alfs
{
     namespace detail
     {
         // Exception helper, should really be in a file of its own:
         bool throwX( char const s[] ) { throw std::runtime_error( s ); }

         std::string narrow( wchar_t const wide[] )
         {
             std::string result( 2*wcslen(wide), '\0' );
             size_t const n = wcstombs( &result[0], wide, result.size() );
             (n != size_t(-1)) || throwX( "alfs::narrow: failed" );
             result.resize( n );
             return result;
         }

         bool throwHRX( char const s[], HRESULT hr )
         {
             throw std::runtime_error( s + narrow( _com_error( hr
).ErrorMessage() ) );
         }

         _COM_SMARTPTR_TYPEDEF( IDispatch, __uuidof(IDispatch) ); // IDispatchPtr

     } // namespace detail

     class DispatchParams
     {
     private:
         std::vector<VARIANTARG> myArgValues;
         std::vector<DISPID> myNamedArgIds;
         DISPPARAMS myParams;

         DispatchParams( DispatchParams const& ); // No such.
         DispatchParams& operator=( DispatchParams const& ); // No such.

     public:
         static VARIANTARG defaultParam()
         {
             VARIANTARG v = {};

             v.vt = VT_ERROR;
             v.scode = DISP_E_PARAMNOTFOUND;
             return v;
         }

         DispatchParams( int nParameters )
             : myArgValues( nParameters == 0? 1 : nParameters, defaultParam() )
             , myNamedArgIds( 1 )
         {
             myParams.rgvarg = &myArgValues[0];
             myParams.rgdispidNamedArgs = &myNamedArgIds[0];
             myParams.cArgs = nParameters;
             myParams.cNamedArgs = 0;
         }

         ~DispatchParams()
         {
             // Not really sure if this should be done or is callee's
responsibility,
             // and I'm too lazy to check that just for a Usenet posting!
Anyway, it
             // seems to work.
             for( size_t i = 0; i < myArgValues.size(); ++i )
             {
                 ::VariantClear( &myArgValues[i] );
             }
         }

         void setParam( size_t i, std::wstring const& s )
         {
             _variant_t v( s.c_str() );
             myArgValues.at( (myArgValues.size() - 1) - i ) = v.Detach();
         }

         DISPPARAMS* ptr() { return &myParams; }
     };

     class OleAutomationObject
     {
     private:
         detail::IDispatchPtr myDispatch;

         enum CallTypeEnum
         {
             methodCall = DISPATCH_METHOD,
             propertyGet = DISPATCH_PROPERTYGET,
             propertyPut = DISPATCH_PROPERTYPUT,
             propertyPutRef = DISPATCH_PROPERTYPUTREF
         };

         _variant_t invokeAs(
             CallTypeEnum callType,
             wchar_t const name[],
             DispatchParams& params
             ) const
         {
             using namespace detail;
             EXCEPINFO exceptionInfo = {};
             _variant_t returnValue;
             unsigned erronousArgIndex = 0;

             DISPID const dispId = dispIdOf( name );
             HRESULT const hr = myDispatch->Invoke(
                 dispId,
                 IID_NULL, // reserved
                 0, // locale id
                 static_cast<WORD>( callType ),
                 params.ptr(),
                 &returnValue, // VARIANT FAR* pVarResult
                 &exceptionInfo, // EXCEPINFO FAR* pExcepInfo
                 &erronousArgIndex
                 );
             (SUCCEEDED( hr )) || throwHRX( "OleAutomationObject: Invoke: ", hr );
             return returnValue;
         }

     public:
         OleAutomationObject( wchar_t const progId[], DWORD serverType =
CLSCTX_ALL )
             : myDispatch( progId, 0, serverType )
         {
             using namespace detail;
             (myDispatch != 0) || throwX( "OleAutomationObject::<init> failed" );
         }

         DISPID dispIdOf( wchar_t const name[] ) const
         {
             using namespace detail;
             DISPID dispId = 0;

             HRESULT const hr = myDispatch->GetIDsOfNames(
                 IID_NULL, // reserved
                 const_cast<wchar_t**>( &name ),
                 1, // count of names
                 0, // locale id
                 &dispId
                 );
             (SUCCEEDED( hr )) ||
                 throwHRX( "OleAutomationObject::dispIdOf: GetIDsOfNames: ", hr );
             return dispId;
         }

         _variant_t call( wchar_t const methodName[], DispatchParams& params )
         {
             return invokeAs( methodCall, methodName, params );
         }

         _variant_t call( wchar_t const methodName[], int nArgs )
         {
             DispatchParams params( nArgs );
             return call( methodName, params );
         }

         _variant_t get( wchar_t const propertyName[] ) const
         {
             // E.g. WordApp.Name requires non-zero arg pointers. Silly.
             DispatchParams params( 0 );
             return invokeAs( propertyGet, propertyName, params );
         }

         _bstr_t getAsBString( wchar_t const propertyName[] ) const
         {
             return get( propertyName );
         }

         std::wstring getAsStdString( wchar_t const propertyName[] ) const
         {
             return getAsBString( propertyName ).operator wchar_t const*();
         }
     };
}

#endif
</code>

<code file="main.cpp">
#include <cassert>
#include <iostream>
#include <ostream>
#include <stdexcept>
#include <string>

#include "OleAutomationObject.hpp"

bool throwX( char const s[] ) { throw std::runtime_error( s ); }

class WshShell: public alfs::OleAutomationObject
{
private:
     void quit()
     {
         try
         {
             call( L"Quit", 3 ); // 3 defaulted arguments.
         }
         catch( std::exception const& )
         {
             assert( "Word application object failed to quit" && 0 );
             std::abort();
         }
     }

public:
     WshShell(): alfs::OleAutomationObject( L"WScript.Shell" ) {}

     long run( std::wstring const& path )
     {
         alfs::DispatchParams params( 3 );

         params.setParam( 0, path );
         return call( L"Run", params );
     }
};

struct ComUsage
{
     ComUsage()
     {
         (SUCCEEDED( CoInitialize(0) )) || throwX( "CoInitialize failed" );
     }

     ~ComUsage() { CoUninitialize(); }
};

void cppMain()
{
     ComUsage com;
     WshShell wshShell;

     std::cout << wshShell.run( L"notepad" ) << std::endl;
}

int main()
{
     try
     {
         cppMain();
         return EXIT_SUCCESS;
     }
     catch( std::exception const& x )
     {
         std::cerr << "!" << x.what() << std::endl;
         return EXIT_FAILURE;
     }
} // main
</code>

<output>
     <comment>Notepad appears, 0 as program's own output</comment>
</output>

Cheers, & hth.,

- Alf

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?