STDMETHODIMP CScdSpVector::get_Vector(/*[in]*/ VARIANT_BOOL EnthalpyBasis, /*[out, retval]*/ SAFEARRAY **pVal)
{
dllSCD_COMENTRYGET(long, pVal)
{
SAFEARRAY *pSA=NULL;
SAFEARRAYBOUND bound[1]={SDB.Count()+3,0};
pSA=SafeArrayCreate(VT_R8, 1, bound);
double d;
long Cnt=bound[0].cElements;
for (long i=0; i<SDB.Count(); i++)
{
d=m_pOwn->Model()->VMass[i];
SafeArrayPutElement(pSA, &i, &d);
}
// NBNB EnthalpyBasis is ignored on "get"
d=m_pOwn->Model()->totHz(som_ALL, m_pOwn->Model()->Temp(), m_pOwn->Model()->Press());
SafeArrayPutElement(pSA, &i, &d);
i++;
d=m_pOwn->Model()->Temp();
SafeArrayPutElement(pSA, &i, &d);
i++;
d=m_pOwn->Model()->Press();
SafeArrayPutElement(pSA, &i, &d);
*pVal=pSA;
}
HRESULT CKhParser::GetNextHomonym( SAFEARRAY** lpHomonym )
{
if (currHom == -1)
return S_OK;
std::wstring str;
if (currHom < homonyms.size())
str = homonyms[currHom].khak;
else
str = homonyms[currHom % homonyms.size()].rus;
long idx, len, start;
len = (long)str.length();
SafeArrayLock(*lpHomonym);
SafeArrayGetUBound(*lpHomonym, 1, &len);
SafeArrayGetLBound(*lpHomonym, 1, &start);
short asterisk = L'*';
for (idx = start; idx < len; idx ++) {
if (idx == str.length()) {
// if (str[idx] == 0x0) {
SafeArrayPutElement(*lpHomonym, &idx, &asterisk);
break;
}
SafeArrayPutElement(*lpHomonym, &idx, &str[ idx ]);
}
SafeArrayUnlock(*lpHomonym);
currHom++;
return S_OK;
}
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");
}
}
void
addCircleThroughCom()
{
AutoCAD::IAcadApplication *pAcad;
AutoCAD::IAcadDocument *pDoc;
AutoCAD::IAcadModelSpace *pMSpace;
HRESULT hr = NOERROR;
LPUNKNOWN pUnk = NULL;
LPDISPATCH pAcadDisp = acedGetIDispatch(TRUE);
if(pAcadDisp==NULL)
return;
hr = pAcadDisp->QueryInterface(AutoCAD::IID_IAcadApplication,(void**)&pAcad);
pAcadDisp->Release();
if (FAILED(hr))
return;
hr = pAcad->get_ActiveDocument(&pDoc);
pAcad->Release();
if (FAILED(hr))
return;
hr = pDoc->get_ModelSpace(&pMSpace);
pDoc->Release();
if (FAILED(hr))
return;
SAFEARRAYBOUND rgsaBound;
rgsaBound.lLbound = 0L;
rgsaBound.cElements = 3;
long i;
SAFEARRAY* pStartPoint = NULL;
pStartPoint = SafeArrayCreate(VT_R8, 1, &rgsaBound);
i = 0;
double value = 4.0;
SafeArrayPutElement(pStartPoint, &i, &value);
i = 1;
value = 2.0;
SafeArrayPutElement(pStartPoint, &i, &value);
i = 2;
value = 0.0;
SafeArrayPutElement(pStartPoint, &i, &value);
VARIANT pt1;
pt1.vt = VT_ARRAY | VT_R8;
pt1.parray = pStartPoint;
AutoCAD::IAcadCircle *pCircle;
pMSpace->AddCircle(pt1, 2.0, &pCircle);
VariantClear(&pt1);
pMSpace->Release();
}
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);
}
}
}
}
/// <summary>
/// Loads and invokes the managed portion of the proxy.
/// </summary>
/// <param name="pInitMethod">Managed initialize method to be invoked.</param>
/// <param name="hSession">Handle to the installer session,
/// used for logging errors and to be passed on to the managed initialize method.</param>
/// <param name="szClassName">Name of the UI class to be loaded.
/// This must be of the form: AssemblyName!Namespace.Class</param>
/// <param name="pdwInternalUILevel">MSI install UI level passed to and returned from
/// the managed initialize method.</param>
/// <param name="puiResult">Return value of the invoked initialize method.</param>
/// <returns>True if the managed proxy was invoked successfully, or an
/// error code if there was some error. Note the initialize method itself may
/// return an error via puiResult while this method still returns true
/// since the invocation was successful.</returns>
bool InvokeInitializeMethod(_MethodInfo* pInitMethod, MSIHANDLE hSession, const wchar_t* szClassName, LPDWORD pdwInternalUILevel, UINT* puiResult)
{
VARIANT vResult;
VariantInit(&vResult);
VARIANT vNull;
vNull.vt = VT_EMPTY;
SAFEARRAY* saArgs = SafeArrayCreateVector(VT_VARIANT, 0, 3);
VARIANT vSessionHandle;
vSessionHandle.vt = VT_I4;
vSessionHandle.lVal = (LONG) hSession;
LONG index = 0;
HRESULT hr = SafeArrayPutElement(saArgs, &index, &vSessionHandle);
if (FAILED(hr)) goto LExit;
VARIANT vEntryPoint;
vEntryPoint.vt = VT_BSTR;
vEntryPoint.bstrVal = SysAllocString(szClassName);
if (vEntryPoint.bstrVal == NULL)
{
hr = E_OUTOFMEMORY;
goto LExit;
}
index = 1;
hr = SafeArrayPutElement(saArgs, &index, &vEntryPoint);
if (FAILED(hr)) goto LExit;
VARIANT vUILevel;
vUILevel.vt = VT_I4;
vUILevel.ulVal = *pdwInternalUILevel;
index = 2;
hr = SafeArrayPutElement(saArgs, &index, &vUILevel);
if (FAILED(hr)) goto LExit;
hr = pInitMethod->Invoke_3(vNull, saArgs, &vResult);
LExit:
SafeArrayDestroy(saArgs);
if (SUCCEEDED(hr))
{
*puiResult = (UINT) vResult.lVal;
if ((*puiResult & 0xFFFF) == 0)
{
// Due to interop limitations, the successful resulting UILevel is returned
// as the high-word of the return value instead of via a ref parameter.
*pdwInternalUILevel = *puiResult >> 16;
*puiResult = 0;
}
return true;
}
SEXP rCallStaticMethod(SEXP p) {
// 1 - Get data from SEXP
p = CDR(p); // Skip the first parameter: because function name
char* strTypeName = readStringFromSexp(p); p = CDR(p);
char* strMethodName = readStringFromSexp(p); p = CDR(p);
SAFEARRAY* parameters = readParametersFromSexp(p);
// 2 - Prepare arguments to call proxy
SAFEARRAY* args = SafeArrayCreateVector(VT_VARIANT, 0, 3);
long i = 0;
// 2.1 - Type name
variant_t typeName(strTypeName);
SafeArrayPutElement(args, &i, &typeName); i++;
// 2.2 - Method name
variant_t methodName(strMethodName);
SafeArrayPutElement(args, &i, &methodName); i++;
// 2.3 parameters
VARIANT* pvt = new variant_t();
VariantInit(pvt);
pvt->vt = VT_ARRAY | VT_I8;
pvt->parray = parameters;
SafeArrayPutElement(args, &i, pvt); i++;
// 3 - Call the proxy
CLR_OBJ result;
char* errorMsg;
HRESULT hr = callProxy(L"CallStaticMethod", args, &result, &errorMsg);
if(FAILED(hr)) {
Rprintf(errorMsg);
error("Exception during netCallStatic !");
free(errorMsg);
return R_NilValue;
}
// 4 - Free memory
SafeArrayDestroy(parameters);
SafeArrayDestroy(args);
//free_variant_array(pvt);
//free(strTypeName);
//free(strMethodName);
return convertToSEXP(result);
}
int wdGetArrayLengthScriptResult(WebDriver* driver, ScriptResult* result,
int* length)
{
// Prepare an array for the Javascript execution, containing only one
// element - the original returned array from a JS execution.
SAFEARRAYBOUND lengthQuery;
lengthQuery.cElements = 1;
lengthQuery.lLbound = 0;
SAFEARRAY* lengthArgs = SafeArrayCreate(VT_VARIANT, 1, &lengthQuery);
LONG index = 0;
SafeArrayPutElement(lengthArgs, &index, &(result->result));
CComVariant lengthVar;
int lengthResult = driver->ie->executeScript(
L"(function(){return function() {return arguments[0].length;}})();",
lengthArgs, &lengthVar);
SafeArrayDestroy(lengthArgs);
if (lengthResult != SUCCESS) {
return lengthResult;
}
// Expect the return type to be an integer. A non-integer means this was
// not an array after all.
if (lengthVar.vt != VT_I4) {
return EUNEXPECTEDJSERROR;
}
*length = lengthVar.lVal;
return SUCCESS;
}
void __declspec(dllexport) __stdcall
vbCSLToVariant( char **papszList, VARIANT *out_list )
{
USES_CONVERSION;
SAFEARRAYBOUND sBounds;
SAFEARRAY *result;
long i, nLength = CSLCount( papszList );
/* -------------------------------------------------------------------- */
/* Create safe array result. */
/* -------------------------------------------------------------------- */
sBounds.lLbound = 1;
sBounds.cElements = nLength;
result = SafeArrayCreate( VT_BSTR, 1, &sBounds );
for( i = 1; i <= nLength; i++ )
{
SafeArrayPutElement( result, &i,
SysAllocString( A2BSTR(papszList[i-1]) ) );
// MessageBox( NULL, papszList[i-1], "Metadata Item", MB_OK );
}
/* -------------------------------------------------------------------- */
/* Assign to variant. */
/* -------------------------------------------------------------------- */
VariantClear( out_list );
out_list->vt = VT_BSTR | VT_ARRAY;
out_list->parray = result;
}
template<typename T> T ExecuteMethod(mscorlib::_MethodInfoPtr method, std::vector<variant_t>& args)
{
variant_t obj;
T retObj;
SAFEARRAY * psa;
SAFEARRAYBOUND rgsabound[1];
rgsabound[0].lLbound = 0;
rgsabound[0].cElements = (ULONG)args.size();
psa = SafeArrayCreate(VT_VARIANT, 1, rgsabound);
for (LONG indicies = 0; indicies < (LONG)args.size(); ++indicies)
{
SafeArrayPutElement(psa, &indicies, &args[indicies]);
}
variant_t ret = method->Invoke_3(obj, psa);
if ((ret.vt == VT_UNKNOWN) || (ret.vt == VT_DISPATCH))
{
retObj = ret.punkVal;
}
SafeArrayDestroy(psa);
return retObj;
}
INT CADOParameters::Add(const BYTE *pBytes, INT iLen)
{
_ParameterPtr pParam;
// Create Parameter
HRESULT hr = pParam.CreateInstance(__uuidof(Parameter));
if (FAILED(hr))
_com_issue_error(hr);
// Set param for the value;
pParam->Direction = adParamInput;
pParam->Type = adBinary;
pParam->Size = iLen;
_variant_t var;
SAFEARRAY *psa = NULL;
SAFEARRAYBOUND rgsabound[1];
rgsabound[0].lLbound = 0L;
rgsabound[0].cElements = iLen;
psa = SafeArrayCreate(VT_UI1, 1, rgsabound);
if (NULL == psa)
_com_issue_error(E_OUTOFMEMORY);
for (LONG l=0; l<iLen; l++)
SafeArrayPutElement(psa, &l, (LPVOID)&pBytes[l]);
var.vt = VT_ARRAY|VT_UI1;
var.parray = psa;
pParam->AppendChunk(var);
return Add((_Parameter*)pParam);
}
STDMETHODIMP CFusionCHPHeaderCOM::get_AlgorithmParameters(VARIANT* pVal)
{
VariantInit(pVal);
pVal->vt = VT_ARRAY | VT_DISPATCH;
pVal->parray = NULL;
affymetrix_fusion_io::FusionTagValuePairTypeList values;
header->AlgorithmParameters(values);
int nparams = (int)values.size();
SAFEARRAYBOUND rgsaBound[1];
rgsaBound[0].lLbound = 0;
rgsaBound[0].cElements = nparams;
pVal->parray = SafeArrayCreate(VT_DISPATCH, 1, rgsaBound);
long index=0;
affymetrix_fusion_io::FusionTagValuePairTypeList::iterator it;
for (it=values.begin(); it!=values.end(); ++it)
{
CComPtr<IFusionTagValuePairType> param;
param.CoCreateInstance(CLSID_FusionTagValuePairType);
CFusionTagValuePairTypeCOM *pParam = static_cast<CFusionTagValuePairTypeCOM *>(param.p);
pParam->SetParam((*it));
HRESULT hr = SafeArrayPutElement(pVal->parray, &index, param);
++index;
}
return S_OK;
}
STDMETHODIMP CFusionCHPQuantificationDataCOM::get_SummaryParameters(VARIANT* pVal)
{
if (chp == NULL)
return E_FAIL;
VariantInit(pVal);
pVal->vt = VT_ARRAY | VT_DISPATCH;
pVal->parray = NULL;
affymetrix_calvin_parameter::ParameterNameValueTypeList params = chp->GetSummaryParams();
int nparams = (int)params.size();
SAFEARRAYBOUND rgsaBound[1];
rgsaBound[0].lLbound = 0;
rgsaBound[0].cElements = nparams;
pVal->parray = SafeArrayCreate(VT_DISPATCH, 1, rgsaBound);
long index=0;
affymetrix_calvin_parameter::ParameterNameValueTypeList::iterator it;
for (it=params.begin(); it!=params.end(); ++it)
{
CComPtr<IFusionTagValuePairType> param;
affymetrix_fusion_io::FusionTagValuePairType fparam;
param.CoCreateInstance(CLSID_FusionTagValuePairType);
CFusionTagValuePairTypeCOM *pParam = static_cast<CFusionTagValuePairTypeCOM *>(param.p);
fparam.Tag = it->GetName();
fparam.Value = it->ToString();
pParam->SetParam(fparam);
HRESULT hr = SafeArrayPutElement(pVal->parray, &index, param);
++index;
}
return S_OK;
}
STDMETHODIMP CFusionCHPHeaderCOM::GetBackgroundZones(VARIANT *zones)
{
VariantInit(zones);
zones->vt = VT_ARRAY | VT_DISPATCH;
zones->parray = NULL;
affxchp::BackgroundZoneTypeList czones;
header->GetBackgroundZones(czones);
int nzones = (int)czones.size();
SAFEARRAYBOUND rgsaBound[1];
rgsaBound[0].lLbound = 0;
rgsaBound[0].cElements = nzones;
zones->parray = SafeArrayCreate(VT_DISPATCH, 1, rgsaBound);
long index=0;
affxchp::BackgroundZoneTypeList::iterator it;
for (it=czones.begin(); it!=czones.end(); ++it)
{
CComPtr<IBackgroundZoneType> z;
z.CoCreateInstance(CLSID_BackgroundZoneType);
CBackgroundZoneTypeCOM *pz = static_cast<CBackgroundZoneTypeCOM *>(z.p);
pz->SetBg(*it);
HRESULT hr = SafeArrayPutElement(zones->parray, &index, z);
++index;
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE SumatraUIAutomationDocumentProvider::GetVisibleRanges(SAFEARRAY** pRetVal) {
if (pRetVal == nullptr)
return E_POINTER;
if (released)
return E_FAIL;
// return all pages' ranges that are even partially visible
Vec<SumatraUIAutomationTextRange*> rangeArray;
SumatraUIAutomationPageProvider* it = child_first;
while (it && rangeArray.size() > ULONG_MAX) {
if (it->dm->GetPageInfo(it->pageNum) && it->dm->GetPageInfo(it->pageNum)->shown &&
it->dm->GetPageInfo(it->pageNum)->visibleRatio > 0.0f) {
rangeArray.Append(new SumatraUIAutomationTextRange(this, it->pageNum));
}
it = it->sibling_next;
}
CrashIf(ULONG_MAX == rangeArray.size());
SAFEARRAY* psa = SafeArrayCreateVector(VT_UNKNOWN, 0, (ULONG)rangeArray.size());
if (!psa) {
for (size_t i = 0; i < rangeArray.size(); i++) {
rangeArray[i]->Release();
}
return E_OUTOFMEMORY;
}
for (LONG i = 0; i < (LONG)rangeArray.size(); i++) {
HRESULT hr = SafeArrayPutElement(psa, &i, rangeArray[i]);
CrashIf(FAILED(hr));
rangeArray[i]->Release();
}
*pRetVal = psa;
return S_OK;
}
IFACEMETHODIMP AccessibleSelectionProvider::GetSelection(SAFEARRAY **pRetVal) {
LOG("In AccessibleSelectionProvider::GetSelection\n");
LOG(" this: %p\n", this);
if (pRetVal == NULL)
return E_INVALIDARG;
JNIEnv* env = GetEnv();
jlongArray selectedElements = static_cast<jlongArray>(env->CallObjectMethod(m_self, midGetSelection));
if( selectedElements == NULL )
return S_OK;
jint size = env->GetArrayLength(selectedElements);
if (size != 0) {
//LOG(" size: %d\n", size);
jlong* selectedElementsPatterns = env->GetLongArrayElements(selectedElements, JNI_FALSE);
SAFEARRAY *psaElements = SafeArrayCreateVector(VT_I4, 0, size);
if (psaElements == NULL) {
return E_OUTOFMEMORY;
}
for (LONG idx = 0; idx < size; idx++) {
LOG(" idx: %d\n", idx);
LOG(" selectedElements: %p\n", reinterpret_cast<void*>(jlong_to_ptr(selectedElementsPatterns[idx])) );
SafeArrayPutElement(psaElements, &idx, (void*)(jlong_to_ptr(selectedElementsPatterns[idx])));
}
env->ReleaseLongArrayElements(selectedElements, selectedElementsPatterns, JNI_FALSE);
*pRetVal = psaElements;
} else
LOG("AccessibleSelectionProvider size=%d\n" , size);
return S_OK;
}
void ImportDotXSI()
{
CComPtr<XSIApplication> l_pApplication;
CLSID lclsid;
CLSIDFromProgID(L"XSI.Application", &lclsid );
CoCreateInstance(lclsid, NULL, CLSCTX_INPROC, IID_XSIApplication, (void **)&l_pApplication);
_variant_t args;
_variant_t v;
long l = 0 ;
SAFEARRAY* psa = NULL;
const int cntArgs = 1 ;
psa = ::SafeArrayCreateVector( VT_VARIANT, 0, cntArgs );
args.vt = VT_VARIANT | VT_ARRAY;
args.parray = psa;
v = _bstr_t ( "c:\\__tmp.xsi" );
SafeArrayPutElement(psa, &l, &v);
l++;
// more args?
//
VARIANT l_vOutValue;
l_pApplication->ExecuteScriptCommand( _bstr_t( L"SIImportDotXSIFile" ), args, &l_vOutValue ) ;
}
//local helpers:
static FC_ARSTAT NodeListToSafeArray(FC_CGArray<FC_CArNode*>* pNList, SAFEARRAY** ppsa)
{
HRESULT hr;
SAFEARRAY* psa;
long i;
long nNodes;
FC_CArNode* pNode;
const TCHAR* pId;
BSTR bstr;
if(!ppsa)
return FC_AR_OK;
*ppsa = NULL;
nNodes = pNList->getUsed();
psa = SafeArrayCreateVector(VT_BSTR, 0, nNodes);
if(!psa)
return FC_AR_OUTOFMEM;
for(i=0; i<nNodes; i++)
{
pNode = pNList->get(i);
pId = pNode->getName();
#ifdef UNICODE
bstr = SysAllocString(pId);
hr = SafeArrayPutElement(psa, &i, bstr);
SysFreeString(bstr);
#else
wchar_t wBuffer[3*MAX_PATH];
int iOk = FC_StringToWideChar(pId, wBuffer, FC_ARRAY_LEN(wBuffer));
assert(iOk>0);
bstr = SysAllocString(wBuffer);
hr = SafeArrayPutElement(psa, &i, bstr);
SysFreeString(bstr);
#endif
if(FAILED(hr))
{
SafeArrayDestroy(psa);
return FC_AR_OUTOFMEM;
}
}
*ppsa = psa;
return FC_AR_OK;
}
void CAddIn::PutNParam(SAFEARRAY *pArray,long lIndex,VARIANT vt)
{
ASSERT(pArray);
ASSERT(pArray->fFeatures | FADF_VARIANT);
HRESULT hRes = SafeArrayPutElement(pArray,&lIndex,&vt);
ASSERT(hRes == S_OK);
}
HRESULT CPyCOMTest::TestOptionals2(double dval, BSTR strval, short sval, SAFEARRAY **pRet)
{
HRESULT hr = S_OK;
SAFEARRAY *psa;
SAFEARRAYBOUND rgsabound[1] = { 3, 0 };
psa = SafeArrayCreate(VT_VARIANT, 1, rgsabound);
long ix[1];
CComVariant v(dval);
ix[0] = 0;
SafeArrayPutElement(psa, ix, &v);
v = strval;
ix[0] = 1;
SafeArrayPutElement(psa, ix, &v);
v = sval;
ix[0] = 2;
SafeArrayPutElement(psa, ix, &v);
*pRet = psa;
return hr;
}
bool com_array_reader::convert_jsarray(IDispatch * pdisp)
{
if (!pdisp) return false;
DISPPARAMS params = {0};
_variant_t ret;
DISPID id_length;
LPOLESTR slength = L"length";
if (FAILED(pdisp->GetIDsOfNames(IID_NULL, &slength, 1, LOCALE_USER_DEFAULT, &id_length)))
return false;
if (FAILED(pdisp->Invoke(id_length, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET,
¶ms, &ret, NULL, NULL)))
return false;
if (FAILED(VariantChangeType(&ret, &ret, 0, VT_I4)))
return false;
m_lbound = 0;
m_ubound = ret.lVal - 1;
SAFEARRAY * psa = SafeArrayCreateVector(VT_VARIANT, 0, get_count());
if (!psa) goto cleanup_and_return;
for (long i = m_lbound; i <= m_ubound; ++i)
{
DISPID dispid = 0;
DISPPARAMS params = {0};
wchar_t buf[33];
LPOLESTR name = buf;
_variant_t element;
HRESULT hr = S_OK;
_itow_s(i, buf, 10);
if (SUCCEEDED(hr)) hr = pdisp->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid);
if (SUCCEEDED(hr)) hr = pdisp->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET,
¶ms, &element, NULL, NULL);
if (FAILED(hr)) goto cleanup_and_return;
if (FAILED(SafeArrayPutElement(psa, &i, &element))) goto cleanup_and_return;
}
m_psa = psa;
return true;
cleanup_and_return:
reset();
SafeArrayDestroy(psa);
return false;
}
INT __stdcall EmbeddedUIHandler(UINT uiMessageType, MSIHANDLE hRecord)
{
if (g_pProcessMessageMethod == NULL)
{
// Initialization was canceled.
return IDCANCEL;
}
VARIANT vResult;
VariantInit(&vResult);
VARIANT vNull;
vNull.vt = VT_EMPTY;
SAFEARRAY* saArgs = SafeArrayCreateVector(VT_VARIANT, 0, 2);
VARIANT vMessageType;
vMessageType.vt = VT_I4;
vMessageType.lVal = (LONG) uiMessageType;
LONG index = 0;
HRESULT hr = SafeArrayPutElement(saArgs, &index, &vMessageType);
if (FAILED(hr)) goto LExit;
VARIANT vRecord;
vRecord.vt = VT_I4;
vRecord.lVal = (LONG) hRecord;
index = 1;
hr = SafeArrayPutElement(saArgs, &index, &vRecord);
if (FAILED(hr)) goto LExit;
hr = g_pProcessMessageMethod->Invoke_3(vNull, saArgs, &vResult);
LExit:
SafeArrayDestroy(saArgs);
if (SUCCEEDED(hr))
{
return vResult.intVal;
}
else
{
return -1;
}
}
HRESULT CContextPlugin::CreateArrayOfEvents( VARIANT *pvarEvents, WMS_EVENT_TYPE *pWMSEvents, long nNumEvents)
{
HRESULT hr = S_OK;
long iEvents = 0;
SAFEARRAY *psa = NULL;
SAFEARRAYBOUND rgsabound[1];
if( NULL == pvarEvents )
{
return( E_POINTER );
}
if( NULL == pWMSEvents || 0 >= nNumEvents )
{
return( E_INVALIDARG );
}
rgsabound[0].lLbound = 0;
rgsabound[0].cElements = nNumEvents;
psa = SafeArrayCreate( VT_VARIANT, 1, rgsabound );
if( NULL == psa )
{
return ( E_OUTOFMEMORY );
}
for( iEvents = 0; iEvents < nNumEvents && SUCCEEDED( hr ); iEvents++ )
{
VARIANT varElement;
VariantInit( &varElement );
V_VT( &varElement ) = VT_I4;
V_I4( &varElement ) = pWMSEvents[ iEvents ];
hr = SafeArrayPutElement( psa, &iEvents, &varElement );
VariantClear( &varElement );
}
if( FAILED( hr ) )
{
SafeArrayDestroy( psa );
psa = NULL;
}
else
{
V_VT( pvarEvents ) = VT_ARRAY | VT_VARIANT;
V_ARRAY( pvarEvents ) = psa;
}
return ( hr );
}
static void
fillSafeArray (
Tcl_Obj *pList,
SAFEARRAY *psa,
unsigned dim,
long *pIndices,
Tcl_Interp *interp,
bool addRef)
{
HRESULT hr;
// Get index range.
long lowerBound;
hr = SafeArrayGetLBound(psa, dim, &lowerBound);
if (FAILED(hr)) {
_com_issue_error(hr);
}
long upperBound;
hr = SafeArrayGetUBound(psa, dim, &upperBound);
if (FAILED(hr)) {
_com_issue_error(hr);
}
int numElements;
Tcl_Obj **pElements;
if (Tcl_ListObjGetElements(interp, pList, &numElements, &pElements)
!= TCL_OK) {
_com_issue_error(E_INVALIDARG);
}
unsigned dim1 = dim - 1;
if (dim < SafeArrayGetDim(psa)) {
// Create list of list for multi-dimensional array.
for (int i = 0; i < numElements; ++i) {
pIndices[dim1] = i;
fillSafeArray(pElements[i], psa, dim + 1, pIndices, interp, addRef);
}
} else {
for (int i = 0; i < numElements; ++i) {
TclObject element(pElements[i]);
NativeValue elementVar;
element.toNativeValue(&elementVar, Type::variant(), interp, addRef);
pIndices[dim1] = i;
hr = SafeArrayPutElement(psa, pIndices, &elementVar);
if (FAILED(hr)) {
_com_issue_error(hr);
}
}
}
}
int wdAddStringScriptArg(ScriptArgs* scriptArgs, const wchar_t* arg)
{
std::wstring value(arg);
CComVariant dest(arg);
LONG index = scriptArgs->currentIndex;
SafeArrayPutElement(scriptArgs->args, &index, &dest);
scriptArgs->currentIndex++;
return SUCCESS;
}
void DensoRobot::Start()
{
/* Start the motor */
CComVariant pVal; // probably empty
hr = pRobot->Execute(CComBSTR(L"Motor"), CComVariant(L"1"), &pVal);
if(FAILED(hr)) throw exception("Failed to start the robot motor!");
/* Set the external robot speed TO DO*/
CComVariant parameters;
parameters.vt = VT_ARRAY | VT_VARIANT;
SAFEARRAYBOUND bounds[1];
bounds[0].lLbound = 0;
bounds[0].cElements = 3;
parameters.parray = SafeArrayCreate(VT_VARIANT, 1, bounds);
CComVariant varSpeed;
varSpeed.vt = VT_R4;
varSpeed.fltVal = (float)this->robotSpeed;
CComVariant varAcceleration;
varAcceleration.vt = VT_R4;
varAcceleration.fltVal = (float)(this->robotSpeed*this->robotSpeed/100);
CComVariant varDeceleration;
varDeceleration.vt = VT_R4;
varDeceleration.fltVal = (float)(this->robotSpeed*this->robotSpeed/100);
long index = 0;
SafeArrayPutElement(parameters.parray, &index, &varSpeed);
index = 1;
SafeArrayPutElement(parameters.parray, &index, &varAcceleration);
index = 2;
SafeArrayPutElement(parameters.parray, &index, &varDeceleration);
CComVariant vntDummy;
hr = pRobot->Execute(CComBSTR(L"ExtSpeed"), parameters, &vntDummy);
if(FAILED(hr)) throw exception("Failed to set the external robot speed!");
parameters.Clear();
}
int wdAddElementScriptArg(ScriptArgs* scriptArgs, WebElement* element)
{
VARIANT dest;
dest.vt = VT_DISPATCH;
dest.pdispVal = element->element->getWrappedElement();
LONG index = scriptArgs->currentIndex;
SafeArrayPutElement(scriptArgs->args, &index, &dest);
scriptArgs->currentIndex++;
return SUCCESS;
}
int wdAddNumberScriptArg(ScriptArgs* scriptArgs, long number)
{
VARIANT dest;
dest.vt = VT_I4;
dest.lVal = (LONG) number;
LONG index = scriptArgs->currentIndex;
SafeArrayPutElement(scriptArgs->args, &index, &dest);
scriptArgs->currentIndex++;
return SUCCESS;
}
int wdAddBooleanScriptArg(ScriptArgs* scriptArgs, int trueOrFalse)
{
VARIANT dest;
dest.vt = VT_BOOL;
dest.boolVal = trueOrFalse == 1;
LONG index = scriptArgs->currentIndex;
SafeArrayPutElement(scriptArgs->args, &index, &dest);
scriptArgs->currentIndex++;
return SUCCESS;
}
SEXP rSetStatic(SEXP p) {
// 1 - Get data from SEXP
p = CDR(p); // Skip the first parameter: because function name
char* strTypeName = readStringFromSexp(p); p = CDR(p);
char* strPropertyName = readStringFromSexp(p); p = CDR(p);
LONGLONG valueAddresse = (LONGLONG)CAR(p);
// 2 - Prepare arguments to call proxy
SAFEARRAY* args = SafeArrayCreateVector(VT_VARIANT, 0, 3);
long i = 0;
// 2.1 - Type name
variant_t typeName(strTypeName);
SafeArrayPutElement(args, &i, &typeName); i++;
// 2.2 - Method name
variant_t propertyName(strPropertyName);
SafeArrayPutElement(args, &i, &propertyName); i++;
// 2.3 property value
variant_t value(valueAddresse);
SafeArrayPutElement(args, &i, &value); i++;
// 3 - Call the proxy
CLR_OBJ result;
char* errorMsg;
HRESULT hr = callProxy(L"SetStaticProperty", args, &result, &errorMsg);
if(FAILED(hr)) {
Rprintf(errorMsg);
error("Exception during netSetStatic !");
free(errorMsg);
return R_NilValue;
}
SafeArrayDestroy(args);
return R_NilValue;
}