zend_object_iterator *php_com_saproxy_iter_get(zend_class_entry *ce, zval *object, int by_ref)
{
php_com_saproxy *proxy = SA_FETCH(object);
php_com_saproxy_iter *I;
int i;
if (by_ref) {
zend_throw_error(NULL, "An iterator cannot be used with foreach by reference");
return NULL;
}
I = ecalloc(1, sizeof(*I));
I->iter.funcs = &saproxy_iter_funcs;
Z_PTR(I->iter.data) = I;
I->proxy = proxy;
ZVAL_COPY(&I->proxy_obj, object);
I->indices = safe_emalloc(proxy->dimensions + 1, sizeof(LONG), 0);
for (i = 0; i < proxy->dimensions; i++) {
convert_to_long(&proxy->indices[i]);
I->indices[i] = (LONG)Z_LVAL(proxy->indices[i]);
}
SafeArrayGetLBound(V_ARRAY(&proxy->obj->v), proxy->dimensions, &I->imin);
SafeArrayGetUBound(V_ARRAY(&proxy->obj->v), proxy->dimensions, &I->imax);
I->key = I->imin;
return &I->iter;
}
HRESULT navigate_url(DocHost *This, LPCWSTR url, const VARIANT *Flags,
const VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
{
PBYTE post_data = NULL;
ULONG post_data_len = 0;
LPWSTR headers = NULL;
HRESULT hres = S_OK;
TRACE("navigating to %s\n", debugstr_w(url));
if((Flags && V_VT(Flags) != VT_EMPTY)
|| (TargetFrameName && V_VT(TargetFrameName) != VT_EMPTY))
FIXME("Unsupported args (Flags %p:%d; TargetFrameName %p:%d)\n",
Flags, Flags ? V_VT(Flags) : -1, TargetFrameName,
TargetFrameName ? V_VT(TargetFrameName) : -1);
if(PostData && V_VT(PostData) == (VT_ARRAY | VT_UI1) && V_ARRAY(PostData)) {
SafeArrayAccessData(V_ARRAY(PostData), (void**)&post_data);
post_data_len = V_ARRAY(PostData)->rgsabound[0].cElements;
}
if(Headers && V_VT(Headers) == VT_BSTR) {
headers = V_BSTR(Headers);
TRACE("Headers: %s\n", debugstr_w(headers));
}
set_doc_state(This, READYSTATE_LOADING);
This->ready_state = READYSTATE_LOADING;
if(This->doc_navigate) {
WCHAR new_url[INTERNET_MAX_URL_LENGTH];
if(PathIsURLW(url)) {
new_url[0] = 0;
}else {
DWORD size;
size = sizeof(new_url)/sizeof(WCHAR);
hres = UrlApplySchemeW(url, new_url, &size, URL_APPLY_GUESSSCHEME);
if(FAILED(hres)) {
WARN("UrlApplyScheme failed: %08x\n", hres);
new_url[0] = 0;
}
}
hres = async_doc_navigate(This, *new_url ? new_url : url, headers, post_data,
post_data_len, TRUE);
}else {
task_navigate_bsc_t *task;
task = heap_alloc(sizeof(*task));
task->bsc = create_callback(This, url, post_data, post_data_len, headers);
push_dochost_task(This, &task->header, navigate_bsc_proc, This->url == NULL);
}
if(post_data)
SafeArrayUnaccessData(V_ARRAY(PostData));
return hres;
}
HRESULT
GetLPBYTEtoOctetString(VARIANT * pVar, LPBYTE * ppByte)
{
HRESULT hr = E_FAIL;
void HUGEP *pArray;
long lLBound, lUBound, cElements;
if ((!pVar) || (!ppByte))
return E_INVALIDARG;
if ((pVar->n1.n2.vt) != (VT_UI1 | VT_ARRAY))
return E_INVALIDARG;
hr = SafeArrayGetLBound(V_ARRAY(pVar), 1, &lLBound);
hr = SafeArrayGetUBound(V_ARRAY(pVar), 1, &lUBound);
cElements = lUBound - lLBound + 1;
hr = SafeArrayAccessData(V_ARRAY(pVar), &pArray);
if (SUCCEEDED(hr)) {
LPBYTE pTemp = (LPBYTE) pArray;
*ppByte = (LPBYTE) CoTaskMemAlloc(cElements);
if (*ppByte)
memcpy(*ppByte, pTemp, cElements);
else
hr = E_OUTOFMEMORY;
}
SafeArrayUnaccessData(V_ARRAY(pVar));
return hr;
}
//Function for handling Octet Strings returned by variants
//It allocates memory for data, copies the data to the buffer, and returns a pointer to the buffer.
//Caller must free the buffer with CoTaskMemFree.
HRESULT GetLPBYTEtoOctetString(VARIANT *pVar, //IN. Pointer to variant containing the octetstring.
LPBYTE *ppByte //OUT. Return LPBYTE to the data represented in octetstring.
)
{
HRESULT hr = E_FAIL;
//Check args
if ((!pVar)||(!ppByte))
return E_INVALIDARG;
//Check the variant type for unsigned char array (octet string).
if ((pVar->vt)!=(VT_UI1|VT_ARRAY))
return E_INVALIDARG;
void HUGEP *pArray;
long lLBound, lUBound;
hr = SafeArrayGetLBound(V_ARRAY(pVar), 1, &lLBound);
hr = SafeArrayGetUBound(V_ARRAY(pVar), 1, &lUBound);
//Get the count of elements
long cElements = lUBound-lLBound + 1;
hr = SafeArrayAccessData( V_ARRAY(pVar),
&pArray );
if (SUCCEEDED(hr))
{
LPBYTE pTemp = (LPBYTE)pArray;
*ppByte = (LPBYTE) CoTaskMemAlloc(cElements);
if (*ppByte)
memcpy(*ppByte, pTemp, cElements);
else
hr = E_OUTOFMEMORY;
}
SafeArrayUnaccessData( V_ARRAY(pVar) );
return hr;
}
static void com_write_dimension(zval *object, zval *offset, zval *value)
{
php_com_dotnet_object *obj;
zval args[2];
VARIANT v;
HRESULT res;
obj = CDNO_FETCH(object);
if (V_VT(&obj->v) == VT_DISPATCH) {
ZVAL_COPY_VALUE(&args[0], offset);
ZVAL_COPY_VALUE(&args[1], value);
VariantInit(&v);
if (SUCCESS == php_com_do_invoke_by_id(obj, DISPID_VALUE,
DISPATCH_METHOD|DISPATCH_PROPERTYPUT, &v, 2, args, 0, 0)) {
VariantClear(&v);
}
} else if (V_ISARRAY(&obj->v)) {
LONG indices = 0;
VARTYPE vt;
if (SafeArrayGetDim(V_ARRAY(&obj->v)) == 1) {
if (FAILED(SafeArrayGetVartype(V_ARRAY(&obj->v), &vt)) || vt == VT_EMPTY) {
vt = V_VT(&obj->v) & ~VT_ARRAY;
}
convert_to_long(offset);
indices = (LONG)Z_LVAL_P(offset);
VariantInit(&v);
php_com_variant_from_zval(&v, value, obj->code_page);
if (V_VT(&v) != vt) {
VariantChangeType(&v, &v, 0, vt);
}
if (vt == VT_VARIANT) {
res = SafeArrayPutElement(V_ARRAY(&obj->v), &indices, &v);
} else {
res = SafeArrayPutElement(V_ARRAY(&obj->v), &indices, &v.lVal);
}
VariantClear(&v);
if (FAILED(res)) {
php_com_throw_exception(res, NULL);
}
} else {
php_com_throw_exception(DISP_E_BADINDEX, "this variant has multiple dimensions; you can't set a new value without specifying *all* dimensions");
}
} else {
php_com_throw_exception(E_INVALIDARG, "this variant is not an array type");
}
}
unsigned vtSize(VARIANT &vt) {
if (V_VT(&vt) != (VT_ARRAY | VT_UI1))
return 0;
long lb,ub;
if (FAILED(SafeArrayGetLBound(V_ARRAY(&vt),1,&lb)) ||
FAILED(SafeArrayGetUBound(V_ARRAY(&vt),1,&ub)))
return 0;
return ub - lb + 1;
}
static HRESULT WINAPI DEVENUM_IPropertyBag_Write(
LPPROPERTYBAG iface,
LPCOLESTR pszPropName,
VARIANT* pVar)
{
RegPropBagImpl *This = impl_from_IPropertyBag(iface);
LPVOID lpData = NULL;
DWORD cbData = 0;
DWORD dwType = 0;
HRESULT res = S_OK;
TRACE("(%p)->(%s, %p)\n", This, debugstr_w(pszPropName), pVar);
switch (V_VT(pVar))
{
case VT_BSTR:
case VT_LPWSTR:
TRACE("writing %s\n", debugstr_w(V_BSTR(pVar)));
lpData = V_BSTR(pVar);
dwType = REG_SZ;
cbData = (lstrlenW(V_BSTR(pVar)) + 1) * sizeof(WCHAR);
break;
case VT_I4:
case VT_UI4:
TRACE("writing %u\n", V_UI4(pVar));
lpData = &V_UI4(pVar);
dwType = REG_DWORD;
cbData = sizeof(DWORD);
break;
case VT_ARRAY | VT_UI1:
{
LONG lUbound = 0;
LONG lLbound = 0;
dwType = REG_BINARY;
res = SafeArrayGetLBound(V_ARRAY(pVar), 1, &lLbound);
res = SafeArrayGetUBound(V_ARRAY(pVar), 1, &lUbound);
cbData = (lUbound - lLbound + 1) /* * sizeof(BYTE)*/;
TRACE("cbData: %d\n", cbData);
res = SafeArrayAccessData(V_ARRAY(pVar), &lpData);
break;
}
default:
FIXME("Variant type %d not handled\n", V_VT(pVar));
return E_FAIL;
}
if (RegSetValueExW(This->hkey,
pszPropName, 0,
dwType, lpData, cbData) != ERROR_SUCCESS)
res = E_FAIL;
if (V_VT(pVar) & VT_ARRAY)
res = SafeArrayUnaccessData(V_ARRAY(pVar));
return res;
}
void vtCopy(VARIANT& vt,void *dest) {
unsigned sz = vtSize(vt);
if (sz > 0) {
void *vp;
if (SUCCEEDED(SafeArrayAccessData(V_ARRAY(&vt),&vp))) {
memcpy(dest,vp,sz);
SafeArrayUnaccessData(V_ARRAY(&vt));
}
}
}
static HRESULT WINAPI WebBrowser_Navigate2(IWebBrowser2 *iface, VARIANT *URL, VARIANT *Flags,
VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
{
WebBrowser *This = WEBBROWSER_THIS(iface);
PBYTE post_data = NULL;
ULONG post_data_len = 0;
LPWSTR headers = NULL;
HRESULT hres;
TRACE("(%p)->(%p %p %p %p %p)\n", This, URL, Flags, TargetFrameName, PostData, Headers);
if(!This->client)
return E_FAIL;
if((Flags && V_VT(Flags) != VT_EMPTY)
|| (TargetFrameName && V_VT(TargetFrameName) != VT_EMPTY))
FIXME("Unsupported arguments\n");
if(!URL)
return S_OK;
if(V_VT(URL) != VT_BSTR)
return E_INVALIDARG;
if(PostData && V_VT(PostData) != VT_EMPTY) {
if(V_VT(PostData) != (VT_ARRAY | VT_UI1)
|| V_ARRAY(PostData)->cDims != 1) {
WARN("Invalid PostData\n");
return E_INVALIDARG;
}
SafeArrayAccessData(V_ARRAY(PostData), (void**)&post_data);
post_data_len = V_ARRAY(PostData)->rgsabound[0].cElements;
}
if(Headers && V_VT(Headers) != VT_EMPTY) {
if(V_VT(Headers) != VT_BSTR)
return E_INVALIDARG;
headers = V_BSTR(Headers);
TRACE("Headers: %s\n", debugstr_w(headers));
}
hres = navigate_url(&This->doc_host, V_BSTR(URL), post_data, post_data_len, headers);
if(post_data)
SafeArrayUnaccessData(V_ARRAY(PostData));
return hres;
}
/*
* call-seq:
* WIN32OLE_VARIANT.array(ary, vt)
*
* Returns Ruby object wrapping OLE variant whose variant type is VT_ARRAY.
* The first argument should be Array object which specifies dimensions
* and each size of dimensions of OLE array.
* The second argument specifies variant type of the element of OLE array.
*
* The following create 2 dimensions OLE array. The first dimensions size
* is 3, and the second is 4.
*
* ole_ary = WIN32OLE_VARIANT.array([3,4], VT_I4)
* ruby_ary = ole_ary.value # => [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
*
*/
static VALUE
folevariant_s_array(VALUE klass, VALUE elems, VALUE vvt)
{
VALUE obj = Qnil;
VARTYPE vt;
struct olevariantdata *pvar;
SAFEARRAYBOUND *psab = NULL;
SAFEARRAY *psa = NULL;
UINT dim = 0;
UINT i = 0;
ole_initialize();
vt = RB_NUM2UINT(vvt);
vt = (vt | VT_ARRAY);
Check_Type(elems, T_ARRAY);
obj = folevariant_s_allocate(klass);
TypedData_Get_Struct(obj, struct olevariantdata, &olevariant_datatype, pvar);
dim = RARRAY_LEN(elems);
psab = ALLOC_N(SAFEARRAYBOUND, dim);
if(!psab) {
rb_raise(rb_eRuntimeError, "memory allocation error");
}
for (i = 0; i < dim; i++) {
psab[i].cElements = RB_FIX2INT(rb_ary_entry(elems, i));
psab[i].lLbound = 0;
}
psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
if (psa == NULL) {
if (psab) free(psab);
rb_raise(rb_eRuntimeError, "memory allocation error(SafeArrayCreate)");
}
V_VT(&(pvar->var)) = vt;
if (vt & VT_BYREF) {
V_VT(&(pvar->realvar)) = (vt & ~VT_BYREF);
V_ARRAY(&(pvar->realvar)) = psa;
V_ARRAYREF(&(pvar->var)) = &(V_ARRAY(&(pvar->realvar)));
} else {
V_ARRAY(&(pvar->var)) = psa;
}
if (psab) free(psab);
return obj;
}
static int saproxy_count_elements(zend_object *object, zend_long *count)
{
php_com_saproxy *proxy = (php_com_saproxy*) object;
LONG ubound, lbound;
if (!V_ISARRAY(&proxy->obj->v)) {
return FAILURE;
}
SafeArrayGetLBound(V_ARRAY(&proxy->obj->v), proxy->dimensions, &lbound);
SafeArrayGetUBound(V_ARRAY(&proxy->obj->v), proxy->dimensions, &ubound);
*count = ubound - lbound + 1;
return SUCCESS;
}
STDMETHODIMP CComDigiDocLib::getSupportedFormats(VARIANT *ret)
{
const char** pArr = ::getSupportedFormats();
unsigned int nElems = 0;
SAFEARRAY* pSArr;
BSTR HUGEP* pData;
// detect number of elements
for(; *pArr != NULL; pArr++, nElems++);
// initialize SAFEARRAY
pSArr = SafeArrayCreateVector(VT_BSTR, 0, nElems);
if (pSArr == NULL) {
return E_OUTOFMEMORY;
}
// init variant
V_ARRAY(ret) = pSArr;
V_VT(ret) = (VT_ARRAY | VT_BSTR);
// copy data to variant
pArr = ::getSupportedFormats();
SafeArrayAccessData(pSArr, (void HUGEP**)&pData);
long lArr[1];
USES_CONVERSION;
ddocDebug(1, "getSupportedFormats", "num formats: %d", nElems);
for(lArr[0] = 0; lArr[0] < (long)nElems; lArr[0]++) {
ddocDebug(1, "getSupportedFormats", "format: %d - %s", lArr[0], pArr[lArr[0]]);
pData[lArr[0]] = SysAllocString(A2OLE(pArr[lArr[0]]));
}
SafeArrayUnaccessData(pSArr);
return S_OK;
}
static zval *com_read_dimension(zval *object, zval *offset, int type, zval *rv)
{
php_com_dotnet_object *obj;
VARIANT v;
ZVAL_NULL(rv);
obj = CDNO_FETCH(object);
if (V_VT(&obj->v) == VT_DISPATCH) {
VariantInit(&v);
if (SUCCESS == php_com_do_invoke_by_id(obj, DISPID_VALUE,
DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, 1, offset, 0, 0)) {
php_com_zval_from_variant(rv, &v, obj->code_page);
VariantClear(&v);
}
} else if (V_ISARRAY(&obj->v)) {
convert_to_long(offset);
if (SafeArrayGetDim(V_ARRAY(&obj->v)) == 1) {
if (php_com_safearray_get_elem(&obj->v, &v, (LONG)Z_LVAL_P(offset))) {
php_com_wrap_variant(rv, &v, obj->code_page);
VariantClear(&v);
}
} else {
php_com_saproxy_create(object, rv, offset);
}
} else {
php_com_throw_exception(E_INVALIDARG, "this variant is not an array type");
}
return rv;
}
/**
* this is a big cover method that returns TRUE if
* the variant type is
* VT_EMPTY, VT_NULL, VT_ERROR or VT_DISPATCH with no dispatch object
* */
JNIEXPORT jboolean JNICALL Java_com_tangram_Variant_isVariantConsideredNull(JNIEnv *env, jobject _this)
{
VARIANT *v = extractVariant(env, _this);
if (!v) return JNI_TRUE;
if ((V_VT(v) & VT_ARRAY))
{
// is it a null safearray
// prior to 4 Dec 2005 the squiggle brackets were missing
// so this did the wrong thing for the else statement
if ((V_VT(v) & VT_BYREF)) {
if (!V_ARRAYREF(v)) return JNI_TRUE;
}
else {
if (!V_ARRAY(v)) return JNI_TRUE;
}
}
switch (V_VT(v))
{
case VT_EMPTY:
case VT_NULL:
case VT_ERROR:
return JNI_TRUE;
// is it a null dispatch (Nothing in VB)
case VT_DISPATCH:
if (!V_DISPATCH(v)) return JNI_TRUE;
}
return JNI_FALSE;
}
/*----------------------------------------------------------------------------------------------
Generate the sort key as a "SAFEARRAY".
----------------------------------------------------------------------------------------------*/
STDMETHODIMP LgIcuCollator::get_SortKeyVariant(BSTR bstrValue, LgCollatingOptions colopt,
VARIANT * psaKey)
{
BEGIN_COM_METHOD;
ChkComBstrArgN(bstrValue);
ChkComArgPtr(psaKey);
psaKey->vt = VT_NULL;
EnsureCollator();
int32_t cbKey = keySize;
byte rgbKey[keySize+1];
Vector<byte> vbKey;
byte * pbKey = GetSortKey(bstrValue, rgbKey, &cbKey, vbKey);
// Allocate the safe array.
SAFEARRAYBOUND rgsabound[1];
rgsabound[0].lLbound = 0;
rgsabound[0].cElements = cbKey;
SAFEARRAY FAR * psa = ::SafeArrayCreate(VT_UI1, 1, rgsabound);
// Copy the key data to the safe array.
byte * pbOut;
CheckHr(::SafeArrayAccessData(psa, (void HUGEP **)&pbOut));
memcpy(pbOut, pbKey, cbKey);
CheckHr(::SafeArrayUnaccessData(psa));
// Push the safe array to the output pointer.
psaKey->vt = VT_UI1 | VT_ARRAY;
V_ARRAY(psaKey) = psa;
return S_OK;
END_COM_METHOD(g_fact, IID_ILgCollatingEngine);
}
STDMETHODIMP CLabInput::GetSingleValues(VARIANT* values)
{
AUTO_LOCK; // Should not be needed inserted on a whim
if (!_isConfig)
DAQ_CHECK(Configure(FORSINGLEVALUE));
// 3 SCANS IS THE MIN with scan_op
SAFEARRAY *ps = SafeArrayCreateVector(VT_I2, 0, _nChannels*2);
if (ps==NULL) return E_SAFEARRAY_ERR;
// set the data type and values
V_ARRAY(values)=ps;
V_VT(values)=VT_ARRAY | VT_I2;
TSafeArrayAccess <short > binarray(values);
if (_nChannels<=2)
{
for (int i=0; i<_nChannels; i++)
{
DAQ_CHECK(AI_Read(_id, _chanList[i], _gainList[i], &binarray[i]));
}
}
else
{
// setup the channels to read and scan them
DAQ_TRACE(Set_DAQ_Device_Info(_id, ND_DATA_XFER_MODE_AI, ND_INTERRUPTS));
short *dummy=(short*)_alloca(_nChannels*sizeof(short));
DAQ_CHECK(Lab_ISCAN_Op(_id,static_cast<i16>(_nChannels),_gainList[0],&binarray[0],
_nChannels, 1.0/_chanSkew,0,dummy));
}
return S_OK;
}
static zval* saproxy_iter_get_data(zend_object_iterator *iter)
{
php_com_saproxy_iter *I = (php_com_saproxy_iter*)Z_PTR(iter->data);
VARIANT v;
VARTYPE vt;
SAFEARRAY *sa;
I->indices[I->proxy->dimensions-1] = I->key;
sa = V_ARRAY(&I->proxy->obj->v);
if (FAILED(SafeArrayGetVartype(sa, &vt)) || vt == VT_EMPTY) {
vt = V_VT(&I->proxy->obj->v) & ~VT_ARRAY;
}
VariantInit(&v);
if (vt == VT_VARIANT) {
SafeArrayGetElement(sa, I->indices, &v);
} else {
V_VT(&v) = vt;
SafeArrayGetElement(sa, I->indices, &v.lVal);
}
ZVAL_NULL(&I->data);
php_com_wrap_variant(&I->data, &v, I->proxy->obj->code_page);
VariantClear(&v);
return &I->data;
}
static void html_window_navigate(DocHost *This, IHTMLPrivateWindow *window, BSTR url, BSTR headers, SAFEARRAY *post_data)
{
VARIANT headers_var, post_data_var;
BSTR empty_str;
HRESULT hres;
hres = set_dochost_url(This, url);
if(FAILED(hres))
return;
empty_str = SysAllocStringLen(NULL, 0);
if(headers) {
V_VT(&headers_var) = VT_BSTR;
V_BSTR(&headers_var) = headers;
}else {
V_VT(&headers_var) = VT_EMPTY;
}
if(post_data) {
V_VT(&post_data_var) = VT_UI1|VT_ARRAY;
V_ARRAY(&post_data_var) = post_data;
}else {
V_VT(&post_data_var) = VT_EMPTY;
}
set_doc_state(This, READYSTATE_LOADING);
hres = IHTMLPrivateWindow_SuperNavigate(window, url, empty_str, NULL, NULL, &post_data_var, &headers_var, 0);
SysFreeString(empty_str);
if(FAILED(hres))
WARN("SuprtNavigate failed: %08x\n", hres);
}
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 unsigned long wire_extra_user_size(unsigned long *pFlags, unsigned long Start, VARIANT *pvar)
{
if (V_ISARRAY(pvar))
{
if (V_ISBYREF(pvar))
return LPSAFEARRAY_UserSize(pFlags, Start, V_ARRAYREF(pvar));
else
return LPSAFEARRAY_UserSize(pFlags, Start, &V_ARRAY(pvar));
}
switch (V_VT(pvar)) {
case VT_BSTR:
return BSTR_UserSize(pFlags, Start, &V_BSTR(pvar));
case VT_BSTR | VT_BYREF:
return BSTR_UserSize(pFlags, Start, V_BSTRREF(pvar));
case VT_VARIANT | VT_BYREF:
return VARIANT_UserSize(pFlags, Start, V_VARIANTREF(pvar));
case VT_UNKNOWN:
return Start + interface_variant_size(pFlags, &IID_IUnknown, pvar);
case VT_DISPATCH:
return Start + interface_variant_size(pFlags, &IID_IDispatch, pvar);
case VT_RECORD:
FIXME("wire-size record\n");
return Start;
case VT_SAFEARRAY:
case VT_SAFEARRAY | VT_BYREF:
FIXME("wire-size safearray: shouldn't be marshaling this\n");
return Start;
default:
return Start;
}
}
HRESULT WINAPI InitVariantFromBuffer(const VOID *pv, UINT cb, VARIANT *pvar)
{
SAFEARRAY *arr;
void *data;
HRESULT hres;
TRACE("(%p %u %p)\n", pv, cb, pvar);
arr = SafeArrayCreateVector(VT_UI1, 0, cb);
if(!arr)
return E_OUTOFMEMORY;
hres = SafeArrayAccessData(arr, &data);
if(FAILED(hres)) {
SafeArrayDestroy(arr);
return hres;
}
memcpy(data, pv, cb);
hres = SafeArrayUnaccessData(arr);
if(FAILED(hres)) {
SafeArrayDestroy(arr);
return hres;
}
V_VT(pvar) = VT_ARRAY|VT_UI1;
V_ARRAY(pvar) = arr;
return S_OK;
}
/**
* Finds the associated Win32_NetworkAdapterConfiguration for Win32_NetworkAdapter adapterObj.
* Iterates through the IP addresses associated with the adapter calling
* stringToAdaptorIp() to choose the highest priority address (according to EnumIPSelectionPriority)
* as the adapter address which is used to populate adapter->userData->ipAddr.
* If two addresses have the same highest priority, then the first one seen is chosen.
*/
static void readIpAddressesWin32(IWbemServices *pNamespace, IWbemClassObject *adapterObj, SFLAdaptor *adaptor)
{
IEnumWbemClassObject *configEnum;
HRESULT hr = associatorsOf(pNamespace, adapterObj,
L"Win32_NetworkAdapterSetting",
L"Win32_NetworkAdapterConfiguration",
L"Setting", &configEnum);
if (SUCCEEDED(hr)) {
IWbemClassObject *configObj;
ULONG configCount;
hr = configEnum->Next(WBEM_INFINITE, 1, &configObj, &configCount);
if (SUCCEEDED(hr) && configCount == 1) {
VARIANT addresses;
hr = configObj->Get(L"IPAddress", 0, &addresses, 0, 0);
if (WBEM_S_NO_ERROR == hr && addresses.vt == (VT_ARRAY | VT_BSTR)) {
SAFEARRAY *sa = V_ARRAY(&addresses);
LONG lstart, lend;
hr = SafeArrayGetLBound(sa, 1, &lstart);
hr = SafeArrayGetUBound(sa, 1, &lend);
BSTR *pbstr;
hr = SafeArrayAccessData(sa, (void HUGEP **)&pbstr);
if (SUCCEEDED(hr)) {
for (LONG idx=lstart; idx <= lend; idx++) {
PCWSTR addrStr = pbstr[idx];
stringToAdaptorIp(addrStr, adaptor);
}
SafeArrayUnaccessData(sa);
}
}
VariantClear(&addresses);
configObj->Release();
}
configEnum->Release();
}
}
/*
* call-seq:
* WIN32OLE_VARIANT.value #=> Ruby object.
*
* Returns Ruby object value from OLE variant.
* obj = WIN32OLE_VARIANT.new(1, WIN32OLE::VARIANT::VT_BSTR)
* obj.value # => "1" (not Integer object, but String object "1")
*
*/
static VALUE
folevariant_value(VALUE self)
{
struct olevariantdata *pvar;
VALUE val = Qnil;
VARTYPE vt;
int dim;
SAFEARRAY *psa;
TypedData_Get_Struct(self, struct olevariantdata, &olevariant_datatype, pvar);
val = ole_variant2val(&(pvar->var));
vt = V_VT(&(pvar->var));
if ((vt & ~VT_BYREF) == (VT_UI1|VT_ARRAY)) {
if (vt & VT_BYREF) {
psa = *V_ARRAYREF(&(pvar->var));
} else {
psa = V_ARRAY(&(pvar->var));
}
if (!psa) {
return val;
}
dim = SafeArrayGetDim(psa);
if (dim == 1) {
val = rb_funcall(val, rb_intern("pack"), 1, rb_str_new2("C*"));
}
}
return val;
}
void goToURL (const String& url,
const StringArray* headers,
const MemoryBlock* postData)
{
if (browser != nullptr)
{
LPSAFEARRAY sa = nullptr;
VARIANT flags, frame, postDataVar, headersVar; // (_variant_t isn't available in all compilers)
VariantInit (&flags);
VariantInit (&frame);
VariantInit (&postDataVar);
VariantInit (&headersVar);
if (headers != nullptr)
{
V_VT (&headersVar) = VT_BSTR;
V_BSTR (&headersVar) = SysAllocString ((const OLECHAR*) headers->joinIntoString ("\r\n").toWideCharPointer());
}
if (postData != nullptr && postData->getSize() > 0)
{
LPSAFEARRAY sa = SafeArrayCreateVector (VT_UI1, 0, (ULONG) postData->getSize());
if (sa != 0)
{
void* data = nullptr;
SafeArrayAccessData (sa, &data);
jassert (data != nullptr);
if (data != nullptr)
{
postData->copyTo (data, 0, postData->getSize());
SafeArrayUnaccessData (sa);
VARIANT postDataVar2;
VariantInit (&postDataVar2);
V_VT (&postDataVar2) = VT_ARRAY | VT_UI1;
V_ARRAY (&postDataVar2) = sa;
postDataVar = postDataVar2;
}
}
}
browser->Navigate ((BSTR) (const OLECHAR*) url.toWideCharPointer(),
&flags, &frame,
&postDataVar, &headersVar);
if (sa != 0)
SafeArrayDestroy (sa);
VariantClear (&flags);
VariantClear (&frame);
VariantClear (&postDataVar);
VariantClear (&headersVar);
}
}
static int com_object_count(zval *object, zend_long *count)
{
php_com_dotnet_object *obj;
LONG ubound = 0, lbound = 0;
obj = CDNO_FETCH(object);
if (!V_ISARRAY(&obj->v)) {
return FAILURE;
}
SafeArrayGetLBound(V_ARRAY(&obj->v), 1, &lbound);
SafeArrayGetUBound(V_ARRAY(&obj->v), 1, &ubound);
*count = ubound - lbound + 1;
return SUCCESS;
}
HRESULT navigate_url(DocHost *This, LPCWSTR url, const VARIANT *Flags,
const VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
{
task_navigate_bsc_t *task;
PBYTE post_data = NULL;
ULONG post_data_len = 0;
LPWSTR headers = NULL;
TRACE("navigating to %s\n", debugstr_w(url));
if((Flags && V_VT(Flags) != VT_EMPTY)
|| (TargetFrameName && V_VT(TargetFrameName) != VT_EMPTY))
FIXME("Unsupported args (Flags %p:%d; TargetFrameName %p:%d)\n",
Flags, Flags ? V_VT(Flags) : -1, TargetFrameName,
TargetFrameName ? V_VT(TargetFrameName) : -1);
if(PostData) {
TRACE("PostData vt=%d\n", V_VT(PostData));
if(V_VT(PostData) == (VT_ARRAY | VT_UI1)) {
SafeArrayAccessData(V_ARRAY(PostData), (void**)&post_data);
post_data_len = V_ARRAY(PostData)->rgsabound[0].cElements;
}
}
if(Headers && V_VT(Headers) != VT_EMPTY && V_VT(Headers) != VT_ERROR) {
if(V_VT(Headers) != VT_BSTR)
return E_INVALIDARG;
headers = V_BSTR(Headers);
TRACE("Headers: %s\n", debugstr_w(headers));
}
task = heap_alloc(sizeof(*task));
task->bsc = create_callback(This, url, post_data, post_data_len, headers);
if(post_data)
SafeArrayUnaccessData(V_ARRAY(PostData));
push_dochost_task(This, &task->header, navigate_bsc_proc, This->url == NULL);
return S_OK;
}
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));
}
HRESULT CDisk::GetFormat(VARIANT *buf, DSK_FORMAT **bufout, unsigned length)
{
long lBound, uBound;
unsigned char HUGEP* FAR pData;
SAFEARRAY *psa;
HRESULT hr;
unsigned n;
DSK_FORMAT *fmt;
if (V_VT(buf) != (VT_ARRAY | VT_UI1))
{
return Error("Passed parameter must be an array of unsigned characters", IID_IDisk, E_INVALIDARG);
}
psa = V_ARRAY(buf);
// Check dimensions of the array.
if (SafeArrayGetDim(psa) != 1)
{
return Error("Passed parameter must be a 1-dimensional array", IID_IDisk, E_INVALIDARG);
}
// Get array bounds.
hr = SafeArrayGetLBound(psa, 1, &lBound);
if (FAILED(hr))
{
return Error("Could not get array bounds", IID_IDisk, hr);
}
hr = SafeArrayGetUBound(psa, 1, &uBound);
if (FAILED(hr))
{
return Error("Could not get array bounds", IID_IDisk, hr);
}
if (uBound + 1 - lBound < (long)length*4)
{
return Error("Passed array is too short", IID_IDisk, E_INVALIDARG);
}
// Get a pointer to the elements of the array.
hr = SafeArrayAccessData(psa, (void HUGEP * FAR *)&pData);
if (FAILED(hr))
{
return Error("Could not access array data", IID_IDisk, E_INVALIDARG);
}
*bufout = (DSK_FORMAT *)dsk_malloc(length * sizeof(DSK_FORMAT));
if (!bufout) return MapError(DSK_ERR_NOMEM);
fmt = bufout[0];
for (n = 0; n < length; n++)
{
fmt->fmt_cylinder = *pData++;
fmt->fmt_head = *pData++;
fmt->fmt_sector = *pData++;
fmt->fmt_secsize = 128 << (*pData++);
++fmt;
}
SafeArrayUnaccessData(psa);
return S_OK;
}
HRESULT STDMETHODCALLTYPE CBandProxy::NavigateToPIDL(LPCITEMIDLIST pidl)
{
CComPtr<IOleWindow> oleWindow;
CComPtr<IServiceProvider> serviceProvider;
CComPtr<IUnknown> webBrowserUnknown;
CComPtr<IWebBrowser2> webBrowser;
HWND browserWindow;
CComVariant args;
CComVariant emptyVariant;
unsigned int arraySize;
HRESULT hResult;
hResult = FindBrowserWindow(&webBrowserUnknown);
if (FAILED_UNEXPECTEDLY(hResult))
return hResult;
hResult = webBrowserUnknown->QueryInterface(IID_PPV_ARG(IWebBrowser2, &webBrowser));
if (FAILED_UNEXPECTEDLY(hResult))
return hResult;
hResult = webBrowser->put_Visible(TRUE);
hResult = webBrowser->QueryInterface(IID_PPV_ARG(IServiceProvider, &serviceProvider));
if (SUCCEEDED(hResult))
{
hResult = serviceProvider->QueryService(SID_STopLevelBrowser,
IID_PPV_ARG(IOleWindow, &oleWindow));
if (SUCCEEDED(hResult))
{
hResult = oleWindow->GetWindow(&browserWindow);
if (IsIconic(browserWindow))
ShowWindow(browserWindow, SW_RESTORE);
}
}
arraySize = ILGetSize(pidl);
V_VT(&args) = VT_ARRAY | VT_UI1;
V_ARRAY(&args) = SafeArrayCreateVector(VT_UI1, 0, arraySize);
if (V_ARRAY(&args) == NULL)
return E_OUTOFMEMORY;
memcpy(V_ARRAY(&args)->pvData, pidl, arraySize);
hResult = webBrowser->Navigate2(&args, &emptyVariant, &emptyVariant, &emptyVariant, &emptyVariant);
if (FAILED_UNEXPECTEDLY(hResult))
return hResult;
return S_OK;
}
void SimpleBrowser::Print(LPCTSTR header,LPCTSTR footer)
{
if (m_pBrowser != NULL) {
// construct two element SAFEARRAY;
// first element is header string, second element is footer string
HRESULT hr;
VARIANT header_variant;
VariantInit(&header_variant);
V_VT(&header_variant) = VT_BSTR;
V_BSTR(&header_variant) = CString(header).AllocSysString();
VARIANT footer_variant;
VariantInit(&footer_variant);
V_VT(&footer_variant) = VT_BSTR;
V_BSTR(&footer_variant) = CString(footer).AllocSysString();
long index;
SAFEARRAYBOUND parameter_array_bound[1];
SAFEARRAY *parameter_array = NULL;
parameter_array_bound[0].cElements = 2;
parameter_array_bound[0].lLbound = 0;
parameter_array = SafeArrayCreate(VT_VARIANT,1,parameter_array_bound);
index = 0;
hr = SafeArrayPutElement(parameter_array,&index,&header_variant);
index = 1;
hr = SafeArrayPutElement(parameter_array,&index,&footer_variant);
VARIANT parameter;
VariantInit(¶meter);
V_VT(¶meter) = VT_ARRAY | VT_BYREF;
V_ARRAY(¶meter) = parameter_array;
// start printing browser contents
hr = m_pBrowser->ExecWB(OLECMDID_PRINT,OLECMDEXECOPT_DODEFAULT,¶meter,NULL);
// Note: There is no simple way to determine that printing has completed.
// In fact, if the browser is destroyed while printing is in progress,
// only part of the contents will be printed.
// release SAFEARRAY
if (!SUCCEEDED(hr)) {
VariantClear(&header_variant);
VariantClear(&footer_variant);
if (parameter_array != NULL) {
SafeArrayDestroy(parameter_array);
}
}
}
}
