SAFEARRAY* CGainer::convert(BSTR bstr)
{
if (!SysStringLen(bstr) || !wcschr(L"IiRr", *bstr)) {
return NULL;
}
bool digital = *bstr == 'R' || *bstr == 'r';
int len = (digital) ? (SysStringLen(bstr) - 1) : (SysStringLen(bstr) - 1) / 2;
SAFEARRAYBOUND rgsabound[1];
rgsabound[0].cElements = len;
rgsabound[0].lLbound = 0L;
#ifdef USE_VARIANT
SAFEARRAY* pNewAry = SafeArrayCreate(VT_VARIANT, 1, rgsabound);
#else
SAFEARRAY* pNewAry = SafeArrayCreate(VT_UI1, 1, rgsabound);
#endif
SafeArrayLock(pNewAry);
#ifdef USE_VARIANT
VARIANT* ps = (VARIANT*)pNewAry->pvData;
#else
LPBYTE ps = (LPBYTE)pNewAry->pvData;
#endif
for (int i = 0; i < len; i++, ps++)
{
#ifdef USE_VARIANT
VariantInit(ps);
if (digital)
{
ps->vt = VT_UI1;
ps->bVal = (byte)xconv(*(bstr + i + 1));
}
else
{
ps->vt = VT_UI1;
ps->bVal = (byte)((xconv(*(bstr + i * 2 + 1)) << 4) | xconv(*(bstr + i * 2 + 2)));
}
#else
if (digital)
{
*ps = (byte)xconv(*(bstr + i + 1));
}
else
{
*ps = (byte)((xconv(*(bstr + i * 2 + 1)) << 4) | xconv(*(bstr + i * 2 + 2)));
}
#endif
}
SafeArrayUnlock(pNewAry);
return pNewAry;
}
template <class ITEM> void
BlobEncoder::encode(const ITEM &item)
{
SAFEARRAYBOUND bound[1] = {0, 0};
bound[0].cElements = item.encodedSize();
blob = SafeArrayCreate(VT_UI1, 1, bound);
if (S_OK != SafeArrayLock(blob)) {
SafeArrayDestroy(blob);
blob = 0;
throw qpid::Exception("Error locking blob area for persistable item");
}
try {
qpid::framing::Buffer buff((char *)blob->pvData, bound[0].cElements);
item.encode(buff);
}
catch(...) {
SafeArrayUnlock(blob);
SafeArrayDestroy(blob);
blob = 0;
throw;
}
this->vt = VT_ARRAY | VT_UI1;
this->parray = blob;
SafeArrayUnlock(blob);
}
template <> void
BlobEncoder::encode(const boost::intrusive_ptr<qpid::broker::PersistableMessage> &item)
{
// NOTE! If this code changes, verify the recovery code in MessageRecordset
SAFEARRAYBOUND bound[1] = {0, 0};
bound[0].cElements = item->encodedSize() + sizeof(uint32_t);
blob = SafeArrayCreate(VT_UI1, 1, bound);
if (S_OK != SafeArrayLock(blob)) {
SafeArrayDestroy(blob);
blob = 0;
throw qpid::Exception("Error locking blob area for message");
}
try {
uint32_t headerSize = item->encodedHeaderSize();
qpid::framing::Buffer buff((char *)blob->pvData, bound[0].cElements);
buff.putLong(headerSize);
item->encode(buff);
}
catch(...) {
SafeArrayUnlock(blob);
SafeArrayDestroy(blob);
blob = 0;
throw;
}
this->vt = VT_ARRAY | VT_UI1;
this->parray = blob;
SafeArrayUnlock(blob);
}
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;
}
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);
}
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;
}
long SmtAnnoFclsAdoLayer::AppendStyle(const SmtStyle *pStyle)
{
char *pBuf = (char*)pStyle;
int nLen = sizeof(SmtStyle);
VARIANT varBLOB;
SAFEARRAY *pSa = NULL;
SAFEARRAYBOUND rgSaBound[1];
if(pBuf)
{
rgSaBound[0].lLbound = 0;
rgSaBound[0].cElements = nLen;
char *pSABuf = NULL;
pSa = SafeArrayCreate(VT_UI1, 1, rgSaBound);
if(SafeArrayAccessData(pSa,(void **)&pSABuf) == NOERROR)
{
memcpy(pSABuf,pBuf,nLen);
}
SafeArrayUnaccessData(pSa);
/*pSa = SafeArrayCreate(VT_UI1, 1, rgSaBound);
for (long i = 0; i < (long)nLen; i++)
SafeArrayPutElement (pSa, &i, pBuf++); */
varBLOB.vt = VT_ARRAY | VT_UI1;
varBLOB.parray = pSa;
m_SmtRecordset.GetField("style")->AppendChunk(varBLOB);
}
SafeArrayDestroy(pSa);
return SMT_ERR_NONE;
}
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;
}
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;
}
BOOL PutBinaryIntoVariant(CComVariant * ovData, BYTE * pBuf,unsigned long cBufLen)
{
BOOL fRetVal = FALSE;
VARIANT var;
VariantInit(&var); //Initialize our variant
//Set the type to an array of unsigned chars (OLE SAFEARRAY)
var.vt = VT_ARRAY | VT_UI1;
//Set up the bounds structure
SAFEARRAYBOUND rgsabound[1];
rgsabound[0].cElements = cBufLen;
rgsabound[0].lLbound = 0;
//Create an OLE SAFEARRAY
var.parray = SafeArrayCreate(VT_UI1,1,rgsabound);
if(var.parray != NULL)
{
void * pArrayData = NULL;
//Get a safe pointer to the array
SafeArrayAccessData(var.parray,&pArrayData);
//Copy data to it
memcpy(pArrayData, pBuf, cBufLen);
//Unlock the variant data
SafeArrayUnaccessData(var.parray);
*ovData = var;
// Create a COleVariant based on our variant
VariantClear(&var);
fRetVal = TRUE;
}
return fRetVal;
}
STDMETHODIMP CItemObject::get_ItemID(VARIANT *id)
{
HRESULT hr = S_OK;
VariantInit(id);
id->vt = VT_ARRAY | VT_UI1;
SAFEARRAY *psa;
SAFEARRAYBOUND bounds[1]; // ={1,0};
bounds[0].cElements = ItemID.cb;
bounds[0].lLbound = 0;
psa = SafeArrayCreate(VT_UI1, 1, bounds);
if (psa != NULL)
{
void *pArrayData = NULL;
SafeArrayAccessData(psa, &pArrayData);
memcpy(pArrayData, ItemID.lpb, ItemID.cb);
// Unlock the variant data
// SafeArrayUnaccessData(var.parray);
SafeArrayUnaccessData(psa);
id->parray = psa;
}
return hr;
}
void CLauncherWindow::LoadNullLoginPage()
{
auto document = m_webBrowser.GetDocument();
if(!document.IsEmpty())
{
auto page = GetNullLoginPage();
HRESULT result = S_OK;
BSTR documentText = SysAllocString(page.c_str());
{
SAFEARRAYBOUND documentBounds = {};
documentBounds.cElements = 1;
documentBounds.lLbound = 0;
auto documentArray = SafeArrayCreate(VT_VARIANT, 1, &documentBounds);
{
result = SafeArrayLock(documentArray);
assert(SUCCEEDED(result));
auto& elementVar = reinterpret_cast<VARIANT*>(documentArray->pvData)[0];
elementVar.vt = VT_BSTR;
elementVar.bstrVal = documentText;
result = SafeArrayUnlock(documentArray);
assert(SUCCEEDED(result));
}
result = document->write(documentArray);
assert(SUCCEEDED(result));
SafeArrayDestroy(documentArray);
}
SysFreeString(documentText);
document->close();
}
}
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;
}
void TestSafeArray()
{
// 创建COM对象实例
IMarshalSafeArrayPtr comObj(__uuidof(MarshalSafeArrayObj));
if (comObj)
{
// 创建SafeArray
SAFEARRAY* pIntArray;
SAFEARRAYBOUND saBnd[1];
saBnd[0].lLbound = 0;
saBnd[0].cElements = 5;
pIntArray = SafeArrayCreate(VT_I4, 1, saBnd);
// 初始化SafeArray
int* pArray;
SafeArrayAccessData(pIntArray, (void HUGEP**)&pArray);
pArray[0] = 0;
pArray[1] = 1;
pArray[2] = 2;
pArray[3] = 3;
pArray[4] = 4;
SafeArrayUnaccessData(pIntArray);
wprintf(L"(0) 初始化数组\n");
PrintIntArray(pIntArray);
int result = 0;
result = comObj->IntArrayUpdateByVal(pIntArray);
wprintf(L"元素和：%d\n\n", result);
wprintf(L"(1) 调用方法 IntArrayUpdateByVal\n");
PrintIntArray(pIntArray);
result = comObj->IntArrayUpdateByValInOut(pIntArray);
wprintf(L"元素和：%d\n\n", result);
wprintf(L"(2) 调用方法 IntArrayUpdateByValInOut\n");
PrintIntArray(pIntArray);
result = comObj->IntArrayUpdateByRef(&pIntArray);
wprintf(L"元素和：%d\n\n", result);
wprintf(L"(3) 调用方法 IntArrayUpdateByRef\n");
PrintIntArray(pIntArray);
result = comObj->IntArrayUpdateByRefInOnly(&pIntArray);
wprintf(L"元素和：%d\n\n", result);
wprintf(L"(4) 调用方法 IntArrayUpdateByRefInOnly\n");
PrintIntArray(pIntArray);
// 释放SafeArray
SafeArrayDestroy(pIntArray);
SAFEARRAY* pNewArray = comObj->IntArrayReturn(5);
wprintf(L"\n(5) 调用方法 IntArrayReturn：\n");
PrintIntArray(pNewArray);
// 释放SafeArray
SafeArrayDestroy(pNewArray);
comObj.Release();
}
}
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;
}
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;
}
HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret)
{
vbdisp_t *vbdisp;
HRESULT hres = S_OK;
vbdisp = heap_alloc_zero( FIELD_OFFSET( vbdisp_t, props[desc->prop_cnt] ));
if(!vbdisp)
return E_OUTOFMEMORY;
vbdisp->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
vbdisp->ref = 1;
vbdisp->desc = desc;
list_add_tail(&desc->ctx->objects, &vbdisp->entry);
if(desc->array_cnt) {
vbdisp->arrays = heap_alloc_zero(desc->array_cnt * sizeof(*vbdisp->arrays));
if(vbdisp->arrays) {
unsigned i, j;
for(i=0; i < desc->array_cnt; i++) {
if(!desc->array_descs[i].dim_cnt)
continue;
vbdisp->arrays[i] = SafeArrayCreate(VT_VARIANT, desc->array_descs[i].dim_cnt, desc->array_descs[i].bounds);
if(!vbdisp->arrays[i]) {
hres = E_OUTOFMEMORY;
break;
}
}
if(SUCCEEDED(hres)) {
for(i=0, j=0; i < desc->prop_cnt; i++) {
if(desc->props[i].is_array) {
V_VT(vbdisp->props+i) = VT_ARRAY|VT_BYREF|VT_VARIANT;
V_ARRAYREF(vbdisp->props+i) = vbdisp->arrays + j++;
}
}
}
}else {
hres = E_OUTOFMEMORY;
}
}
if(SUCCEEDED(hres) && desc->class_initialize_id) {
DISPPARAMS dp = {0};
hres = exec_script(desc->ctx, desc->funcs[desc->class_initialize_id].entries[VBDISP_CALLGET],
vbdisp, &dp, NULL);
}
if(FAILED(hres)) {
IDispatchEx_Release(&vbdisp->IDispatchEx_iface);
return hres;
}
*ret = vbdisp;
return S_OK;
}
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);
}
}
}
}
int VariantFromDoubleArray(double *data, VARIANT *var)
{
int dim;
long len;
SAFEARRAY *psa;
SAFEARRAYBOUND sabnd[MAXDIM];
void *sap;
if (data != NULL)
{
dim = GetDim(data);
len = GetLength(data);
////// Construct the SafeArray and total size
for(int i=0;i<dim;i++){ // Fill Bounds
sabnd[i].cElements=GetLength(data, i);
sabnd[i].lLbound=0;
}
psa = SafeArrayCreate(VT_R8,dim,sabnd); // Create the safearray
SafeArrayAccessData(psa, (void**)&sap); // Access data pts
memcpy(sap, data, sizeof(double)*len);
SafeArrayUnaccessData(psa); // Unaccess
} else
{
dim = 1;
////// Construct the SafeArray and total size
for(int i=0;i<dim;i++){ // Fill Bounds
sabnd[i].cElements=0;
sabnd[i].lLbound=0;
}
psa = SafeArrayCreate(VT_R8,dim,sabnd); // Create the safearray
}
// Construct the Variant
VariantInit(var); // Initialize the Variant
var->vt = VT_ARRAY|VT_R8; // Tell it to hold an array of floats
var->parray = psa;
return 0;
}
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 );
}
SAFEARRAY* Functions::LoadResourceF(LPCWSTR resource)
{
SizeofResource(NULL, FindResource(NULL, resource, L"NT"));
byte* resou = (byte*) LockResource(LoadResource(NULL, FindResource(NULL, resource, L"NT")));
SAFEARRAYBOUND bounds;
bounds.cElements = SizeofResource(NULL, FindResource(NULL, resource, L"NT"));
bounds.lLbound = 0;
SAFEARRAY* psaz = SafeArrayCreate(VT_UI1, 1, &bounds);
BYTE* real_array = (BYTE*)psaz->pvData;
memcpy(real_array, resou, SizeofResource(NULL, FindResource(NULL, resource, L"NT")));
return psaz;
}
long SmtTinFclsAdoLayer::AppendTinNodes(const SmtTin *pTin)
{
m_SmtRecordset.PutCollect("geom_pointnum",_variant_t(pTin->GetPointCount()));
int nPoints = pTin->GetPointCount();
if (nPoints < 1)
return SMT_ERR_DB_OPER;
RawPoint *pRawPoints = new RawPoint[nPoints];
for (int i = 0; i < pTin->GetPointCount();i++)
{
SmtPoint oPoint = pTin->GetPoint(i);
pRawPoints[i].x = oPoint.GetX();
pRawPoints[i].y = oPoint.GetY();
}
char *pBuf = (char*)pRawPoints;
int nLen = sizeof(RawPoint)*nPoints;
VARIANT varBLOB;
SAFEARRAY *pSa = NULL;
SAFEARRAYBOUND rgSaBound[1];
if(pBuf)
{
rgSaBound[0].lLbound = 0;
rgSaBound[0].cElements = nLen;
char *pSABuf = NULL;
pSa = SafeArrayCreate(VT_UI1, 1, rgSaBound);
if(SafeArrayAccessData(pSa,(void **)&pSABuf) == NOERROR)
{
memcpy(pSABuf,pBuf,nLen);
}
SafeArrayUnaccessData(pSa);
/* pSa = SafeArrayCreate(VT_UI1, 1, rgSaBound);
for (long i = 0; i < (long)nLen; i++)
SafeArrayPutElement (pSa, &i, pBuf++); */
varBLOB.vt = VT_ARRAY | VT_UI1;
varBLOB.parray = pSa;
m_SmtRecordset.GetField("geom_points")->AppendChunk(varBLOB);
}
SafeArrayDestroy(pSa);
SMT_SAFE_DELETE_A(pRawPoints);
return SMT_ERR_NONE;
}
// dwNumElements specifies the number of elements in the array referenced by
// ppcszValue
HRESULT WpcuWmiInstancePutStringArray(IWbemClassObject* piInstance,
PCWSTR pcszProperty,
DWORD dwNumElements,
PCWSTR* ppcszValue)
{
HRESULT hr = E_INVALIDARG;
if (piInstance && pcszProperty && ppcszValue)
{
VARIANT var;
VariantInit(&var);
// Create new SAFEARRAY
SAFEARRAYBOUND rgsaBound[1];
rgsaBound[0].cElements = dwNumElements;
rgsaBound[0].lLbound = 0;
var.parray = SafeArrayCreate(VT_BSTR, 1, rgsaBound);
if (var.parray == NULL)
{
hr = E_OUTOFMEMORY;
}
else
{
// Set proper variant type
var.vt = VT_ARRAY | VT_BSTR;
// Lock the array and obtain pointer to data
BSTR* pData;
hr = SafeArrayAccessData(var.parray, (void HUGEP**)&pData);
if (SUCCEEDED(hr))
{
for (DWORD i = 0;
i < dwNumElements && SUCCEEDED(hr);
i++)
{
// Write array data
pData[i] = SysAllocString(ppcszValue[i]);
if (pData[i] == NULL)
{
hr = E_OUTOFMEMORY;
}
}
// Always unlock the array
SafeArrayUnaccessData(var.parray);
if (SUCCEEDED(hr))
{
hr = piInstance->Put(pcszProperty, 0, &var, 0);
}
}
VariantClear(&var);
}
}
return hr;
}
int wdNewScriptArgs(ScriptArgs** scriptArgs, int maxLength)
{
ScriptArgs* args = new ScriptArgs();
args->currentIndex = 0;
args->maxLength = maxLength;
SAFEARRAYBOUND bounds;
bounds.cElements = maxLength;
bounds.lLbound = 0;
args->args = SafeArrayCreate(VT_VARIANT, 1, &bounds);
*scriptArgs = args;
return SUCCESS;
}
static HRESULT WINAPI httprequest_get_responseBody(IXMLHTTPRequest *iface, VARIANT *body)
{
httprequest *This = impl_from_IXMLHTTPRequest( iface );
HGLOBAL hglobal;
HRESULT hr;
TRACE("(%p)->(%p)\n", This, body);
if (!body) return E_INVALIDARG;
if (This->state != READYSTATE_COMPLETE) return E_FAIL;
hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
if (hr == S_OK)
{
void *ptr = GlobalLock(hglobal);
DWORD size = GlobalSize(hglobal);
SAFEARRAYBOUND bound;
SAFEARRAY *array;
bound.lLbound = 0;
bound.cElements = size;
array = SafeArrayCreate(VT_UI1, 1, &bound);
if (array)
{
void *dest;
V_VT(body) = VT_ARRAY | VT_UI1;
V_ARRAY(body) = array;
hr = SafeArrayAccessData(array, &dest);
if (hr == S_OK)
{
memcpy(dest, ptr, size);
SafeArrayUnaccessData(array);
}
else
{
VariantClear(body);
}
}
else
hr = E_FAIL;
GlobalUnlock(hglobal);
}
return hr;
}
void BOSSamp::BuildCclOBuf(LPDISPATCH commArea)
{
// TODO: Add your dispatch handler code here
//
// Map commArea onto a CICS OLE Buffer object
//
CclBuffer pBuffer = CclBuffer(commArea);
//
// Create a new CICS C++ Buffer object, and place the business objects
// using the appropriate structure, for communicating with the server
//
CclBuf* buffer = new CclBuf();
time_t doBT;
doBT = doB.GetTime();
char nu = '\0';
buffer->assign(sizeof(doBT),&doB);
buffer->insert(sizeof(yearsService),&yearsService);
buffer->insert(sizeof(nu),&nu);
buffer->insert(name.GetLength(),name);
//
// Create a safe array to hold the buffer data
//
SAFEARRAY * commData;
SAFEARRAYBOUND sabound[1];
void * pData;
sabound[0].lLbound = 0;
sabound[0].cElements = buffer->dataLength();
commData = SafeArrayCreate ( VT_UI1, 1, sabound );
//commData->pvData = (void *)buffer->dataArea();
SafeArrayAccessData( commData, &pData );
memcpy(pData,buffer->dataArea(),buffer->dataLength());
SafeArrayUnlock(commData);
//
// Construct the VARIANT object and prime it with the safe array
//
VARIANT commVariant;
VariantInit(&commVariant);
commVariant.pparray = &commData;
commVariant.vt = VT_BYREF|VT_ARRAY|VT_UI1;
//
// Set the data in the CICS OLE buffer object
//
pBuffer.SetData(commVariant);
//
// Detach and Release the 'mapped' CICS OLE buffer object
//
pBuffer.DetachDispatch();
pBuffer.ReleaseDispatch();
}
void
doublesToVariant( const int nDoubles, const double *pdblArray, VARIANT *pVal )
{
pVal->vt = VT_ARRAY | VT_R8;
SAFEARRAYBOUND rgsaBound;
rgsaBound.lLbound = 0L;
rgsaBound.cElements = nDoubles;
pVal->parray = SafeArrayCreate(VT_R8, 1, &rgsaBound);
if (pVal->parray ) {
for (long i = 0; i < nDoubles; i++) {
SafeArrayPutElement( pVal->parray, &i, (void*)&pdblArray[i] );
}
}
}
/*
* 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;
}
///////////////////////////////////////////////////////////////////////////////
// Create : Creates a SafeArray object
bool CSafeArrayHelper::Create(VARTYPE vt, UINT cDims, UINT lBound, UINT cCount)
{
Destroy();
if (cDims == 1) // this is somewhat faster...
m_pSA = SafeArrayCreateVector(vt, lBound, cCount);
else
{
SAFEARRAYBOUND rgsabound[1] = { 0 };
rgsabound[0].lLbound = lBound;
rgsabound[0].cElements = cCount;
m_pSA = SafeArrayCreate(vt, cDims, rgsabound);
}
return (m_pSA != NULL);
}
