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;
}
Beispiel #3
0
//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;
}
Beispiel #4
0
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;
}
Beispiel #5
0
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;
        }
    }
}
Beispiel #6
0
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*)&param);
		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;
}
Beispiel #8
0
//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;
}
Beispiel #9
0
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;
}
Beispiel #10
0
	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;
	}
Beispiel #11
0
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;
}
Beispiel #12
0
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);
        }
    }
Beispiel #14
0
	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,
			&params, &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, 
				&params, &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;
	}
Beispiel #15
0
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);
}
Beispiel #16
0
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;
}
Beispiel #17
0
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;
}
Beispiel #18
0
// 写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
Beispiel #20
0
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;
}
Beispiel #21
0
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;
}
Beispiel #22
0
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); 
}
Beispiel #23
0
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;
}
Beispiel #24
0
/// <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;
	}
Beispiel #25
0
///////////////////////////////////////////////////////////////////////////////
// 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
Beispiel #27
0
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;
}
Beispiel #30
0
	//-------------------------------------------------------------------------
	// 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;
	}