STDMETHODIMP XcpPropertyBag::Read(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog) { HRESULT hr = E_INVALIDARG; BSTR bstrValue = NULL; if (_wcsicmp(pszPropName, L"Source") == 0) { bstrValue = SysAllocString(L"SilverlightBalls.xap"); } else if (_wcsicmp(pszPropName, L"Background") == 0) { bstrValue = SysAllocString(L"Transparent"); } else if (_wcsicmp(pszPropName, L"EnableGPUAcceleration") == 0) { V_VT(pVar) = VT_BOOL; V_BOOL(pVar) = VARIANT_TRUE; hr = S_OK; } else if (_wcsicmp(pszPropName, L"Windowless") == 0) { V_VT(pVar) = VT_BOOL; V_BOOL(pVar) = VARIANT_FALSE; hr = S_OK; } if (bstrValue != NULL) { V_VT(pVar) = VT_BSTR; V_BSTR(pVar) = bstrValue; hr = S_OK; } return hr; }
static HRESULT WINAPI ClDispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) { DocHost *This = impl_from_IDispatch(iface); TRACE("(%p)->(%s %s %d %04x %p %p %p %p)\n", This, debugstr_dispid(dispIdMember), debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); switch(dispIdMember) { case DISPID_AMBIENT_USERMODE: case DISPID_AMBIENT_DLCONTROL: case DISPID_AMBIENT_USERAGENT: case DISPID_AMBIENT_PALETTE: if(!This->client_disp) return E_FAIL; return IDispatch_Invoke(This->client_disp, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED: V_VT(pVarResult) = VT_BOOL; V_BOOL(pVarResult) = This->offline; return S_OK; case DISPID_AMBIENT_SILENT: V_VT(pVarResult) = VT_BOOL; V_BOOL(pVarResult) = This->offline; return S_OK; } FIXME("unhandled dispid %d\n", dispIdMember); return E_NOTIMPL; }
static void test_change_type(IVariantChangeType *change_type, VARIANT *src, const conv_results_t *ex) { VARIANT v; call_change_type(change_type, &v, src, VT_I4); ok(V_I4(&v) == ex->int_result, "V_I4(v) = %d, expected %d\n", V_I4(&v), ex->int_result); call_change_type(change_type, &v, src, VT_BSTR); ok(!strcmp_wa(V_BSTR(&v), ex->str_result), "V_BSTR(v) = %s, expected %s\n", wine_dbgstr_w(V_BSTR(&v)), ex->str_result); VariantClear(&v); call_change_type(change_type, &v, src, VT_BOOL); ok(V_BOOL(&v) == ex->bool_result, "V_BOOL(v) = %x, expected %x\n", V_BOOL(&v), ex->bool_result); if(ex->test_double) { call_change_type(change_type, &v, src, VT_R8); ok(V_R8(&v) == ex->double_result, "V_R8(v) = %lf, expected %lf\n", V_R8(&v), ex->double_result); call_change_type(change_type, &v, src, VT_R4); ok(V_R4(&v) == (float)ex->double_result, "V_R4(v) = %f, expected %f\n", V_R4(&v), (float)ex->double_result); } if(V_VT(src) == VT_NULL) call_change_type(change_type, &v, src, VT_NULL); else change_type_fail(change_type, src, VT_NULL, E_NOTIMPL); if(V_VT(src) == VT_EMPTY) call_change_type(change_type, &v, src, VT_EMPTY); else change_type_fail(change_type, src, VT_EMPTY, E_NOTIMPL); call_change_type(change_type, &v, src, VT_I2); ok(V_I2(&v) == (INT16)ex->int_result, "V_I2(v) = %d, expected %d\n", V_I2(&v), ex->int_result); }
void prepare_for_binding(HTMLDocument *This, IMoniker *mon, DWORD flags) { HRESULT hres; if(This->doc_obj->client) { VARIANT silent, offline; hres = get_client_disp_property(This->doc_obj->client, DISPID_AMBIENT_SILENT, &silent); if(SUCCEEDED(hres)) { if(V_VT(&silent) != VT_BOOL) WARN("silent = %s\n", debugstr_variant(&silent)); else if(V_BOOL(&silent)) FIXME("silent == true\n"); } hres = get_client_disp_property(This->doc_obj->client, DISPID_AMBIENT_OFFLINEIFNOTCONNECTED, &offline); if(SUCCEEDED(hres)) { if(V_VT(&offline) != VT_BOOL) WARN("offline = %s\n", debugstr_variant(&offline)); else if(V_BOOL(&offline)) FIXME("offline == true\n"); } } if(This->window->mon) { update_doc(This, UPDATE_TITLE|UPDATE_UI); }else { update_doc(This, UPDATE_TITLE); set_current_mon(This->window, mon, flags); } if(This->doc_obj->client) { IOleCommandTarget *cmdtrg = NULL; hres = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget, (void**)&cmdtrg); if(SUCCEEDED(hres)) { VARIANT var, out; if(flags & BINDING_NAVIGATED) { V_VT(&var) = VT_UNKNOWN; V_UNKNOWN(&var) = (IUnknown*)&This->window->base.IHTMLWindow2_iface; V_VT(&out) = VT_EMPTY; hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 63, 0, &var, &out); if(SUCCEEDED(hres)) VariantClear(&out); }else if(!(flags & BINDING_FROMHIST)) { V_VT(&var) = VT_I4; V_I4(&var) = 0; IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 37, 0, &var, NULL); } IOleCommandTarget_Release(cmdtrg); } } }
static HRESULT WINAPI ActiveScriptProperty_SetProperty(IActiveScriptProperty *iface, DWORD dwProperty, VARIANT *pvarIndex, VARIANT *pvarValue) { CHECK_EXPECT(SetProperty); ok(dwProperty == SCRIPTPROP_HACK_TRIDENTEVENTSINK, "unexpected property %d\n", dwProperty); ok(!pvarIndex, "pvarIndex != NULL\n"); ok(pvarValue != NULL, "pvarValue == NULL\n"); ok(V_VT(pvarValue) == VT_BOOL, "V_VT(pvarValue)=%d\n", V_VT(pvarValue)); ok(V_BOOL(pvarValue) == VARIANT_TRUE, "V_BOOL(pvarValue)=%x\n", V_BOOL(pvarValue)); return E_NOTIMPL; }
static void test_change_types(IVariantChangeType *change_type, IDispatch *obj_disp) { VARIANT v, dst; HRESULT hres; static const conv_results_t bool_results[] = { {0, "false", VARIANT_FALSE, 1,0.0}, {1, "true", VARIANT_TRUE, 1,1.0}}; static const conv_results_t int_results[] = { {0, "0", VARIANT_FALSE, 1,0.0}, {-100, "-100", VARIANT_TRUE, 1,-100.0}, {0x10010, "65552", VARIANT_TRUE, 1,65552.0}}; static const conv_results_t empty_results = {0, "undefined", VARIANT_FALSE, 0,0}; static const conv_results_t null_results = {0, "null", VARIANT_FALSE, 0,0}; static const conv_results_t obj_results = {10, "strval", VARIANT_TRUE, 1,10.0}; V_VT(&v) = VT_BOOL; V_BOOL(&v) = VARIANT_FALSE; test_change_type(change_type, &v, bool_results); V_BOOL(&v) = VARIANT_TRUE; test_change_type(change_type, &v, bool_results+1); V_VT(&v) = VT_I4; V_I4(&v) = 0; test_change_type(change_type, &v, int_results); V_I4(&v) = -100; test_change_type(change_type, &v, int_results+1); V_I4(&v) = 0x10010; test_change_type(change_type, &v, int_results+2); V_VT(&v) = VT_EMPTY; test_change_type(change_type, &v, &empty_results); V_VT(&v) = VT_NULL; test_change_type(change_type, &v, &null_results); V_VT(&v) = VT_DISPATCH; V_DISPATCH(&v) = obj_disp; test_change_type(change_type, &v, &obj_results); V_VT(&v) = VT_BOOL; V_BOOL(&v) = VARIANT_FALSE; V_VT(&dst) = 0xdead; hres = IVariantChangeType_ChangeType(change_type, &dst, &v, 0, VT_I4); ok(hres == DISP_E_BADVARTYPE, "ChangeType failed: %08x, expected DISP_E_BADVARTYPE\n", hres); ok(V_VT(&dst) == 0xdead, "V_VT(dst) = %d\n", V_VT(&dst)); }
// SupportIRowsetChange ------------------------------------------------ // // @func This function returns if IrowsetChange is supported // BOOL CRowset::SupportIRowsetChange() { BOOL fIRowsetChange = FALSE; ULONG cPropSets = 0; DBPROPSET * rgPropSets = NULL; DBPROPID rgPropId[1]; DBPROPIDSET rgPropertySets[1]; // Get the value of the DBPROP_CANHOLDROWS property rgPropertySets[0].guidPropertySet = DBPROPSET_ROWSET; rgPropertySets[0].rgPropertyIDs = rgPropId; rgPropertySets[0].cPropertyIDs = 1; rgPropId[0] = DBPROP_IRowsetChange; // Get the IRowsetChange Property from m_pUtilProp GetCUtilProp()->GetProperties(PROPSET_ROWSET, 1, rgPropertySets, &cPropSets, &rgPropSets); // Get the Prompt value if( V_BOOL(&rgPropSets->rgProperties->vValue) == VARIANT_TRUE ) fIRowsetChange = TRUE; // release properties FreeProperties(&cPropSets, &rgPropSets); return fIRowsetChange; }
static bool IsDeferred(CCUBRIDRowset *pRowset) { CComVariant var; HRESULT hr = pRowset->GetPropValue(&DBPROPSET_ROWSET, DBPROP_IRowsetUpdate, &var); ATLASSERT(SUCCEEDED(hr)); return V_BOOL(&var)==ATL_VARIANT_TRUE; }
/* ECMA-262 3rd Edition 9.2 */ HRESULT to_boolean(VARIANT *v, VARIANT_BOOL *b) { switch(V_VT(v)) { case VT_EMPTY: case VT_NULL: *b = VARIANT_FALSE; break; case VT_I4: *b = V_I4(v) ? VARIANT_TRUE : VARIANT_FALSE; break; case VT_R8: *b = V_R8(v) ? VARIANT_TRUE : VARIANT_FALSE; break; case VT_BSTR: *b = V_BSTR(v) && *V_BSTR(v) ? VARIANT_TRUE : VARIANT_FALSE; break; case VT_DISPATCH: *b = V_DISPATCH(v) ? VARIANT_TRUE : VARIANT_FALSE; break; case VT_BOOL: *b = V_BOOL(v); break; default: FIXME("unimplemented for vt %d\n", V_VT(v)); return E_NOTIMPL; } return S_OK; }
const char *debugstr_variant(const VARIANT *v) { if (!v) return "(null)"; switch (V_VT(v)) { case VT_EMPTY: return "{VT_EMPTY}"; case VT_NULL: return "{VT_NULL}"; case VT_I2: return wine_dbg_sprintf("{VT_I2: %d}", V_I2(v)); case VT_I4: return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v)); case VT_R8: return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v)); case VT_BSTR: return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v))); case VT_DISPATCH: return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v)); case VT_ERROR: return wine_dbg_sprintf("{VT_ERROR: %08x}", V_ERROR(v)); case VT_BOOL: return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v)); case VT_UINT: return wine_dbg_sprintf("{VT_UINT: %u}", V_UINT(v)); default: return wine_dbg_sprintf("{vt %d}", V_VT(v)); } }
static HRESULT WINAPI Global_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp, VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller) { switch(id) { case DISPID_GLOBAL_OK: ok(wFlags == INVOKE_FUNC || wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags); ok(pdp != NULL, "pdp == NULL\n"); ok(pdp->rgvarg != NULL, "rgvarg == NULL\n"); ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n"); ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs); ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs); ok(pei != NULL, "pei == NULL\n"); ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg)); ok(V_VT(pdp->rgvarg+1) == VT_BOOL, "V_VT(psp->rgvargs+1) = %d\n", V_VT(pdp->rgvarg)); ok(V_BOOL(pdp->rgvarg+1), "%s\n", wine_dbgstr_w(V_BSTR(pdp->rgvarg))); break; default: ok(0, "unexpected call\n"); return E_NOTIMPL; } return S_OK; }
static HRESULT WINAPI HTMLElement3_get_disabled(IHTMLElement3 *iface, VARIANT_BOOL *p) { HTMLElement *This = impl_from_IHTMLElement3(iface); VARIANT *var; HRESULT hres; TRACE("(%p)->(%p)\n", This, p); if(This->node.vtbl->get_disabled) return This->node.vtbl->get_disabled(&This->node, p); hres = dispex_get_dprop_ref(&This->node.dispex, disabledW, FALSE, &var); if(hres == DISP_E_UNKNOWNNAME) { *p = VARIANT_FALSE; return S_OK; } if(FAILED(hres)) return hres; if(V_VT(var) != VT_BOOL) { FIXME("value is %s\n", debugstr_variant(var)); return E_NOTIMPL; } *p = V_BOOL(var); return S_OK; }
static const char *debugstr_variant(const VARIANT *var) { static char buf[400]; if (!var) return "(null)"; switch (V_VT(var)) { case VT_EMPTY: return "{VT_EMPTY}"; case VT_BSTR: sprintf(buf, "{VT_BSTR: %s}", wine_dbgstr_w(V_BSTR(var))); break; case VT_BOOL: sprintf(buf, "{VT_BOOL: %x}", V_BOOL(var)); break; case VT_UI4: sprintf(buf, "{VT_UI4: %u}", V_UI4(var)); break; default: sprintf(buf, "{vt %d}", V_VT(var)); break; } return buf; }
void CCmdTarget::GetStandardProp(const AFX_DISPMAP_ENTRY* pEntry, VARIANT* pvarResult, UINT* puArgErr) { ASSERT(pEntry != NULL); ASSERT(*puArgErr != 0); // it is a DISPATCH_PROPERTYGET (for standard, non-function property) void* pProp = (BYTE*)this + pEntry->nPropOffset; if (pEntry->vt != VT_VARIANT) pvarResult->vt = pEntry->vt; switch (pEntry->vt) { case VT_I1: pvarResult->bVal = *(BYTE*)pProp; break; case VT_I2: pvarResult->iVal = *(short*)pProp; break; case VT_I4: pvarResult->lVal = *(long*)pProp; break; case VT_R4: pvarResult->fltVal = *(float*)pProp; break; case VT_R8: pvarResult->dblVal = *(double*)pProp; break; case VT_DATE: pvarResult->date = *(double*)pProp; break; case VT_CY: pvarResult->cyVal = *(CY*)pProp; break; case VT_BSTR: { CString* pString = (CString*)pProp; pvarResult->bstrVal = pString->AllocSysString(); } break; case VT_ERROR: pvarResult->scode = *(SCODE*)pProp; break; case VT_BOOL: V_BOOL(pvarResult) = (VARIANT_BOOL)(*(BOOL*)pProp != 0 ? -1 : 0); break; case VT_VARIANT: if (VariantCopy(pvarResult, (LPVARIANT)pProp) != S_OK) *puArgErr = 0; break; case VT_DISPATCH: case VT_UNKNOWN: pvarResult->punkVal = *(LPDISPATCH*)pProp; if (pvarResult->punkVal != NULL) pvarResult->punkVal->AddRef(); break; default: *puArgErr = 0; } }
wchar_t *Variant2CWString(VARIANT *result){ switch(V_VT(result)){ case VT_EMPTY: return L"empty"; break; case VT_NULL: return L"null"; break; case VT_I2: // short return Number2String((long)V_I2(result)); break; case VT_I4: // long return Number2String((long)V_I4(result)); break; case VT_R4: // float return Double2String(V_R4(result)); break; case VT_R8: // double return Double2String(V_R8(result)); break; case VT_BOOL: //(True -1,False 0) return (V_BOOL(result) ? L"True" : L"False"); break; case VT_BSTR: return (wchar_t*)(V_BSTR(result)); break; case VT_DATE: return Date2String( V_DATE(result)); break; } }
static HRESULT change_type(VARIANT *dst, VARIANT *src, VARTYPE vt, IServiceProvider *caller) { V_VT(dst) = VT_EMPTY; if(caller) { IVariantChangeType *change_type = NULL; HRESULT hres; hres = IServiceProvider_QueryService(caller, &SID_VariantConversion, &IID_IVariantChangeType, (void**)&change_type); if(SUCCEEDED(hres)) { hres = IVariantChangeType_ChangeType(change_type, dst, src, LOCALE_NEUTRAL, vt); IVariantChangeType_Release(change_type); return hres; } } switch(vt) { case VT_BOOL: if(V_VT(src) == VT_BSTR) { V_VT(dst) = VT_BOOL; V_BOOL(dst) = V_BSTR(src) && *V_BSTR(src) ? VARIANT_TRUE : VARIANT_FALSE; return S_OK; } break; } return VariantChangeType(dst, src, 0, vt); }
static const char *debugstr_variant(const VARIANT *v) { if(!v) return "(null)"; switch(V_VT(v)) { case VT_EMPTY: return "{VT_EMPTY}"; case VT_NULL: return "{VT_NULL}"; case VT_I4: return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v)); case VT_R8: return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v)); case VT_BSTR: return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v))); case VT_DISPATCH: return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v)); case VT_BOOL: return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v)); case VT_UNKNOWN: return wine_dbg_sprintf("{VT_UNKNOWN: %p}", V_UNKNOWN(v)); case VT_UINT: return wine_dbg_sprintf("{VT_UINT: %u}", V_UINT(v)); case VT_BSTR|VT_BYREF: return wine_dbg_sprintf("{VT_BSTR|VT_BYREF: ptr %p, data %s}", V_BSTRREF(v), debugstr_w(V_BSTRREF(v) ? *V_BSTRREF(v) : NULL)); default: return wine_dbg_sprintf("{vt %d}", V_VT(v)); } }
HRESULT CModuleConfiguration::GetBOOL(IAppHostElement* section, LPCWSTR propertyName, BOOL* value) { HRESULT hr = S_OK; BSTR sysPropertyName = NULL; IAppHostProperty* prop = NULL; VARIANT var; CheckNull(value); *value = FALSE; VariantInit(&var); ErrorIf(NULL == (sysPropertyName = SysAllocString(propertyName)), ERROR_NOT_ENOUGH_MEMORY); CheckError(section->GetPropertyByName(sysPropertyName, &prop)); CheckError(prop->get_Value(&var)); CheckError(VariantChangeType(&var, &var, 0, VT_BOOL)); *value = (V_BOOL(&var) == VARIANT_TRUE); Error: VariantClear(&var); if ( sysPropertyName ) { SysFreeString(sysPropertyName); sysPropertyName = NULL; } if (prop) { prop->Release(); prop = NULL; } return hr; }
STDMETHODIMP CGPAXPlugin::Save(LPPROPERTYBAG pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties) { u16 wurl[MAXLEN_URL]; const char *sptr; u16 len; VARIANT value; if( pPropBag == NULL) return E_INVALIDARG; VariantInit(&value); V_VT(&value) = VT_BOOL; V_BOOL(&value) = m_bAutoStart ? VARIANT_TRUE : VARIANT_FALSE; pPropBag->Write(OLESTR("AutoStart"), &value); VariantClear(&value); V_VT(&value) = VT_BSTR; sptr = (const char *)m_url; len = gf_utf8_mbstowcs(wurl, MAXLEN_URL, &sptr); V_BSTR(&value) = SysAllocStringLen(NULL, len+1); memcpy(V_BSTR(&value) , wurl, len*sizeof(u16)); V_BSTR(&value) [len] = 0; pPropBag->Write(OLESTR("src"), &value); VariantClear(&value); return S_OK; }
// C/C++ Interface HRESULT CoAuthServiceCall::Init(LPCTSTR szMethod, LPCTSTR szUrl) { _ASSERT(NULL == m_spRequest); // initalize only once m_spRequest.CreateInstance(XMLHTTP_COMPONENT); // add sink to xml http request const DWORD dwRef = CCmdTarget::m_dwRef; HRESULT hr = m_spRequest->put_onreadystatechange(GetIDispatch(FALSE)); _ASSERT(SUCCEEDED(hr) && (dwRef + 1 == CCmdTarget::m_dwRef)); m_eState = InitialRequest; m_pRenewTokenAsync = NULL; m_bstrMethod = szMethod; m_bstrUrl = szUrl; TRACE2(" %s: %s (first trial)\n", szMethod, szUrl); /* * hier laeuft schon der erste (synchrone) Callback (OnReadStateChange(READYSTATE_LOADING)) * ungluecklicherweise koennen wir fuer den fall das der IWorkflow::AuthorizeRequest() failed KEINEN returnwert/exception liefern * ergo wird das IXMLHTTPRequest::send() unbedingt nachgeschoben. das heist wir muessen spaeter evtl. auf den falschen fehler 401 reagieren. */ CComVariant varAsync(VARIANT_TRUE); m_spRequest->open(m_bstrMethod, m_bstrUrl, varAsync); #ifdef AUTHORIZATION_SERVER_SUPPORT_JSON m_spRequest->setRequestHeader(L"Accept", L"application/json"); // m_spRequest->setRequestHeader(L"Accept", L"application/json,application/xml"); #else m_spRequest->setRequestHeader(L"Accept", L"application/xml"); #endif m_spRequest->send(); return VARIANT_TRUE == V_BOOL(&varAsync) ? E_PENDING : NOERROR; }
static void test_service(void) { static const WCHAR spooler[] = {'S','p','o','o','l','e','r',0}; static const WCHAR dummyW[] = {'d','u','m','m','y',0}; SERVICE_STATUS_PROCESS status; SC_HANDLE scm, service; IShellDispatch2 *sd; DWORD dummy; HRESULT hr; BSTR name; VARIANT v; hr = CoCreateInstance(&CLSID_Shell, NULL, CLSCTX_INPROC_SERVER, &IID_IShellDispatch2, (void**)&sd); if (hr != S_OK) { win_skip("IShellDispatch2 not supported\n"); return; } V_VT(&v) = VT_I2; V_I2(&v) = 10; hr = IShellDispatch2_IsServiceRunning(sd, NULL, &v); ok(V_VT(&v) == VT_BOOL, "got %d\n", V_VT(&v)); ok(V_BOOL(&v) == VARIANT_FALSE, "got %d\n", V_BOOL(&v)); EXPECT_HR(hr, S_OK); scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT); service = OpenServiceW(scm, spooler, SERVICE_QUERY_STATUS); QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (BYTE *)&status, sizeof(SERVICE_STATUS_PROCESS), &dummy); CloseServiceHandle(service); CloseServiceHandle(scm); /* service should exist */ name = SysAllocString(spooler); V_VT(&v) = VT_I2; hr = IShellDispatch2_IsServiceRunning(sd, name, &v); EXPECT_HR(hr, S_OK); ok(V_VT(&v) == VT_BOOL, "got %d\n", V_VT(&v)); if (status.dwCurrentState == SERVICE_RUNNING) ok(V_BOOL(&v) == VARIANT_TRUE, "got %d\n", V_BOOL(&v)); else ok(V_BOOL(&v) == VARIANT_FALSE, "got %d\n", V_BOOL(&v)); SysFreeString(name); /* service doesn't exist */ name = SysAllocString(dummyW); V_VT(&v) = VT_I2; hr = IShellDispatch2_IsServiceRunning(sd, name, &v); EXPECT_HR(hr, S_OK); ok(V_VT(&v) == VT_BOOL, "got %d\n", V_VT(&v)); ok(V_BOOL(&v) == VARIANT_FALSE, "got %d\n", V_BOOL(&v)); SysFreeString(name); IShellDispatch2_Release(sd); }
static inline HRESULT add_prop_bool( IDxDiagContainer* cont, LPCWSTR prop, BOOL data ) { VARIANT var; V_VT( &var ) = VT_BOOL; V_BOOL( &var ) = data; return IDxDiagContainerImpl_AddProp( cont, prop, &var ); }
STDMETHODIMP CComCertificate::get_containsCert(VARIANT *pVal) { VariantInit(pVal); V_VT(pVal) = VT_BOOL; V_BOOL(pVal) = ((m_pX509 == NULL) ? FALSE : TRUE); return S_OK; }
//+--------------------------------------------------------------------------- // // Function: CVarToVARIANTARG // // Synopsis: Converts a C-language variable to a VARIANT. // // Arguments: [pv] -- Pointer to C-language variable. // [vt] -- Type of C-language variable. // [pvarg] -- Resulting VARIANT. Must be initialized by caller. // Any contents will be freed. // // Modifies: [pvarg] // // History: 2-23-94 adams Created // // Notes: Supports all variant pointer types, VT_UI2, VT_I2, VT_UI4, // VT_I4, VT_R4, VT_R8, VT_ERROR. // //---------------------------------------------------------------------------- void CVarToVARIANTARG(void* pv, VARTYPE vt, VARIANTARG* pvarg) { Assert(pv); Assert(pvarg); VariantClear(pvarg); V_VT(pvarg) = vt; if(V_ISBYREF(pvarg)) { // Use a supported pointer type for derefencing. vt = VT_UNKNOWN; } switch(vt) { case VT_BOOL: // convert TRUE to VT_TRUE Assert(*(BOOL*)pv==1 || *(BOOL*)pv==0); V_BOOL(pvarg) = VARIANT_BOOL(-*(BOOL*)pv); break; case VT_I2: V_I2(pvarg) = *(short*)pv; break; case VT_ERROR: case VT_I4: V_I4(pvarg) = *(long*)pv; break; case VT_R4: V_R4(pvarg) = *(float*)pv; break; case VT_R8: V_R8(pvarg) = *(double*)pv; break; case VT_CY: V_CY(pvarg) = *(CY*)pv; break; // All Pointer types. case VT_PTR: case VT_BSTR: case VT_LPSTR: case VT_LPWSTR: case VT_DISPATCH: case VT_UNKNOWN: V_BYREF(pvarg) = *(void**)pv; break; default: Assert(FALSE && "Unknown type."); break; } }
HRESULT variant_to_jsval(VARIANT *var, jsval_t *r) { switch(V_VT(var)) { case VT_EMPTY: *r = jsval_undefined(); return S_OK; case VT_NULL: *r = jsval_null(); return S_OK; case VT_BOOL: *r = jsval_bool(V_BOOL(var)); return S_OK; case VT_I4: *r = jsval_number(V_I4(var)); return S_OK; case VT_R8: *r = jsval_number(V_R8(var)); return S_OK; case VT_BSTR: { jsstr_t *str; str = jsstr_alloc_len(V_BSTR(var), SysStringLen(V_BSTR(var))); if(!str) return E_OUTOFMEMORY; if(!V_BSTR(var)) str->length_flags |= JSSTR_FLAG_NULLBSTR; *r = jsval_string(str); return S_OK; } case VT_DISPATCH: { if(V_DISPATCH(var)) IDispatch_AddRef(V_DISPATCH(var)); *r = jsval_disp(V_DISPATCH(var)); return S_OK; } case VT_I2: *r = jsval_number(V_I2(var)); return S_OK; case VT_INT: *r = jsval_number(V_INT(var)); return S_OK; case VT_UNKNOWN: if(V_UNKNOWN(var)) { IDispatch *disp; HRESULT hres; hres = IUnknown_QueryInterface(V_UNKNOWN(var), &IID_IDispatch, (void**)&disp); if(SUCCEEDED(hres)) { *r = jsval_disp(disp); return S_OK; } } /* fall through */ default: return jsval_variant(r, var); } }
STDMETHODIMP CXMLHttpRequest::open(BSTR bstrMethod, BSTR bstrUrl,VARIANT varAsync,VARIANT bstrUser,VARIANT bstrPassword) { ATLTRACE(_T("CXMLHttpRequest::open\n")); // do not open if there is a send active if (NULL != m_hThread) { DWORD exitCode = 0; BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode); if (!rc || STILL_ACTIVE == exitCode) return E_FAIL; ::CloseHandle(m_hThread); m_hThread = NULL; } if (V_VT(&varAsync) != VT_BOOL) return E_INVALIDARG; _bstr_t method = bstrMethod; if (0 == method.length()) return E_INVALIDARG; _bstr_t url = bstrUrl; if (0 == url.length()) return E_INVALIDARG; TCHAR hostName[INTERNET_MAX_PATH_LENGTH] = _T(""); TCHAR strPathName[INTERNET_MAX_PATH_LENGTH] = _T(""); URL_COMPONENTS urlComponents; memset(&urlComponents, 0, sizeof(URL_COMPONENTS)); urlComponents.dwStructSize = sizeof(URL_COMPONENTS); urlComponents.lpszHostName = hostName; urlComponents.dwHostNameLength = INTERNET_MAX_PATH_LENGTH; urlComponents.lpszUrlPath = strPathName; urlComponents.dwUrlPathLength = INTERNET_MAX_PATH_LENGTH; if (!InternetCrackUrl(url, url.length(), 0, &urlComponents)) return E_INVALIDARG; m_Method = method; m_HostName = hostName; if (urlComponents.nPort != 0) m_Port = urlComponents.nPort; m_URLPath = strPathName; m_bAsync = (VARIANT_TRUE == V_BOOL(&varAsync)) ? true : false; if (VT_BSTR == V_VT(&bstrUser)) m_User = V_BSTR(&bstrUser); else m_User = _T(""); if (VT_BSTR == V_VT(&bstrPassword) && m_User.length() > 0) m_Password = V_BSTR(&bstrPassword); else m_Password = _T(""); return S_OK; }
static HRESULT WINAPI httprequest_open(IXMLHTTPRequest *iface, BSTR method, BSTR url, VARIANT async, VARIANT user, VARIANT password) { httprequest *This = impl_from_IXMLHTTPRequest( iface ); HRESULT hr; VARIANT str, is_async; TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(method), debugstr_w(url), debugstr_variant(&async)); if (!method || !url) return E_INVALIDARG; /* free previously set data */ SysFreeString(This->url); SysFreeString(This->user); SysFreeString(This->password); This->url = This->user = This->password = NULL; if (lstrcmpiW(method, MethodGetW) == 0) { This->verb = BINDVERB_GET; } else if (lstrcmpiW(method, MethodPutW) == 0) { This->verb = BINDVERB_PUT; } else if (lstrcmpiW(method, MethodPostW) == 0) { This->verb = BINDVERB_POST; } else { FIXME("unsupported request type %s\n", debugstr_w(method)); This->verb = -1; return E_FAIL; } This->url = SysAllocString(url); VariantInit(&is_async); hr = VariantChangeType(&is_async, &async, 0, VT_BOOL); This->async = hr == S_OK && V_BOOL(&is_async) == VARIANT_TRUE; VariantInit(&str); hr = VariantChangeType(&str, &user, 0, VT_BSTR); if (hr == S_OK) This->user = V_BSTR(&str); hr = VariantChangeType(&str, &password, 0, VT_BSTR); if (hr == S_OK) This->password = V_BSTR(&str); httprequest_setreadystate(This, READYSTATE_LOADING); return S_OK; }
JNIEXPORT void JNICALL Java_com_tangram_Variant_putVariantBoolean(JNIEnv *env, jobject _this, jboolean b) { VARIANT *v = extractVariant(env, _this); if (v) { VariantClear(v); // whatever was there before V_VT(v) = VT_BOOL; V_BOOL(v) = b == JNI_TRUE ? VARIANT_TRUE : VARIANT_FALSE; } else ThrowComFail(env, "putVariantBoolean failed", -1); }
static HRESULT WINAPI ShellDispatch_IsServiceRunning(IShellDispatch2 *iface, BSTR name, VARIANT *running) { SERVICE_STATUS_PROCESS status; SC_HANDLE scm, service; DWORD dummy; TRACE("(%s, %p)\n", debugstr_w(name), running); V_VT(running) = VT_BOOL; V_BOOL(running) = VARIANT_FALSE; scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT); if (!scm) { ERR("failed to connect to service manager\n"); return S_OK; } service = OpenServiceW(scm, name, SERVICE_QUERY_STATUS); if (!service) { ERR("Failed to open service %s (%u)\n", debugstr_w(name), GetLastError()); CloseServiceHandle(scm); return S_OK; } if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (BYTE *)&status, sizeof(SERVICE_STATUS_PROCESS), &dummy)) { TRACE("failed to query service status (%u)\n", GetLastError()); CloseServiceHandle(service); CloseServiceHandle(scm); return S_OK; } if (status.dwCurrentState == SERVICE_RUNNING) V_BOOL(running) = VARIANT_TRUE; CloseServiceHandle(service); CloseServiceHandle(scm); return S_OK; }
HRESULT jsval_to_variant(jsval_t val, VARIANT *retv) { switch(jsval_type(val)) { case JSV_UNDEFINED: V_VT(retv) = VT_EMPTY; return S_OK; case JSV_NULL: V_VT(retv) = VT_NULL; return S_OK; case JSV_OBJECT: V_VT(retv) = VT_DISPATCH; if(get_object(val)) IDispatch_AddRef(get_object(val)); V_DISPATCH(retv) = get_object(val); return S_OK; case JSV_STRING: { jsstr_t *str = get_string(val); V_VT(retv) = VT_BSTR; if(str->length_flags & JSSTR_FLAG_NULLBSTR) { V_BSTR(retv) = NULL; } else { V_BSTR(retv) = SysAllocStringLen(NULL, jsstr_length(str)); if(V_BSTR(retv)) jsstr_flush(str, V_BSTR(retv)); else return E_OUTOFMEMORY; } return S_OK; } case JSV_NUMBER: { double n = get_number(val); if(is_int32(n)) { V_VT(retv) = VT_I4; V_I4(retv) = n; } else { V_VT(retv) = VT_R8; V_R8(retv) = n; } return S_OK; } case JSV_BOOL: V_VT(retv) = VT_BOOL; V_BOOL(retv) = get_bool(val) ? VARIANT_TRUE : VARIANT_FALSE; return S_OK; case JSV_VARIANT: V_VT(retv) = VT_EMPTY; return VariantCopy(retv, get_variant(val)); } assert(0); return E_FAIL; }