static void on_before_navigate2(DocHost *This, LPCWSTR url, SAFEARRAY *post_data, LPWSTR headers, VARIANT_BOOL *cancel)
{
VARIANT var_url, var_flags, var_frame_name, var_post_data, var_post_data2, var_headers;
DISPPARAMS dispparams;
VARIANTARG params[7];
WCHAR file_path[MAX_PATH];
DWORD file_path_len = sizeof(file_path) / sizeof(*file_path);
dispparams.cArgs = 7;
dispparams.cNamedArgs = 0;
dispparams.rgdispidNamedArgs = NULL;
dispparams.rgvarg = params;
This->busy = VARIANT_TRUE;
V_VT(params) = VT_BOOL|VT_BYREF;
V_BOOLREF(params) = cancel;
V_VT(params+1) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+1) = &var_headers;
V_VT(&var_headers) = VT_BSTR;
V_BSTR(&var_headers) = headers;
V_VT(params+2) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+2) = &var_post_data2;
V_VT(&var_post_data2) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(&var_post_data2) = &var_post_data;
if(post_data) {
V_VT(&var_post_data) = VT_UI1|VT_ARRAY;
V_ARRAY(&var_post_data) = post_data;
}else {
V_VT(&var_post_data) = VT_EMPTY;
}
V_VT(params+3) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+3) = &var_frame_name;
V_VT(&var_frame_name) = VT_BSTR;
V_BSTR(&var_frame_name) = NULL;
V_VT(params+4) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+4) = &var_flags;
V_VT(&var_flags) = VT_I4;
V_I4(&var_flags) = 0;
V_VT(params+5) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+5) = &var_url;
V_VT(&var_url) = VT_BSTR;
if(PathCreateFromUrlW(url, file_path, &file_path_len, 0) == S_OK)
V_BSTR(&var_url) = SysAllocString(file_path);
else
V_BSTR(&var_url) = SysAllocString(url);
V_VT(params+6) = (VT_DISPATCH);
V_DISPATCH(params+6) = (IDispatch*)This->wb;
call_sink(This->cps.wbe2, DISPID_BEFORENAVIGATE2, &dispparams);
SysFreeString(V_BSTR(&var_url));
}
static void on_before_navigate2(DocHost *This, LPCWSTR url, SAFEARRAY *post_data, LPWSTR headers, VARIANT_BOOL *cancel)
{
VARIANT var_url, var_flags, var_frame_name, var_post_data, var_post_data2, var_headers;
DISPPARAMS dispparams;
VARIANTARG params[7];
dispparams.cArgs = 7;
dispparams.cNamedArgs = 0;
dispparams.rgdispidNamedArgs = NULL;
dispparams.rgvarg = params;
This->busy = VARIANT_TRUE;
V_VT(params) = VT_BOOL|VT_BYREF;
V_BOOLREF(params) = cancel;
V_VT(params+1) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+1) = &var_headers;
V_VT(&var_headers) = VT_BSTR;
V_BSTR(&var_headers) = headers;
V_VT(params+2) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+2) = &var_post_data2;
V_VT(&var_post_data2) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(&var_post_data2) = &var_post_data;
if(post_data) {
V_VT(&var_post_data) = VT_UI1|VT_ARRAY;
V_ARRAY(&var_post_data) = post_data;
}else {
V_VT(&var_post_data) = VT_EMPTY;
}
V_VT(params+3) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+3) = &var_frame_name;
V_VT(&var_frame_name) = VT_BSTR;
V_BSTR(&var_frame_name) = NULL;
V_VT(params+4) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+4) = &var_flags;
V_VT(&var_flags) = VT_I4;
V_I4(&var_flags) = 0;
V_VT(params+5) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+5) = &var_url;
V_VT(&var_url) = VT_BSTR;
V_BSTR(&var_url) = SysAllocString(url);
V_VT(params+6) = (VT_DISPATCH);
V_DISPATCH(params+6) = This->disp;
call_sink(This->cps.wbe2, DISPID_BEFORENAVIGATE2, &dispparams);
SysFreeString(V_BSTR(&var_url));
}
JNIEXPORT void JNICALL Java_com_tangram_Variant_putVariantBooleanRef(JNIEnv *env, jobject _this, jboolean b)
{
VARIANT *v = extractVariant(env, _this);
if (v) {
VariantClear(v); // whatever was there before
VARIANT_BOOL *br = (VARIANT_BOOL *)CoTaskMemAlloc(sizeof(VARIANT_BOOL));
*br = b ? VARIANT_TRUE : VARIANT_FALSE;
V_VT(v) = VT_BOOL | VT_BYREF;
V_BOOLREF(v) = br;
}
}
JNIEXPORT jboolean JNICALL Java_com_tangram_Variant_getVariantBooleanRef(JNIEnv *env, jobject _this)
{
VARIANT *v = extractVariant(env, _this);
if (v) {
if (V_VT(v) != (VT_BOOL | VT_BYREF)) {
return NULL;
}
return (jboolean)*V_BOOLREF(v);
}
return NULL;
}
void handle_navigation_error(DocHost* doc_host, HRESULT hres, BSTR url, IHTMLWindow2 *win2)
{
VARIANT var_status_code, var_frame_name, var_url;
DISPPARAMS dispparams;
VARIANTARG params[5];
VARIANT_BOOL cancel = VARIANT_FALSE;
dispparams.cArgs = 5;
dispparams.cNamedArgs = 0;
dispparams.rgdispidNamedArgs = NULL;
dispparams.rgvarg = params;
V_VT(params) = VT_BOOL|VT_BYREF;
V_BOOLREF(params) = &cancel;
V_VT(params+1) = VT_VARIANT|VT_BYREF;
V_VARIANTREF(params+1) = &var_status_code;
V_VT(&var_status_code) = VT_I4;
V_I4(&var_status_code) = hres;
V_VT(params+2) = VT_VARIANT|VT_BYREF;
V_VARIANTREF(params+2) = &var_frame_name;
V_VT(&var_frame_name) = VT_BSTR;
if(win2) {
hres = IHTMLWindow2_get_name(win2, &V_BSTR(&var_frame_name));
if(FAILED(hres))
V_BSTR(&var_frame_name) = NULL;
} else
V_BSTR(&var_frame_name) = NULL;
V_VT(params+3) = VT_VARIANT|VT_BYREF;
V_VARIANTREF(params+3) = &var_url;
V_VT(&var_url) = VT_BSTR;
V_BSTR(&var_url) = url;
V_VT(params+4) = VT_DISPATCH;
V_DISPATCH(params+4) = (IDispatch*)doc_host->wb;
call_sink(doc_host->cps.wbe2, DISPID_NAVIGATEERROR, &dispparams);
SysFreeString(V_BSTR(&var_frame_name));
if(!cancel)
FIXME("Navigate to error page\n");
}
SEXP
R_getDynamicVariantValue(SEXP ref)
{
VARIANT *var;
VARTYPE rtype;
var = R_getVariantRef(ref);
rtype = V_VT(var) & (~ VT_BYREF);
switch(rtype) {
case VT_BOOL:
return(ScalarLogical(*V_BOOLREF(var)));
break;
case VT_I4:
return(ScalarInteger(*V_I4REF(var)));
break;
case VT_R8:
return(ScalarReal(*V_R8REF(var)));
break;
default:
return(R_NilValue);
}
return(R_NilValue);
}
SEXP
R_setDynamicVariantValue(SEXP ref, SEXP val)
{
VARIANT *var;
VARTYPE rtype;
var = R_getVariantRef(ref);
rtype = V_VT(var) & (~ VT_BYREF);
switch(rtype) {
case VT_BOOL:
*V_BOOLREF(var) = LOGICAL(val)[0];
break;
case VT_I4:
*V_I4REF(var) = INTEGER(val)[0];
break;
case VT_R8:
*V_R8REF(var) = REAL(val)[0];
break;
default:
return(R_NilValue);
}
return(R_NilValue);
}
PHP_COM_DOTNET_API int php_com_copy_variant(VARIANT *dstvar, VARIANT *srcvar)
{
int ret = SUCCESS;
switch (V_VT(dstvar) & ~VT_BYREF) {
case VT_EMPTY:
case VT_NULL:
case VT_VOID:
/* should not be possible */
break;
case VT_UI1:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI1REF(dstvar) = V_UI1(srcvar);
} else {
V_UI1(dstvar) = V_UI1(srcvar);
}
break;
case VT_I1:
if (V_VT(dstvar) & VT_BYREF) {
*V_I1REF(dstvar) = V_I1(srcvar);
} else {
V_I1(dstvar) = V_I1(srcvar);
}
break;
case VT_UI2:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI2REF(dstvar) = V_UI2(srcvar);
} else {
V_UI2(dstvar) = V_UI2(srcvar);
}
break;
case VT_I2:
if (V_VT(dstvar) & VT_BYREF) {
*V_I2REF(dstvar) = V_I2(srcvar);
} else {
V_I2(dstvar) = V_I2(srcvar);
}
break;
case VT_UI4:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI4REF(dstvar) = V_UI4(srcvar);
} else {
V_UI4(dstvar) = V_UI4(srcvar);
}
break;
case VT_I4:
if (V_VT(dstvar) & VT_BYREF) {
*V_I4REF(dstvar) = V_I4(srcvar);
} else {
V_I4(dstvar) = V_I4(srcvar);
}
break;
#if SIZEOF_ZEND_LONG == 8
case VT_UI8:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI8REF(dstvar) = V_UI8(srcvar);
} else {
V_UI8(dstvar) = V_UI8(srcvar);
}
break;
case VT_I8:
if (V_VT(dstvar) & VT_BYREF) {
*V_I8REF(dstvar) = V_I8(srcvar);
} else {
V_I8(dstvar) = V_I8(srcvar);
}
break;
#endif
case VT_INT:
if (V_VT(dstvar) & VT_BYREF) {
*V_INTREF(dstvar) = V_INT(srcvar);
} else {
V_INT(dstvar) = V_INT(srcvar);
}
break;
case VT_UINT:
if (V_VT(dstvar) & VT_BYREF) {
*V_UINTREF(dstvar) = V_UINT(srcvar);
} else {
V_UINT(dstvar) = V_UINT(srcvar);
}
break;
case VT_R4:
if (V_VT(dstvar) & VT_BYREF) {
*V_R4REF(dstvar) = V_R4(srcvar);
} else {
V_R4(dstvar) = V_R4(srcvar);
}
break;
case VT_R8:
if (V_VT(dstvar) & VT_BYREF) {
*V_R8REF(dstvar) = V_R8(srcvar);
} else {
V_R8(dstvar) = V_R8(srcvar);
}
break;
case VT_BOOL:
if (V_VT(dstvar) & VT_BYREF) {
*V_BOOLREF(dstvar) = V_BOOL(srcvar);
} else {
V_BOOL(dstvar) = V_BOOL(srcvar);
}
break;
case VT_BSTR:
if (V_VT(dstvar) & VT_BYREF) {
*V_BSTRREF(dstvar) = V_BSTR(srcvar);
} else {
V_BSTR(dstvar) = V_BSTR(srcvar);
}
break;
case VT_UNKNOWN:
if (V_VT(dstvar) & VT_BYREF) {
*V_UNKNOWNREF(dstvar) = V_UNKNOWN(srcvar);
} else {
V_UNKNOWN(dstvar) = V_UNKNOWN(srcvar);
}
break;
case VT_DISPATCH:
if (V_VT(dstvar) & VT_BYREF) {
*V_DISPATCHREF(dstvar) = V_DISPATCH(srcvar);
} else {
V_DISPATCH(dstvar) = V_DISPATCH(srcvar);
}
break;
case VT_VARIANT:
return php_com_copy_variant(V_VARIANTREF(dstvar), srcvar);
default:
php_error_docref(NULL, E_WARNING, "variant->variant: failed to copy from 0x%x to 0x%x", V_VT(dstvar), V_VT(srcvar));
ret = FAILURE;
}
return ret;
}
static void
ole_val2ptr_variant(VALUE val, VARIANT *var)
{
switch (TYPE(val)) {
case T_STRING:
if (V_VT(var) == (VT_BSTR | VT_BYREF)) {
*V_BSTRREF(var) = ole_vstr2wc(val);
}
break;
case T_FIXNUM:
switch(V_VT(var)) {
case (VT_UI1 | VT_BYREF) :
*V_UI1REF(var) = NUM2CHR(val);
break;
case (VT_I2 | VT_BYREF) :
*V_I2REF(var) = (short)NUM2INT(val);
break;
case (VT_I4 | VT_BYREF) :
*V_I4REF(var) = NUM2INT(val);
break;
case (VT_R4 | VT_BYREF) :
*V_R4REF(var) = (float)NUM2INT(val);
break;
case (VT_R8 | VT_BYREF) :
*V_R8REF(var) = NUM2INT(val);
break;
default:
break;
}
break;
case T_FLOAT:
switch(V_VT(var)) {
case (VT_I2 | VT_BYREF) :
*V_I2REF(var) = (short)NUM2INT(val);
break;
case (VT_I4 | VT_BYREF) :
*V_I4REF(var) = NUM2INT(val);
break;
case (VT_R4 | VT_BYREF) :
*V_R4REF(var) = (float)NUM2DBL(val);
break;
case (VT_R8 | VT_BYREF) :
*V_R8REF(var) = NUM2DBL(val);
break;
default:
break;
}
break;
case T_BIGNUM:
if (V_VT(var) == (VT_R8 | VT_BYREF)) {
*V_R8REF(var) = rb_big2dbl(val);
}
break;
case T_TRUE:
if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
*V_BOOLREF(var) = VARIANT_TRUE;
}
break;
case T_FALSE:
if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
*V_BOOLREF(var) = VARIANT_FALSE;
}
break;
default:
break;
}
}
static void on_before_navigate2(DocHost *This, LPCWSTR url, const BYTE *post_data,
ULONG post_data_len, LPWSTR headers, VARIANT_BOOL *cancel)
{
VARIANT var_url, var_flags, var_frame_name, var_post_data, var_post_data2, var_headers;
DISPPARAMS dispparams;
VARIANTARG params[7];
dispparams.cArgs = 7;
dispparams.cNamedArgs = 0;
dispparams.rgdispidNamedArgs = NULL;
dispparams.rgvarg = params;
This->busy = VARIANT_TRUE;
V_VT(params) = VT_BOOL|VT_BYREF;
V_BOOLREF(params) = cancel;
V_VT(params+1) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+1) = &var_headers;
V_VT(&var_headers) = VT_BSTR;
V_BSTR(&var_headers) = headers;
V_VT(params+2) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+2) = &var_post_data2;
V_VT(&var_post_data2) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(&var_post_data2) = &var_post_data;
VariantInit(&var_post_data);
if(post_data_len) {
SAFEARRAYBOUND bound = {post_data_len, 0};
void *data;
V_VT(&var_post_data) = VT_UI1|VT_ARRAY;
V_ARRAY(&var_post_data) = SafeArrayCreate(VT_UI1, 1, &bound);
SafeArrayAccessData(V_ARRAY(&var_post_data), &data);
memcpy(data, post_data, post_data_len);
SafeArrayUnaccessData(V_ARRAY(&var_post_data));
}
V_VT(params+3) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+3) = &var_frame_name;
V_VT(&var_frame_name) = VT_BSTR;
V_BSTR(&var_frame_name) = NULL;
V_VT(params+4) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+4) = &var_flags;
V_VT(&var_flags) = VT_I4;
V_I4(&var_flags) = 0;
V_VT(params+5) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+5) = &var_url;
V_VT(&var_url) = VT_BSTR;
V_BSTR(&var_url) = SysAllocString(url);
V_VT(params+6) = (VT_DISPATCH);
V_DISPATCH(params+6) = This->disp;
call_sink(This->cps.wbe2, DISPID_BEFORENAVIGATE2, &dispparams);
SysFreeString(V_BSTR(&var_url));
if(post_data_len)
SafeArrayDestroy(V_ARRAY(&var_post_data));
}
static HRESULT WINAPI DocObjectService_FireBeforeNavigate2(
IDocObjectService* iface,
IDispatch *pDispatch,
LPCWSTR lpszUrl,
DWORD dwFlags,
LPCWSTR lpszFrameName,
BYTE *pPostData,
DWORD cbPostData,
LPCWSTR lpszHeaders,
BOOL fPlayNavSound,
BOOL *pfCancel)
{
ShellBrowser *This = impl_from_IDocObjectService(iface);
VARIANT var_url, var_flags, var_frame_name, var_post_data, var_post_data2, var_headers;
VARIANTARG params[7];
DISPPARAMS dp = {params, NULL, 7, 0};
VARIANT_BOOL cancel = VARIANT_FALSE;
SAFEARRAY *post_data;
TRACE("%p %p %s %x %s %p %d %s %d %p\n", This, pDispatch, debugstr_w(lpszUrl),
dwFlags, debugstr_w(lpszFrameName), pPostData, cbPostData,
debugstr_w(lpszHeaders), fPlayNavSound, pfCancel);
if(cbPostData) {
post_data = SafeArrayCreateVector(VT_UI1, 0, cbPostData);
if(!post_data)
return E_OUTOFMEMORY;
memcpy(post_data->pvData, pPostData, cbPostData);
}else {
post_data = NULL;
}
V_VT(params) = VT_BOOL|VT_BYREF;
V_BOOLREF(params) = &cancel;
V_VT(params+1) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+1) = &var_headers;
V_VT(&var_headers) = VT_BSTR;
V_BSTR(&var_headers) = lpszHeaders ? SysAllocString(lpszHeaders) : NULL;
V_VT(params+2) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+2) = &var_post_data2;
V_VT(&var_post_data2) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(&var_post_data2) = &var_post_data;
if(post_data) {
V_VT(&var_post_data) = VT_UI1|VT_ARRAY;
V_ARRAY(&var_post_data) = post_data;
}else {
V_VT(&var_post_data) = VT_EMPTY;
}
V_VT(params+3) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+3) = &var_frame_name;
V_VT(&var_frame_name) = VT_BSTR;
V_BSTR(&var_frame_name) = lpszFrameName ? SysAllocString(lpszFrameName) : NULL;
V_VT(params+4) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+4) = &var_flags;
V_VT(&var_flags) = VT_I4;
V_I4(&var_flags) = 0;
V_VT(params+5) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+5) = &var_url;
V_VT(&var_url) = VT_BSTR;
V_BSTR(&var_url) = SysAllocString(lpszUrl);
V_VT(params+6) = (VT_DISPATCH);
V_DISPATCH(params+6) = (IDispatch*)This->doc_host->wb;
/* Keep reference to This. It may be released in event handler. */
IShellBrowser_AddRef(&This->IShellBrowser_iface);
TRACE(">>>\n");
call_sink(This->doc_host->cps.wbe2, DISPID_BEFORENAVIGATE2, &dp);
TRACE("<<<\n");
IShellBrowser_Release(&This->IShellBrowser_iface);
SysFreeString(V_BSTR(&var_url));
SysFreeString(V_BSTR(&var_headers));
SysFreeString(V_BSTR(&var_frame_name));
SafeArrayDestroy(post_data);
*pfCancel = !!cancel;
return S_OK;
}
static void
putOutVariant (Tcl_Interp *interp,
VARIANT *pDest,
TclObject &tclObject,
const Type &type)
{
switch (type.vartype()) {
case VT_BOOL:
*V_BOOLREF(pDest) = tclObject.getBool() ? VARIANT_TRUE : VARIANT_FALSE;
break;
case VT_R4:
*V_R4REF(pDest) = static_cast<float>(tclObject.getDouble());
break;
case VT_R8:
*V_R8REF(pDest) = tclObject.getDouble();
break;
case VT_DISPATCH:
case VT_UNKNOWN:
case VT_USERDEFINED:
{
IUnknown *pUnknown;
Tcl_Obj *pObj = tclObject;
if (pObj->typePtr == &Extension::unknownPointerType) {
pUnknown =
static_cast<IUnknown *>(pObj->internalRep.otherValuePtr);
} else {
Reference *pRef = Extension::referenceHandles.find(
interp, tclObject);
pUnknown = (pRef == 0) ? 0 : pRef->unknown();
}
*V_UNKNOWNREF(pDest) = pUnknown;
// The COM rules say we must increment the reference count of
// interface pointers returned from methods.
if (pUnknown != 0) {
pUnknown->AddRef();
}
}
break;
case VT_BSTR:
*V_BSTRREF(pDest) = tclObject.getBSTR();
break;
case VT_VARIANT:
{
// Must increment reference count of interface pointers returned
// from methods.
tclObject.toVariant(
V_VARIANTREF(pDest), Type::variant(), interp, true);
}
break;
case VT_SAFEARRAY:
if (*V_ARRAYREF(pDest) != 0) {
SafeArrayDestroy(*V_ARRAYREF(pDest));
}
*V_ARRAYREF(pDest) =
tclObject.getSafeArray(type.elementType(), interp);
break;
default:
*V_I4REF(pDest) = tclObject.getLong();
}
}
static void
ole_set_byref(VARIANT *realvar, VARIANT *var, VARTYPE vt)
{
V_VT(var) = vt;
if (vt == (VT_VARIANT|VT_BYREF)) {
V_VARIANTREF(var) = realvar;
} else {
if (V_VT(realvar) != (vt & ~VT_BYREF)) {
rb_raise(eWIN32OLERuntimeError, "variant type mismatch");
}
switch(vt & ~VT_BYREF) {
case VT_I1:
V_I1REF(var) = &V_I1(realvar);
break;
case VT_UI1:
V_UI1REF(var) = &V_UI1(realvar);
break;
case VT_I2:
V_I2REF(var) = &V_I2(realvar);
break;
case VT_UI2:
V_UI2REF(var) = &V_UI2(realvar);
break;
case VT_I4:
V_I4REF(var) = &V_I4(realvar);
break;
case VT_UI4:
V_UI4REF(var) = &V_UI4(realvar);
break;
case VT_R4:
V_R4REF(var) = &V_R4(realvar);
break;
case VT_R8:
V_R8REF(var) = &V_R8(realvar);
break;
#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
#ifdef V_I8REF
case VT_I8:
V_I8REF(var) = &V_I8(realvar);
break;
#endif
#ifdef V_UI8REF
case VT_UI8:
V_UI8REF(var) = &V_UI8(realvar);
break;
#endif
#endif
case VT_INT:
V_INTREF(var) = &V_INT(realvar);
break;
case VT_UINT:
V_UINTREF(var) = &V_UINT(realvar);
break;
case VT_CY:
V_CYREF(var) = &V_CY(realvar);
break;
case VT_DATE:
V_DATEREF(var) = &V_DATE(realvar);
break;
case VT_BSTR:
V_BSTRREF(var) = &V_BSTR(realvar);
break;
case VT_DISPATCH:
V_DISPATCHREF(var) = &V_DISPATCH(realvar);
break;
case VT_ERROR:
V_ERRORREF(var) = &V_ERROR(realvar);
break;
case VT_BOOL:
V_BOOLREF(var) = &V_BOOL(realvar);
break;
case VT_UNKNOWN:
V_UNKNOWNREF(var) = &V_UNKNOWN(realvar);
break;
case VT_ARRAY:
V_ARRAYREF(var) = &V_ARRAY(realvar);
break;
default:
rb_raise(eWIN32OLERuntimeError, "unknown type specified(setting BYREF):%d", vt);
break;
}
}
}
void EventProxy::convertJavaVariant(VARIANT *java, VARIANT *com) {
switch (com->vt)
{
case VT_DISPATCH:
{
switch (java->vt)
{
case VT_DISPATCH:
{
V_DISPATCH(com) = V_DISPATCH(java);
break;
}
case VT_DISPATCH | VT_BYREF:
{
V_DISPATCH(com) = *V_DISPATCHREF(java);
break;
}
}
break;
}
case VT_DISPATCH | VT_BYREF:
{
switch (java->vt)
{
case VT_DISPATCH:
{
*V_DISPATCHREF(com) = V_DISPATCH(java);
break;
}
case VT_DISPATCH | VT_BYREF:
{
*V_DISPATCHREF(com) = *V_DISPATCHREF(java);
break;
}
}
break;
}
case VT_BOOL:
{
switch (java->vt)
{
case VT_BOOL:
{
V_BOOL(com) = V_BOOL(java);
break;
}
case VT_BOOL | VT_BYREF:
{
V_BOOL(com) = *V_BOOLREF(java);
break;
}
}
break;
}
case VT_BOOL | VT_BYREF:
{
switch (java->vt)
{
case VT_BOOL:
{
*V_BOOLREF(com) = V_BOOL(java);
break;
}
case VT_BOOL | VT_BYREF:
{
*V_BOOLREF(com) = *V_BOOLREF(java);
break;
}
}
break;
}
case VT_UI1:
{
switch (java->vt)
{
case VT_UI1:
{
V_UI1(com) = V_UI1(java);
break;
}
case VT_UI1 | VT_BYREF:
{
V_UI1(com) = *V_UI1REF(java);
break;
}
}
break;
}
case VT_UI1 | VT_BYREF:
{
switch (java->vt)
{
case VT_UI1:
{
*V_UI1REF(com) = V_UI1(java);
break;
}
case VT_UI1 | VT_BYREF:
{
*V_UI1REF(com) = *V_UI1REF(java);
break;
}
}
break;
}
case VT_I2:
{
switch (java->vt)
{
case VT_I2:
{
V_I2(com) = V_I2(java);
break;
}
case VT_I2 | VT_BYREF:
{
V_I2(com) = *V_I2REF(java);
break;
}
}
break;
}
case VT_I2 | VT_BYREF:
{
switch (java->vt)
{
case VT_I2:
{
*V_I2REF(com) = V_I2(java);
break;
}
case VT_I2 | VT_BYREF:
{
*V_I2REF(com) = *V_I2REF(java);
break;
}
}
break;
}
case VT_I4:
{
switch (java->vt)
{
case VT_I4:
{
V_I4(com) = V_I4(java);
break;
}
case VT_I4 | VT_BYREF:
{
V_I4(com) = *V_I4REF(java);
break;
}
}
break;
}
case VT_I4 | VT_BYREF:
{
switch (java->vt)
{
case VT_I4:
{
*V_I4REF(com) = V_I4(java);
break;
}
case VT_I4 | VT_BYREF:
{
*V_I4REF(com) = *V_I4REF(java);
break;
}
}
break;
}
case VT_R4:
{
switch (java->vt)
{
case VT_R4:
{
V_R4(com) = V_R4(java);
break;
}
case VT_R4 | VT_BYREF:
{
V_R4(com) = *V_R4REF(java);
break;
}
}
break;
}
case VT_R4 | VT_BYREF:
{
switch (java->vt)
{
case VT_R4:
{
*V_R4REF(com) = V_R4(java);
break;
}
case VT_R4 | VT_BYREF:
{
*V_R4REF(com) = *V_R4REF(java);
break;
}
}
break;
}
case VT_R8:
{
switch (java->vt)
{
case VT_R8:
{
V_R8(com) = V_R8(java);
break;
}
case VT_R8 | VT_BYREF:
{
V_R8(com) = *V_R8REF(java);
break;
}
}
break;
}
case VT_R8 | VT_BYREF:
{
switch (java->vt)
{
case VT_R8:
{
*V_R8REF(com) = V_R8(java);
break;
}
case VT_R8 | VT_BYREF:
{
*V_R8REF(com) = *V_R8REF(java);
break;
}
}
break;
}
case VT_I1:
{
switch (java->vt)
{
case VT_I1:
{
V_I1(com) = V_I1(java);
break;
}
case VT_I1 | VT_BYREF:
{
V_I1(com) = *V_I1REF(java);
break;
}
}
break;
}
case VT_I1 | VT_BYREF:
{
switch (java->vt)
{
case VT_I1:
{
*V_I1REF(com) = V_I1(java);
break;
}
case VT_I1 | VT_BYREF:
{
*V_I1REF(com) = *V_I1REF(java);
break;
}
}
break;
}
case VT_UI2:
{
switch (java->vt)
{
case VT_UI2:
{
V_UI2(com) = V_UI2(java);
break;
}
case VT_UI2 | VT_BYREF:
{
V_UI2(com) = *V_UI2REF(java);
break;
}
}
break;
}
case VT_UI2 | VT_BYREF:
{
switch (java->vt)
{
case VT_UI2:
{
*V_UI2REF(com) = V_UI2(java);
break;
}
case VT_UI2 | VT_BYREF:
{
*V_UI2REF(com) = *V_UI2REF(java);
break;
}
}
break;
}
case VT_UI4:
{
switch (java->vt)
{
case VT_UI4:
{
V_UI4(com) = V_UI4(java);
break;
}
case VT_UI4 | VT_BYREF:
{
V_UI4(com) = *V_UI4REF(java);
break;
}
}
break;
}
case VT_UI4 | VT_BYREF:
{
switch (java->vt)
{
case VT_UI4:
{
*V_UI4REF(com) = V_UI4(java);
break;
}
case VT_UI4 | VT_BYREF:
{
*V_UI4REF(com) = *V_UI4REF(java);
break;
}
}
break;
}
case VT_INT:
{
switch (java->vt)
{
case VT_INT:
{
V_INT(com) = V_INT(java);
break;
}
case VT_INT | VT_BYREF:
{
V_INT(com) = *V_INTREF(java);
break;
}
}
break;
}
case VT_INT | VT_BYREF:
{
switch (java->vt)
{
case VT_INT:
{
*V_INTREF(com) = V_INT(java);
break;
}
case VT_INT | VT_BYREF:
{
*V_INTREF(com) = *V_INTREF(java);
break;
}
}
break;
}
case VT_UINT:
{
switch (java->vt)
{
case VT_UINT:
{
V_UINT(com) = V_UINT(java);
break;
}
case VT_UINT | VT_BYREF:
{
V_UINT(com) = *V_UINTREF(java);
break;
}
}
break;
}
case VT_UINT | VT_BYREF:
{
switch (java->vt)
{
case VT_UINT:
{
*V_UINTREF(com) = V_UINT(java);
break;
}
case VT_UINT | VT_BYREF:
{
*V_UINTREF(com) = *V_UINTREF(java);
break;
}
}
break;
}
case VT_CY:
{
switch (java->vt)
{
case VT_CY:
{
V_CY(com) = V_CY(java);
break;
}
case VT_CY | VT_BYREF:
{
V_CY(com) = *V_CYREF(java);
break;
}
}
break;
}
case VT_CY | VT_BYREF:
{
switch (java->vt)
{
case VT_CY:
{
*V_CYREF(com) = V_CY(java);
break;
}
case VT_CY | VT_BYREF:
{
*V_CYREF(com) = *V_CYREF(java);
break;
}
}
break;
}
case VT_DATE:
{
switch (java->vt)
{
case VT_DATE:
{
V_DATE(com) = V_DATE(java);
break;
}
case VT_DATE | VT_BYREF:
{
V_DATE(com) = *V_DATEREF(java);
break;
}
}
break;
}
case VT_DATE | VT_BYREF:
{
switch (java->vt)
{
case VT_DATE:
{
*V_DATEREF(com) = V_DATE(java);
break;
}
case VT_DATE | VT_BYREF:
{
*V_DATEREF(com) = *V_DATEREF(java);
break;
}
}
break;
}
case VT_BSTR:
{
switch (java->vt)
{
case VT_BSTR:
{
V_BSTR(com) = V_BSTR(java);
break;
}
case VT_BSTR | VT_BYREF:
{
V_BSTR(com) = *V_BSTRREF(java);
break;
}
}
break;
}
case VT_BSTR | VT_BYREF:
{
switch (java->vt)
{
case VT_BSTR:
{
*V_BSTRREF(com) = V_BSTR(java);
break;
}
case VT_BSTR | VT_BYREF:
{
*V_BSTRREF(com) = *V_BSTRREF(java);
break;
}
}
break;
}
case VT_DECIMAL:
{
switch (java->vt)
{
case VT_DECIMAL:
{
V_DECIMAL(com) = V_DECIMAL(java);
break;
}
case VT_DECIMAL | VT_BYREF:
{
V_DECIMAL(com) = *V_DECIMALREF(java);
break;
}
}
break;
}
case VT_DECIMAL | VT_BYREF:
{
switch (java->vt)
{
case VT_DECIMAL:
{
*V_DECIMALREF(com) = V_DECIMAL(java);
break;
}
case VT_DECIMAL | VT_BYREF:
{
*V_DECIMALREF(com) = *V_DECIMALREF(java);
break;
}
}
break;
}
}
}
static HRESULT STDMETHODCALLTYPE
dispatch_Invoke(IDispatch* self, DISPID disp_id, REFIID riid, LCID lcid,
WORD flags, DISPPARAMS* params, VARIANT* var_res,
EXCEPINFO* except, UINT* arg_err)
{
html_t* html = MC_HTML_FROM_DISPTACH(self);
switch(disp_id) {
case DISPID_BEFORENAVIGATE2:
{
BSTR url = V_BSTR(V_VARIANTREF(¶ms->rgvarg[5]));
VARIANT_BOOL* cancel = V_BOOLREF(¶ms->rgvarg[0]);
HTML_TRACE("dispatch_Invoke: DISPID_BEFORENAVIGATE2(%S)", url);
if(url != NULL && wcsncmp(url, L"app:", 4) == 0) {
html_notify_text(html, MC_HN_APPLINK, url);
*cancel = VARIANT_TRUE;
}
break;
}
#if 0
/* Unfortunately, IE does not send DISPID_DOCUMENTCOMPLETE
* when refreshing the page (e.g. from context menu). So we workaround
* via DISPID_PROGRESSCHANGE below. */
case DISPID_DOCUMENTCOMPLETE:
{
BSTR url = V_BSTR(V_VARIANTREF(¶ms->rgvarg[0]));
html_notify_text(html, MC_HN_DOCUMENTCOMPLETE, url);
break;
}
#endif
case DISPID_PROGRESSCHANGE:
{
LONG progress_max = V_I4(¶ms->rgvarg[0]);
LONG progress = V_I4(¶ms->rgvarg[1]);
MC_NMHTMLPROGRESS notify;
HTML_TRACE("dispatch_Invoke: DISPID_PROGRESSCHANGE(%ld, %ld)",
progress, progress_max);
/* Send also notification about the progress */
notify.hdr.hwndFrom = html->win;
notify.hdr.idFrom = GetDlgCtrlID(html->win);
notify.hdr.code = MC_HN_PROGRESS;
notify.lProgress = progress;
notify.lProgressMax = progress_max;
MC_SEND(html->notify_win, WM_NOTIFY, notify.hdr.idFrom, ¬ify);
/* This replaces DISPID_DOCUMENTCOMPLETE above */
if(progress < 0 || progress_max < 0) {
IWebBrowser2* browser_iface;
HRESULT hr;
hr = html->browser_obj->lpVtbl->QueryInterface(html->browser_obj,
&IID_IWebBrowser2, (void**)&browser_iface);
if(MC_ERR(hr != S_OK || browser_iface == NULL)) {
MC_TRACE("dispatch_Invoke(DISPID_PROGRESSCHANGE): "
"QueryInterface(IID_IWebBrowser2) failed [0x%lx]", hr);
} else {
BSTR url = NULL;
hr = browser_iface->lpVtbl->get_LocationURL(browser_iface, &url);
if(hr == S_OK && url != NULL) {
html_notify_text(html, MC_HN_DOCUMENTCOMPLETE, url);
html_SysFreeString(url);
}
browser_iface->lpVtbl->Release(browser_iface);
}
}
break;
}
case DISPID_STATUSTEXTCHANGE:
HTML_TRACE("dispatch_Invoke: DISPID_STATUSTEXTCHANGE");
html_notify_text(html, MC_HN_STATUSTEXT, V_BSTR(¶ms->rgvarg[0]));
break;
case DISPID_TITLECHANGE:
HTML_TRACE("dispatch_Invoke: DISPID_TITLECHANGE");
html_notify_text(html, MC_HN_TITLETEXT, V_BSTR(¶ms->rgvarg[0]));
break;
case DISPID_COMMANDSTATECHANGE:
{
LONG cmd = V_I4(¶ms->rgvarg[1]);
HTML_TRACE("dispatch_Invoke: DISPID_COMMANDSTATECHANGE");
if(cmd == CSC_NAVIGATEBACK || cmd == CSC_NAVIGATEFORWARD) {
MC_NMHTMLHISTORY notify;
BOOL enabled = (V_BOOL(¶ms->rgvarg[0]) != VARIANT_FALSE);
if(cmd == CSC_NAVIGATEBACK)
html->can_back = enabled;
else
html->can_forward = enabled;
notify.hdr.hwndFrom = html->win;
notify.hdr.idFrom = GetDlgCtrlID(html->win);
notify.hdr.code = MC_HN_HISTORY;
notify.bCanBack = html->can_back;
notify.bCanForward = html->can_forward;
MC_SEND(html->notify_win, WM_NOTIFY, notify.hdr.idFrom, ¬ify);
}
break;
}
case DISPID_NEWWINDOW2:
/* This is called instead of DISPID_NEWWINDOW3 on Windows XP SP2
* and older. */
{
VARIANT_BOOL* cancel = V_BOOLREF(¶ms->rgvarg[0]);
HTML_TRACE("dispatch_Invoke: DISPID_NEWWINDOW2");
if(html_notify_text(html, MC_HN_NEWWINDOW, L"") == 0) {
*cancel = VARIANT_TRUE;
HTML_TRACE("dispatch_Invoke(DISPID_NEWWINDOW2): Canceled.");
}
break;
}
case DISPID_NEWWINDOW3:
{
BSTR url = V_BSTR(¶ms->rgvarg[0]);
VARIANT_BOOL* cancel = V_BOOLREF(¶ms->rgvarg[3]);
HTML_TRACE("dispatch_Invoke: DISPID_NEWWINDOW3");
if(html_notify_text(html, MC_HN_NEWWINDOW, url) == 0) {
*cancel = VARIANT_TRUE;
HTML_TRACE("dispatch_Invoke(DISPID_NEWWINDOW3, '%S'): Canceled.", url);
}
break;
}
default:
HTML_TRACE("dispatch_Invoke: unsupported disp_id %d", disp_id);
return DISP_E_MEMBERNOTFOUND;
}
return S_OK;
}
////////////////////////////////////////////////////////
// CompareVariant
//
////////////////////////////////////////////////////////
LONG CompareVariant
(
VARIANT *pVar1, //@parm [in]: Pointer to the variant in the consumer's buffer.
VARIANT *pVar2, //@parm [in]: Pointer to the variant at the backend.
BOOL fCaseSensitive
)
{
//Handle NULL cases...
if(pVar1==NULL || pVar2==NULL)
{
if(pVar1 == pVar2)
return TRUE;
return FALSE;
}
// The variant has to be the same type
if (V_VT(pVar1) != V_VT(pVar2))
return FALSE;
// Return FALSE if vt is ORed with VT_RESERVED
if (V_VT(pVar1) & VT_RESERVED)
return FALSE;
// Return TRUE is the vt is VT_EMPTY or VT_NULL
if (V_VT(pVar1)==VT_EMPTY || V_VT(pVar1)==VT_NULL)
return TRUE;
switch(V_VT(pVar1))
{
case VT_UI1:
return V_UI1(pVar1) == V_UI1(pVar2);
case VT_I2:
return V_I2(pVar1) == V_I2(pVar2);
case VT_I4:
return V_I4(pVar1) == V_I4(pVar2);
case VT_R4:
return V_R4(pVar1) == V_R4(pVar2);
case VT_R8:
return V_R8(pVar1) == V_R8(pVar2);
case VT_BOOL:
return V_BOOL(pVar1) == V_BOOL(pVar2);
case VT_ERROR:
return V_ERROR(pVar1) == V_ERROR(pVar2);
case VT_CY:
return memcmp(&V_CY(pVar1), &V_CY(pVar2),8)==0;
case VT_DATE:
return V_DATE(pVar1) == V_DATE(pVar2);
case VT_BSTR:
if(fCaseSensitive)
return wcscmp(V_BSTR(pVar1), V_BSTR(pVar2));
else
return _wcsicmp(V_BSTR(pVar1), V_BSTR(pVar2));
// As we are not testing OLE object, return FALSE for VT_UNKNOWN
case VT_UNKNOWN:
return FALSE;
// As we are not testing OLE object, return FALSE for VT_DISPATCH
case VT_DISPATCH:
return FALSE;
case VT_I2 | VT_BYREF:
return *V_I2REF(pVar1) == *V_I2REF(pVar2);
case VT_I4 | VT_BYREF:
return *V_I4REF(pVar1) == *V_I4REF(pVar2);
case VT_R4 | VT_BYREF:
return *V_R4REF(pVar1) == *V_R4REF(pVar2);
case VT_R8 | VT_BYREF:
return *V_R8REF(pVar1) == *V_R8REF(pVar2);
case VT_BOOL | VT_BYREF:
return *V_BOOLREF(pVar1) == *V_BOOLREF(pVar2);
case VT_ERROR | VT_BYREF:
return *V_ERRORREF(pVar1) == *V_ERRORREF(pVar2);
case VT_CY | VT_BYREF:
return memcmp(V_CYREF(pVar1), V_CYREF(pVar2),8)==0;
case VT_DATE | VT_BYREF:
return *V_DATEREF(pVar1) == *V_DATEREF(pVar2);
case VT_BSTR | VT_BYREF:
if(fCaseSensitive)
return wcscmp(*V_BSTRREF(pVar1), *V_BSTRREF(pVar2));
else
return _wcsicmp(*V_BSTRREF(pVar1), *V_BSTRREF(pVar2));
// As we are not testing OLE object, return FALSE for VT_UNKNOWN
case VT_UNKNOWN | VT_BYREF:
return FALSE;
// As we are not testing OLE object, return FALSE for VT_DISPATCH
case VT_DISPATCH | VT_BYREF:
return FALSE;
}
return FALSE;
}
void wxWebViewIE::onActiveXEvent(wxActiveXEvent& evt)
{
if (m_webBrowser == NULL) return;
switch (evt.GetDispatchId())
{
case DISPID_BEFORENAVIGATE2:
{
m_isBusy = true;
wxString url = evt[1].GetString();
wxString target = evt[3].GetString();
wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_NAVIGATING,
GetId(), url, target);
//skip empty javascript events.
if(url == "javascript:\"\"" && target.IsEmpty())
{
event.Veto();
}
else
{
event.SetEventObject(this);
HandleWindowEvent(event);
}
if (!event.IsAllowed())
{
wxActiveXEventNativeMSW* nativeParams =
evt.GetNativeParameters();
*V_BOOLREF(&nativeParams->pDispParams->rgvarg[0]) = VARIANT_TRUE;
}
// at this point, either the navigation event has been cancelled
// and we're not busy, either it was accepted and IWebBrowser2's
// Busy property will be true; so we don't need our override
// flag anymore.
m_isBusy = false;
break;
}
case DISPID_NAVIGATECOMPLETE2:
{
wxString url = evt[1].GetString();
// TODO: set target parameter if possible
wxString target = wxEmptyString;
wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_NAVIGATED,
GetId(), url, target);
event.SetEventObject(this);
HandleWindowEvent(event);
break;
}
case DISPID_PROGRESSCHANGE:
{
// download progress
break;
}
case DISPID_DOCUMENTCOMPLETE:
{
//Only send a complete even if we are actually finished, this brings
//the event in to line with webkit
READYSTATE rs;
m_webBrowser->get_ReadyState( &rs );
if(rs != READYSTATE_COMPLETE)
break;
wxString url = evt[1].GetString();
//As we are complete we also add to the history list, but not if the
//page is not the main page, ie it is a subframe
//We also have to check if we are loading a file:// url, if so we
//need to change the comparison as ie passes back a different style
//of url
if(m_historyEnabled && !m_historyLoadingFromList &&
(url == GetCurrentURL() ||
(GetCurrentURL().substr(0, 4) == "file" &&
wxFileSystem::URLToFileName(GetCurrentURL()).GetFullPath() == url)))
{
//If we are not at the end of the list, then erase everything
//between us and the end before adding the new page
if(m_historyPosition != static_cast<int>(m_historyList.size()) - 1)
{
m_historyList.erase(m_historyList.begin() + m_historyPosition + 1,
m_historyList.end());
}
wxSharedPtr<wxWebViewHistoryItem> item(new wxWebViewHistoryItem(url, GetCurrentTitle()));
m_historyList.push_back(item);
m_historyPosition++;
}
//Reset as we are done now
m_historyLoadingFromList = false;
// TODO: set target parameter if possible
wxString target = wxEmptyString;
wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_LOADED, GetId(),
url, target);
event.SetEventObject(this);
HandleWindowEvent(event);
break;
}
case DISPID_STATUSTEXTCHANGE:
{
break;
}
case DISPID_TITLECHANGE:
{
wxString title = evt[0].GetString();
wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_TITLE_CHANGED,
GetId(), GetCurrentURL(), "");
event.SetString(title);
event.SetEventObject(this);
HandleWindowEvent(event);
break;
}
case DISPID_NAVIGATEERROR:
{
wxWebViewNavigationError errorType = wxWEB_NAV_ERR_OTHER;
wxString errorCode = "?";
switch (evt[3].GetLong())
{
case INET_E_INVALID_URL: // (0x800C0002L or -2146697214)
errorCode = "INET_E_INVALID_URL";
errorType = wxWEB_NAV_ERR_REQUEST;
break;
case INET_E_NO_SESSION: // (0x800C0003L or -2146697213)
errorCode = "INET_E_NO_SESSION";
errorType = wxWEB_NAV_ERR_CONNECTION;
break;
case INET_E_CANNOT_CONNECT: // (0x800C0004L or -2146697212)
errorCode = "INET_E_CANNOT_CONNECT";
errorType = wxWEB_NAV_ERR_CONNECTION;
break;
case INET_E_RESOURCE_NOT_FOUND: // (0x800C0005L or -2146697211)
errorCode = "INET_E_RESOURCE_NOT_FOUND";
errorType = wxWEB_NAV_ERR_NOT_FOUND;
break;
case INET_E_OBJECT_NOT_FOUND: // (0x800C0006L or -2146697210)
errorCode = "INET_E_OBJECT_NOT_FOUND";
errorType = wxWEB_NAV_ERR_NOT_FOUND;
break;
case INET_E_DATA_NOT_AVAILABLE: // (0x800C0007L or -2146697209)
errorCode = "INET_E_DATA_NOT_AVAILABLE";
errorType = wxWEB_NAV_ERR_NOT_FOUND;
break;
case INET_E_DOWNLOAD_FAILURE: // (0x800C0008L or -2146697208)
errorCode = "INET_E_DOWNLOAD_FAILURE";
errorType = wxWEB_NAV_ERR_CONNECTION;
break;
case INET_E_AUTHENTICATION_REQUIRED: // (0x800C0009L or -2146697207)
errorCode = "INET_E_AUTHENTICATION_REQUIRED";
errorType = wxWEB_NAV_ERR_AUTH;
break;
case INET_E_NO_VALID_MEDIA: // (0x800C000AL or -2146697206)
errorCode = "INET_E_NO_VALID_MEDIA";
errorType = wxWEB_NAV_ERR_REQUEST;
break;
case INET_E_CONNECTION_TIMEOUT: // (0x800C000BL or -2146697205)
errorCode = "INET_E_CONNECTION_TIMEOUT";
errorType = wxWEB_NAV_ERR_CONNECTION;
break;
case INET_E_INVALID_REQUEST: // (0x800C000CL or -2146697204)
errorCode = "INET_E_INVALID_REQUEST";
errorType = wxWEB_NAV_ERR_REQUEST;
break;
case INET_E_UNKNOWN_PROTOCOL: // (0x800C000DL or -2146697203)
errorCode = "INET_E_UNKNOWN_PROTOCOL";
errorType = wxWEB_NAV_ERR_REQUEST;
break;
case INET_E_SECURITY_PROBLEM: // (0x800C000EL or -2146697202)
errorCode = "INET_E_SECURITY_PROBLEM";
errorType = wxWEB_NAV_ERR_SECURITY;
break;
case INET_E_CANNOT_LOAD_DATA: // (0x800C000FL or -2146697201)
errorCode = "INET_E_CANNOT_LOAD_DATA";
errorType = wxWEB_NAV_ERR_OTHER;
break;
case INET_E_CANNOT_INSTANTIATE_OBJECT:
// CoCreateInstance will return an error code if this happens,
// we'll handle this above.
return;
break;
case INET_E_REDIRECT_FAILED: // (0x800C0014L or -2146697196)
errorCode = "INET_E_REDIRECT_FAILED";
errorType = wxWEB_NAV_ERR_OTHER;
break;
case INET_E_REDIRECT_TO_DIR: // (0x800C0015L or -2146697195)
errorCode = "INET_E_REDIRECT_TO_DIR";
errorType = wxWEB_NAV_ERR_REQUEST;
break;
case INET_E_CANNOT_LOCK_REQUEST: // (0x800C0016L or -2146697194)
errorCode = "INET_E_CANNOT_LOCK_REQUEST";
errorType = wxWEB_NAV_ERR_OTHER;
break;
case INET_E_USE_EXTEND_BINDING: // (0x800C0017L or -2146697193)
errorCode = "INET_E_USE_EXTEND_BINDING";
errorType = wxWEB_NAV_ERR_OTHER;
break;
case INET_E_TERMINATED_BIND: // (0x800C0018L or -2146697192)
errorCode = "INET_E_TERMINATED_BIND";
errorType = wxWEB_NAV_ERR_OTHER;
break;
case INET_E_INVALID_CERTIFICATE: // (0x800C0019L or -2146697191)
errorCode = "INET_E_INVALID_CERTIFICATE";
errorType = wxWEB_NAV_ERR_CERTIFICATE;
break;
case INET_E_CODE_DOWNLOAD_DECLINED: // (0x800C0100L or -2146696960)
errorCode = "INET_E_CODE_DOWNLOAD_DECLINED";
errorType = wxWEB_NAV_ERR_USER_CANCELLED;
break;
case INET_E_RESULT_DISPATCHED: // (0x800C0200L or -2146696704)
// cancel request cancelled...
errorCode = "INET_E_RESULT_DISPATCHED";
errorType = wxWEB_NAV_ERR_OTHER;
break;
case INET_E_CANNOT_REPLACE_SFP_FILE: // (0x800C0300L or -2146696448)
errorCode = "INET_E_CANNOT_REPLACE_SFP_FILE";
errorType = wxWEB_NAV_ERR_SECURITY;
break;
case INET_E_CODE_INSTALL_BLOCKED_BY_HASH_POLICY:
errorCode = "INET_E_CODE_INSTALL_BLOCKED_BY_HASH_POLICY";
errorType = wxWEB_NAV_ERR_SECURITY;
break;
case INET_E_CODE_INSTALL_SUPPRESSED:
errorCode = "INET_E_CODE_INSTALL_SUPPRESSED";
errorType = wxWEB_NAV_ERR_SECURITY;
break;
}
wxString url = evt[1].GetString();
wxString target = evt[2].GetString();
wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_ERROR, GetId(),
url, target);
event.SetEventObject(this);
event.SetInt(errorType);
event.SetString(errorCode);
HandleWindowEvent(event);
break;
}
case DISPID_NEWWINDOW3:
{
wxString url = evt[4].GetString();
wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_NEWWINDOW,
GetId(), url, wxEmptyString);
event.SetEventObject(this);
HandleWindowEvent(event);
//We always cancel this event otherwise an Internet Exporer window
//is opened for the url
wxActiveXEventNativeMSW* nativeParams = evt.GetNativeParameters();
*V_BOOLREF(&nativeParams->pDispParams->rgvarg[3]) = VARIANT_TRUE;
break;
}
}
evt.Skip();
}
