//////////////////////////////////////////////////////// // CompareVariant // //////////////////////////////////////////////////////// LONG CompareVariant ( VARIANT *pVar1, //@parm [in]: Pointer to the variant in the consumer's buffer. VARIANT *pVar2, //@parm [in]: Pointer to the variant at the backend. BOOL fCaseSensitive ) { //Handle NULL cases... if(pVar1==NULL || pVar2==NULL) { if(pVar1 == pVar2) return TRUE; return FALSE; } // The variant has to be the same type if (V_VT(pVar1) != V_VT(pVar2)) return FALSE; // Return FALSE if vt is ORed with VT_RESERVED if (V_VT(pVar1) & VT_RESERVED) return FALSE; // Return TRUE is the vt is VT_EMPTY or VT_NULL if (V_VT(pVar1)==VT_EMPTY || V_VT(pVar1)==VT_NULL) return TRUE; switch(V_VT(pVar1)) { case VT_UI1: return V_UI1(pVar1) == V_UI1(pVar2); case VT_I2: return V_I2(pVar1) == V_I2(pVar2); case VT_I4: return V_I4(pVar1) == V_I4(pVar2); case VT_R4: return V_R4(pVar1) == V_R4(pVar2); case VT_R8: return V_R8(pVar1) == V_R8(pVar2); case VT_BOOL: return V_BOOL(pVar1) == V_BOOL(pVar2); case VT_ERROR: return V_ERROR(pVar1) == V_ERROR(pVar2); case VT_CY: return memcmp(&V_CY(pVar1), &V_CY(pVar2),8)==0; case VT_DATE: return V_DATE(pVar1) == V_DATE(pVar2); case VT_BSTR: if(fCaseSensitive) return wcscmp(V_BSTR(pVar1), V_BSTR(pVar2)); else return _wcsicmp(V_BSTR(pVar1), V_BSTR(pVar2)); // As we are not testing OLE object, return FALSE for VT_UNKNOWN case VT_UNKNOWN: return FALSE; // As we are not testing OLE object, return FALSE for VT_DISPATCH case VT_DISPATCH: return FALSE; case VT_I2 | VT_BYREF: return *V_I2REF(pVar1) == *V_I2REF(pVar2); case VT_I4 | VT_BYREF: return *V_I4REF(pVar1) == *V_I4REF(pVar2); case VT_R4 | VT_BYREF: return *V_R4REF(pVar1) == *V_R4REF(pVar2); case VT_R8 | VT_BYREF: return *V_R8REF(pVar1) == *V_R8REF(pVar2); case VT_BOOL | VT_BYREF: return *V_BOOLREF(pVar1) == *V_BOOLREF(pVar2); case VT_ERROR | VT_BYREF: return *V_ERRORREF(pVar1) == *V_ERRORREF(pVar2); case VT_CY | VT_BYREF: return memcmp(V_CYREF(pVar1), V_CYREF(pVar2),8)==0; case VT_DATE | VT_BYREF: return *V_DATEREF(pVar1) == *V_DATEREF(pVar2); case VT_BSTR | VT_BYREF: if(fCaseSensitive) return wcscmp(*V_BSTRREF(pVar1), *V_BSTRREF(pVar2)); else return _wcsicmp(*V_BSTRREF(pVar1), *V_BSTRREF(pVar2)); // As we are not testing OLE object, return FALSE for VT_UNKNOWN case VT_UNKNOWN | VT_BYREF: return FALSE; // As we are not testing OLE object, return FALSE for VT_DISPATCH case VT_DISPATCH | VT_BYREF: return FALSE; } return FALSE; }
void CTemplateWizardDialog::DocumentComplete(LPDISPATCH pDisp, VARIANT* URL) { UNUSED_ALWAYS(pDisp); // ASSERT(V_VT(URL) == VT_BSTR); CString str(V_BSTR(URL)); // Load in the new file... HRESULT hr; LPUNKNOWN pUnkContainedBrowser = NULL; LPUNKNOWN pUnkDispParam = NULL; IStream *pStream = NULL; HGLOBAL hHTMLText; CComPtr<IDispatch> pDispDocument; // HWND shellWnd; // HWND ieWnd; // Test for valid pointers. if (!m_pBrowserApp || !pDisp) goto CleanUp; // To test object equality, use COM identity rules: query both // pointers for IUnknown and compare them. hr = m_pBrowserApp->QueryInterface(IID_IUnknown, (void**)&pUnkContainedBrowser); if (hr) goto CleanUp; // Query the passed-in IDispatch for IUnknown. hr = pDisp->QueryInterface(IID_IUnknown, (void**)&pUnkDispParam); if (hr) goto CleanUp; // If they're unequal, the event is for a subframe and we're not // interested. if (pUnkContainedBrowser != pUnkDispParam) goto CleanUp; // As a further check, make sure the URL is "about:blank". if (str == "about:blank") { // The string is about:blank. This means load the correct page. LONG len = (LONG)m_htmlFile.GetLength(); BYTE* data = m_htmlFile.Detach(); hHTMLText = GlobalAlloc(GPTR, len + 1); if (!hHTMLText) goto CleanUp; memcpy((CHAR *)hHTMLText, (char*)data, len); *(char*)((char*)hHTMLText + len) = 0; free(data); hr = ::CreateStreamOnHGlobal(hHTMLText, TRUE, &pStream); if (hr) goto CleanUp; // Call the helper function to load the WebOC from the stream. // hr = LoadWebOCFromStream(m_pBrowserApp, pStream); goto CleanUp; } /* // Set the focus to the right window. shellWnd = ::FindWindowEx(m_wndBrowser.GetSafeHwnd(), NULL, "Shell DocObject View", NULL); ieWnd = ::FindWindowEx(shellWnd, NULL, "Internet Explorer_Server", NULL); ::SetFocus(ieWnd); */ // Set to the first available input field. m_pBrowserApp->get_Document(&pDispDocument); if (pDispDocument) { CComQIPtr<IHTMLDocument2, &IID_IHTMLDocument2> pDocument(pDispDocument); // Get all of the HTML elements. CComPtr<IHTMLElementCollection> pElements; pDocument->get_all(&pElements); CComVariant nullVariant; CComPtr<IDispatch> pDispFirstElement; // Now get the INPUT elements. CComPtr<IDispatch> pDispInputElements; pElements->tags(CComVariant("INPUT"), &pDispInputElements); if (pDispInputElements) { CComQIPtr<IHTMLElementCollection, &IID_IHTMLElementCollection> pInputElements(pDispInputElements); if (pInputElements) { long count; pInputElements->get_length(&count); for (int i = 0; i < count; i++) { // Get the element, if it exists. CComPtr<IDispatch> pDispElement; pInputElements->item(CComVariant(i), nullVariant, &pDispElement); if (!pDispElement) continue; CComQIPtr<IHTMLElement, &IID_IHTMLElement> pElement(pDispElement); if (!pElement) continue; //?? CComBSTR bstrID; pElement->get_id(&bstrID); CComQIPtr<IHTMLInputElement, &IID_IHTMLInputElement> pInputElement(pElement); if (!pInputElement) continue; //?? // Get the type. CComBSTR bstrType; pInputElement->get_type(&bstrType); CString strType(bstrType); CString id(bstrID); CString value; if (!m_params.Lookup(id, value)) { value = m_code.GetEntry(id); } if (strType == "text") { value = g_wwhizTemplateManager->ParseCode(value, NULL, &m_code); pInputElement->put_value(CComBSTR(value)); if (!pDispFirstElement) pDispFirstElement = pDispElement; } else if (strType == "checkbox") { pInputElement->put_checked(value == "1" ? VARIANT_TRUE : VARIANT_FALSE); } else if (strType == "radio") { pInputElement->put_checked(value == "1" ? VARIANT_TRUE : VARIANT_FALSE); } else if (strType == "file") { CComQIPtr<IHTMLInputFileElement, &IID_IHTMLInputFileElement> pInputFileElement(pElement); if (!pInputFileElement) continue; //?? value = g_wwhizTemplateManager->ParseCode(value, NULL, &m_code); pInputFileElement->put_value(CComBSTR(value)); if (!pDispFirstElement) pDispFirstElement = pDispElement; } } } } // Now get the SELECT elements. CComPtr<IDispatch> pDispSelectElements; pElements->tags(CComVariant("SELECT"), &pDispSelectElements); if (pDispSelectElements) { CComQIPtr<IHTMLElementCollection, &IID_IHTMLElementCollection> pSelectElements(pDispSelectElements); if (pSelectElements) { long count; pSelectElements->get_length(&count); for (int i = 0; i < count; i++) { // Get the element, if it exists. CComPtr<IDispatch> pDispElement; pSelectElements->item(CComVariant(i), nullVariant, &pDispElement); if (!pDispElement) continue; CComQIPtr<IHTMLElement, &IID_IHTMLElement> pElement(pDispElement); if (!pElement) continue; //?? CComBSTR bstrID; pElement->get_id(&bstrID); CComQIPtr<IHTMLSelectElement, &IID_IHTMLSelectElement> pSelectElement(pElement); if (!pSelectElement) continue; //?? // Get the type. CComBSTR bstrType; pSelectElement->get_type(&bstrType); CString strType(bstrType); CString id(bstrID); CString value; if (!m_params.Lookup(id, value)) { value = m_code.GetEntry(id); } // This is the only way I can figure out to do this! // Match the name. long optionCount; pSelectElement->get_length(&optionCount); int j; for (j = 0; j < optionCount; j++) { // Get the item at the index. CComPtr<IDispatch> pDispOptionElement; pSelectElement->item(CComVariant(j), nullVariant, &pDispOptionElement); if (pDispOptionElement) { CComQIPtr<IHTMLOptionElement, &IID_IHTMLOptionElement> pOptionElement(pDispOptionElement); CComBSTR bstrItem; pOptionElement->get_text(&bstrItem); CString strItem(bstrItem); if (value == strItem) { pSelectElement->put_selectedIndex(j); break; } } } if (j == optionCount) { pSelectElement->put_selectedIndex(0); } } } } if (pDispFirstElement) { CComQIPtr<IHTMLControlElement, &IID_IHTMLControlElement> pHtmlElement(pDispFirstElement); pHtmlElement->focus(); CComQIPtr<IHTMLInputTextElement, &IID_IHTMLInputTextElement> pElement(pDispFirstElement); if (pElement) { pElement->select(); } } } CleanUp: if (pStream) pStream->Release(); if (pUnkContainedBrowser) pUnkContainedBrowser->Release(); if (pUnkDispParam) pUnkDispParam->Release(); if (!m_asciiFilename.IsEmpty()) { _unlink(m_asciiFilename); m_asciiFilename.Empty(); } }
HRESULT CContextPlugin::WriteContextInformation( HANDLE hFile, IWMSContext *pContext ) { HRESULT hr = S_OK; ContextNameHint *pContextHintValues = NULL; DWORD nValue = 0; WMS_CONTEXT_TYPE wmsContextType = WMS_UNKNOWN_CONTEXT_TYPE; WCHAR wstrBuffer[MAX_PATH]; DWORD cbWritten = 0; DWORD dwRet = 0; if( NULL == pContext ) { // There is no Context, nothing to write return( hr ); } hr = pContext->GetContextType( &wmsContextType ); if( FAILED( hr ) ) { return( hr ); } ZeroMemory( wstrBuffer, MAX_PATH * sizeof( WCHAR ) ); switch( wmsContextType ) { case WMS_USER_CONTEXT_TYPE: // Create a header for this context type wcsncpy_s( wstrBuffer,MAX_PATH, CONTEXT_SAMPLE_USER_CONTEXT_HEADER, MAX_PATH ); pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_UserContextHintValues); break; case WMS_PRESENTATION_CONTEXT_TYPE: // Create a header for this context type wcsncpy_s( wstrBuffer, MAX_PATH,CONTEXT_SAMPLE_PRESENTATION_CONTEXT_HEADER, MAX_PATH ); pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_PresentationContextHintValues); break; case WMS_COMMAND_REQUEST_CONTEXT_TYPE: // Create a header for this context type wcsncpy_s( wstrBuffer,MAX_PATH, CONTEXT_SAMPLE_COMMAND_REQUEST_CONTEXT_HEADER, MAX_PATH ); pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_CommandContextHintValues); break; case WMS_COMMAND_RESPONSE_CONTEXT_TYPE: // Create a header for this context type wcsncpy_s( wstrBuffer,MAX_PATH, CONTEXT_SAMPLE_COMMAND_RESPONSE_CONTEXT_HEADER, MAX_PATH ); pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_CommandContextHintValues); break; } if( !::WriteFile( hFile, (LPVOID) wstrBuffer, DWORD(wcslen( wstrBuffer ) * sizeof( WCHAR )), &cbWritten, NULL ) ) { dwRet = GetLastError(); hr = HRESULT_FROM_WIN32( dwRet ); // Failed to write the header should we still continue // No! return( hr ); } if( NULL == pContextHintValues ) { return( E_UNEXPECTED ); } // Now we loop until -1 and Write the data while( ( NULL != pContextHintValues[nValue].wstrContextName ) && ( -1 != pContextHintValues[nValue].lContextHint ) ) { VARIANT varValue; VariantInit( &varValue ); ZeroMemory( wstrBuffer, MAX_PATH * sizeof( WCHAR ) ); hr = pContext->GetValue( pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, &varValue, 0 ); if( SUCCEEDED( hr ) ) { // Write string with data information switch( V_VT( &varValue ) ) { case VT_BSTR: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_BSTR_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_BSTR( &varValue ) ); break; case VT_I4: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_I4_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_I4( &varValue ), V_I4( &varValue ) ); break; case VT_UI8: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_UI8_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_UI8( &varValue ) ); break; case VT_CY: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_CY_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_CY( &varValue ) ); break; case VT_DATE: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_DATE_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_DATE( &varValue ) ); break; case VT_DECIMAL: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_DECIMAL_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_DECIMAL( &varValue ) ); break; case VT_UNKNOWN: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_UNKNOWN_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_UNKNOWN( &varValue ) ); break; case VT_DISPATCH: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_DISPATCH_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_DISPATCH( &varValue ) ); break; default: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_ARRAY_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_ARRAY( &varValue ) ); break; } if( !::WriteFile( hFile, (LPVOID) wstrBuffer, DWORD(wcslen( wstrBuffer ) * sizeof( WCHAR )), &cbWritten, NULL ) ) { dwRet = GetLastError(); hr = HRESULT_FROM_WIN32( dwRet ); } } else { // Value probably didn't exist for this event, don't worry about it // good place to put breakpoint hr = S_OK; } // It doesn't hurt to do a VariantClear on an Empty Variant, this way we won't leak anything. VariantClear( &varValue ); nValue ++; } return( hr ); }
static HRESULT invoke_builtin(vbdisp_t *This, const builtin_prop_t *prop, WORD flags, DISPPARAMS *dp, VARIANT *res) { VARIANT args[8]; unsigned argn, i; switch(flags) { case DISPATCH_PROPERTYGET: if(!(prop->flags & (BP_GET|BP_GETPUT))) { FIXME("property does not support DISPATCH_PROPERTYGET\n"); return E_FAIL; } break; case DISPATCH_PROPERTYGET|DISPATCH_METHOD: if(!prop->proc && prop->flags == BP_GET) { const int vt = prop->min_args, val = prop->max_args; switch(vt) { case VT_I2: V_VT(res) = VT_I2; V_I2(res) = val; break; case VT_I4: V_VT(res) = VT_I4; V_I4(res) = val; break; case VT_BSTR: { const string_constant_t *str = (const string_constant_t*)prop->max_args; BSTR ret; ret = SysAllocStringLen(str->buf, str->len); if(!ret) return E_OUTOFMEMORY; V_VT(res) = VT_BSTR; V_BSTR(res) = ret; break; } DEFAULT_UNREACHABLE; } return S_OK; } break; case DISPATCH_METHOD: if(prop->flags & (BP_GET|BP_GETPUT)) { FIXME("Call on property\n"); return E_FAIL; } break; case DISPATCH_PROPERTYPUT: if(!(prop->flags & BP_GETPUT)) { FIXME("property does not support DISPATCH_PROPERTYPUT\n"); return E_FAIL; } FIXME("call put\n"); return E_NOTIMPL; default: FIXME("unsupported flags %x\n", flags); return E_NOTIMPL; } argn = arg_cnt(dp); if(argn < prop->min_args || argn > (prop->max_args ? prop->max_args : prop->min_args)) { FIXME("invalid number of arguments\n"); return E_FAIL; } assert(argn < sizeof(args)/sizeof(*args)); for(i=0; i < argn; i++) { if(V_VT(dp->rgvarg+dp->cArgs-i-1) == (VT_BYREF|VT_VARIANT)) args[i] = *V_VARIANTREF(dp->rgvarg+dp->cArgs-i-1); else args[i] = dp->rgvarg[dp->cArgs-i-1]; } return prop->proc(This, args, dp->cArgs, res); }
HRESULT CMatlabEngine::PutMatrix( LPCTSTR szName, const std::vector<double>& vArray, UINT nRows, UINT nCols) { BSTR bstrName=NULL; if (!m_bInitialized || !m_pMtlbDispApp || (nRows*nCols > vArray.size()) ) return m_hr=S_FALSE; ProcessString(szName, bstrName); SAFEARRAYBOUND realPartDims[2]; realPartDims[0].lLbound = 0; // Lower bound of the first dimension realPartDims[0].cElements = nRows; realPartDims[1].lLbound = 0; // Lower bound of the second dimension realPartDims[1].cElements = nCols; SAFEARRAY *realPart = ::SafeArrayCreate(VT_R8, 2, realPartDims); long lIndex[2]; double val; for (int i = 0; i < nRows; i++) { lIndex[0] = i; for (int j = 0; j < nCols; j++) { lIndex[1] = j; val=vArray[i*nCols+j]; m_hr = ::SafeArrayPutElement(realPart, lIndex, &val); if (FAILED(m_hr)) goto Exit; } } VARIANT vArgPutFullMatrix[4]; for (i = 0; i < 4; ++i) ::VariantInit(&vArgPutFullMatrix[i]); V_VT(&vArgPutFullMatrix[0]) = VT_ARRAY | VT_R8; V_ARRAY(&vArgPutFullMatrix[0]) = NULL; // do set to NULL when not complex V_VT(&vArgPutFullMatrix[1]) = VT_ARRAY | VT_R8; V_ARRAY(&vArgPutFullMatrix[1])= realPart; V_VT(&vArgPutFullMatrix[2]) = VT_BSTR; V_BSTR(&vArgPutFullMatrix[2]) = m_bstrWorkspace; V_VT(&vArgPutFullMatrix[3]) = VT_BSTR; V_BSTR(&vArgPutFullMatrix[3]) = bstrName; DISPPARAMS dpPutFullMatrix; dpPutFullMatrix.cArgs = 4; dpPutFullMatrix.cNamedArgs = 0; dpPutFullMatrix.rgvarg = vArgPutFullMatrix; m_hr = m_pMtlbDispApp ->Invoke(m_dispid_PutFullMatrix, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &dpPutFullMatrix, NULL, &m_excep, &m_uArgErr); if (FAILED(m_hr)) goto Exit; Exit: ::SysFreeString(bstrName); m_hr = ::SafeArrayDestroy(realPart); return m_hr; }
//+------------------------------------------------------------------------ // // Member: Item // // Synopsis: collection object model // // we handle the following parameter cases: // 0 params : by index = 0 // 1 params bstr : by name, index = 0 // 1 params # : by index // 2 params bstr, # : by name, index // 2 params #, bstr : by index, ignoring bstr // //------------------------------------------------------------------------- HRESULT CCollectionCache::Item(long lCollection, VARIANTARG var1, VARIANTARG var2, IDispatch** ppResult) { VARIANT* pvarName = NULL; VARIANT* pvarOne = NULL; VARIANT* pvarIndex = NULL; long lIndex = 0; HRESULT hr=E_INVALIDARG; if(!ppResult) { goto Cleanup; } *ppResult = NULL; pvarOne = (V_VT(&var1) == (VT_BYREF|VT_VARIANT)) ? V_VARIANTREF(&var1) : &var1; if((V_VT(pvarOne)==VT_BSTR) || V_VT(pvarOne)==(VT_BYREF|VT_BSTR)) { pvarName = (V_VT(pvarOne)&VT_BYREF) ? V_VARIANTREF(pvarOne) : pvarOne; if((V_VT(&var2)!=VT_ERROR) && (V_VT(&var2)!=VT_EMPTY)) { pvarIndex = &var2; } } else if((V_VT(&var1)!=VT_ERROR )&& (V_VT(&var1)!=VT_EMPTY)) { pvarIndex = &var1; } if(pvarIndex) { VARIANT varNum; VariantInit(&varNum); hr = VariantChangeTypeSpecial(&varNum, pvarIndex, VT_I4); if(hr) { goto Cleanup; } lIndex = V_I4(&varNum); } // Make sure our collection is up-to-date. hr = EnsureAry(lCollection); if(hr) { goto Cleanup; } // Get a collection or element of the specified object. if(pvarName) { BSTR Name = V_BSTR(pvarName); if(pvarIndex) { hr = GetDisp( lCollection, Name, lIndex, ppResult, FALSE); // BUBUG rgardner - shouldn't ignore case if(hr) { goto Cleanup; } } else { hr = GetDisp( lCollection, Name, CacheType_Named, ppResult, FALSE); // BUBUG rgardner - shouldn't ignore case if(FAILED(hr)) { HRESULT hrSave = hr; // save error code, and see if it a cell range hr = GetDisp( lCollection, Name, CacheType_CellRange, ppResult, FALSE); // BUBUG rgardner - shouldn't ignore case if(hr) { hr = hrSave; // restore error code goto Cleanup; } } } } else { hr = GetDisp(lCollection, lIndex, ppResult); if(hr) { goto Cleanup; } } Cleanup: // If we didn't find anything, make sure to just return NULL. if(hr == DISP_E_MEMBERNOTFOUND) { hr = S_OK; } RRETURN(hr); }
void TclObject::toVariant (VARIANT *pDest, const Type &type, Tcl_Interp *interp, bool addRef) { VariantClear(pDest); VARTYPE vt = type.vartype(); Reference *pReference = Extension::referenceHandles.find(interp, m_pObj); if (pReference != 0) { // Convert interface pointer handle to interface pointer. if (addRef) { // Must increment reference count of interface pointers returned // from methods. pReference->unknown()->AddRef(); } IDispatch *pDispatch = pReference->dispatch(); if (pDispatch != 0) { V_VT(pDest) = VT_DISPATCH; V_DISPATCH(pDest) = pDispatch; } else { V_VT(pDest) = VT_UNKNOWN; V_UNKNOWN(pDest) = pReference->unknown(); } } else if (m_pObj->typePtr == &Extension::unknownPointerType) { // Convert to interface pointer. IUnknown *pUnknown = static_cast<IUnknown *>( m_pObj->internalRep.otherValuePtr); if (addRef && pUnknown != 0) { // Must increment reference count of interface pointers returned // from methods. pUnknown->AddRef(); } V_VT(pDest) = VT_UNKNOWN; V_UNKNOWN(pDest) = pUnknown; } else if (vt == VT_SAFEARRAY) { const Type &elementType = type.elementType(); V_VT(pDest) = VT_ARRAY | elementType.vartype(); V_ARRAY(pDest) = getSafeArray(elementType, interp); } else if (m_pObj->typePtr == TclTypes::listType()) { // Convert Tcl list to array of VARIANT. int numElements; Tcl_Obj **pElements; if (Tcl_ListObjGetElements(interp, m_pObj, &numElements, &pElements) != TCL_OK) { _com_issue_error(E_INVALIDARG); } SAFEARRAYBOUND bounds[2]; bounds[0].cElements = numElements; bounds[0].lLbound = 0; unsigned numDimensions; // Check if the first element of the list is a list. if (numElements > 0 && pElements[0]->typePtr == TclTypes::listType()) { int colSize; Tcl_Obj **pCol; if (Tcl_ListObjGetElements(interp, pElements[0], &colSize, &pCol) != TCL_OK) { _com_issue_error(E_INVALIDARG); } bounds[1].cElements = colSize; bounds[1].lLbound = 0; numDimensions = 2; } else { numDimensions = 1; } SAFEARRAY *psa = SafeArrayCreate(VT_VARIANT, numDimensions, bounds); std::vector<long> indices(numDimensions); fillSafeArray(m_pObj, psa, 1, &indices[0], interp, addRef); V_VT(pDest) = VT_ARRAY | VT_VARIANT; V_ARRAY(pDest) = psa; #if TCL_MINOR_VERSION >= 1 } else if (m_pObj->typePtr == TclTypes::byteArrayType()) { // Convert Tcl byte array to SAFEARRAY of bytes. V_VT(pDest) = VT_ARRAY | VT_UI1; V_ARRAY(pDest) = newSafeArray(m_pObj, VT_UI1); #endif } else if (m_pObj->typePtr == &Extension::naType) { // This variant indicates a missing optional argument. VariantCopy(pDest, &vtMissing); } else if (m_pObj->typePtr == &Extension::nullType) { V_VT(pDest) = VT_NULL; } else if (m_pObj->typePtr == &Extension::variantType) { VariantCopy( pDest, static_cast<_variant_t *>(m_pObj->internalRep.otherValuePtr)); } else if (m_pObj->typePtr == TclTypes::intType()) { long value; if (Tcl_GetLongFromObj(interp, m_pObj, &value) != TCL_OK) { value = 0; } V_VT(pDest) = VT_I4; V_I4(pDest) = value; if (vt != VT_VARIANT && vt != VT_USERDEFINED) { VariantChangeType(pDest, pDest, 0, vt); } } else if (m_pObj->typePtr == TclTypes::doubleType()) { double value; if (Tcl_GetDoubleFromObj(interp, m_pObj, &value) != TCL_OK) { value = 0.0; } V_VT(pDest) = VT_R8; V_R8(pDest) = value; if (vt != VT_VARIANT && vt != VT_USERDEFINED) { VariantChangeType(pDest, pDest, 0, vt); } } else if (m_pObj->typePtr == TclTypes::booleanType()) { int value; if (Tcl_GetBooleanFromObj(interp, m_pObj, &value) != TCL_OK) { value = 0; } V_VT(pDest) = VT_BOOL; V_BOOL(pDest) = (value != 0) ? VARIANT_TRUE : VARIANT_FALSE; if (vt != VT_VARIANT && vt != VT_USERDEFINED) { VariantChangeType(pDest, pDest, 0, vt); } } else if (vt == VT_BOOL) { V_VT(pDest) = VT_BOOL; V_BOOL(pDest) = getBool() ? VARIANT_TRUE : VARIANT_FALSE; } else { V_VT(pDest) = VT_BSTR; V_BSTR(pDest) = getBSTR(); // If trying to convert from a string to a date, // we need to convert to a double (VT_R8) first. if (vt == VT_DATE) { VariantChangeType(pDest, pDest, 0, VT_R8); } // Try to convert from a string representation. if (vt != VT_VARIANT && vt != VT_USERDEFINED && vt != VT_LPWSTR) { VariantChangeType(pDest, pDest, 0, vt); } } }
void SMTPServersNT( CCFXRequest* pRequest ) { USES_CONVERSION; #ifdef _DEBUG CString tmp; pRequest->Write("DEBUGGING: ENTRY: SMTPServersNT<br>"); #endif // fields CCFXStringSet* pColumns = pRequest->CreateStringSet(); int iServer = pColumns->AddString( "Server" ); int iState = pColumns->AddString( "State" ); int iDescription = pColumns->AddString( "Description" ); int iBindings = pColumns->AddString( "Bindings" ); int iVersion = pColumns->AddString( "Version" ); int iMessageSizeLimit = pColumns->AddString( "MessageSizeLimit" ); int iSessionSizeLimit = pColumns->AddString( "SessionSizeLimit" ); int iMessagesPerConnectionLimit = pColumns->AddString( "MessagesPerConnectionLimit" ); int iRecipientsPerMessageLimit = pColumns->AddString( "RecipientsPerMessageLimit" ); int iBadMailDirectory = pColumns->AddString( "BadMailDirectory" ); int iNonDeliveryMailTo = pColumns->AddString( "NonDeliveryMailTo" ); int iBadMailTo = pColumns->AddString( "BadMailTo" ); int iRetryInterval = pColumns->AddString( "RetryInterval" ); int iDelayNotification = pColumns->AddString( "DelayNotification" ); int iExpirationTimeout = pColumns->AddString( "ExpirationTimeout" ); int iHopCount = pColumns->AddString( "HopCount" ); int iMasqueradeDomain = pColumns->AddString( "MasqueradeDomain" ); int iFullyQualifiedDomainName = pColumns->AddString( "FullyQualifiedDomainName" ); int iSmartHost = pColumns->AddString( "SmartHost" ); int iEnableReverseDnsLookup = pColumns->AddString( "EnableReverseDnsLookup" ); CCFXQuery* pQuery = pRequest->AddQuery( get_query_variable(), pColumns ); // optional CString strinComputer = pRequest->GetAttribute( "COMPUTER" ); pRequest->SetVariable( "IISComputer", strinComputer ); CString computer; if( strinComputer.IsEmpty() ) computer="LocalHost"; else computer=strinComputer; // HRESULT hr,hr2,hrw; CString pathe; // pathe.Format("IIS://%s/SmtpSVC",computer); #ifdef _DEBUG tmp.Format("DEBUGGING: Trying container %s...<br>",pathe); pRequest->Write(tmp); #endif IADsContainer *pContainer=NULL; hr=ADsGetObject(A2W(pathe), IID_IADsContainer, (void**)&pContainer); log_COMError(__LINE__,hr); // if(SUCCEEDED(hr)) { #ifdef _DEBUG pRequest->Write("DEBUGGING: success<br>"); #endif #ifdef _DEBUG pRequest->Write("DEBUGGING: enumerating container...<br>"); #endif // IEnumVARIANT *pEnum=NULL; hrw = ADsBuildEnumerator(pContainer, &pEnum); log_COMError(__LINE__,hrw); // hr2=pContainer->Release(); log_COMError(__LINE__,hr2); // if(SUCCEEDED(hrw)) { #ifdef _DEBUG pRequest->Write("DEBUGGING: success<br>"); #endif // VARIANT var; ULONG ulElements=1; // while ( (SUCCEEDED(hrw)) && (ulElements==1) ) { #ifdef _DEBUG tmp.Format("DEBUGGING: enumerating %d elements...<br>",ulElements); pRequest->Write(tmp); #endif // hrw = ADsEnumerateNext(pEnum, 1, &var, &ulElements); log_COMError(__LINE__,hrw); // if(SUCCEEDED(hrw) && (ulElements==1) ) { #ifdef _DEBUG pRequest->Write("DEBUGGING: success<br>"); #endif // CString strServer; CString strState; CString strDescription; CString strBindings; CString strVersion; CString strMessageSizeLimit; CString strSessionSizeLimit; CString strMessagesPerConnectionLimit; CString strRecipientsPerMessageLimit; CString strBadMailDirectory; CString strNonDeliveryMailTo; CString strBadMailTo; CString strRetryInterval; CString strDelayNotification; CString strExpirationTimeout; CString strHopCount; CString strMasqueradeDomain; CString strFullyQualifiedDomainName; CString strSmartHost; CString strEnableReverseDnsLookup; // IADs *pADs=(IADs*)var.pdispVal; // BSTR bstrName; hr2 = pADs->get_Name(&bstrName); log_COMError(__LINE__,hr2); if(SUCCEEDED(hr2)) strServer=bstrName; BSTR bstrClass; hr2 = pADs->get_Class(&bstrClass); log_COMError(__LINE__,hr2); CString strClass; if(SUCCEEDED(hr2)) strClass=bstrClass; #ifdef _DEBUG tmp.Format("DEBUGGING: server %s class %s...<br>",strServer,strClass); pRequest->Write(tmp); #endif // if(strClass.Compare("IIsSmtpServer")==0) { #ifdef _DEBUG pRequest->Write("DEBUGGING: success<br>"); #endif // VARIANT var; VariantInit(&var); // hr2 = pADs->Get(L"ServerState",&var); if(SUCCEEDED(hr2)) { switch(V_INT(&var)) { case MD_SERVER_STATE_STARTING: strState="Starting"; break; case MD_SERVER_STATE_STARTED: strState="Started"; break; case MD_SERVER_STATE_STOPPING: strState="Stopping"; break; case MD_SERVER_STATE_STOPPED: strState="Stopped"; break; case MD_SERVER_STATE_PAUSING: strState="Pausing"; break; case MD_SERVER_STATE_PAUSED: strState="Paused"; break; case MD_SERVER_STATE_CONTINUING: strState="Continuing"; break; default: strState="Unknown"; } } VariantClear(&var); hr2 = pADs->Get(L"ServerComment",&var); if(SUCCEEDED(hr2)) strDescription = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"ServerBindings",&var); if(SUCCEEDED(hr2)) { VARIANTARRAYtoCString(var,strBindings,pRequest,';'); } VariantClear(&var); hr2 = pADs->Get(L"SmtpServiceVersion",&var); if(SUCCEEDED(hr2)) strVersion.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"MaxMessageSize",&var); if(SUCCEEDED(hr2)) strMessageSizeLimit.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"MaxSessionSize",&var); if(SUCCEEDED(hr2)) strSessionSizeLimit.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"MaxBatchedMessages",&var); if(SUCCEEDED(hr2)) strMessagesPerConnectionLimit.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"MaxRecipients",&var); if(SUCCEEDED(hr2)) strRecipientsPerMessageLimit.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"BadMailDirectory",&var); if(SUCCEEDED(hr2)) strBadMailDirectory = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"SendNdrTo",&var); if(SUCCEEDED(hr2)) strNonDeliveryMailTo = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"SendBadTo",&var); if(SUCCEEDED(hr2)) strBadMailTo = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"SmtpRemoteProgressiveRetry",&var); if(SUCCEEDED(hr2)) strRetryInterval = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"SmtpLocalDelayExpireMinutes",&var); if(SUCCEEDED(hr2)) strDelayNotification.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"SmtpLocalNDRExpireMinutes",&var); if(SUCCEEDED(hr2)) strExpirationTimeout.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"HopCount",&var); if(SUCCEEDED(hr2)) strHopCount.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"MasqueradeDomain",&var); if(SUCCEEDED(hr2)) strMasqueradeDomain = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"FullyQualifiedDomainName",&var); if(SUCCEEDED(hr2)) strFullyQualifiedDomainName = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"SmartHost",&var); if(SUCCEEDED(hr2)) strSmartHost = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"EnableReverseDnsLookup",&var); if(SUCCEEDED(hr2)) strEnableReverseDnsLookup.Format("%d",abs(V_BOOL(&var))); VariantClear(&var); // int iRow = pQuery->AddRow(); pQuery->SetData( iRow, iServer, strServer ); pQuery->SetData( iRow, iState, strState ); pQuery->SetData( iRow, iDescription, strDescription ); pQuery->SetData( iRow, iBindings, strBindings ); pQuery->SetData( iRow, iVersion, strVersion ); pQuery->SetData( iRow, iMessageSizeLimit, strMessageSizeLimit ); pQuery->SetData( iRow, iSessionSizeLimit, strSessionSizeLimit ); pQuery->SetData( iRow, iMessagesPerConnectionLimit, strMessagesPerConnectionLimit ); pQuery->SetData( iRow, iRecipientsPerMessageLimit, strRecipientsPerMessageLimit ); pQuery->SetData( iRow, iBadMailDirectory, strBadMailDirectory ); pQuery->SetData( iRow, iNonDeliveryMailTo, strNonDeliveryMailTo ); pQuery->SetData( iRow, iBadMailTo, strBadMailTo ); pQuery->SetData( iRow, iRetryInterval, strRetryInterval ); pQuery->SetData( iRow, iDelayNotification, strDelayNotification ); pQuery->SetData( iRow, iExpirationTimeout, strExpirationTimeout ); pQuery->SetData( iRow, iHopCount, strHopCount ); pQuery->SetData( iRow, iMasqueradeDomain, strMasqueradeDomain ); pQuery->SetData( iRow, iFullyQualifiedDomainName, strFullyQualifiedDomainName ); pQuery->SetData( iRow, iSmartHost, strSmartHost ); pQuery->SetData( iRow, iEnableReverseDnsLookup, strEnableReverseDnsLookup ); } // hr2=pADs->Release(); log_COMError(__LINE__,hr2); // SysFreeString(bstrClass); SysFreeString(bstrName); } } } // hr2 = ADsFreeEnumerator(pEnum); log_COMError(__LINE__,hr2); } #ifdef _DEBUG pRequest->Write("DEBUGGING: EXIT: SMTPServersNT<br>"); #endif }
static HRESULT WINAPI HTMLElementCollection_item(IHTMLElementCollection *iface, VARIANT name, VARIANT index, IDispatch **pdisp) { HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface); HRESULT hres = S_OK; TRACE("(%p)->(%s %s %p)\n", This, debugstr_variant(&name), debugstr_variant(&index), pdisp); *pdisp = NULL; switch(V_VT(&name)) { case VT_I4: if(V_I4(&name) < 0) return E_INVALIDARG; hres = get_item_idx(This, V_I4(&name), pdisp); break; case VT_UINT: hres = get_item_idx(This, V_UINT(&name), pdisp); break; case VT_BSTR: { DWORD i; if(V_VT(&index) == VT_I4) { LONG idx = V_I4(&index); if(idx < 0) return E_INVALIDARG; for(i=0; i<This->len; i++) { if(is_elem_name(This->elems[i], V_BSTR(&name)) && !idx--) break; } if(i != This->len) { *pdisp = (IDispatch*)&This->elems[i]->IHTMLElement_iface; IDispatch_AddRef(*pdisp); } }else { elem_vector_t buf = {NULL, 0, 8}; buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*)); for(i=0; i<This->len; i++) { if(is_elem_name(This->elems[i], V_BSTR(&name))) { node_addref(&This->elems[i]->node); elem_vector_add(&buf, This->elems[i]); } } if(buf.len > 1) { elem_vector_normalize(&buf); *pdisp = (IDispatch*)HTMLElementCollection_Create(buf.buf, buf.len); }else { if(buf.len == 1) { /* Already AddRef-ed */ *pdisp = (IDispatch*)&buf.buf[0]->IHTMLElement_iface; } heap_free(buf.buf); } } break; } default: FIXME("Unsupported name %s\n", debugstr_variant(&name)); hres = E_NOTIMPL; } if(SUCCEEDED(hres)) TRACE("returning %p\n", *pdisp); return hres; }
static HRESULT STDMETHODCALLTYPE dispatch_Invoke(IDispatch* self, DISPID disp_id, REFIID riid, LCID lcid, WORD flags, DISPPARAMS* params, VARIANT* var_res, EXCEPINFO* except, UINT* arg_err) { html_t* html = MC_HTML_FROM_DISPTACH(self); switch(disp_id) { case DISPID_BEFORENAVIGATE2: { BSTR url = V_BSTR(V_VARIANTREF(¶ms->rgvarg[5])); VARIANT_BOOL* cancel = V_BOOLREF(¶ms->rgvarg[0]); HTML_TRACE("dispatch_Invoke: DISPID_BEFORENAVIGATE2(%S)", url); if(url != NULL && wcsncmp(url, L"app:", 4) == 0) { html_notify_text(html, MC_HN_APPLINK, url); *cancel = VARIANT_TRUE; } break; } #if 0 /* Unfortunately, IE does not send DISPID_DOCUMENTCOMPLETE * when refreshing the page (e.g. from context menu). So we workaround * via DISPID_PROGRESSCHANGE below. */ case DISPID_DOCUMENTCOMPLETE: { BSTR url = V_BSTR(V_VARIANTREF(¶ms->rgvarg[0])); html_notify_text(html, MC_HN_DOCUMENTCOMPLETE, url); break; } #endif case DISPID_PROGRESSCHANGE: { LONG progress_max = V_I4(¶ms->rgvarg[0]); LONG progress = V_I4(¶ms->rgvarg[1]); MC_NMHTMLPROGRESS notify; HTML_TRACE("dispatch_Invoke: DISPID_PROGRESSCHANGE(%ld, %ld)", progress, progress_max); /* Send also notification about the progress */ notify.hdr.hwndFrom = html->win; notify.hdr.idFrom = GetDlgCtrlID(html->win); notify.hdr.code = MC_HN_PROGRESS; notify.lProgress = progress; notify.lProgressMax = progress_max; MC_SEND(html->notify_win, WM_NOTIFY, notify.hdr.idFrom, ¬ify); /* This replaces DISPID_DOCUMENTCOMPLETE above */ if(progress < 0 || progress_max < 0) { IWebBrowser2* browser_iface; HRESULT hr; hr = html->browser_obj->lpVtbl->QueryInterface(html->browser_obj, &IID_IWebBrowser2, (void**)&browser_iface); if(MC_ERR(hr != S_OK || browser_iface == NULL)) { MC_TRACE("dispatch_Invoke(DISPID_PROGRESSCHANGE): " "QueryInterface(IID_IWebBrowser2) failed [0x%lx]", hr); } else { BSTR url = NULL; hr = browser_iface->lpVtbl->get_LocationURL(browser_iface, &url); if(hr == S_OK && url != NULL) { html_notify_text(html, MC_HN_DOCUMENTCOMPLETE, url); html_SysFreeString(url); } browser_iface->lpVtbl->Release(browser_iface); } } break; } case DISPID_STATUSTEXTCHANGE: html_notify_text(html, MC_HN_STATUSTEXT, V_BSTR(¶ms->rgvarg[0])); break; case DISPID_TITLECHANGE: html_notify_text(html, MC_HN_TITLETEXT, V_BSTR(¶ms->rgvarg[0])); break; case DISPID_COMMANDSTATECHANGE: { LONG cmd = V_I4(¶ms->rgvarg[1]); if(cmd == CSC_NAVIGATEBACK || cmd == CSC_NAVIGATEFORWARD) { MC_NMHTMLHISTORY notify; BOOL enabled = (V_BOOL(¶ms->rgvarg[0]) != VARIANT_FALSE); if(cmd == CSC_NAVIGATEBACK) html->can_back = enabled; else html->can_forward = enabled; notify.hdr.hwndFrom = html->win; notify.hdr.idFrom = GetDlgCtrlID(html->win); notify.hdr.code = MC_HN_HISTORY; notify.bCanBack = html->can_back; notify.bCanForward = html->can_forward; MC_SEND(html->notify_win, WM_NOTIFY, notify.hdr.idFrom, ¬ify); } break; } case DISPID_NEWWINDOW2: /* This is called instead of DISPID_NEWWINDOW3 on Windows XP SP2 * and older. */ { VARIANT_BOOL* cancel = V_BOOLREF(¶ms->rgvarg[0]); if(html_notify_text(html, MC_HN_NEWWINDOW, L"") == 0) { *cancel = VARIANT_TRUE; HTML_TRACE("dispatch_Invoke(DISPID_NEWWINDOW2): Canceled."); } break; } case DISPID_NEWWINDOW3: { BSTR url = V_BSTR(¶ms->rgvarg[0]); VARIANT_BOOL* cancel = V_BOOLREF(¶ms->rgvarg[3]); if(html_notify_text(html, MC_HN_NEWWINDOW, url) == 0) { *cancel = VARIANT_TRUE; HTML_TRACE("dispatch_Invoke(DISPID_NEWWINDOW3, '%S'): Canceled.", url); } break; } default: HTML_TRACE("dispatch_Invoke: disp_id %d", disp_id); return DISP_E_MEMBERNOTFOUND; } return S_OK; }
static HRESULT function_invoke(DispatchEx *This, func_info_t *func, WORD flags, DISPPARAMS *dp, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller) { HRESULT hres; switch(flags) { case DISPATCH_METHOD|DISPATCH_PROPERTYGET: if(!res) return E_INVALIDARG; /* fall through */ case DISPATCH_METHOD: if(This->dynamic_data && This->dynamic_data->func_disps && This->dynamic_data->func_disps[func->func_disp_idx].func_obj) { func_obj_entry_t *entry = This->dynamic_data->func_disps + func->func_disp_idx; if(V_VT(&entry->val) != VT_DISPATCH) { FIXME("calling %s not supported\n", debugstr_variant(&entry->val)); return E_NOTIMPL; } if((IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface != V_DISPATCH(&entry->val)) { if(!V_DISPATCH(&entry->val)) { FIXME("Calling null\n"); return E_FAIL; } hres = invoke_disp_value(This, V_DISPATCH(&entry->val), 0, flags, dp, res, ei, NULL); break; } } if(func->call_vtbl_off) hres = invoke_builtin_function(This, func, dp, res, caller); else hres = typeinfo_invoke(This, func, flags, dp, res, ei); break; case DISPATCH_PROPERTYGET: { func_obj_entry_t *entry; if(func->id == DISPID_VALUE) { BSTR ret; ret = SysAllocString(objectW); if(!ret) return E_OUTOFMEMORY; V_VT(res) = VT_BSTR; V_BSTR(res) = ret; return S_OK; } hres = get_func_obj_entry(This, func, &entry); if(FAILED(hres)) return hres; V_VT(res) = VT_EMPTY; return VariantCopy(res, &entry->val); } case DISPATCH_PROPERTYPUT: { func_obj_entry_t *entry; if(dp->cArgs != 1 || (dp->cNamedArgs == 1 && *dp->rgdispidNamedArgs != DISPID_PROPERTYPUT) || dp->cNamedArgs > 1) { FIXME("invalid args\n"); return E_INVALIDARG; } /* * NOTE: Although we have IDispatchEx tests showing, that it's not allowed to set * function property using InvokeEx, it's possible to do that from jscript. * Native probably uses some undocumented interface in this case, but it should * be fine for us to allow IDispatchEx handle that. */ hres = get_func_obj_entry(This, func, &entry); if(FAILED(hres)) return hres; return VariantCopy(&entry->val, dp->rgvarg); } default: FIXME("Unimplemented flags %x\n", flags); hres = E_NOTIMPL; } return hres; }
HRESULT variant_to_jsval(VARIANT *var, jsval_t *r) { if(V_VT(var) == (VT_VARIANT|VT_BYREF)) var = V_VARIANTREF(var); switch(V_VT(var)) { case VT_EMPTY: *r = jsval_undefined(); return S_OK; case VT_NULL: *r = jsval_null(); return S_OK; case VT_BOOL: *r = jsval_bool(V_BOOL(var)); return S_OK; case VT_I4: *r = jsval_number(V_I4(var)); return S_OK; case VT_R8: *r = jsval_number(V_R8(var)); return S_OK; case VT_BSTR: { jsstr_t *str; if(V_BSTR(var)) { str = jsstr_alloc_len(V_BSTR(var), SysStringLen(V_BSTR(var))); if(!str) return E_OUTOFMEMORY; }else { str = jsstr_null_bstr(); } *r = jsval_string(str); return S_OK; } case VT_DISPATCH: { if(V_DISPATCH(var)) IDispatch_AddRef(V_DISPATCH(var)); *r = jsval_disp(V_DISPATCH(var)); return S_OK; } case VT_I2: *r = jsval_number(V_I2(var)); return S_OK; case VT_UI2: *r = jsval_number(V_UI2(var)); return S_OK; case VT_INT: *r = jsval_number(V_INT(var)); return S_OK; case VT_UI4: *r = jsval_number(V_UI4(var)); return S_OK; case VT_UI8: /* * Native doesn't support VT_UI8 here, but it's needed for IE9+ APIs * (native IE9 doesn't use jscript.dll for JavaScript). */ *r = jsval_number(V_UI8(var)); return S_OK; case VT_R4: *r = jsval_number(V_R4(var)); return S_OK; case VT_UNKNOWN: if(V_UNKNOWN(var)) { IDispatch *disp; HRESULT hres; hres = IUnknown_QueryInterface(V_UNKNOWN(var), &IID_IDispatch, (void**)&disp); if(SUCCEEDED(hres)) { *r = jsval_disp(disp); return S_OK; } }else { *r = jsval_disp(NULL); return S_OK; } /* fall through */ default: return jsval_variant(r, var); } }
static HRESULT DXDiag_InitDXDiagDirectShowFiltersContainer(IDxDiagContainer* pSubCont) { HRESULT hr = S_OK; static const WCHAR szName[] = {'s','z','N','a','m','e',0}; static const WCHAR szCatName[] = {'s','z','C','a','t','N','a','m','e',0}; static const WCHAR szClsidCat[] = {'s','z','C','l','s','i','d','C','a','t',0}; static const WCHAR szClsidFilter[] = {'s','z','C','l','s','i','d','F','i','l','t','e','r',0}; static const WCHAR dwInputs[] = {'d','w','I','n','p','u','t','s',0}; static const WCHAR dwOutputs[] = {'d','w','O','u','t','p','u','t','s',0}; static const WCHAR dwMerit[] = {'d','w','M','e','r','i','t',0}; /* static const WCHAR szFileName[] = {'s','z','F','i','l','e','N','a','m','e',0}; static const WCHAR szFileVersion[] = {'s','z','F','i','l','e','V','e','r','s','i','o','n',0}; */ VARIANT v; static const WCHAR wszClsidName[] = {'C','L','S','I','D',0}; static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0}; static const WCHAR wszFilterDataName[] = {'F','i','l','t','e','r','D','a','t','a',0}; /*static const WCHAR wszMeritName[] = {'M','e','r','i','t',0};*/ ICreateDevEnum* pCreateDevEnum = NULL; IEnumMoniker* pEmCat = NULL; IMoniker* pMCat = NULL; /** */ hr = CoCreateInstance(&CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, &IID_ICreateDevEnum, (void**) &pCreateDevEnum); if (FAILED(hr)) return hr; hr = ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum, &CLSID_ActiveMovieCategories, &pEmCat, 0); if (FAILED(hr)) goto out_show_filters; VariantInit(&v); while (S_OK == IEnumMoniker_Next(pEmCat, 1, &pMCat, NULL)) { IPropertyBag* pPropBag = NULL; CLSID clsidCat; hr = IMoniker_BindToStorage(pMCat, NULL, NULL, &IID_IPropertyBag, (void**) &pPropBag); if (SUCCEEDED(hr)) { WCHAR* wszCatName = NULL; WCHAR* wszCatClsid = NULL; hr = IPropertyBag_Read(pPropBag, wszFriendlyName, &v, 0); wszCatName = SysAllocString(V_BSTR(&v)); VariantClear(&v); hr = IPropertyBag_Read(pPropBag, wszClsidName, &v, 0); wszCatClsid = SysAllocString(V_BSTR(&v)); hr = CLSIDFromString(V_UNION(&v, bstrVal), &clsidCat); VariantClear(&v); /* hr = IPropertyBag_Read(pPropBag, wszMeritName, &v, 0); hr = IDxDiagContainerImpl_AddProp(pSubCont, dwMerit, &v); VariantClear(&v); */ if (SUCCEEDED(hr)) { IEnumMoniker* pEnum = NULL; IMoniker* pMoniker = NULL; hr = ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum, &clsidCat, &pEnum, 0); TRACE("\tClassEnumerator for clsid(%s) pEnum(%p)\n", debugstr_guid(&clsidCat), pEnum); if (FAILED(hr) || pEnum == NULL) { goto class_enum_failed; } while (NULL != pEnum && S_OK == IEnumMoniker_Next(pEnum, 1, &pMoniker, NULL)) { IPropertyBag* pPropFilterBag = NULL; TRACE("\tIEnumMoniker_Next(%p, 1, %p)\n", pEnum, pMoniker); hr = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (void**) &pPropFilterBag); if (SUCCEEDED(hr)) { LPBYTE pData = NULL; LPBYTE pCurrent = NULL; struct REG_RF* prrf = NULL; DWORD it; DWORD dwNOutputs = 0; DWORD dwNInputs = 0; add_prop_str(pSubCont, szCatName, wszCatName); add_prop_str(pSubCont, szClsidCat, wszCatClsid); hr = IPropertyBag_Read(pPropFilterBag, wszFriendlyName, &v, 0); hr = IDxDiagContainerImpl_AddProp(pSubCont, szName, &v); TRACE("\tName:%s\n", debugstr_w(V_BSTR(&v))); VariantClear(&v); hr = IPropertyBag_Read(pPropFilterBag, wszClsidName, &v, 0); TRACE("\tClsid:%s\n", debugstr_w(V_BSTR(&v))); hr = IDxDiagContainerImpl_AddProp(pSubCont, szClsidFilter, &v); VariantClear(&v); hr = IPropertyBag_Read(pPropFilterBag, wszFilterDataName, &v, NULL); hr = SafeArrayAccessData(V_UNION(&v, parray), (LPVOID*) &pData); prrf = (struct REG_RF*) pData; pCurrent = pData; add_prop_ui4(pSubCont, szName, prrf->dwVersion); add_prop_ui4(pSubCont, dwMerit, prrf->dwMerit); pCurrent += sizeof(struct REG_RF); for (it = 0; it < prrf->dwPins; ++it) { struct REG_RFP* prrfp = (struct REG_RFP*) pCurrent; UINT j; if (prrfp->dwFlags & REG_PINFLAG_B_OUTPUT) ++dwNOutputs; else ++dwNInputs; pCurrent += sizeof(struct REG_RFP); if (prrfp->bCategory) { pCurrent += sizeof(DWORD); } for (j = 0; j < prrfp->dwMediaTypes; ++j) { struct REG_TYPE* prt = (struct REG_TYPE *)pCurrent; pCurrent += sizeof(*prt); } for (j = 0; j < prrfp->dwMediums; ++j) { DWORD dwOffset = *(DWORD*) pCurrent; pCurrent += sizeof(dwOffset); } } add_prop_ui4(pSubCont, dwInputs, dwNInputs); add_prop_ui4(pSubCont, dwOutputs, dwNOutputs); SafeArrayUnaccessData(V_UNION(&v, parray)); VariantClear(&v); } IPropertyBag_Release(pPropFilterBag); pPropFilterBag = NULL; } IEnumMoniker_Release(pEnum); pEnum = NULL; } class_enum_failed: SysFreeString(wszCatName); SysFreeString(wszCatClsid); IPropertyBag_Release(pPropBag); pPropBag = NULL; } IEnumMoniker_Release(pMCat); pMCat = NULL; } out_show_filters: if (NULL != pEmCat) { IEnumMoniker_Release(pEmCat); pEmCat = NULL; } if (NULL != pCreateDevEnum) { ICreateDevEnum_Release(pCreateDevEnum); pCreateDevEnum = NULL; } return hr; }
HRESULT navigate_url(DocHost *This, LPCWSTR url, const VARIANT *Flags, const VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers) { SAFEARRAY *post_array = NULL; 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 && V_VT(Flags) != VT_ERROR) || (TargetFrameName && V_VT(TargetFrameName) != VT_EMPTY && V_VT(TargetFrameName) != VT_ERROR)) FIXME("Unsupported args (Flags %s; TargetFrameName %s)\n", debugstr_variant(Flags), debugstr_variant(TargetFrameName)); if(PostData) { if(V_VT(PostData) & VT_ARRAY) post_array = V_ISBYREF(PostData) ? *V_ARRAYREF(PostData) : V_ARRAY(PostData); else WARN("Invalid post data %s\n", debugstr_variant(PostData)); } if(post_array) { LONG elem_max; SafeArrayAccessData(post_array, (void**)&post_data); SafeArrayGetUBound(post_array, 1, &elem_max); post_data_len = (elem_max+1) * SafeArrayGetElemsize(post_array); } 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 | URL_APPLY_GUESSFILE | URL_APPLY_DEFAULT); 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, navigate_bsc_task_destr, This->url == NULL); } if(post_data) SafeArrayUnaccessData(post_array); return hres; }
/*** IDataInitialize methods ***/ static HRESULT WINAPI datainit_GetDataSource(IDataInitialize *iface, IUnknown *outer, DWORD clsctx, LPWSTR initstring, REFIID riid, IUnknown **datasource) { static const WCHAR providerW[] = {'P','r','o','v','i','d','e','r','=',0}; static const WCHAR msdasqlW[] = {'M','S','D','A','S','Q','L',0}; datainit *This = impl_from_IDataInitialize(iface); IDBProperties *dbprops; DBPROPSET *propset; WCHAR *prov = NULL; CLSID provclsid; HRESULT hr; TRACE("(%p)->(%p 0x%x %s %s %p)\n", This, outer, clsctx, debugstr_w(initstring), debugstr_guid(riid), datasource); /* first get provider name */ provclsid = IID_NULL; if (initstring && (prov = strstrW(initstring, providerW))) { WCHAR *start, *progid; int len; prov += sizeof(providerW)/sizeof(WCHAR)-1; start = prov; while (*prov && *prov != ';') ++prov; TRACE("got provider %s\n", debugstr_wn(start, prov-start)); len = prov - start; progid = CoTaskMemAlloc((len+1)*sizeof(WCHAR)); if (!progid) return E_OUTOFMEMORY; memcpy(progid, start, len*sizeof(WCHAR)); progid[len] = 0; hr = CLSIDFromProgID(progid, &provclsid); CoTaskMemFree(progid); if (FAILED(hr)) { ERR("provider %s not registered\n", debugstr_wn(start, prov-start)); return hr; } } else { hr = CLSIDFromProgID(msdasqlW, &provclsid); if (FAILED(hr)) ERR("ODBC provider for OLE DB not registered\n"); } /* check for provider mismatch if it was specified in init string */ if (*datasource && prov) { DBPROPIDSET propidset; enum DBPROPENUM prop; CLSID initprov; ULONG count; hr = IUnknown_QueryInterface(*datasource, &IID_IDBProperties, (void**)&dbprops); if (FAILED(hr)) { WARN("provider doesn't support IDBProperties\n"); return hr; } prop = DBPROP_INIT_DATASOURCE; propidset.rgPropertyIDs = ∝ propidset.cPropertyIDs = 1; propidset.guidPropertySet = DBPROPSET_DBINIT; count = 0; propset = NULL; hr = IDBProperties_GetProperties(dbprops, 1, &propidset, &count, &propset); IDBProperties_Release(dbprops); if (FAILED(hr)) { WARN("GetProperties failed for datasource, 0x%08x\n", hr); return hr; } TRACE("initial data source provider %s\n", debugstr_w(V_BSTR(&propset->rgProperties[0].vValue))); initprov = IID_NULL; CLSIDFromProgID(V_BSTR(&propset->rgProperties[0].vValue), &initprov); free_dbpropset(count, propset); if (!IsEqualIID(&provclsid, &initprov)) return DB_E_MISMATCHEDPROVIDER; } if (!*datasource) { if (!IsEqualIID(&provclsid, &IID_NULL)) hr = CoCreateInstance(&provclsid, outer, clsctx, riid, (void**)datasource); if (FAILED(hr) && IsEqualIID(riid, &IID_IDBInitialize)) hr = create_db_init(datasource); } /* now set properties */ if (initstring) { WCHAR *eq, *start; hr = IUnknown_QueryInterface(*datasource, &IID_IDBProperties, (void**)&dbprops); if (FAILED(hr)) { WARN("provider doesn't support IDBProperties\n"); return hr; } start = initstring; while (start && (eq = strchrW(start, '='))) { static const WCHAR providerW[] = {'P','r','o','v','i','d','e','r',0}; WCHAR *scol = strchrW(eq+1, ';'); BSTR value, name; name = SysAllocStringLen(start, eq - start); /* skip equal sign to get value */ eq++; value = SysAllocStringLen(eq, scol ? scol - eq : -1); /* skip semicolon if present */ if (scol) scol++; start = scol; if (!strcmpW(name, providerW)) { SysFreeString(name); SysFreeString(value); continue; } TRACE("property (name=%s, value=%s)\n", debugstr_w(name), debugstr_w(value)); hr = set_dbpropset(name, value, &propset); SysFreeString(name); SysFreeString(value); if (FAILED(hr)) break; hr = IDBProperties_SetProperties(dbprops, 1, propset); free_dbpropset(1, propset); TRACE("provider ret 0x%08x\n", hr); } IDBProperties_Release(dbprops); } return hr; }
static HRESULT WINAPI DocObjectService_FireBeforeNavigate2( IDocObjectService* iface, IDispatch *pDispatch, LPCWSTR lpszUrl, DWORD dwFlags, LPCWSTR lpszFrameName, BYTE *pPostData, DWORD cbPostData, LPCWSTR lpszHeaders, BOOL fPlayNavSound, BOOL *pfCancel) { ShellBrowser *This = impl_from_IDocObjectService(iface); VARIANT var_url, var_flags, var_frame_name, var_post_data, var_post_data2, var_headers; VARIANTARG params[7]; DISPPARAMS dp = {params, NULL, 7, 0}; VARIANT_BOOL cancel = VARIANT_FALSE; SAFEARRAY *post_data; TRACE("%p %p %s %x %s %p %d %s %d %p\n", This, pDispatch, debugstr_w(lpszUrl), dwFlags, debugstr_w(lpszFrameName), pPostData, cbPostData, debugstr_w(lpszHeaders), fPlayNavSound, pfCancel); if(cbPostData) { post_data = SafeArrayCreateVector(VT_UI1, 0, cbPostData); if(!post_data) return E_OUTOFMEMORY; memcpy(post_data->pvData, pPostData, cbPostData); }else { post_data = NULL; } V_VT(params) = VT_BOOL|VT_BYREF; V_BOOLREF(params) = &cancel; V_VT(params+1) = (VT_BYREF|VT_VARIANT); V_VARIANTREF(params+1) = &var_headers; V_VT(&var_headers) = VT_BSTR; V_BSTR(&var_headers) = lpszHeaders ? SysAllocString(lpszHeaders) : NULL; V_VT(params+2) = (VT_BYREF|VT_VARIANT); V_VARIANTREF(params+2) = &var_post_data2; V_VT(&var_post_data2) = (VT_BYREF|VT_VARIANT); V_VARIANTREF(&var_post_data2) = &var_post_data; if(post_data) { V_VT(&var_post_data) = VT_UI1|VT_ARRAY; V_ARRAY(&var_post_data) = post_data; }else { V_VT(&var_post_data) = VT_EMPTY; } V_VT(params+3) = (VT_BYREF|VT_VARIANT); V_VARIANTREF(params+3) = &var_frame_name; V_VT(&var_frame_name) = VT_BSTR; V_BSTR(&var_frame_name) = NULL; V_VT(params+4) = (VT_BYREF|VT_VARIANT); V_VARIANTREF(params+4) = &var_flags; V_VT(&var_flags) = VT_I4; V_I4(&var_flags) = 0; V_VT(params+5) = (VT_BYREF|VT_VARIANT); V_VARIANTREF(params+5) = &var_url; V_VT(&var_url) = VT_BSTR; V_BSTR(&var_url) = SysAllocString(lpszUrl); V_VT(params+6) = (VT_DISPATCH); V_DISPATCH(params+6) = (IDispatch*)This->doc_host->wb; TRACE(">>>\n"); call_sink(This->doc_host->cps.wbe2, DISPID_BEFORENAVIGATE2, &dp); TRACE("<<<\n"); SysFreeString(V_BSTR(&var_url)); SysFreeString(V_BSTR(&var_headers)); SafeArrayDestroy(post_data); *pfCancel = !!cancel; return S_OK; }
HRESULT variant_change_type(script_ctx_t *ctx, VARIANT *dst, VARIANT *src, VARTYPE vt) { jsval_t val; HRESULT hres; clear_ei(ctx); hres = variant_to_jsval(src, &val); if(FAILED(hres)) return hres; switch(vt) { case VT_I2: case VT_I4: { INT i; hres = to_int32(ctx, val, &i); if(SUCCEEDED(hres)) { if(vt == VT_I4) V_I4(dst) = i; else V_I2(dst) = i; } break; } case VT_R8: { double n; hres = to_number(ctx, val, &n); if(SUCCEEDED(hres)) V_R8(dst) = n; break; } case VT_R4: { double n; hres = to_number(ctx, val, &n); if(SUCCEEDED(hres)) V_R4(dst) = n; break; } case VT_BOOL: { BOOL b; hres = to_boolean(val, &b); if(SUCCEEDED(hres)) V_BOOL(dst) = b ? VARIANT_TRUE : VARIANT_FALSE; break; } case VT_BSTR: { jsstr_t *str; hres = to_string(ctx, val, &str); if(FAILED(hres)) break; if(str->length_flags & JSSTR_FLAG_NULLBSTR) { V_BSTR(dst) = NULL; break; } V_BSTR(dst) = SysAllocStringLen(str->str, jsstr_length(str)); if(!V_BSTR(dst)) hres = E_OUTOFMEMORY; break; } case VT_EMPTY: hres = V_VT(src) == VT_EMPTY ? S_OK : E_NOTIMPL; break; case VT_NULL: hres = V_VT(src) == VT_NULL ? S_OK : E_NOTIMPL; break; default: FIXME("vt %d not implemented\n", vt); hres = E_NOTIMPL; } jsval_release(val); if(FAILED(hres)) return hres; V_VT(dst) = vt; return S_OK; }
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 | URL_APPLY_GUESSFILE | URL_APPLY_DEFAULT); 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, navigate_bsc_task_destr, This->url == NULL); } if(post_data) SafeArrayUnaccessData(V_ARRAY(PostData)); return hres; }
/*********************************************************************** * AtlAxCreateControlEx [ATL.@] * * REMARKS * See http://www.codeproject.com/com/cwebpage.asp for some background * */ HRESULT WINAPI AtlAxCreateControlEx(LPCOLESTR lpszName, HWND hWnd, IStream *pStream, IUnknown **ppUnkContainer, IUnknown **ppUnkControl, REFIID iidSink, IUnknown *punkSink) { CLSID controlId; HRESULT hRes; IOleObject *pControl; IUnknown *pUnkControl; IPersistStreamInit *pPSInit; IUnknown *pContainer; enum {IsGUID=0,IsHTML=1,IsURL=2} content; TRACE("(%s %p %p %p %p %p %p)\n", debugstr_w(lpszName), hWnd, pStream, ppUnkContainer, ppUnkControl, iidSink, punkSink); hRes = CLSIDFromString( lpszName, &controlId ); if ( FAILED(hRes) ) hRes = CLSIDFromProgID( lpszName, &controlId ); if ( SUCCEEDED( hRes ) ) content = IsGUID; else { /* FIXME - check for MSHTML: prefix! */ content = IsURL; controlId = CLSID_WebBrowser; } hRes = CoCreateInstance( &controlId, 0, CLSCTX_ALL, &IID_IOleObject, (void**) &pControl ); if ( FAILED( hRes ) ) { WARN( "cannot create ActiveX control %s instance - error 0x%08x\n", debugstr_guid( &controlId ), hRes ); return hRes; } hRes = IOleObject_QueryInterface( pControl, &IID_IPersistStreamInit, (void**) &pPSInit ); if ( SUCCEEDED( hRes ) ) { if (!pStream) IPersistStreamInit_InitNew( pPSInit ); else IPersistStreamInit_Load( pPSInit, pStream ); IPersistStreamInit_Release( pPSInit ); } else WARN("cannot get IID_IPersistStreamInit out of control\n"); IOleObject_QueryInterface( pControl, &IID_IUnknown, (void**) &pUnkControl ); IOleObject_Release( pControl ); hRes = AtlAxAttachControl( pUnkControl, hWnd, &pContainer ); if ( FAILED( hRes ) ) WARN("cannot attach control to window\n"); if ( content == IsURL ) { IWebBrowser2 *browser; hRes = IOleObject_QueryInterface( pControl, &IID_IWebBrowser2, (void**) &browser ); if ( !browser ) WARN( "Cannot query IWebBrowser2 interface: %08x\n", hRes ); else { VARIANT url; IWebBrowser2_put_Visible( browser, VARIANT_TRUE ); /* it seems that native does this on URL (but do not on MSHTML:! why? */ V_VT(&url) = VT_BSTR; V_BSTR(&url) = SysAllocString( lpszName ); hRes = IWebBrowser2_Navigate2( browser, &url, NULL, NULL, NULL, NULL ); if ( FAILED( hRes ) ) WARN( "IWebBrowser2::Navigate2 failed: %08x\n", hRes ); SysFreeString( V_BSTR(&url) ); IWebBrowser2_Release( browser ); } } if (ppUnkContainer) { *ppUnkContainer = pContainer; if ( pContainer ) IUnknown_AddRef( pContainer ); } if (ppUnkControl) { *ppUnkControl = pUnkControl; if ( pUnkControl ) IUnknown_AddRef( pUnkControl ); } if ( pUnkControl ) IUnknown_Release( pUnkControl ); if ( pContainer ) IUnknown_Release( pContainer ); return S_OK; }
PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepage) { OLECHAR *olestring = NULL; int ret = SUCCESS; switch (V_VT(v)) { case VT_EMPTY: case VT_NULL: case VT_VOID: ZVAL_NULL(z); break; case VT_UI1: ZVAL_LONG(z, (zend_long)V_UI1(v)); break; case VT_I1: ZVAL_LONG(z, (zend_long)V_I1(v)); break; case VT_UI2: ZVAL_LONG(z, (zend_long)V_UI2(v)); break; case VT_I2: ZVAL_LONG(z, (zend_long)V_I2(v)); break; case VT_UI4: /* TODO: promote to double if large? */ ZVAL_LONG(z, (long)V_UI4(v)); break; case VT_I4: ZVAL_LONG(z, (long)V_I4(v)); break; #if SIZEOF_ZEND_LONG == 8 case VT_UI8: ZVAL_LONG(z, (zend_long)V_UI8(v)); break; case VT_I8: ZVAL_LONG(z, (zend_long)V_I8(v)); break; #endif case VT_INT: ZVAL_LONG(z, V_INT(v)); break; case VT_UINT: /* TODO: promote to double if large? */ ZVAL_LONG(z, (zend_long)V_UINT(v)); break; case VT_R4: ZVAL_DOUBLE(z, (double)V_R4(v)); break; case VT_R8: ZVAL_DOUBLE(z, V_R8(v)); break; case VT_BOOL: ZVAL_BOOL(z, V_BOOL(v) ? 1 : 0); break; case VT_BSTR: olestring = V_BSTR(v); if (olestring) { size_t len; char *str = php_com_olestring_to_string(olestring, &len, codepage); ZVAL_STRINGL(z, str, len); // TODO: avoid reallocation??? efree(str); olestring = NULL; } break; case VT_UNKNOWN: if (V_UNKNOWN(v) != NULL) { IDispatch *disp; if (SUCCEEDED(IUnknown_QueryInterface(V_UNKNOWN(v), &IID_IDispatch, &disp))) { php_com_wrap_dispatch(z, disp, codepage); IDispatch_Release(disp); } else { ret = FAILURE; } } break; case VT_DISPATCH: if (V_DISPATCH(v) != NULL) { php_com_wrap_dispatch(z, V_DISPATCH(v), codepage); } break; case VT_VARIANT: /* points to another variant */ return php_com_zval_from_variant(z, V_VARIANTREF(v), codepage); default: php_com_wrap_variant(z, v, codepage); } if (olestring) { efree(olestring); } if (ret == FAILURE) { php_error_docref(NULL, E_WARNING, "variant->zval: conversion from 0x%x ret=%d", V_VT(v), ret); } return ret; }
static HRESULT function_invoke(DispatchEx *This, func_info_t *func, WORD flags, DISPPARAMS *dp, VARIANT *res, EXCEPINFO *ei) { HRESULT hres; switch(flags) { case DISPATCH_METHOD|DISPATCH_PROPERTYGET: if(!res) return E_INVALIDARG; /* fall through */ case DISPATCH_METHOD: if(This->dynamic_data && This->dynamic_data->func_disps && This->dynamic_data->func_disps[func->func_disp_idx].func_obj) { func_obj_entry_t *entry = This->dynamic_data->func_disps + func->func_disp_idx; if((IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface != entry->val) { if(!entry->val) { FIXME("Calling null\n"); return E_FAIL; } hres = invoke_disp_value(This, entry->val, 0, flags, dp, res, ei, NULL); break; } } hres = typeinfo_invoke(This, func, flags, dp, res, ei); break; case DISPATCH_PROPERTYGET: { func_obj_entry_t *entry; if(func->id == DISPID_VALUE) { BSTR ret; ret = SysAllocString(objectW); if(!ret) return E_OUTOFMEMORY; V_VT(res) = VT_BSTR; V_BSTR(res) = ret; return S_OK; } hres = get_func_obj_entry(This, func, &entry); if(FAILED(hres)) return hres; V_VT(res) = VT_DISPATCH; V_DISPATCH(res) = entry->val; if(V_DISPATCH(res)) IDispatch_AddRef(V_DISPATCH(res)); hres = S_OK; break; } case DISPATCH_PROPERTYPUT: { func_obj_entry_t *entry; VARIANT *v; if(dp->cArgs != 1 || (dp->cNamedArgs == 1 && *dp->rgdispidNamedArgs != DISPID_PROPERTYPUT) || dp->cNamedArgs > 1) { FIXME("invalid args\n"); return E_INVALIDARG; } v = dp->rgvarg; /* FIXME: not exactly right */ if(V_VT(v) != VT_DISPATCH) return E_NOTIMPL; hres = get_func_obj_entry(This, func, &entry); if(FAILED(hres)) return hres; if(entry->val) IDispatch_Release(entry->val); entry->val = V_DISPATCH(v); if(entry->val) IDispatch_AddRef(entry->val); hres = S_OK; break; } default: FIXME("Unimplemented flags %x\n", flags); hres = E_NOTIMPL; } return hres; }
PHP_COM_DOTNET_API int php_com_copy_variant(VARIANT *dstvar, VARIANT *srcvar) { int ret = SUCCESS; switch (V_VT(dstvar) & ~VT_BYREF) { case VT_EMPTY: case VT_NULL: case VT_VOID: /* should not be possible */ break; case VT_UI1: if (V_VT(dstvar) & VT_BYREF) { *V_UI1REF(dstvar) = V_UI1(srcvar); } else { V_UI1(dstvar) = V_UI1(srcvar); } break; case VT_I1: if (V_VT(dstvar) & VT_BYREF) { *V_I1REF(dstvar) = V_I1(srcvar); } else { V_I1(dstvar) = V_I1(srcvar); } break; case VT_UI2: if (V_VT(dstvar) & VT_BYREF) { *V_UI2REF(dstvar) = V_UI2(srcvar); } else { V_UI2(dstvar) = V_UI2(srcvar); } break; case VT_I2: if (V_VT(dstvar) & VT_BYREF) { *V_I2REF(dstvar) = V_I2(srcvar); } else { V_I2(dstvar) = V_I2(srcvar); } break; case VT_UI4: if (V_VT(dstvar) & VT_BYREF) { *V_UI4REF(dstvar) = V_UI4(srcvar); } else { V_UI4(dstvar) = V_UI4(srcvar); } break; case VT_I4: if (V_VT(dstvar) & VT_BYREF) { *V_I4REF(dstvar) = V_I4(srcvar); } else { V_I4(dstvar) = V_I4(srcvar); } break; #if SIZEOF_ZEND_LONG == 8 case VT_UI8: if (V_VT(dstvar) & VT_BYREF) { *V_UI8REF(dstvar) = V_UI8(srcvar); } else { V_UI8(dstvar) = V_UI8(srcvar); } break; case VT_I8: if (V_VT(dstvar) & VT_BYREF) { *V_I8REF(dstvar) = V_I8(srcvar); } else { V_I8(dstvar) = V_I8(srcvar); } break; #endif case VT_INT: if (V_VT(dstvar) & VT_BYREF) { *V_INTREF(dstvar) = V_INT(srcvar); } else { V_INT(dstvar) = V_INT(srcvar); } break; case VT_UINT: if (V_VT(dstvar) & VT_BYREF) { *V_UINTREF(dstvar) = V_UINT(srcvar); } else { V_UINT(dstvar) = V_UINT(srcvar); } break; case VT_R4: if (V_VT(dstvar) & VT_BYREF) { *V_R4REF(dstvar) = V_R4(srcvar); } else { V_R4(dstvar) = V_R4(srcvar); } break; case VT_R8: if (V_VT(dstvar) & VT_BYREF) { *V_R8REF(dstvar) = V_R8(srcvar); } else { V_R8(dstvar) = V_R8(srcvar); } break; case VT_BOOL: if (V_VT(dstvar) & VT_BYREF) { *V_BOOLREF(dstvar) = V_BOOL(srcvar); } else { V_BOOL(dstvar) = V_BOOL(srcvar); } break; case VT_BSTR: if (V_VT(dstvar) & VT_BYREF) { *V_BSTRREF(dstvar) = V_BSTR(srcvar); } else { V_BSTR(dstvar) = V_BSTR(srcvar); } break; case VT_UNKNOWN: if (V_VT(dstvar) & VT_BYREF) { *V_UNKNOWNREF(dstvar) = V_UNKNOWN(srcvar); } else { V_UNKNOWN(dstvar) = V_UNKNOWN(srcvar); } break; case VT_DISPATCH: if (V_VT(dstvar) & VT_BYREF) { *V_DISPATCHREF(dstvar) = V_DISPATCH(srcvar); } else { V_DISPATCH(dstvar) = V_DISPATCH(srcvar); } break; case VT_VARIANT: return php_com_copy_variant(V_VARIANTREF(dstvar), srcvar); default: php_error_docref(NULL, E_WARNING, "variant->variant: failed to copy from 0x%x to 0x%x", V_VT(dstvar), V_VT(srcvar)); ret = FAILURE; } return ret; }
static void test_wshshell(void) { static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0}; static const WCHAR lnk1W[] = {'f','i','l','e','.','l','n','k',0}; IWshShell3 *sh3; IDispatchEx *dispex; IWshCollection *coll; IDispatch *disp, *shortcut; IUnknown *shell, *unk; IFolderCollection *folders; ITypeInfo *ti; HRESULT hr; TYPEATTR *tattr; DISPPARAMS dp; EXCEPINFO ei; VARIANT arg, res; BSTR str; UINT err; hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, &IID_IDispatch, (void**)&disp); if(FAILED(hr)) { win_skip("Could not create WshShell object: %08x\n", hr); return; } hr = IDispatch_QueryInterface(disp, &IID_IWshShell3, (void**)&shell); EXPECT_HR(hr, S_OK); IDispatch_Release(disp); hr = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); EXPECT_HR(hr, E_NOINTERFACE); hr = IDispatch_QueryInterface(shell, &IID_IWshShell3, (void**)&sh3); EXPECT_HR(hr, S_OK); hr = IWshShell3_get_SpecialFolders(sh3, &coll); EXPECT_HR(hr, S_OK); hr = IWshCollection_QueryInterface(coll, &IID_IFolderCollection, (void**)&folders); EXPECT_HR(hr, E_NOINTERFACE); hr = IWshCollection_QueryInterface(coll, &IID_IDispatch, (void**)&disp); EXPECT_HR(hr, S_OK); hr = IDispatch_GetTypeInfo(disp, 0, 0, &ti); EXPECT_HR(hr, S_OK); hr = ITypeInfo_GetTypeAttr(ti, &tattr); EXPECT_HR(hr, S_OK); ok(IsEqualIID(&tattr->guid, &IID_IWshCollection), "got wrong type guid\n"); ITypeInfo_ReleaseTypeAttr(ti, tattr); /* try to call Item() with normal IDispatch procedure */ str = SysAllocString(desktopW); V_VT(&arg) = VT_BSTR; V_BSTR(&arg) = str; dp.rgvarg = &arg; dp.rgdispidNamedArgs = NULL; dp.cArgs = 1; dp.cNamedArgs = 0; hr = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 1033, DISPATCH_PROPERTYGET, &dp, &res, &ei, &err); EXPECT_HR(hr, DISP_E_MEMBERNOTFOUND); /* try Item() directly, it returns directory path apparently */ V_VT(&res) = VT_EMPTY; hr = IWshCollection_Item(coll, &arg, &res); EXPECT_HR(hr, S_OK); ok(V_VT(&res) == VT_BSTR, "got res type %d\n", V_VT(&res)); SysFreeString(str); VariantClear(&res); /* CreateShortcut() */ str = SysAllocString(lnk1W); hr = IWshShell3_CreateShortcut(sh3, str, &shortcut); EXPECT_HR(hr, S_OK); SysFreeString(str); hr = IDispatch_QueryInterface(shortcut, &IID_IWshShortcut, (void**)&unk); EXPECT_HR(hr, S_OK); IUnknown_Release(unk); IDispatch_Release(shortcut); IWshCollection_Release(coll); IDispatch_Release(disp); IWshShell3_Release(sh3); IUnknown_Release(shell); }
PHP_COM_DOTNET_API void php_com_variant_from_zval(VARIANT *v, zval *z, int codepage) { OLECHAR *olestring; php_com_dotnet_object *obj; zend_uchar ztype = IS_NULL; if (z) { ZVAL_DEREF(z); ztype = Z_TYPE_P(z); } switch (ztype) { case IS_NULL: V_VT(v) = VT_NULL; break; case IS_FALSE: V_VT(v) = VT_BOOL; V_BOOL(v) = VARIANT_FALSE; break; case IS_TRUE: V_VT(v) = VT_BOOL; V_BOOL(v) = VARIANT_TRUE; break; case IS_OBJECT: if (php_com_is_valid_object(z)) { obj = CDNO_FETCH(z); if (V_VT(&obj->v) == VT_DISPATCH) { /* pass the underlying object */ V_VT(v) = VT_DISPATCH; if (V_DISPATCH(&obj->v)) { IDispatch_AddRef(V_DISPATCH(&obj->v)); } V_DISPATCH(v) = V_DISPATCH(&obj->v); } else { /* pass the variant by reference */ V_VT(v) = VT_VARIANT | VT_BYREF; V_VARIANTREF(v) = &obj->v; } } else { /* export the PHP object using our COM wrapper */ V_VT(v) = VT_DISPATCH; V_DISPATCH(v) = php_com_wrapper_export(z); } break; case IS_ARRAY: /* map as safe array */ safe_array_from_zval(v, z, codepage); break; case IS_LONG: #if SIZEOF_ZEND_LONG == 4 V_VT(v) = VT_I4; V_I4(v) = Z_LVAL_P(z); #else V_VT(v) = VT_I8; V_I8(v) = Z_LVAL_P(z); #endif break; case IS_DOUBLE: V_VT(v) = VT_R8; V_R8(v) = Z_DVAL_P(z); break; case IS_STRING: V_VT(v) = VT_BSTR; olestring = php_com_string_to_olestring(Z_STRVAL_P(z), Z_STRLEN_P(z), codepage); if (CP_UTF8 == codepage) { V_BSTR(v) = SysAllocStringByteLen((char*)olestring, (UINT)(wcslen(olestring) * sizeof(OLECHAR))); } else { V_BSTR(v) = SysAllocStringByteLen((char*)olestring, (UINT)(Z_STRLEN_P(z) * sizeof(OLECHAR))); } efree(olestring); break; case IS_RESOURCE: case IS_CONSTANT_AST: default: V_VT(v) = VT_NULL; break; } }
HRESULT CMatlabEngine::GetMatrixKnownSize( LPCTSTR szName, UINT nRows, UINT nCols, std::vector<double>& vRealArray, std::vector<double>& vImgArray) { if (!m_bInitialized || !m_pMtlbDispApp) return m_hr=S_FALSE; BSTR bstrName=NULL; UINT i,j; SAFEARRAY *realPart=NULL; SAFEARRAY *imgPart=NULL; double* pRealDummy = NULL ; // for access to the data double* pImgDummy = NULL ; // for access to the data VARIANT vArgGetFullMatrix[4]; // Preparing name ProcessString(szName, bstrName); SAFEARRAYBOUND realPartDims[2]; realPartDims[0].lLbound = 1; // Lower bound of the first dimension realPartDims[0].cElements = nRows; realPartDims[1].lLbound = 1; // Lower bound of the second dimension realPartDims[1].cElements = nCols; realPart=::SafeArrayCreate(VT_R8, 2, realPartDims); SAFEARRAYBOUND imgPartDims[2]; imgPartDims[0].lLbound = 1; // Lower bound of the first dimension imgPartDims[0].cElements = nRows; imgPartDims[1].lLbound = 1; // Lower bound of the second dimension imgPartDims[1].cElements = nCols; imgPart=::SafeArrayCreate(VT_R8, 2, imgPartDims); //loading data... for (i = 0; i < 4; ++i) ::VariantInit(&vArgGetFullMatrix[i]); V_VT(&vArgGetFullMatrix[0]) = VT_ARRAY | VT_R8 | VT_BYREF; vArgGetFullMatrix[0].pparray = &imgPart; // do set to NULL when not complex V_VT(&vArgGetFullMatrix[1]) = VT_ARRAY | VT_R8 | VT_BYREF; vArgGetFullMatrix[1].pparray = &realPart; V_VT(&vArgGetFullMatrix[2]) = VT_BSTR; V_BSTR(&vArgGetFullMatrix[2]) = m_bstrWorkspace; V_VT(&vArgGetFullMatrix[3]) = VT_BSTR; V_BSTR(&vArgGetFullMatrix[3]) = bstrName; DISPPARAMS dpGetFullMatrix; dpGetFullMatrix.cArgs = 4; dpGetFullMatrix.cNamedArgs = 0; dpGetFullMatrix.rgvarg = vArgGetFullMatrix; m_hr = m_pMtlbDispApp ->Invoke(m_dispid_GetFullMatrix, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &dpGetFullMatrix, NULL, &m_excep, &m_uArgErr); if (FAILED(m_hr)) goto Exit; if (::SafeArrayGetDim(realPart) != 2) { m_hr = S_FALSE; goto Exit; } vRealArray.resize(nRows*nCols); vImgArray.resize(nRows*nCols); SafeArrayAccessData(realPart, (void HUGEP **)(&pRealDummy)) ; // dummy now points to the data SafeArrayAccessData(imgPart, (void HUGEP **)(&pImgDummy)) ; // dummy now points to the data // copy each element across into the matrix to return for (i = 0; i < nRows ; ++i) { for (j = 0; j < nCols ; ++j) { vRealArray[i*nCols+j]=pRealDummy[i*nCols+j] ; vImgArray[i*nCols+j]=pImgDummy[i*nCols+j] ; } } pRealDummy = NULL ; // no longer valid pImgDummy = NULL ; // no longer valid Exit: ::SysFreeString(bstrName); ::SafeArrayUnaccessData(realPart) ; // release the safe array data pointer ::SafeArrayUnaccessData(imgPart) ; // release the safe array data pointer ::SafeArrayDestroy(realPart); ::SafeArrayDestroy(imgPart); return m_hr; }
static HRESULT WINAPI xmlelem_getAttribute(IXMLElement *iface, BSTR name, VARIANT *value) { static const WCHAR xmllangW[] = { 'x','m','l',':','l','a','n','g',0 }; xmlelem *This = impl_from_IXMLElement(iface); xmlChar *val = NULL; TRACE("(%p, %s, %p)\n", iface, debugstr_w(name), value); if (!value) return E_INVALIDARG; VariantInit(value); V_BSTR(value) = NULL; if (!name) return E_INVALIDARG; /* case for xml:lang attribute */ if (!lstrcmpiW(name, xmllangW)) { xmlNsPtr ns; ns = xmlSearchNs(This->node->doc, This->node, (xmlChar*)"xml"); val = xmlGetNsProp(This->node, (xmlChar*)"lang", ns->href); } else { xmlAttrPtr attr; xmlChar *xml_name; xml_name = xmlChar_from_wchar(name); attr = This->node->properties; while (attr) { BSTR attr_name; attr_name = bstr_from_xmlChar(attr->name); if (!lstrcmpiW(name, attr_name)) { val = xmlNodeListGetString(attr->doc, attr->children, 1); SysFreeString(attr_name); break; } attr = attr->next; SysFreeString(attr_name); } heap_free(xml_name); } if (val) { V_VT(value) = VT_BSTR; V_BSTR(value) = bstr_from_xmlChar(val); } xmlFree(val); TRACE("returning %s\n", debugstr_w(V_BSTR(value))); return (val) ? S_OK : S_FALSE; }
HRESULT CContextPlugin::LoadConfigValues() { HRESULT hr = S_OK; IWMSNamedValue *pValue = NULL; VARIANT var; if( NULL == m_pNamedValues ) { return( E_UNEXPECTED ); } VariantInit( &var ); // // Get our properties from the server // hr = m_pNamedValues->get_Item( CComVariant(CContextPlugin::s_wstrNamedValueOutputPath), &pValue ); // // Get the Output Path Name // if ( SUCCEEDED(hr) ) { hr = pValue->get_Value(&var); if ( SUCCEEDED(hr) ) { hr = ::VariantChangeType( &var, &var, 0, VT_BSTR ); } if ( SUCCEEDED(hr) ) { m_bstrOutputPath = ::SysAllocString( V_BSTR( &var ) ); if( NULL == m_bstrOutputPath ) { hr = E_OUTOFMEMORY; goto abort; } } } hr = S_OK; // Default is OK VariantClear( &var ); if( NULL != pValue ) { pValue->Release(); pValue = NULL; } // // Get the flags for ContextTypes // hr = m_pNamedValues->get_Item( CComVariant(CContextPlugin::s_wstrNamedValueContextTypes), &pValue ); if ( SUCCEEDED(hr) ) { hr = pValue->get_Value( &var ); if ( SUCCEEDED(hr) ) { m_wmsContexts = (WMS_CONTEXT_PLUGIN_CONTEXT_TYPE) V_I4( &var ); } } hr = S_OK; // Default is OK abort: VariantClear( &var ); if( NULL != pValue ) { pValue->Release(); pValue = NULL; } return( hr ); }
static HRESULT set_dbpropset(BSTR name, BSTR value, DBPROPSET **propset) { VARIANT src, dest; int min, max, n; HRESULT hr; min = 0; max = sizeof(dbproperties)/sizeof(struct dbproperty) - 1; while (min <= max) { int r; n = (min+max)/2; r = strcmpiW(dbproperties[n].name, name); if (!r) break; if (r < 0) min = n+1; else max = n-1; } if (min > max) { *propset = NULL; FIXME("unsupported property %s\n", debugstr_w(name)); return E_FAIL; } VariantInit(&dest); V_VT(&src) = VT_BSTR; V_BSTR(&src) = value; hr = VariantChangeType(&dest, &src, 0, dbproperties[n].type); if (FAILED(hr)) { ERR("failed to init property %s value as type %d\n", debugstr_w(name), dbproperties[n].type); return hr; } *propset = CoTaskMemAlloc(sizeof(DBPROPSET)); if (!*propset) { VariantClear(&dest); return E_OUTOFMEMORY; } (*propset)->rgProperties = CoTaskMemAlloc(sizeof(DBPROP)); if (!(*propset)->rgProperties) { VariantClear(&dest); CoTaskMemFree(*propset); return E_OUTOFMEMORY; } (*propset)->cProperties = 1; (*propset)->guidPropertySet = DBPROPSET_DBINIT; (*propset)->rgProperties[0].dwPropertyID = dbproperties[n].id; (*propset)->rgProperties[0].dwOptions = dbproperties[n].options; (*propset)->rgProperties[0].dwStatus = 0; memset(&(*propset)->rgProperties[0].colid, 0, sizeof(DBID)); (*propset)->rgProperties[0].vValue = dest; return S_OK; }
static inline BOOL is_variant_null(const VARIANT *var) { return V_VT(var) == VT_EMPTY || V_VT(var) == VT_NULL || (V_VT(var) == VT_BSTR && (V_BSTR(var) == NULL || !*V_BSTR(var))); }
//--------------------------------------------------------------------------- HRESULT GetRegistryKeyValue( HKEY RootKey, const wchar_t * KeyName, const wchar_t * Name, VARIANT * Result) { HRESULT hr = E_FAIL; HKEY hkey; DWORD err; err = RegOpenKeyExW(RootKey,KeyName,0,KEY_READ,&hkey); if( err == ERROR_SUCCESS ){ DWORD ValueType, ValueSize, sLen; err = RegQueryValueExW(hkey,Name,NULL,&ValueType,NULL,&ValueSize); if( err == ERROR_SUCCESS ){ PBYTE pValueData = (PBYTE) malloc(ValueSize); if( pValueData == NULL ){ err = ERROR_NOT_ENOUGH_MEMORY; } else { err = RegQueryValueExW(hkey,Name,NULL,&ValueType,pValueData,&ValueSize); if( err == ERROR_SUCCESS ){ BSTR sValue = NULL; switch( ValueType ){ case REG_BINARY : break; case REG_DWORD : if( SUCCEEDED(VariantChangeTypeEx(Result,Result,0,0,VT_I4)) ){ V_I4(Result) = *(DWORD *) pValueData; hr = S_OK; } break; case REG_EXPAND_SZ : sLen = ExpandEnvironmentStringsW((LPCWSTR) pValueData,sValue,0); if( sLen == 0 ){ err = GetLastError(); } else { sValue = SysAllocStringLen(NULL,sLen - 1); if( sValue == NULL ){ err = ERROR_NOT_ENOUGH_MEMORY; } else { ExpandEnvironmentStringsW((LPCWSTR) pValueData,sValue,sLen); if( SUCCEEDED(VariantChangeTypeEx(Result,Result,0,0,VT_EMPTY)) ){ V_BSTR(Result) = sValue; V_VT(Result) = VT_BSTR; hr = S_OK; sValue = NULL; } SysFreeString(sValue); } } /*Val.resize(ExpandEnvironmentStringsW((LPCWSTR) pValueData,Val.c_str(),0) + 1); ExpandEnvironmentStringsW((LPCWSTR) pValueData,Val.c_str(),Val.strlen()); Val.resize(wcslen(Val.c_str()));*/ break; case REG_LINK : case REG_MULTI_SZ : case REG_NONE : case REG_RESOURCE_LIST : hr = E_FAIL; break; case REG_SZ : sLen = (DWORD) wcslen((LPCWSTR) pValueData); sValue = SysAllocStringLen(NULL,sLen); if( sValue == NULL ){ err = ERROR_NOT_ENOUGH_MEMORY; } else { if( SUCCEEDED(VariantChangeTypeEx(Result,Result,0,0,VT_EMPTY)) ){ V_BSTR(Result) = sValue; V_VT(Result) = VT_BSTR; hr = S_OK; sValue = NULL; } SysFreeString(sValue); } /*Val = (wchar_t *) pValueData;*/ break; } } free(pValueData); } } RegCloseKey(hkey); } SetLastError(err); return hr; }