HRESULT OcxObject::RawInvoke(IRef<ITypeInfo>& typeinfo, IDispatch *dispatch, DISPID dispid, word flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep, unsigned *arg_err)
{
LOGINVOKE("IDispatch::Invoke");
if(dispid == 0) { // convert object to dispatch value
if(!result) return E_INVALIDARG;
result->vt = VT_DISPATCH;
result->pdispVal = dispatch;
if(dispatch) dispatch->AddRef();
return S_OK;
}
if(!typeinfo) {
LOG("dispid = " << FormatIntHex(dispid) << ": typeinfo = NULL");
return E_FAIL;
}
#if LOG_INVOKES >= 1
BSTR names[1] = { NULL };
unsigned count = 0;
typeinfo->GetNames(dispid, names, 1, &count);
String name;
if(names[0])
name = BSTRToString(names[0]);
else
name = FormatIntHex(dispid);
switch(flags) {
case DISPATCH_METHOD: name << " - method"; break;
case DISPATCH_PROPERTYGET: name << " - propget"; break;
case DISPATCH_PROPERTYPUT: name << " - propput"; break;
case DISPATCH_PROPERTYPUTREF: name << " - propputref"; break;
}
LOG("Member name: " << name);
#endif
if(!typeinfo)
return E_FAIL;
TYPEATTR *attr;
typeinfo->GetTypeAttr(&attr);
LOGINVOKE("GetTypeInfo: typekind = " << (int)attr->typekind);
// HRESULT res = typeinfo->Invoke(dispatch, dispid, flags, params, result, excep, arg_err);
HRESULT res = DispInvoke(dispatch, ~typeinfo, dispid, flags, params, result, excep, arg_err);
if(FAILED(res)) {
RLOG("failure: dispid = " << (int)dispid << ", #args = " << (int)params->cArgs
<< ", #named args = " << (int)params->cNamedArgs << ", return " << FormatIntHex(result));
for(int i = 0; i < (int)params->cArgs; i++) {
RLOG("arg[" << i << "] (vt = " << (int)params->rgvarg[i].vt << "): " << StdFormat(AsValue(params->rgvarg[i])));
}
RLOG("#funcs = " << attr->cFuncs);
for(int i = 0; i < attr->cFuncs; i++) {
FUNCDESC *func;
typeinfo->GetFuncDesc(i, &func);
RLOG("memid = " << func->memid << ", cParams " << func->cParams
<< ", cParamsOpt = " << func->cParamsOpt << ", cScodes " << func->cScodes
<< ", funckind = " << (int)func->funckind << ", invkind " << (int)func->invkind
<< ", flags = " << FormatIntHex(func->wFuncFlags));
typeinfo->ReleaseFuncDesc(func);
}
}
typeinfo->ReleaseTypeAttr(attr);
LOGINVOKE("//IDispatch::Invoke");
return LOGRESULT(res);
}
HRESULT __stdcall CoCOMServer::Invoke(DISPID dispidMember, REFIID riid,
LCID lcid, WORD wFlags, DISPPARAMS* pdispparams, VARIANT* pvarResult,
EXCEPINFO* pexcepinfo, UINT* puArgErr)
{
return DispInvoke(
this, m_ptinfo,
dispidMember, wFlags, pdispparams,
pvarResult, pexcepinfo, puArgErr);
}
STDMETHODIMP VLCControl2::Invoke(DISPID dispIdMember, REFIID riid,
LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
{
if( SUCCEEDED(loadTypeInfo()) )
{
return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
}
return E_NOTIMPL;
};
/******************************************************************************
* IDispatch_Invoke {OLEAUT32}
*
* Call an object method.
*
* PARAMS
* iface [I] IDispatch interface
* dispIdMember [I] DISPID of the method (from GetIDsOfNames())
* riid [I] Reserved, set to IID_NULL
* lcid [I] Locale of the type information to convert parameters with
* wFlags, [I] Kind of method call (DISPATCH_ flags from "oaidl.h")
* pDispParams [I] Array of method arguments
* pVarResult [O] Destination for the result of the call
* pExcepInfo [O] Destination for exception information
* puArgErr [O] Destination for bad argument
*
* RETURNS
* Success: S_OK.
* Failure: See DispInvoke() for failure cases.
*
* NOTES
* See DispInvoke() and IDispatch().
*/
static HRESULT WINAPI StdDispatch_Invoke(LPDISPATCH iface, DISPID dispIdMember, REFIID riid, LCID lcid,
WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult,
EXCEPINFO * pExcepInfo, UINT * puArgErr)
{
StdDispatch *This = impl_from_IDispatch(iface);
TRACE("(%d, %s, 0x%x, 0x%x, %p, %p, %p, %p)\n", dispIdMember, debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
if (!IsEqualGUID(riid, &IID_NULL))
{
FIXME(" expected riid == IID_NULL\n");
return E_INVALIDARG;
}
return DispInvoke(This->pvThis, This->pTypeInfo, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
}
Handle<Value> DispObject::set(LPOLESTR name, Local<Value> value)
{
// Prepare disp
if (!isPrepared()) Prepare();
if (!disp) return DispError(E_NOTIMPL, __FUNCTIONW__);
// Set value using dispatch
DISPID dispid;
CComVariant ret;
VarArgumets vargs(value);
HRESULT hrcode = DispInvoke(disp, name, 0, 0, &ret, DISPATCH_PROPERTYPUT, &dispid);
if FAILED(hrcode) return DispError(hrcode, L"DispPropertyPut");
return DispObject::NodeCreate(disp, name, dispid);
}
HRESULT __stdcall Sorter::Invoke( DISPID dispid, REFIID riid, LCID lcid,
WORD wFlags, DISPPARAMS * params, VARIANT * result,
EXCEPINFO * pExceptInfo, UINT * puArgErr
)
{
// check that the client is requesting the default interface (IAdd)
if( !IsEqualIID( riid, IID_NULL ) )
{ return DISP_E_UNKNOWNINTERFACE; }
if( !Sorter::pITypeInfo )
{
HRESULT hr = Sorter::loadITypeInfo();
if( !SUCCEEDED(hr) ) return hr;
}
return DispInvoke( this, Sorter::pITypeInfo, dispid, wFlags, params, result, pExceptInfo, puArgErr );
}
STDMETHODIMP
HippoMenu::Invoke (DISPID member,
const IID &iid,
LCID lcid,
WORD flags,
DISPPARAMS *dispParams,
VARIANT *result,
EXCEPINFO *excepInfo,
unsigned int *argErr)
{
if (!ifaceTypeInfo_)
return E_OUTOFMEMORY;
HippoQIPtr<IHippoMenu> hippoMenu(static_cast<IHippoMenu *>(this));
HRESULT hr = DispInvoke(hippoMenu, ifaceTypeInfo_, member, flags,
dispParams, result, excepInfo, argErr);
return hr;
}
STDMETHODIMP CoFoldersMonitor::Invoke(DISPID dispidMember, REFIID riid,
LCID lcid, WORD wFlags,
DISPPARAMS* pdispparams, VARIANT* pvarResult,
EXCEPINFO* pexcepinfo, UINT* puArgErr)
{
HRESULT hr = DispInvoke(static_cast<IDispatch*>(this),
m_typeInfo,
dispidMember,
wFlags,
pdispparams,
pvarResult,
pexcepinfo,
puArgErr);
_ASSERT(SUCCEEDED(hr));
return hr;
}
Handle<Value> DispObject::call(const Arguments &args)
{
CComVariant ret;
VarArgumets vargs(args);
IDispatch *pdisp = (disp) ? disp : owner_disp;
DISPID dispid = (disp) ? DISPID_VALUE : owner_id;
size_t argcnt = vargs.items.size();
VARIANT *argptr = (argcnt > 0) ? &vargs.items.front() : 0;
HRESULT hrcode = DispInvoke(pdisp, dispid, argcnt, argptr, &ret, DISPATCH_METHOD);
if FAILED(hrcode) return DispError(hrcode, L"DispMethod");
// Prepare result as object
CComPtr<IDispatch> ret_disp;
if (VariantDispGet(&ret, &ret_disp))
return DispObject::NodeCreate(ret_disp, /*name.GetString()*/ L"Result");
// Other result
return Variant2Value(ret);
}
// MzObj's Invoke()
static ULONG STDMETHODCALLTYPE Invoke(IMzObj *com_obj, DISPID dispid, REFIID riid, LCID lcid, WORD wFlags,
DISPPARAMS *params, VARIANT *result, EXCEPINFO *pexcepinfo,
UINT *puArgErr)
{
// We implement only a "default" interface
if (!IsEqualIID(riid, &IID_NULL))
return(DISP_E_UNKNOWNINTERFACE);
// We need our type lib's TYPEINFO (to pass to DispInvoke)
if (!MyTypeInfo)
{
register HRESULT hr;
if ((hr = loadMyTypeInfo())) return(hr);
}
// Let OLE32.DLL's DispInvoke() do all the real work of calling the appropriate
// function in our object, and massaging the passed args into the correct format
return(DispInvoke(com_obj, MyTypeInfo, dispid, wFlags, params, result, pexcepinfo, puArgErr));
}
HRESULT __stdcall Invoke(
dispid_t dispidMember,
const uuid::c_t &,
lcid_t,
word_t wFlags,
dispparams_t * pdispparams,
variant_t * pvarResult,
excepinfo_t * pexcepinfo,
uint_t * puArgErr)
{
return DispInvoke(
(Base *)this,
internal<in>(scoped_type_info<Base>::typeinfo()),
dispidMember,
wFlags,
pdispparams,
pvarResult,
pexcepinfo,
puArgErr);
}
HRESULT DispObject::Prepare(VARIANT *value)
{
IDispatch *pdisp = (disp) ? disp : owner_disp;
DISPID dispid = (disp) ? DISPID_VALUE : owner_id;
CComVariant val;
if (!value) value = &val;
// Get value using dispatch
CComVariant arg(index);
LONG argcnt = (index >= 0) ? 1 : 0;
HRESULT hrcode = DispInvoke(pdisp, dispid, argcnt, &arg, value, DISPATCH_PROPERTYGET);
if FAILED(hrcode) value->vt = VT_EMPTY;
// Init dispatch interface
if ((state & Prepared) == 0)
{
state |= Prepared;
VariantDispGet(value, &disp);
}
return hrcode;
}
STDMETHODIMP
HippoChatRoomWrapper::Invoke (DISPID member,
const IID &iid,
LCID lcid,
WORD flags,
DISPPARAMS *dispParams,
VARIANT *result,
EXCEPINFO *excepInfo,
unsigned int *argErr)
{
if (!ifaceTypeInfo_)
return E_OUTOFMEMORY;
HippoQIPtr<IHippoChatRoom> hippoEmbed(static_cast<IHippoChatRoom *>(this));
HRESULT hr = DispInvoke(hippoEmbed, ifaceTypeInfo_, member, flags,
dispParams, result, excepInfo, argErr);
#if 0
hippoDebug(L"Invoke: %#x - result %#x\n", member, hr);
#endif
return hr;
}
STDMETHODIMP
HippoChatControl::Invoke (DISPID member,
const IID &iid,
LCID lcid,
WORD flags,
DISPPARAMS *dispParams,
VARIANT *result,
EXCEPINFO *excepInfo,
unsigned int *argErr)
{
// Forward chat room events on to our connected listeners
if (member == HIPPO_DISPID_ONUSERJOIN ||
member == HIPPO_DISPID_ONUSERLEAVE ||
member == HIPPO_DISPID_ONMESSAGE ||
member == HIPPO_DISPID_ONRECONNECT ||
member == HIPPO_DISPID_ONUSERMUSICCHANGE)
{
HRESULT hr;
HippoPtr<IConnectionPoint> point;
hr = connectionPointContainer_.FindConnectionPoint(IID_IHippoChatRoomEvents, &point);
if (FAILED(hr))
return hr;
HippoPtr<IEnumConnections> e;
hr = point->EnumConnections(&e);
if (FAILED(hr))
return hr;
CONNECTDATA data;
ULONG fetched;
while (e->Next(1, &data, &fetched) == S_OK) {
HippoQIPtr<IDispatch> dispatch(data.pUnk);
if (dispatch) {
// If we passed the result return value, then we'd have to worry about freeing
// it to avoid leaks when it was overwritten. Just pass in null for the
// return value since these events don't have return values
hr = dispatch->Invoke(member, IID_NULL, 0 /* LCID */,
DISPATCH_METHOD, dispParams,
NULL /* result */, NULL /* exception */, NULL /* argError */);
// we debug log failure but otherwise ignore it
if (FAILED(hr))
hippoDebugLogW(L"Invoke of notification %d failed: %x", member, hr);
}
}
return S_OK;
}
if (!ifaceTypeInfo_)
return E_OUTOFMEMORY;
HippoQIPtr<IHippoChatRoom> hippoChatControl(static_cast<IHippoChatRoom *>(this));
HRESULT hr = DispInvoke(hippoChatControl, ifaceTypeInfo_, member, flags,
dispParams, result, excepInfo, argErr);
#if 0
hippoDebugDialog(L"Invoke: %#x - result %#x\n", member, hr);
#endif
return hr;
}
