const Interface * Reference::findInterfaceFromDispatch (IUnknown *pUnknown) { HRESULT hr; // See if the object implements IDispatch. IDispatchPtr pDispatch; hr = pUnknown->QueryInterface( IID_IDispatch, reinterpret_cast<void **>(&pDispatch)); if (FAILED(hr)) { return 0; } // Ask the IDispatch interface for type information. unsigned count; hr = pDispatch->GetTypeInfoCount(&count); if (hr == E_NOTIMPL) { return 0; } if (FAILED(hr)) { _com_issue_error(hr); } if (count == 0) { return 0; } ITypeInfoPtr pTypeInfo; hr = pDispatch->GetTypeInfo( 0, LOCALE_USER_DEFAULT, &pTypeInfo); if (FAILED(hr)) { _com_issue_error(hr); } // Get the interface description. TypeAttr typeAttr(pTypeInfo); if (IsEqualIID(typeAttr->guid, __uuidof(DotNetObject))) { // The .NET Framework implements IDispatch::GetTypeInfo for classes // declared with the attribute ClassInterface(ClassInterfaceType.None) // by returning a description of the _Object interface. return 0; } const Interface *pInterface = InterfaceManager::instance().newInterface(typeAttr->guid, pTypeInfo); if (pInterface->methods().empty() && pInterface->properties().empty()) { // No invokable methods or properties where found in the interface // description. return 0; } return pInterface; }
void ArchiveExtractCallback::GetPropertySize(UInt32 index) { CPropVariant prop; HRESULT hr = m_archiveHandler->GetProperty(index, kpidSize, &prop); if (hr != S_OK) { _com_issue_error(hr); } switch (prop.vt) { case VT_EMPTY: m_hasNewFileSize = false; return; case VT_UI1: m_newFileSize = prop.bVal; break; case VT_UI2: m_newFileSize = prop.uiVal; break; case VT_UI4: m_newFileSize = prop.ulVal; break; case VT_UI8: m_newFileSize = (UInt64)prop.uhVal.QuadPart; break; default: _com_issue_error(E_FAIL); } m_hasNewFileSize = true; }
INT CADOParameters::Add(const BYTE *pBytes, INT iLen) { _ParameterPtr pParam; // Create Parameter HRESULT hr = pParam.CreateInstance(__uuidof(Parameter)); if (FAILED(hr)) _com_issue_error(hr); // Set param for the value; pParam->Direction = adParamInput; pParam->Type = adBinary; pParam->Size = iLen; _variant_t var; SAFEARRAY *psa = NULL; SAFEARRAYBOUND rgsabound[1]; rgsabound[0].lLbound = 0L; rgsabound[0].cElements = iLen; psa = SafeArrayCreate(VT_UI1, 1, rgsabound); if (NULL == psa) _com_issue_error(E_OUTOFMEMORY); for (LONG l=0; l<iLen; l++) SafeArrayPutElement(psa, &l, (LPVOID)&pBytes[l]); var.vt = VT_ARRAY|VT_UI1; var.parray = psa; pParam->AppendChunk(var); return Add((_Parameter*)pParam); }
void ArchiveExtractCallback::GetPropertyFilePath(UInt32 index) { CPropVariant prop; HRESULT hr = m_archiveHandler->GetProperty(index, kpidPath, &prop); if (hr != S_OK) { _com_issue_error(hr); } if ( prop.vt == VT_EMPTY ) { m_relPath = EmptyFileAlias; } else if (prop.vt != VT_BSTR) { _com_issue_error(E_FAIL); } else { _bstr_t bstr = prop.bstrVal; #ifdef _UNICODE m_relPath = bstr; #else char relPath[MAX_PATH]; int size = WideCharToMultiByte(CP_UTF8, 0, bstr, bstr.length(), relPath, MAX_PATH, NULL, NULL); m_relPath.assign(relPath, size); #endif } }
bool Reference::operator== (const Reference &rhs) const { HRESULT hr; IUnknown *pUnknown1; hr = m_pUnknown->QueryInterface( IID_IUnknown, reinterpret_cast<void **>(&pUnknown1)); if (FAILED(hr)) { _com_issue_error(hr); } IUnknown *pUnknown2; rhs.m_pUnknown->QueryInterface( IID_IUnknown, reinterpret_cast<void **>(&pUnknown2)); if (FAILED(hr)) { pUnknown1->Release(); _com_issue_error(hr); } bool result = pUnknown1 == pUnknown2; pUnknown1->Release(); pUnknown2->Release(); return result; }
// die folgende Funktion ist das konkrete äquivalent für 'OleLoadFromStream' -- HRESULT CreateStringFromStream (IStream *pIStream, LPSTR lpstr, int iLen) { ASSERT(pIStream); ASSERT(lpstr); ASSERT(0 < iLen); if (NULL == lpstr) return E_POINTER; if (0 == iLen) return E_INVALIDARG; USES_CONVERSION; *lpstr = '\0'; try { // Variant liest sich selbst vom Stream CComVariant cv;// VariantInit() HRESULT hr = cv.ReadFromStream (pIStream); if (FAILED(hr)) _com_issue_error(hr); // Richtigen Typ rausholen hr = cv.ChangeType (VT_BSTR); if (FAILED(hr)) _com_issue_error(hr); // Wert lesen CComBSTR bstr = cv.bstrVal; // SysAllocString(... LPSTR lpstrName = OLE2A(bstr.m_str); if (iLen < strlen(lpstrName)) _com_issue_error(E_INVALIDARG); strcpy(lpstr, lpstrName); // in ~CComVariant() VariantClear() } // in ~CComBSTR() SysFreeString(m_str) catch (_com_error& e) { return _COM_ERROR(e); } return NOERROR; }
STDMETHODIMP CPropertyChoice::AddActionsByCLSID (CALPCLSID *pcaClsIds) { HRESULT hr = E_FAIL; if (!m_fIsInitialized) { hr = InitNew(); if (FAILED(hr)) return hr; } // hinzufügen der einzelnen Aktionen for (ULONG i = 0; i < pcaClsIds -> cElems; i++) { try { WPropertyAction WAct (*(pcaClsIds -> ppElems[i])); // throws hr { WPersistStreamInit Init = WAct; // throws hr hr = Init -> InitNew(); if (FAILED(hr)) _com_issue_error(hr); } hr = AddAction (WAct); if (FAILED(hr)) _com_issue_error(hr); } catch (_com_error& hr) { return _COM_ERROR(hr); } } return NOERROR; }
Reference * Reference::queryInterface (IUnknown *pOrig, REFIID iid) { if (pOrig == 0) { _com_issue_error(E_POINTER); } IUnknown *pUnknown; HRESULT hr = pOrig->QueryInterface( iid, reinterpret_cast<void **>(&pUnknown)); if (FAILED(hr)) { _com_issue_error(hr); } const Interface *pInterface = 0; if (!IsEqualIID(iid, IID_IDispatch)) { pInterface = findInterfaceFromIid(iid); if (pInterface == 0) { pInterface = findInterfaceFromDispatch(pUnknown); } } return new Reference(pUnknown, pInterface); }
HRESULT CRunBreakPoint::OnDemandBreakpoint(CebScript *pScript, CebThread *pThread, IObjectManagement *pIOM, IStreamInfo *pISI) { ASSERT(NULL != pScript); ASSERT(NULL != pThread); if (pScript == NULL || pThread == NULL) return E_POINTER; ASSERT(NULL != pThread->GetHandle()); ASSERT(NULL != pScript->GetHandle()); if (NULL == pScript->GetHandle() || NULL == pThread->GetHandle()) return E_HANDLE; HRESULT hr = NOERROR; try {// evtl. Debuggerfenster erzeugen hr = CreateDebugger(WM_CLOSEBREAKPOINTDEBUGGERDIALOG, false, 0, pIOM, pISI); if (FAILED(hr)) _com_issue_error(hr); // Fertzigen Script und Thread unterschieben if (!ebDebugger_SetScript(GetDebuggerWnd(), pScript->GetHandle())) _com_issue_error(E_FAIL); if (!ebDebugger_SetThread(GetDebuggerWnd(), pThread->GetHandle())) _com_issue_error(E_FAIL); // jetzt Debugger anzeigen hr = m_pScriptDebugger -> RunModal(); if (FAILED(hr)) _com_issue_error(hr); } catch(_com_error& e) { if (m_pScriptDebugger) m_pScriptDebugger -> DestroyWindow(); m_pScriptDebugger = NULL; return _COM_ERROR(e); } return S_OK; }
XLWordBreaker::XLWordBreaker() { HRESULT hr; CLSID clsidWordBreaker; hr = CLSIDFromString(L"NLG.Japanese Wordbreaker",&clsidWordBreaker); if (FAILED(hr)) { _com_issue_error(hr); } // hr = this->WordBreaker.CoCreateInstance(__uuidof(CLSID_IWordBreaker_WinXP)); hr = this->WordBreaker.CoCreateInstance(clsidWordBreaker); if (FAILED(hr)) { _com_issue_error(hr); } //初期化 BOOL pfLicense = TRUE; hr = WordBreaker->Init(true, 2000, &pfLicense); if (FAILED(hr)) { _com_issue_error(hr); } }
HRESULT CAddFunctionDlg::FillComboBox() { HRESULT hr = NOERROR; int iResID = IDR_NOTIFCLOSING; try { while (iResID != IDR_NOTIFEND) { CTemplateManagement *pTM = new CTemplateManagement; THROW_FAILED_HRESULT(pTM -> Load(iResID, "Notification")); char str[MAXSTRLENGTH]; THROW_FAILED_HRESULT(pTM -> GetName(str, MAXSTRLENGTH)); int i = m_cbxNotification.AddString(str); if (i == CB_ERRSPACE) _com_issue_error(E_OUTOFMEMORY); if (i == CB_ERR) _com_issue_error(E_FAIL); m_cbxNotification.SetItemData(i, (DWORD) pTM); iResID++; } } catch(_com_error& e) { hr = _COM_ERROR(e); } return hr; }
//***************************************************************************** //* Function Name: LoadCustomXMLResource //* Description: Load a custom resource of type "XMLRESOURCE" and return it //* as a Unicode string. //***************************************************************************** _bstr_t LoadCustomXMLResource (UINT p_uResourceId) { HMODULE l_hModule = NULL; HRSRC l_hResInfo = ::FindResource ( l_hModule, // hModule MAKEINTRESOURCE (p_uResourceId), // lpName _T("XMLRESOURCE")); // lpType if (l_hResInfo == NULL) { _com_issue_error (HRESULT_FROM_WIN32 (GetLastError ())); } DWORD l_cbResource = ::SizeofResource ( l_hModule, // hModule l_hResInfo); // hResInfo if (l_cbResource == 0) { _com_issue_error (HRESULT_FROM_WIN32 (GetLastError ())); } HGLOBAL l_hGlobal = ::LoadResource ( l_hModule, // hModule l_hResInfo); // hResInfo if (l_hGlobal == NULL) { _com_issue_error (HRESULT_FROM_WIN32 (GetLastError ())); } LPCVOID l_lpvResource = ::LockResource (l_hGlobal); _ASSERTE (l_lpvResource != NULL); // Use the IXMLDOMDocument::load() method passing a SAFEARRAY of VT_UI1. // This will honour the encoding declaration in the XML document. SAFEARRAY l_sa = {0}; _variant_t l_svarXML; WrapInSafeArray (l_sa, l_svarXML, l_lpvResource, l_cbResource); // __uuidof(DOMDocument30) is the CLSID that // corresponds to ProgID "MSXML2.DOMDocument.3.0" MSXML2::IXMLDOMDocumentPtr l_spXMLDOMDocument; HRESULT l_hr = l_spXMLDOMDocument.CreateInstance (__uuidof (MSXML2::DOMDocument30)); if (FAILED (l_hr)) _com_issue_error (l_hr); l_spXMLDOMDocument->async = VARIANT_FALSE; if (l_spXMLDOMDocument->load (l_svarXML) == VARIANT_FALSE) { _com_issue_error (E_UNEXPECTED); } return l_spXMLDOMDocument->xml; }
static void fillSafeArray ( Tcl_Obj *pList, SAFEARRAY *psa, unsigned dim, long *pIndices, Tcl_Interp *interp, bool addRef) { HRESULT hr; // Get index range. long lowerBound; hr = SafeArrayGetLBound(psa, dim, &lowerBound); if (FAILED(hr)) { _com_issue_error(hr); } long upperBound; hr = SafeArrayGetUBound(psa, dim, &upperBound); if (FAILED(hr)) { _com_issue_error(hr); } int numElements; Tcl_Obj **pElements; if (Tcl_ListObjGetElements(interp, pList, &numElements, &pElements) != TCL_OK) { _com_issue_error(E_INVALIDARG); } unsigned dim1 = dim - 1; if (dim < SafeArrayGetDim(psa)) { // Create list of list for multi-dimensional array. for (int i = 0; i < numElements; ++i) { pIndices[dim1] = i; fillSafeArray(pElements[i], psa, dim + 1, pIndices, interp, addRef); } } else { for (int i = 0; i < numElements; ++i) { TclObject element(pElements[i]); NativeValue elementVar; element.toNativeValue(&elementVar, Type::variant(), interp, addRef); pIndices[dim1] = i; hr = SafeArrayPutElement(psa, pIndices, &elementVar); if (FAILED(hr)) { _com_issue_error(hr); } } } }
HRESULT CAddFunctionDlg::SetTemplatePieces() { HRESULT hr = NOERROR; CTemplateManagement *pTM = NULL; BOOL fDelete = false; try { // Wenn Notification, dann alle Funktionselemente aus diesem Item holen if (1 == m_chckNotification.GetCheck()) { // Istein Text im EditCtrl ? CString str; m_cbxNotification.GetWindowText(str); if (str.IsEmpty()) _com_issue_error(E_INVALIDARG); // Wenn je, liefere den Index int iFind = m_cbxNotification.FindString(-1, str); if (CB_ERR == iFind) _com_issue_error(E_FAIL); // Den Templtemenager geben lassen DWORD dw = m_cbxNotification.GetItemData(iFind); if (CB_ERR == dw) _com_issue_error(E_FAIL); pTM = (CTemplateManagement *)dw; } else { fDelete = true; THROW_FAILED_HRESULT(MakeTemplate(&pTM)); } char str [MAXSTRLENGTH]; *str = '\0'; char strType[MAXSTRLENGTH]; *strType = '\0'; char strPar [MAXSTRLENGTH]; *strPar = '\0'; char strName[MAXSTRLENGTH]; *strName = '\0'; char strComment[MAXSTRLENGTH]; *strComment = '\0'; THROW_FAILED_HRESULT(pTM -> GetComment(strComment, MAXSTRLENGTH)); THROW_FAILED_HRESULT(pTM -> GetDeclaration(str, MAXSTRLENGTH)); THROW_FAILED_HRESULT(pTM -> GetParams(strPar, MAXSTRLENGTH)); THROW_FAILED_HRESULT(pTM -> GetName(strName, MAXSTRLENGTH)); THROW_FAILED_HRESULT(pTM -> GetType(strType, MAXSTRLENGTH)); m_strTyp = strType; m_strParams = strPar; m_strDeclaration = str; m_strName = strName; m_strComment = strComment; } catch (_com_error& e) { hr = _COM_ERROR(e); } if (fDelete) DELETE_OBJ(pTM); return hr; }
/////////////////////////////////////////////////////////////////////////////////////////////// // IPropertyAction methods // PropertyPages einhängen // diese Stelle wird bei DoActions() erreicht STDMETHODIMP CRegOperatPropAct::AddConfigPages (LPFNADDPROPSHEETPAGE lpfnAddPage, LPARAM lParam, LPCSTR pcDesc, UINT *puiCnt) { char cbCaption[_MAX_PATH]; try { if (NULL != pcDesc) // Caption ist gegeben strcpy (cbCaption, pcDesc); else // von zugehöriger ClassProperty unseren Namen besorgen GetPropInfo (cbCaption, sizeof(cbCaption), NULL); // zugehörigen ConfigDialog (PropertyPage(s)) anlegen DELETE_OBJ (m_pRegOperDlg); // evtl. vorherigen freigeben m_pRegOperDlg = CRegardOperatDlg::CreateInstance (ResID(IDD_REGOPERATPROPACT, pRF), cbCaption, this, m_caSelInfo, *pRF); if (NULL == m_pRegOperDlg) _com_issue_error (E_OUTOFMEMORY); if (!IsNoShow()) { // Seite hinzufügen, wenn selbige angezeigt werden soll HPROPSHEETPAGE hPSP = m_pRegOperDlg -> CreatePage(); if (NULL == hPSP) return E_HANDLE; if (!(*lpfnAddPage) (hPSP, lParam)) return E_UNEXPECTED; } // Initialisierungsdaten für den Dialog wurden von Load() bereitgestellt, konnten aber // noch nicht an diesen weitergereicht werden if (m_bHasInitData) { // Initialisierungsdaten jetzt an den Dialog weiterreichen HRESULT hr = m_pRegOperDlg->SetSelectedInfo (&m_caSelInfo, IsNoShow()); if (FAILED(hr)) _com_issue_error(hr); } if (NULL != puiCnt) *puiCnt = IsNoShow() ? 0 : 1; // "1" ist die Anzahl der einzuhängenden Pages } catch (_com_error& e) { DELETE_OBJ (m_pRegOperDlg); if (puiCnt) *puiCnt = 0; return _COM_ERROR (e); } return S_OK; } // AddConfigPages
void PropertySequence_cmd_Save (ebHTHREAD hThread, int iNumArgs, ebARGS lpArgs) { BASIC_OP_TRACE(PropertySequence_cmd_Save); if (NULL != lpArgs[0]) // als Funktion gerufen ebSetBool (lpArgs, 0, 0); // für alle Fälle WPropertyActionSequence ISeq ((IPropertyActionSequence *)ebGetObject (lpArgs, 1)); HRESULT hr = E_FAIL; // Versuchen aus SubStream einzulesen try { // SubStorage eröffnen/erzeugen WStorage IStg; hr = GetSubPropSeqStorage (IStg.ppi(), true); if (FAILED(hr)) _com_issue_error(hr); // Description geben lassen char cbBuffer[_MAX_PATH]; hr = ISeq -> GetDescription (cbBuffer, _MAX_PATH, NULL); if (FAILED(hr)) _com_issue_error(hr); WStream IStm; WPersistStream IPersistStm (ISeq); // throw hr string strName = MakeStreamName(cbBuffer); // Stream erzeugen USES_CONVERSION; hr = IStg -> CreateStream (A2OLE(strName.c_str()), STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_CREATE, 0L, 0L, IStm.ppi()); if (FAILED(hr)) _com_issue_error(hr); hr = OleSaveToStream (IPersistStm, IStm); if (FAILED(hr)) _com_issue_error(hr); hr = IStg -> Commit (STGC_DEFAULT); if (FAILED(hr)) _com_issue_error(hr); DEX_SetDirtyGeoDB(true); } catch (...) { TRACE("Couldn't OleSaveToStream for IPropertyActionSequence\n"); return; // Fehler } if (NULL != lpArgs[0]) // als Funktion gerufen ebSetBool (lpArgs, 0, -1); }
static HRESULT SavePropSeq ( LPCSTR pcDesc, IPropertyActionSequence *pISeq, IStorage *pIStg) { HRESULT hr = E_FAIL; WStorage IStg (pIStg); USES_CONVERSION; if (NULL == pIStg) { // SubStorage anlegen, da es noch nicht existiert WStorage IRootStg; if (!DEX_GetProjectStorage(*IRootStg.ppv())) return E_FAIL; hr = IRootStg -> CreateStorage (A2OLE(g_cbPropertyChoices), STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_TRANSACTED, 0L, 0L, IStg.ppi()); if (FAILED(hr)) return hr; hr = WriteClassStg (IStg, CLSID_PropertyChoice); if (FAILED(hr)) return hr; } try { WStream IStm; WPersistStream IPersistStm (pISeq); // throws hr string strName = MakeStreamName(pcDesc); // Stream erzeugen hr = IStg -> CreateStream (A2OLE(strName.c_str()), STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_CREATE, 0L, 0L, IStm.ppi()); if (FAILED(hr)) _com_issue_error(hr); hr = OleSaveToStream (IPersistStm, IStm); // und wegschreiben if (FAILED(hr)) _com_issue_error(hr); hr = IStm -> Commit (STGC_DEFAULT); if (FAILED(hr)) _com_issue_error(hr); } catch (_com_error& hr) { return _COM_ERROR(hr); } hr = IStg -> Commit (STGC_DEFAULT); if (SUCCEEDED(hr)) DEX_SetDirtyGeoDB(true); return hr; }
///////////////////////////////////////////////////////////////////////////// // IPropertyAction methods STDMETHODIMP CTextSearchEngine::AddConfigPages (LPFNADDPROPSHEETPAGE lpfnAddPage, LPARAM lParam, LPCSTR pcDesc, UINT *puiCnt) { char cbCaption[128]; try { if (NULL != pcDesc) // Caption ist gegeben strcpy (cbCaption, pcDesc); else // von zugehöriger ClassProperty unseren Namen besorgen GetPropInfo (cbCaption, sizeof(cbCaption), NULL); // Kontext des Dialoges feststellen WClassProperty Cls; bool fChoice = false; if (SUCCEEDED(GetSite (IID_IClassProperty, Cls.ppv()))) { // Kontext ist entweder PropertyChoice oder PropertySequence DWORD dwFlags = 0; if (SUCCEEDED(Cls -> GetPropInfo (NULL, 0, &dwFlags))) fChoice = (dwFlags & PROPCAPS_CONTAINER_IS_CHOICE) ? true : false; } // zugehörigen ConfigDialog (PropertyPage(s)) anlegen ResourceFile RF (g_pDLLName); UINT uiRes = fChoice ? IDD_TEXTSEARCHENGINE_CFGPP : IDD_TEXTSEARCHENGINE_CFG; DELETE_OBJ(m_pCfgDlg); // evtl. vorherigen freigeben m_pCfgDlg = CCfgTextSearch::CreateInstance (this, ResID (uiRes, &RF), cbCaption); if (NULL == m_pCfgDlg) _com_issue_error(E_OUTOFMEMORY); HPROPSHEETPAGE hPSP = this -> CreatePage(m_pCfgDlg); if (NULL == hPSP || !lpfnAddPage(hPSP, lParam)) _com_issue_error(E_UNEXPECTED); if (puiCnt) *puiCnt = 1; m_pCfgDlg -> InitWithData (m_Status); } catch (_com_error& hr_result) { DELETE_OBJ (m_pCfgDlg); if (puiCnt) *puiCnt = 0; return _COM_ERROR(hr_result); } return S_OK; }
void CCommonServiceTests::Execute_WithBadVersion_ReturnsError () { try { HRESULT l_hr; WineApi::IConfigPtr l_spConfig; l_hr = l_spConfig.CreateInstance (__uuidof (WineApi::Config)); if (FAILED (l_hr)) _com_issue_error (l_hr); l_spConfig->ApiKey = API_KEY; l_spConfig->Version = L"BogusVersion"; WineApi::ICatalogServicePtr l_spCatalogService; l_hr = l_spCatalogService.CreateInstance (__uuidof (WineApi::CatalogService)); try { WineApi::ICatalogPtr l_spCatalog = l_spCatalogService->Execute (); CPPUNIT_FAIL (_T("Expected a _com_error exception to be thrown!")); } catch (const _com_error& l_ce) { CPPUNIT_ASSERT (l_ce.Error () == E_UNEXPECTED); CPPUNIT_ASSERT (l_ce.Description ().length () > 0); } } catch (const _com_error& l_ce) { HandleComErrorException (l_ce); } }
void CCommonServiceTests::Execute_WithBadQueryString_ReturnsError () { try { HRESULT l_hr; WineApi::IConfigPtr l_spConfig; l_hr = l_spConfig.CreateInstance (__uuidof (WineApi::Config)); if (FAILED (l_hr)) _com_issue_error (l_hr); l_spConfig->ApiKey = API_KEY; l_spConfig->Version = VERSION; WineApi::ICatalogServicePtr l_spCatalogService; l_hr = l_spCatalogService.CreateInstance (__uuidof (WineApi::CatalogService)); WineApi::ICatalogPtr l_spCatalog = l_spCatalogService ->Search1 (L"merlot") ->State (L"Bogus") ->Execute (); CPPUNIT_ASSERT (l_spCatalog->Status->ReturnCode == WineApi::ReturnCodeCriticalError); CPPUNIT_ASSERT (l_spCatalog->Status->Messages->Count == 1); } catch (const _com_error& l_ce) { HandleComErrorException (l_ce); } }
Reference * Reference::newReference (IUnknown *pOrig, const Interface *pInterface) { if (pOrig == 0) { _com_issue_error(E_POINTER); } if (pInterface == 0) { pInterface = findInterfaceFromDispatch(pOrig); } // If we know it's a custom interface, then query for an interface pointer // to that interface, otherwise query for an IUnknown interface. const IID &iid = (pInterface == 0) ? IID_IUnknown : pInterface->iid(); IUnknown *pUnknown; HRESULT hr = pOrig->QueryInterface( iid, reinterpret_cast<void **>(&pUnknown)); if (FAILED(hr)) { pUnknown = pOrig; pUnknown->AddRef(); } return new Reference(pUnknown, pInterface); }
void PropertyAdmin::uninitialize() { if (!m_bInitialized) return; m_bInitialized = false; try { CComPtr<IPropertyManager> pPropMan; if ((pPropMan.p = GET_OPMPROPERTY_MANAGER(m_pClass))==NULL) _com_issue_error(E_FAIL); if (m_pSimple) { _com_util::CheckError(pPropMan->RemoveProperty(m_pSimple)); m_pSimple->Release(); } if (m_pCategorized) { _com_util::CheckError(pPropMan->RemoveProperty(m_pCategorized)); m_pCategorized->Release(); } if (m_pEnum) { _com_util::CheckError(pPropMan->RemoveProperty(m_pEnum)); m_pEnum->Release(); } } catch(const _com_error& ) { acutPrintf("\nSimpleDynProps: uninitialize failed!!!\n"); } }
void PropertyAdmin::initialize() { if (m_bInitialized) return; m_bInitialized = true; try { CComPtr<IPropertyManager> pPropMan; if ((pPropMan.p = GET_OPMPROPERTY_MANAGER(m_pClass))==NULL) _com_issue_error(E_FAIL); _com_util::CheckError(CComObject<CSimpleProperty>::CreateInstance(&m_pSimple)); m_pSimple->AddRef(); _com_util::CheckError(CComObject<CCategorizedProperty>::CreateInstance(&m_pCategorized)); m_pCategorized->AddRef(); _com_util::CheckError(CComObject<CEnumProperty>::CreateInstance(&m_pEnum)); m_pEnum->AddRef(); _com_util::CheckError(pPropMan->AddProperty(m_pSimple)); _com_util::CheckError(pPropMan->AddProperty(m_pCategorized)); _com_util::CheckError(pPropMan->AddProperty(m_pEnum)); } catch(const _com_error& ) { uninitialize(); acutPrintf("\nSimpleDynProps: initialize failed!!!\n"); return; } }
// Lesen eines EnumLONG aus einem DataObjekt ---------------------------------- HRESULT GetHWNDData (IDataObject *pIDataObj, HWND *phWnd) { HRESULT hr = E_FAIL; STGMEDIUM stg; memset (&stg, 0, sizeof(STGMEDIUM)); try { // Testen, ob das gewünschte Format überhaupt da ist THROW_FAILED_HRESULT(pIDataObj -> QueryGetData ((FORMATETC *)&c_feObjectWindow)); // Daten vom DataObject geben lassen THROW_FAILED_HRESULT(pIDataObj -> GetData ((FORMATETC *)&c_feObjectWindow, &stg)); // HWND aus STGMEDIUM herauskopieren HWND *phWndGlobal = (HWND *)GlobalLock (stg.hGlobal); if (NULL == phWndGlobal) _com_issue_error(E_UNEXPECTED); *phWnd = *phWndGlobal; ReleaseStgMedium (&stg); } catch (_com_error &e) { if (TYMED_NULL != stg.tymed) ReleaseStgMedium (&stg); return _COM_ERROR(e); } return NOERROR; }
//***************************************************************************** //* Function Name: ThrowComErrorException //* Description: //***************************************************************************** void ThrowComErrorException ( LPCTSTR p_lpszFile, UINT p_uLine, HRESULT p_hr, UINT p_uResourceId, ...) { TCHAR l_szFormatString[1024] = {0}; if (::LoadString (_Module.GetResourceInstance (), p_uResourceId, l_szFormatString, 1024) > 0) { va_list l_varargs; va_start (l_varargs, p_uResourceId); TCHAR l_szDescription[1024] = {0}; #if _MSC_VER >= 1400 (void) _vsntprintf_s (l_szDescription, 1024, l_szFormatString, l_varargs); #else (void) _vsntprintf (l_szDescription, 1024, l_szFormatString, l_varargs); #endif va_end (l_varargs); ThrowComErrorException (p_lpszFile, p_uLine, p_hr, l_szDescription); } else { DWORD l_dwLastError = ::GetLastError (); _com_issue_error (HRESULT_FROM_WIN32 (l_dwLastError)); } }
// Erzeugen eines BYTE-Blobs aus einem Koordinatenfeld HRESULT CreateBlobFromVertices ( unsigned long ulCnt, double_i itx, double_i ity, POINTBASE *pNormal, void *pData, REFCLSID rClsId, void **ppBlob, unsigned long *plSize) { if (NULL == ppBlob || NULL == plSize) return E_POINTER; BYTE *pNewData = NULL; COM_TRY { // resultierende Größe feststellen unsigned long ulSize = 0; CBlobService MakeBlobs; THROW_FAILED_HRESULT(MakeBlobs.GetBlobSize (rClsId, ulCnt, pData, &ulSize)); // SAFEARRAY anlegen und Daten übernehmen pNewData = (BYTE *)::CoTaskMemAlloc (ulSize); if (NULL == pNewData) _com_issue_error(E_OUTOFMEMORY); THROW_FAILED_HRESULT(MakeBlobs.MakeBlob (rClsId, ulCnt, itx, ity, pNormal, pData, pNewData)); // Ergebnisse liefern *ppBlob = pNewData; *plSize = ulSize; } COM_CATCH_OP(::CoTaskMemFree(pNewData)); return S_OK; }
HRESULT CADODB::OpenAccessDB(LPCTSTR strFileName, LPCTSTR strPWD /* = NULL */) /*throw(_com_error &)*/ { if (NULL == strPWD) strPWD = _T(""); // ODBC Driver //LPCTSTR ACCESSDBCNNTEMPLATE = _T("DBQ=%s;PWD=%s;DRIVER={Microsoft Access Driver (*.mdb)};"); // Jet OLEDB (recommend) LPCTSTR ACCESSDBCNNTEMPLATE = _T("Provider=Microsoft.Jet.OLEDB.4.0;User ID=Admin;Data Source=%s;") _T("Mode=Share Deny None;Extended Properties=\"\";Jet OLEDB:System database=\"\";") _T("Jet OLEDB:Registry Path=\"\";Jet OLEDB:Engine Type=5;Jet OLEDB:Database Locking Mode=0;") _T("Jet OLEDB:Database Password=%s;Jet OLEDB:Global Partial Bulk Ops=2;Jet OLEDB:Global Bulk Transactions=1;") _T("Jet OLEDB:Create System Database=False;Jet OLEDB:Encrypt Database=False;") _T("Jet OLEDB:Don't Copy Locale on Compact=False;Jet OLEDB:Compact Without Replica Repair=False;Jet OLEDB:SFP=False"); CString strcnn; strcnn.Format(ACCESSDBCNNTEMPLATE, strFileName, strPWD); m_bstrCnn = strcnn; HRESULT hr = m_pConnection.CreateInstance(__uuidof(Connection)); if (FAILED(hr)) _com_issue_error(hr); m_pConnection->CursorLocation = adUseClient; return m_pConnection->Open(m_bstrCnn, "", "", adConnectUnspecified); }
void get_wmi_init() { static bool isinit = false; if (isinit) { return; } isinit = true; HRESULT hres = CoInitializeSecurity( NULL, -1, // COM authentication NULL, // Authentication services NULL, // Reserved RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation NULL, // Authentication info EOAC_NONE, // Additional capabilities NULL // Reserved ); if (FAILED(hres)) { _com_issue_error(hres); } }
//***************************************************************************** //* Function Name: InvokeUrl //* Description: //***************************************************************************** _bstr_t CInternalUrlInvoker::InvokeUrl ( const _bstr_t& p_sbstrMethod, const _bstr_t& p_sbstrUrl) { MSXML2::IServerXMLHTTPRequestPtr l_spXMLHTTPRequest; HRESULT l_hr = l_spXMLHTTPRequest.CreateInstance (__uuidof (MSXML2::ServerXMLHTTP)); if (FAILED (l_hr)) _com_issue_error (l_hr); l_spXMLHTTPRequest->open (p_sbstrMethod, p_sbstrUrl, false /* varAsync */); l_spXMLHTTPRequest->send (); long l_lHttpStatus = l_spXMLHTTPRequest->status; _bstr_t l_sbstrHttpStatusText = l_spXMLHTTPRequest->statusText; if (l_lHttpStatus != HTTP_STATUS_OK) { ThrowComErrorException ( __FILE__, __LINE__, E_UNEXPECTED, IDS_HTTP_REQUEST_FAILED, l_lHttpStatus, static_cast<LPCTSTR>(l_sbstrHttpStatusText)); } return l_spXMLHTTPRequest->responseText; }
///////////////////////////////////////////////////////////////////////////// // Erzeugen eines VT_UI1-SAFEARRAY aus einem Koordinatenfeld HRESULT CreateSABlobFromVertices ( double_v &rX, double_v &rY, POINTBASE *pNormal, void *pData, REFCLSID rClsId, SAFEARRAY **pSA) { if (NULL == pSA) return E_POINTER; COM_TRY { // resultierende Größe feststellen unsigned long ulSize = 0; CBlobService MakeBlobs; _ASSERTE(rX.size() == rY.size()); THROW_FAILED_HRESULT(MakeBlobs.GetBlobSize (rClsId, rX.size(), pData, &ulSize)); // SAFEARRAY anlegen und Daten übernehmen CSafeArray sa (VT_UI1, ulSize); if (!sa) _com_issue_error(E_OUTOFMEMORY); { CSafeArrayLock<BYTE> lock (sa); THROW_FAILED_HRESULT(MakeBlobs.MakeBlob (rClsId, rX.size(), rX.begin(), rY.begin(), pNormal, pData, lock)); } // lock goes out of scope *pSA = sa.Detach(); // Ergebnis liefern } COM_CATCH; return S_OK; }