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;
}
