HRESULT CWtlHtmlView::SetDocumentText( CString cstr)
{
_bstr_t str(cstr);
HRESULT hr = S_OK;
VARIANT *param;
SAFEARRAY *sfArray;
IHTMLDocument2 *document;
BSTR bstr = str.Detach();
// Creates a new one-dimensional array
sfArray = SafeArrayCreateVector(VT_VARIANT, 0, 1);
if(m_spHTMLDocument==NULL)
this->GetBody();
document= m_spHTMLDocument;
if (sfArray == NULL || document == NULL) {
hr=E_FAIL;
goto cleanup;
}
hr = SafeArrayAccessData(sfArray,(LPVOID*) & param);
param->vt = VT_BSTR;
param->bstrVal = bstr;
hr = SafeArrayUnaccessData(sfArray);
hr = document->write(sfArray);
cleanup:
if (sfArray != NULL) {
SafeArrayDestroy(sfArray);
}
return hr;
}
//==============================================================================
STDMETHODIMP CVMain::GetEventLog(SAFEARRAY** ppsaLogID, SAFEARRAY** ppsaTimeStampMs){
SAFEARRAY *psaMtx;
int * piData;
double * pdData;
* ppsaLogID =NULL;
* ppsaTimeStampMs = NULL;
if( g_MakeSafeArray( g_nLogEvents, &psaMtx, &piData ) ){
return g_ErrorToHresult(1);
}
memcpy( piData, g_aiLogIDs, sizeof(int) * g_nLogEvents);
SafeArrayUnaccessData( psaMtx );
* ppsaLogID = psaMtx;
if( g_MakeSafeArray( g_nLogEvents, &psaMtx, &pdData ) ){
return g_ErrorToHresult(1);
}
memcpy( pdData, g_adEventTimes, sizeof(double) * g_nLogEvents);
SafeArrayUnaccessData( psaMtx );
* ppsaTimeStampMs = psaMtx;
return S_OK;
}
HRESULT STDMETHODCALLTYPE CPmcDB::writeSnapshots(
ULONG count,
VARIANT _tagNames,
VARIANT _tagValues)
{
TAG_NAME *names,*n;
pmc_value_t *values,*v;
void * heap;
__uint heapSize;
HRESULT hr;
VARIANT * pn;
VARIANT * pv;
int i;
SAFEARRAY * tagNames=getArrayParam(&_tagNames);
SAFEARRAY * tagValues=getArrayParam(&_tagValues);
if(!tagNames || !tagValues){
return E_INVALIDARG;
}
if(SafeArrayGetDim(tagNames) != 1 ||SafeArrayGetDim(tagValues) != 1 ||
tagNames->rgsabound[0].cElements < count || tagValues->rgsabound[0].cElements < count){
return E_INVALIDARG;
}
hr = SafeArrayAccessData(tagNames, (void **)&pn);
if(FAILED(hr)){
return hr;
}
hr = SafeArrayAccessData(tagValues, (void **)&pv);
if(FAILED(hr)){
return hr;
}
heapSize=(sizeof(TAG_NAME)*+ sizeof(pmc_value_t))*count;
heap=malloc(heapSize);
if(!heap){
SafeArrayUnaccessData(tagNames);
SafeArrayUnaccessData(tagValues);
return E_OUTOFMEMORY;
}
ZeroMemory(heap,heapSize);
names=(TAG_NAME*)heap;
values=(pmc_value_t*)(names+count);
for(i=0,n=names,v=values; i<count; i++,n++,pn++,pv++,v++){
// TODO:
if(pn->vt == VT_BSTR){
tagname_by_textW(n, pn->bstrVal);
pmc_variant_to_value(pv, v);
}
}
proxy_write_tags_ex(count, names, values);
free(heap);
SafeArrayUnaccessData(tagNames);
SafeArrayUnaccessData(tagValues);
return S_OK;
}
static HRESULT VBArray_toArray(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
jsval_t *r)
{
VBArrayInstance *vbarray;
jsdisp_t *array;
jsval_t val;
VARIANT *v;
int i, size = 1, ubound, lbound;
HRESULT hres;
TRACE("\n");
vbarray = vbarray_this(vthis);
if(!vbarray)
return throw_type_error(ctx, JS_E_VBARRAY_EXPECTED, NULL);
for(i=1; i<=SafeArrayGetDim(vbarray->safearray); i++) {
SafeArrayGetLBound(vbarray->safearray, i, &lbound);
SafeArrayGetUBound(vbarray->safearray, i, &ubound);
size *= ubound-lbound+1;
}
hres = SafeArrayAccessData(vbarray->safearray, (void**)&v);
if(FAILED(hres))
return hres;
hres = create_array(ctx, 0, &array);
if(FAILED(hres)) {
SafeArrayUnaccessData(vbarray->safearray);
return hres;
}
for(i=0; i<size; i++) {
hres = variant_to_jsval(v, &val);
if(SUCCEEDED(hres)) {
hres = jsdisp_propput_idx(array, i, val);
jsval_release(val);
}
if(FAILED(hres)) {
SafeArrayUnaccessData(vbarray->safearray);
jsdisp_release(array);
return hres;
}
v++;
}
SafeArrayUnaccessData(vbarray->safearray);
if(r)
*r = jsval_obj(array);
else
jsdisp_release(array);
return S_OK;
}
STDMETHODIMP SoundDA::SetChannelProperty(long User, NESTABLEPROP *pChan, VARIANT *newValue)
{
int chan=pChan->Index;
if (chan>2) return E_EXCEEDS_MAX_CHANNELS;
long numChans;
HRESULT hRes = _EngineChannelList->GetNumberOfChannels(&numChans);
if (FAILED(hRes)) return hRes;
if (User==HwChan)
{
variant_t val = (variant_t*)newValue;
if (V_VT(newValue)==VT_R8 && (double)val!=chan)
return E_INVALID_CHANNEL;
}
// Winsound supports only an input range of [-1 1]
else if (User==OUTPUTRANGE)
{
if (V_ISARRAY (newValue) || V_ISVECTOR (newValue))
{
SAFEARRAY *ps = newValue->parray;
if (ps==NULL)
return E_OUTOFMEMORY;
double *pr;
HRESULT hr = SafeArrayAccessData (ps, (void **) &pr);
if (FAILED (hr))
{
SafeArrayDestroy (ps);
return hr;
}
if (pr[0]!=-1 || pr[1]!=1)
{
SafeArrayUnaccessData (ps);
return E_INV_OUTPUT_RANGE;
}
SafeArrayUnaccessData (ps);
}
}
if (numChans!=_nChannels)
_nChannels = numChans;
return S_OK;
}
HRESULT CMainFrameDropTarget::PasteHTML(PASTEURLDATA* pPaste)
{
HRESULT hrPasteResult = S_FALSE; // default: nothing was pasted
if (pPaste->m_bstrURLs[0] != L'\0')
{
HRESULT hr;
CComPtr<IHTMLDocument2> doc;
if (SUCCEEDED(hr = doc.CoCreateInstance(CLSID_HTMLDocument, NULL)))
{
SAFEARRAY* psfHtmlLines = SafeArrayCreateVector(VT_VARIANT, 0, 1);
if (psfHtmlLines != NULL)
{
VARIANT* pva;
if (SafeArrayAccessData(psfHtmlLines, (void**)&pva) == S_OK)
{
pva->vt = VT_BSTR;
pva->bstrVal = pPaste->m_bstrURLs;
VERIFY( SafeArrayUnaccessData(psfHtmlLines) == S_OK );
// Build the HTML document
//
// NOTE: 'bstrHTML' may contain a complete HTML document (see CF_HTML) or
// just a fragment (without <HTML>, <BODY>, ... tags).
//
// WOW! We even can pump partially (but well defined) HTML stuff into the
// document (e.g. contents without <HTML>, <BODY>...) *and* we are capable
// of accessing the HTML object model (can use 'get_links'...)
if ((hr = doc->write(psfHtmlLines)) == S_OK)
hrPasteResult = PasteHTMLDocument(doc, pPaste);
else
hrPasteResult = E_FAIL;
}
else
hrPasteResult = E_OUTOFMEMORY;
// Destroy the array *and* all of the data (BSTRs!)
if (SafeArrayAccessData(psfHtmlLines, (void**)&pva) == S_OK)
{
// 'Remove' the BSTR which was specified before, to *NOT* have it deleted by 'SafeArrayDestroy'
pva->vt = VT_NULL;
pva->bstrVal = NULL;
VERIFY( SafeArrayUnaccessData(psfHtmlLines) == S_OK );
}
VERIFY( SafeArrayDestroy(psfHtmlLines) == S_OK );
}
else
hrPasteResult = E_OUTOFMEMORY;
}
else
hrPasteResult = E_FAIL;
}
return hrPasteResult;
}
STDMETHODIMP CAtmoRemoteControlImplEx::setChannelValues(SAFEARRAY *channel_values)
{
if(!channel_values) return S_FALSE;
ATMO_BOOL result = ATMO_FALSE;
unsigned char *pChannel_Values;
SafeArrayAccessData(channel_values,(void **)&pChannel_Values);
int numElements = channel_values->rgsabound[0].cElements;
this->m_pAtmoDynData->LockCriticalSection();
CAtmoConnection *connection = this->m_pAtmoDynData->getAtmoConnection();
if((connection!=NULL) && (connection->isOpen())) {
result = connection->setChannelValues(numElements, pChannel_Values);
}
this->m_pAtmoDynData->UnLockCriticalSection();
SafeArrayUnaccessData(channel_values);
if(result == ATMO_TRUE)
return S_OK;
else
return S_FALSE;
}
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;
}
wstring WindDataParser::GetStrItemByIndex(const VARIANT& safeArray, int index)
{
if(!IsArray(safeArray))
{
return L"";
}
if (VT_BSTR != (safeArray.vt & VT_BSTR_BLOB))
{
return L"";
}
HRESULT hr ;
BSTR *pbItems;
if (index >= GetCountOfSafeArray(safeArray))
{
return L"";
}
hr = SafeArrayAccessData(safeArray.parray, (void HUGEP**)&pbItems);
if (FAILED(hr))
{
return L"";
}
wstring itemStr = pbItems[index];
SafeArrayUnaccessData(safeArray.parray);
return itemStr;
}
int WindDataParser::GetStrItemIndexOfSafeArray(const VARIANT& safeArray, const wstring& itemNameStr)
{
if(!IsArray(safeArray))
{
return -1;
}
int length = GetCountOfSafeArray(safeArray);
HRESULT hr ;
BSTR *pbItems;
hr = SafeArrayAccessData(safeArray.parray, (void HUGEP**)&pbItems);
if (FAILED(hr))
{
return -1;
}
int nRetIndex = -1;
for(int index = 0; index < length; index++)
{
if (0 == itemNameStr.compare(pbItems[index]))
{
nRetIndex = index;
break;
}
}
SafeArrayUnaccessData(safeArray.parray);
return nRetIndex;
}
STDMETHODIMP CDlrComServer::GetByteArray(SAFEARRAY **ppsaRetVal)
{
CComBSTR cbstrTestData(L"GetByteArrayTestData");
CComSafeArray<BYTE> csaData;
void HUGEP *pvData = NULL;
DWORD cbData;
HRESULT hr = S_OK;
// create a stream of bytes encoded as UNICODE text
cbData = SysStringByteLen(cbstrTestData.m_str);
hr = csaData.Create(cbData, 0);
if (FAILED(hr))
goto Error;
hr = SafeArrayAccessData((LPSAFEARRAY)csaData, (void HUGEP **)&pvData);
if (FAILED(hr))
goto Error;
memcpy((void*)pvData, cbstrTestData.m_str, cbData);
hr = SafeArrayUnaccessData((LPSAFEARRAY)csaData);
if (FAILED(hr))
goto Error;
if (FAILED(hr))
goto Error;
*ppsaRetVal = csaData.Detach();
Error:
return hr;
}
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;
}
/**
* 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();
}
}
void CStackerManager::GetCmds(void)
{
DISPPARAMS dp = {NULL, NULL, 0, 0};
CComVariant vPars[2];
CComSafeArray<double> sa(3);
EXCEPINFO einfo;
HRESULT hr;
DRAWING_MODE nMode;
vPars[0] = sa;
vPars[1] = 1;
dp.cArgs = 2;
dp.rgvarg = vPars;
if(NULL != pOGLViewer)
{
// Get Commands
hr = pOGLViewer->Invoke(7,IID_NULL,LOCALE_SYSTEM_DEFAULT,DISPATCH_METHOD,&dp,NULL,&einfo,NULL);
double *pData;
hr = SafeArrayAccessData(vPars[0].parray, (void **)&pData);
double x1 = pData[0] ;
double x2 = pData[1] ;
double x3 = pData[2] ;
SafeArrayUnaccessData(vPars[0].parray);
}
}
long SmtAnnoFclsAdoLayer::GetPoint(SmtGeometry *&pGeom)
{
int nPoints = 0;
m_SmtRecordset.GetCollect("geom_pointnum",nPoints);
if (nPoints != 1)
return SMT_ERR_DB_OPER;
SmtPoint *pPoint = new SmtPoint();
long lDataSize = m_SmtRecordset.GetField("geom_points")->ActualSize;
if(lDataSize > 0)
{
_variant_t varBLOB;
varBLOB = m_SmtRecordset.GetField("geom_points")->GetChunk(lDataSize);
if(varBLOB.vt == (VT_ARRAY | VT_UI1))
{
RawPoint *pRawPointBuf = NULL;
SafeArrayAccessData(varBLOB.parray,(void **)&pRawPointBuf);
pPoint->SetX(pRawPointBuf[0].x);
pPoint->SetY(pRawPointBuf[0].y);
SafeArrayUnaccessData (varBLOB.parray);
}
}
pGeom = pPoint;
return SMT_ERR_NONE;
}
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();
}
}
//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;
}
int listVMs(IVirtualBox *virtualBox)
{
HRESULT rc;
SAFEARRAY *machinesArray = NULL;
rc = virtualBox->get_Machines(&machinesArray);
if (SUCCEEDED(rc))
{
IMachine **machines;
rc = SafeArrayAccessData(machinesArray, (void **) &machines);
if (SUCCEEDED(rc))
{
for (ULONG i = 0; i < machinesArray->rgsabound[0].cElements; ++i)
{
CComBSTR str;
rc = machines[i]->get_Name(&str);
if (SUCCEEDED(rc))
{
printf("Name: %S\n", str);
}
}
SafeArrayUnaccessData(machinesArray);
}
SafeArrayDestroy(machinesArray);
}
return 0;
}
STDMETHODIMP CDlrComServer::GetIntArray(SAFEARRAY **ppsaRetVal)
{
CComSafeArray<INT> csaData;
void HUGEP *pvData = NULL;
HRESULT hr = S_OK;
int rgData [] = { 1, 2, 3, 4, 5 };
hr = csaData.Create(5, 0);
if (FAILED(hr))
goto Error;
hr = SafeArrayAccessData((LPSAFEARRAY)csaData, (void HUGEP **)&pvData);
if (FAILED(hr))
goto Error;
memcpy((void*)pvData, rgData, sizeof(rgData));
hr = SafeArrayUnaccessData((LPSAFEARRAY)csaData);
if (FAILED(hr))
goto Error;
*ppsaRetVal = csaData.Detach();
Error:
return hr;
}
STDMETHODIMP CScdSpVector::put_Masses(/*[in]*/ VARIANT newVal)
{
dllSCD_COMENTRY(long)
{
if ((newVal.vt&VT_R8) && (newVal.vt&VT_ARRAY))
{
HRESULT hr=S_OK;
SAFEARRAY *pSA=newVal.parray;
//SAFEARRAY *pSA=pnewVal;
double HUGEP *pDble;
if (pSA->cDims!=1)
return E_FAIL;
// Get a pointer to the elements of the array.
SCD_TOF(SafeArrayAccessData(pSA, (void HUGEP**)&pDble), "Accessing Data");
long Cnt=pSA->rgsabound->cElements;
long s=pSA->rgsabound->lLbound;
for (long i=0; i<Cnt; i++)
m_pOwn->Model()->VValue[i]=pDble[s++];
SCD_TOF(SafeArrayUnaccessData(pSA), "UnAccessing Data");
//CHECK NBNBNB Why is this not called as per example COM&ATL3.0 pg465
// SafeArrayDestroy(pSA);
return S_OK;
}
return DISP_E_TYPEMISMATCH;
}
SCD_COMEXIT
};
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;
}
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;
}
STDMETHODIMP CPoint::Length(/* in */ VARIANT var, /*[out, retval]*/ double *pSum) {
assert(pSum);
assert(var.vt == (VT_ARRAY | VT_UNKNOWN));
SAFEARRAY *psa = var.parray;
assert(SafeArrayGetDim(psa) == 1);
long ubound, lbound;
HRESULT hr = SafeArrayGetUBound(psa, 1, &ubound);
if(!SUCCEEDED(hr)) return hr;
hr = SafeArrayGetLBound(psa, 1, &lbound);
if(!SUCCEEDED(hr)) return hr;
IUnknown **prgn;
hr = SafeArrayAccessData(psa, (void**)&prgn);
if(!SUCCEEDED(hr)) return hr;
*pSum = 0;
for (long i = lbound + 1; i <= ubound; i++) {
IPoint *p1, *p2;
hr = prgn[i-1]->QueryInterface(IID_IPoint, (void**)&p1);
if(!SUCCEEDED(hr)) return hr;
hr = prgn[i]->QueryInterface(IID_IPoint, (void**)&p2);
if(!SUCCEEDED(hr)) return hr;
long x1, x2, y1, y2;
hr = p1->GetCoords(&x1, &y1);
if(!SUCCEEDED(hr)) return hr;
hr = p2->GetCoords(&x2, &y2);
if(!SUCCEEDED(hr)) return hr;
*pSum += sqrt(pow((double)(x2-x1), 2.0) + pow((double)(y2-y1), 2.0));
p1->Release();
p2->Release();
}
SafeArrayUnaccessData(psa);
return S_OK;
}
long SmtTinFclsAdoLayer::GetTinNodes(SmtTin *&pTin)
{
int nPoints = 0;
m_SmtRecordset.GetCollect("geom_pointnum",nPoints);
long lDataSize = m_SmtRecordset.GetField("geom_points")->ActualSize;
if(lDataSize > 0)
{
_variant_t varBLOB;
varBLOB = m_SmtRecordset.GetField("geom_points")->GetChunk(lDataSize);
if(varBLOB.vt == (VT_ARRAY | VT_UI1))
{
RawPoint *pRawPointBuf = NULL;
SmtPoint *pPointBuf = new SmtPoint[nPoints];
SafeArrayAccessData(varBLOB.parray,(void **)&pRawPointBuf);
for (int i = 0 ; i < nPoints;i++)
{
pPointBuf[i].SetX(pRawPointBuf[i].x);
pPointBuf[i].SetY(pRawPointBuf[i].y);
}
SafeArrayUnaccessData (varBLOB.parray);
//
pTin->AddPointCollection(pPointBuf,nPoints);
SMT_SAFE_DELETE_A(pPointBuf);
}
}
return SMT_ERR_NONE;
}
int WindDataParser::GetDoubleItemIndexOfSafeArray(const VARIANT& safeArray, DOUBLE dbl)
{
if(!IsArray(safeArray))
{
return -1;
}
int length = GetCountOfSafeArray(safeArray);
HRESULT hr;
DOUBLE *pbItems;
hr = SafeArrayAccessData(safeArray.parray, (void HUGEP**)&pbItems);
if (FAILED(hr))
{
return -1;
}
int nRetIndex = -1;
for(int index = 0; index < length; index++)
{
if (dbl == pbItems[index])
{
nRetIndex = index;
break;
}
}
SafeArrayUnaccessData(safeArray.parray);
return nRetIndex;
}
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;
}
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;
}
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;
}
void CEvolverDlg::OnTimer(UINT nIDEvent)
{
if(nIDEvent == m_NotifyTimer)
{
if(m_Counter == 0)
{
// Show changelog
CFrameMain* pFrame = (CFrameMain*) AfxGetApp()->GetMainWnd();
pFrame->OpenBrowser("http://www.gnucleus.com/update2/ChangeLog.txt");
}
m_Counter++;
m_progBar.SetPos(m_Counter);
m_stcProgress.SetWindowText("Evolution in " + DWrdtoStr((150 - m_Counter) / 10) + " seconds...");
if(m_Counter == 150)
StartDownload();
}
if(nIDEvent == m_UpgradeTimer)
{
// Get File IDs
std::vector<int> FileIDs;
VARIANT var = m_autUpdate->GetFileIDs();
SAFEARRAY* psa = var.parray;
int* nArray;
SafeArrayAccessData(psa, reinterpret_cast<void**> (&nArray));
for(int i = 0; i < psa->rgsabound->cElements; i++)
FileIDs.push_back(nArray[i]);
SafeArrayUnaccessData(psa);
VariantClear(&var);
// Update status
if(m_autUpdate->GetTotalCompleted())
m_stcProgress.SetWindowText("Downloading Files...");
if(m_autUpdate->GetTotalSize())
m_progBar.SetPos(m_autUpdate->GetTotalCompleted() * 100 / m_autUpdate->GetTotalSize());
}
if(nIDEvent == m_CloseTimer)
{
m_Counter++;
m_progBar.SetPos(m_Counter);
m_stcProgress.SetWindowText("Restarting in " + DWrdtoStr((150 - m_Counter) / 10) + " seconds...");
if(m_Counter == 150)
{
Restart();
return;
}
}
CDialog::OnTimer(nIDEvent);
}
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);
}
}
