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; }
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; }
//transform dividends STDMETHODIMP CEtsHolidayAtom::TransformDividends(SAFEARRAY **psaDates, LONG nCount, SAFEARRAY **psaTDates, LONG *pnTCount) { if (!pnTCount || !psaDates || !psaTDates) return E_POINTER; HRESULT hr = S_OK; try { *pnTCount = 0; if (nCount > 0) { DOUBLE *pdDates = NULL; LongVector lvDates; if( *psaTDates ) { ::SafeArrayDestroy(*psaTDates); *psaTDates = NULL; } if( SUCCEEDED(hr = ::SafeArrayAccessData(*psaDates, reinterpret_cast<void**>(&pdDates))) ) { DATE dtRealDate; for(int i = 0; i < nCount; i++) { GetPreviousWorkingDate(DATE(pdDates[i] * 365.0), &dtRealDate); lvDates.push_back( static_cast<LONG>(floor(dtRealDate)) ); } ::SafeArrayUnaccessData(*psaDates); *pnTCount = static_cast<LONG>(lvDates.size()); if (*pnTCount > 0) { LPSAFEARRAY pDates = SafeArrayCreateVector(VT_R8, 0, *pnTCount); ::SafeArrayLock(pDates); LPVOID lpDateData = NULL; ::SafeArrayAccessData(pDates, &lpDateData); DOUBLE * pdDates = reinterpret_cast<DOUBLE *>(lpDateData); for(long i = 0; i< *pnTCount; i++) { pdDates[i] = lvDates[i]/365.0; } ::SafeArrayUnaccessData(pDates); ::SafeArrayUnlock(pDates); *psaTDates = pDates; } } } } catch (...) { return E_FAIL; } 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; }
COleVariant::COleVariant(LPCITEMIDLIST pidl) { AfxVariantInit(this); if (pidl != NULL) { // walk through entries in the list and accumulate their size UINT cbTotal = 0; SAFEARRAY *psa = NULL; LPCITEMIDLIST pidlWalker = pidl; while (pidlWalker->mkid.cb) { cbTotal += pidlWalker->mkid.cb; pidlWalker = (LPCITEMIDLIST) (((LPBYTE)pidlWalker) + pidlWalker->mkid.cb); } // add the base structure size cbTotal += sizeof(ITEMIDLIST); // get a safe array for them psa = SafeArrayCreateVector(VT_UI1, 0, cbTotal); // copy it and set members if (psa != NULL) { memcpy(psa->pvData, (LPBYTE) pidl, cbTotal); vt = VT_ARRAY | VT_UI1; parray = psa; } } }
void CHtmlParser::testParseHtml(LPCTSTR szHTML) { HRESULT hr = 0; try { MSHTML::IHTMLDocument2Ptr pDoc; hr = pDoc.CreateInstance(CLSID_HTMlDocument); SAFEARRAY* psa = SafeArrayCreateVector(VT_VARIANT, 0, 1); VARIANT* param; bstr_t bsData = szHTML; hr = SafeArrayAccessData(psa, (LPVOID*)¶m); param->vt = VT_BSTR; param->bstrVal = (BSTR)bsData; hr = pDoc->write(psa); hr = pDoc->close(); SafeArrayDestroy(psa); _bstr_t body = pDoc->body->innerHTML; } catch(_com_error& e) { e; } }
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; }
//return holidays in array STDMETHODIMP CEtsHolidayAtom::GetHolidays(DATE dtToday, SAFEARRAY ** psaDates, LONG* pnCount) { if (!pnCount) return E_POINTER; *pnCount = static_cast<LONG>( m_vHoliday.size() ); if (*pnCount > 0) { LPSAFEARRAY pDates = SafeArrayCreateVector(VT_R8, 0, *pnCount); ::SafeArrayLock(pDates); LPVOID lpDateData = NULL; ::SafeArrayAccessData(pDates, &lpDateData); DOUBLE * pdDates = reinterpret_cast<DOUBLE *>(lpDateData); for(long i = 0; i< *pnCount; i++) { pdDates[i] = m_vHoliday[i]; } ::SafeArrayUnaccessData(pDates); ::SafeArrayUnlock(pDates); *psaDates = pDates; } return S_OK; }
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; }
STDMETHOD(SetSecurity) (THIS_ SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor ) { DWORD bufferLength = 0; MakeSelfRelativeSD(pSecurityDescriptor, NULL, &bufferLength); SAFEARRAY* sdArray = SafeArrayCreateVector(VT_UI1, 0, bufferLength); if (sdArray) { MakeSelfRelativeSD(pSecurityDescriptor, (sdArray)->pvData, &bufferLength); try { m_filesystem->SetPathSecurityDescriptor(m_pathName, sdArray); } catch (_com_error &e) { com_error_Message(e); } SafeArrayDestroy(sdArray); } return S_OK; }
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; }
SafeByteArray::SafeByteArray(void* data, int sizeInBytes) { pArray = SafeArrayCreateVector(VT_UI1, 0, sizeInBytes); SafeArrayLock(pArray); memcpy(pArray->pvData, data, sizeInBytes); SafeArrayUnlock(pArray); }
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); } }
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; }
DLL void AtmoCreateTransferBuffers(int FourCC,int bytePerPixel,int width,int height) { if(pixelDataArr != NULL) SafeArrayDestroy(pixelDataArr); if(bitmapInfoArr != NULL) SafeArrayDestroy(bitmapInfoArr); int size = width * height * bytePerPixel; pixelDataArr = SafeArrayCreateVector(VT_UI1,0,size); bitmapInfoArr = SafeArrayCreateVector(VT_UI1,0,sizeof(BITMAPINFOHEADER)); BITMAPINFOHEADER *header; SafeArrayAccessData(bitmapInfoArr,(void **)&header); header->biSize = sizeof(BITMAPINFOHEADER); header->biWidth = width; header->biHeight = height; header->biBitCount = bytePerPixel*8; header->biCompression = FourCC; SafeArrayUnaccessData(bitmapInfoArr); }
STDMETHODIMP CPoint::GetCoordsArr(SAFEARRAY **ppsa) { if(!ppsa) return E_INVALIDARG; *ppsa = SafeArrayCreateVector(VT_I4, 0, 2); if(!*ppsa) return E_INVALIDARG; long *prgn = 0; HRESULT hr = SafeArrayAccessData(*ppsa, (void**)&prgn); if(!SUCCEEDED(hr)) return hr; prgn[0] = m_x; prgn[1] = m_y; SafeArrayUnaccessData(*ppsa); 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; }
// 写HTML到document void CLog::WriteDocument(const CString& content) { SAFEARRAY *arr = SafeArrayCreateVector(VT_VARIANT, 0, 1); VARIANT *str = NULL; if (FAILED(SafeArrayAccessData(arr, (LPVOID*)&str))) return; str->vt = VT_BSTR; str->bstrVal = content.AllocSysString(); SafeArrayUnaccessData(arr); m_logDocument->write(arr); SafeArrayDestroy(arr); }
HRESULT CSoftHIDInputKbdMapper::SendInputReport ( PVOID pbReportData, ULONG cbReportData ) /*++ Routine Description: Prepares safearray and sends it as Input Report to lower layer. Synchronization: None Arguments: pbReportData - pointer to data buffer with Input Report cbReportData - size of the data buffer Return Value: S_OK Success E_OUTOFMEMORY Could not allocate enough memory for safearray From called function --*/ { SAFEARRAY* psa = NULL; BYTE HUGEP* pArrayData = NULL; HRESULT hr = S_OK; // Create safearray psa = SafeArrayCreateVector(VT_UI1, 0, cbReportData); IfFalseHrGo(NULL != psa, E_OUTOFMEMORY); IfFailHrGo(::SafeArrayAccessData(psa, (void HUGEP**)&pArrayData)); CopyMemory(pArrayData, pbReportData, cbReportData); IfFailHrGo(::SafeArrayUnaccessData(psa)); // Send Input Report IfFailHrGo(m_piSoftProtXlator->WriteInputReport(psa)); Exit: if (NULL != psa) { // Delete safearray ::SafeArrayDestroy(psa); psa = NULL; } return hr; } // CSoftHIDInputKbdMapper::SendInputReport
STDMETHODIMP CPoint::GetCoordsArr2(/*out, retval */ VARIANT *pvar) { assert(pvar); pvar->vt = VT_ARRAY | VT_I4; pvar->parray = SafeArrayCreateVector(VT_I4, 0, 2); if(!pvar->parray) return E_INVALIDARG; long *prgn = 0; HRESULT hr = SafeArrayAccessData(pvar->parray, (void**)&prgn); if(!SUCCEEDED(hr)) return hr; prgn[0] = m_x; prgn[1] = m_y; SafeArrayUnaccessData(pvar->parray); return S_OK; }
static HRESULT async_doc_navigate(DocHost *This, LPCWSTR url, LPCWSTR headers, PBYTE post_data, ULONG post_data_size, BOOL async_notif) { task_doc_navigate_t *task; TRACE("%s\n", debugstr_w(url)); task = heap_alloc_zero(sizeof(*task)); if(!task) return E_OUTOFMEMORY; task->url = SysAllocString(url); if(!task->url) { doc_navigate_task_destr(&task->header); return E_OUTOFMEMORY; } if(headers) { task->headers = SysAllocString(headers); if(!task->headers) { doc_navigate_task_destr(&task->header); return E_OUTOFMEMORY; } } if(post_data) { task->post_data = SafeArrayCreateVector(VT_UI1, 0, post_data_size); if(!task->post_data) { doc_navigate_task_destr(&task->header); return E_OUTOFMEMORY; } memcpy(task->post_data->pvData, post_data, post_data_size); } if(!async_notif) { VARIANT_BOOL cancel = VARIANT_FALSE; on_before_navigate2(This, task->url, task->post_data, task->headers, &cancel); if(cancel) { TRACE("Navigation canceled\n"); doc_navigate_task_destr(&task->header); return S_OK; } } task->async_notif = async_notif; abort_dochost_tasks(This, doc_navigate_proc); push_dochost_task(This, &task->header, doc_navigate_proc, doc_navigate_task_destr, FALSE); return S_OK; }
HRESULT FMediaPlayerVLC_Ex::AddPlaylistItem(const tchar* pFileName, IMediaOptions* pOptions) { if (!m_pPlaylist) return E_FAIL; USES_CONVERSION; long pos = 0; LPSAFEARRAY pSA = SafeArrayCreateVector(VT_VARIANT, 0, 1); if (pOptions->m_Vout == "") { //If GetWindowsVersion() == WindowsVista => "direct3d" //else "directx"; pOptions->m_Vout = "direct3d"; } FString StrVout; StrVout.Format(":vout=%s;", pOptions->m_Vout); FString Options = StrVout; m_bHasSubs = TRUE; if (pOptions->m_SubPath.GetLength() > 0) { Options.Append(";:sub-file: "); Options.Append(pOptions->m_SubPath); } Options.Append(";:sub-autodetect-file;:sub-autodetect-fuzzy:3;"); if (pOptions->rtOffset > 0) { FString StartTime; StartTime.Format(";:start-time:%d;", pOptions->rtOffset / 1000); Options.Append(StartTime); } _variant_t var(_bstr_t(T2OLE(Options))); SafeArrayPutElement(pSA, &pos, (void FAR *)&var); _variant_t v; v.parray = pSA; v.vt = VT_ARRAY; CComVariant vtName = L"LTV_Video"; BSTR bStrName = SysAllocString(T2OLE(pFileName)); long lId = 0; m_pPlaylist->get_itemCount(&lId); return m_pPlaylist->add(bStrName, vtName, v, &lId); }
HRESULT STDMETHODCALLTYPE SumatraUIAutomationTextRange::GetChildren(SAFEARRAY **children) { if (children == NULL) return E_POINTER; if (!document->IsDocumentLoaded()) return E_FAIL; // return all children in range if (IsNullRange()) { SAFEARRAY *psa = SafeArrayCreateVector(VT_UNKNOWN, 0, 0); if (!psa) return E_OUTOFMEMORY; *children = psa; return S_OK; } SAFEARRAY *psa = SafeArrayCreateVector(VT_UNKNOWN, 0, endPage - startPage + 1); if (!psa) return E_OUTOFMEMORY; SumatraUIAutomationPageProvider* it = document->GetFirstPage(); while (it) { if (it->GetPageNum() >= startPage || it->GetPageNum() <= endPage) { LONG index = it->GetPageNum() - startPage; HRESULT hr = SafeArrayPutElement(psa, &index, it); CrashIf(FAILED(hr)); it->AddRef(); } it = it->GetNextPage(); } *children = psa; return S_OK; }
/// <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; }
/////////////////////////////////////////////////////////////////////////////// // 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); }
HRESULT CSoftHIDInputKbdMapper::FinalConstruct() /*++ Routine Description: Overwrites the default FinalConstruct. Creates the default properties, gets pointer to COM task memory allocator. Synchronization: None Arguments: None Return Value: E_OUTOFMEMORY Could not create safearray for Report Descriptor data From called function --*/ { BYTE HUGEP* pArrayData = NULL; HRESULT hr = S_OK; IfFailHrGo(CoGetMalloc(1, &m_pMalloc)); // Register notification messages IfFailHrGo(RegisterMessage(MSG_KEYTOUCHED, &m_KeyTouchedMsg)); IfFailHrGo(RegisterMessage(MSG_OUTREPORTREADY, &m_OutReportReadyMsg)); // Create safearray with Report Descriptor data m_psaReportDescriptor = SafeArrayCreateVector(VT_UI1, 0, sizeof(m_ReportDescriptor)); IfFalseHrGo(NULL != m_psaReportDescriptor, E_OUTOFMEMORY); IfFailHrGo(::SafeArrayAccessData(m_psaReportDescriptor, (void HUGEP**)&pArrayData)); // Copy Report Descriptor data into safearray CopyMemory(pArrayData, &m_ReportDescriptor, sizeof(m_ReportDescriptor)); IfFailHrGo(::SafeArrayUnaccessData(m_psaReportDescriptor)); // Start internal thread IfFailHrGo(CMessageTask::Start(DEFAULT_SYNC_DELAY)); // Call OnConstruct method of CSoftHIDDevice class IfFailHrGo(CSoftHID::OnConstruct(this, m_OutReportReadyMsg)); Exit: return hr; } // CSoftHIDInputKbdMapper::FinalConstruct
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); }
//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; }
HRESULT CHtmlTableSnapshots::SetDocumentText(CComPtr<IWebBrowser2> pWebBrowser, std::string cstr) { _bstr_t tbstr(cstr.c_str()); //HRESULT_EXCEPTION hr = S_OK; HRESULT hr = S_OK; VARIANT *param; SAFEARRAY *sfArray; CComPtr<IHTMLDocument2> document; BSTR bstr= tbstr.Detach(); try { // Creates a new one-dimensional array sfArray = SafeArrayCreateVector(VT_VARIANT, 0, 1); document=GetDocument(pWebBrowser); if (sfArray == NULL || document == NULL) throw std::exception("CMainDlg::SetDocumentText) Failed IHTMLDocument2\n"); hr = SafeArrayAccessData(sfArray,(LPVOID*) & param); param->vt = VT_BSTR; param->bstrVal = bstr; hr = SafeArrayUnaccessData(sfArray); hr = document->write(sfArray); } catch(std::exception e) { AtlTrace(e.what()); throw e; } catch(HRESULT hResult) { std::string errmsg =(LPCSTR)( "CMainDlg::SetDocumentText Failed: %s\n" + ErrorFormatMessage(hResult)); AtlTrace("CMainDlg::SetDocumentText Failed: %s\n", (LPCSTR) ErrorFormatMessage(hResult)); throw std::exception(errmsg.c_str()); } catch(...) { AtlTrace("CMainDlg::OpenIE() Failed\n"); throw std::exception("CMainDlg::OpenIE() Failed\n"); } if (sfArray != NULL) SafeArrayDestroy(sfArray); return S_OK; }
//------------------------------------------------------------------------- // Function Name :EncodeBase64 // Parameter(s) :LPBYTE *pBuf The binary buffer // :ULONG ulSize size // Return :CString the result // Memo :encoding the binary buffer into Base64 string //------------------------------------------------------------------------- CString CXml::Base64Encode(LPBYTE pBuf, ULONG ulSize) { ASSERT( m_pDoc != NULL ); ASSERT( pBuf != NULL ); CString strRet = _T(""); try { MSXML2::IXMLDOMElementPtr pElement = NULL; pElement = m_pDoc->createElement( _bstr_t(_T("Base64")) ); ASSERT( pElement != NULL ); HRESULT hr = S_OK; hr = pElement->put_dataType( _bstr_t(_T("bin.base64")) ); ASSERT( SUCCEEDED(hr) ); SAFEARRAY * pAry = SafeArrayCreateVector( VT_UI1, 0L, ulSize); ::memcpy( pAry->pvData, pBuf, ulSize); VARIANT var; VariantInit(&var); var.parray = pAry; var.vt = VT_ARRAY | VT_UI1; pElement->nodeTypedValue = var; BSTR bstr = NULL; hr = pElement->get_text( &bstr ); ASSERT( SUCCEEDED(hr) ); strRet = (LPCTSTR)_bstr_t( bstr, true); if( bstr != NULL ) { SysFreeString(bstr); bstr = NULL; } RELEASE_PTR(pElement); } catch ( _com_error e ) { TRACE( _T("CXml::Base64Encode failed:%s\n"), e.ErrorMessage()); ASSERT( FALSE ); } return strRet; }