// ---------------------------------------------------------------------------- // refcnt_ToolBarButton // ---------------------------------------------------------------------------- void refcnt_ToolBarButton (ebHTHREAD hThread, int iNumArgs, ebARGS lpArgs) { BASIC_OP_TRACE_SYS(refcnt_GeoObjects); switch (iNumArgs) { case OBJECT_REFNEW: { ebSetObject (lpArgs, 0, NULL); // für alle Fälle try { WDControlToolBarButton ToolBarBttn(CLSID_TRiASToolBarButton); WDispatch Disp; THROW_FAILED_HRESULT(((OLE2AutoExtension *)g_pTE) -> App() -> GetDispatchIF (Disp.ppi())); THROW_FAILED_HRESULT(ToolBarBttn -> put_Application (Disp)); THROW_FAILED_HRESULT(ToolBarBttn -> put_Parent (Disp)); ebSetObject (lpArgs, 0, (DWORD)ToolBarBttn.detach()); } catch (_com_error&) { return; } } break; case OBJECT_REFINC: ((IUnknown *)ebGetObject (lpArgs, 1)) -> AddRef(); break; case OBJECT_REFDEC: ((IUnknown *)ebGetObject (lpArgs, 1)) -> Release(); break; } }
STDMETHODIMP COleObjectPropertyDual::SearchObjects(BSTR bstrToMatch, SEARCHMODE rgFlags, IEnumObjectsByNumber **ppvObj) { if (NULL == ppvObj) return E_POINTER; *ppvObj = NULL; _ASSERTE(m_fSearchAble); // muß suchen können COM_TRY { WDSearchAbleObjectProperty Search(m_ObjProp); WDGeoObjects Objs; THROW_FAILED_HRESULT(Search -> SearchObjects(bstrToMatch, GetSearchMode(rgFlags), Objs.ppi())); WQueryEnumLONG QueryEnum(Objs); WEnumLONG Enum; THROW_FAILED_HRESULT(QueryEnum -> QueryEnumLONG (Enum.ppi())); WEnumObjectsByNumber EnumObjs(Enum); *ppvObj = EnumObjs.detach(); } COM_CATCH; return S_OK; }
HRESULT CFastdbFeature::OnChangedName() { USES_CONVERSION; COM_TRY { // neuen Namen vom Bezugsobjekt besorgen CComBSTR bstrName; WTRiASFeature BaseFeat; THROW_FAILED_HRESULT(m_BaseUnk -> QueryInterface (BaseFeat.ppi())); THROW_FAILED_HRESULT(BaseFeat -> get_Name(CLEARED(&bstrName))) // zugehöriges DB-Objekt referenzieren LONG lCursor (GetPropertyFrom (BaseFeat, g_cbFeatureCursor, 0L)); if (0 != lCursor) { // Objekt fertig initialisiert dbCursor<CDBFeatureDesc> cursor (GetRelatedDatabase(GetUnknown()), dbCursorForUpdate); CDBFeatureDesc *pFeatDesc = cursor.at (dbReference<CDBFeatureDesc>(oid_t(lCursor))); if (NULL == pFeatDesc || cursor.isEmpty()) THROW_FAILED_HRESULT(FASTDB_E_FEATURE_BADREFERENCE); cursor -> m_pName = OLE2A(bstrName); cursor.update(); } } COM_CATCH; return S_OK; }
/////////////////////////////////////////////////////////////////////////////// // IPropertyAction2 methods STDMETHODIMP CPropertyAction::InitFromData (IDataObject *pIDO, BOOL fCreate, DWORD) { if (NULL == pIDO) { if (fCreate) return S_OK; // can attempt to initialize it self else return S_FALSE; // can't attempt to replace internal data } COM_TRY { CComVariant vData; THROW_FAILED_HRESULT(GetVariantData (pIDO, &c_feInitPropAct, &vData)); THROW_FAILED_HRESULT(vData.ChangeType(VT_BSTR)); WParseStringPairs Bag (CLSID_ParseStringPairs); CComVariant v (DISP_E_PARAMNOTFOUND, VT_ERROR); // no error log LONG lCount = 0; CComBSTR bstrData; if (*V_BSTR(&vData) != L';') // Data müssen mit ";PropActData" anfangen bstrData = L";PropActData;"; bstrData += V_BSTR(&vData); THROW_FAILED_HRESULT(Bag -> put_Pattern (CComBSTR(L";%1=%2"))); THROW_FAILED_HRESULT(Bag -> Parse (V_BSTR(&vData), &lCount)); THROW_FAILED_HRESULT(Bag -> InitObject (GetUnknown(), v)); } COM_CATCH; return S_OK; }
// 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; }
///////////////////////////////////////////////////////////////////////////// // 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; }
// ---------------------------------------------------------------------------- // PropertySequence_refcnt // ---------------------------------------------------------------------------- void PropertySequence_refcnt (ebHTHREAD hThread, int iNumArgs, ebARGS lpArgs) { BASIC_OP_TRACE_SYS(PropertySequence_refcnt); switch (iNumArgs) { case OBJECT_REFNEW: { ebSetObject (lpArgs, 0, NULL); // für alle Fälle try { WPropertyActionSequence PropSeq (CLSID_PropertyActionSequence); // throws hr HPROJECT hPrCtx = reinterpret_cast<HPROJECT>(ebThread_GetLong (hThread, SETLONG_HPROJECT)); // Kontext-Datenquelle ebSetObject (lpArgs, 0, (DWORD)PropSeq.detach()); if (HACTCONNECTION != hPrCtx) { WDataObject CtxDO; CComVariant vData (reinterpret_cast<long>(hPrCtx), VT_I4); THROW_FAILED_HRESULT(PropSeq -> GetSequenceContext (CtxDO.ppi())); THROW_FAILED_HRESULT(SetVariantData (vData, CtxDO, &c_feDataSourceHandle)); } } catch (...) { TRACE("Couldn't instantiate PropertyActionSequence\r\n"); } } break; case OBJECT_REFINC: ((IUnknown *)ebGetObject(lpArgs, 1)) -> AddRef(); break; case OBJECT_REFDEC: ((IUnknown *)ebGetObject(lpArgs, 1)) -> Release(); break; } }
bool TextRecherche (HWND hWnd, bool fORWnd) { TX_ASSERT(_countof(cbRechClsIds) == _countof(cbRechPropActs)); TX_ASSERT(_countof(cbRechObjWnd) == _countof(cbRechPropActs)); // RecherchePages zu PropertyChoice zusammenfügen COM_TRY { WPropertyActionSequence Choice (CLSID_PropertyChoice); THROW_FAILED_HRESULT(AddSearchEngines (Choice)); WPropertyAction Action (Choice); // throws hr cbRechPropActs[1] = Action; // gesamte Sequence erzeugen und abarbeiten HRESULT hr = S_OK; if (!fORWnd) { ResString resCap (IDS_SEARCHCAP, 128); hr = RunPropertyActionSequence (hWnd, resCap, &calRechClsIds, NULL, NULL, NULL); } else { ResString resCap (IDS_SEARCHCAP_OR, 128); hr = RunPropertyActionSequence (hWnd, resCap, &calRechObjWnd, NULL, NULL, NULL); } if (hr == E_ABORT) return false; THROW_FAILED_HRESULT(hr); } COM_CATCH_RETURN(false); return true; }
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; }
char * CCoordTransService::CoordTransToStringEx ( double dX, double dY, bool isX, char *pBuffer, int iLen) { if (m_fIsInitialized) { try { CComBSTR bstr; CCSPoint pt (dX, dY); if (isX) { THROW_FAILED_HRESULT(m_CTF -> ToStrings (&pt, &bstr, NULL, NULL)); } else { THROW_FAILED_HRESULT(m_CTF -> ToStrings (&pt, NULL, &bstr, NULL)); } USES_CONVERSION; iLen = min(bstr.Length(), iLen-1); strncpy (pBuffer, OLE2A(bstr), iLen); pBuffer[iLen] = '\0'; return pBuffer; } catch (_com_error &e) { ShowError (_COM_ERROR(e), IDS_CSSERRORCAPTION, g_cbCoordTransToStringEx); return NULL; } } ShowError (TRIAS02_E_CSSNOTINITIALIZED, IDS_CSSERRORCAPTION, g_cbCoordTransToStringEx); return NULL; }
bool CSelectCoordSysActionDlg::PrepareResult() { // Selektierten Eintrag holen HTREEITEM hItem = m_tvCoordSystems.GetSelectedItem(); if (NULL == hItem || m_tvCoordSystems.ItemHasChildren (hItem)) return false; // nur Childs behandeln CCoordSystemItem *pItemData = (CCoordSystemItem *)m_tvCoordSystems.GetItemData (hItem); if (NULL == pItemData) return false; // Koordinatensystem am Parent setzen CString strTcfName = pItemData->GetTcfName(); COM_TRY { CComQIPtr<ITRiASCS, &IID_ITRiASCS> CS; THROW_FAILED_HRESULT(CS.CoCreateInstance(CLSID_TRIASCS)); THROW_FAILED_HRESULT(CS -> LoadFromFile(CComBSTR(strTcfName))); m_CS = CS; // store result coordsystem } COM_CATCH_OP_RETURN(CantLoadCS(strTcfName), false); return true; }
// Serialisieren/DeSerialisieren eines IUnknowns // in diesem Falle ein IDataObject HRESULT CreateStreamOnHGlobalFromIUnknown ( IUnknown *pIUnk, REFCLSID rClsID, IStream **ppIStream) { ASSERT(NULL != pIUnk); ASSERT(NULL != ppIStream); *ppIStream = NULL; try { // neuen Stream anlegen, kreiert eine neuen Memoryblock der Größe NULL // wird selbstständig wieder freigegen (true) WStream IStream; THROW_FAILED_HRESULT(CreateStreamOnHGlobal (NULL, true, IStream.ppi())); // den Enumerator wegschreiben WPersistStream IPersStr (pIUnk); // throws hr THROW_FAILED_HRESULT(OleSaveToStream (IPersStr, IStream)); // wieder zurück positionieren LARGE_INTEGER li; LISet32 (li, 0L); THROW_FAILED_HRESULT(IStream -> Seek (li, STREAM_SEEK_SET, NULL)); *ppIStream = IStream.detach(); } catch (_com_error &e) { return _COM_ERROR(e); } return S_OK; }
HRESULT GetVariantData (IDataObject *pIDO, const FORMATETC *pcfe, CComVariant *pv) { if (NULL == pIDO) return E_POINTER; STGMEDIUM stg; memset (&stg, 0, sizeof(STGMEDIUM)); try { // Testen, ob das gewünschte Format überhaupt da ist HRESULT hr = pIDO -> QueryGetData ((FORMATETC *)pcfe); if (S_OK != hr) return hr; // Format nicht vorhanden if (NULL == pv) return S_OK; // nur nachfragen // Daten vom DataObject geben lassen THROW_FAILED_HRESULT(pIDO -> GetData ((FORMATETC *)pcfe, &stg)); // einlesen des Enumerators aus den erhaltenen STGMEDIUM THROW_FAILED_HRESULT(pv -> ReadFromStream (stg.pstm)); ReleaseStgMedium (&stg); } catch (_com_error& hr_result) { if (TYMED_NULL != stg.tymed) ReleaseStgMedium (&stg); return _COM_ERROR(hr_result); } return S_OK; }
// 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; }
// Dient zum Lesen der Daten (EnumLONG) vom Stream im Datenobjekt HRESULT GetStringData (IDataObject *pIDataObj, LPSTR lpstr, int iLen) { HRESULT hr = NOERROR; STGMEDIUM stg; memset (&stg, 0, sizeof(STGMEDIUM)); try { // Testen, ob das gewünschte Format überhaupt da ist THROW_FAILED_HRESULT(pIDataObj -> QueryGetData ((FORMATETC *)&c_feInitPropAct)); // Daten vom DataObject geben lassen THROW_FAILED_HRESULT(pIDataObj -> GetData ((FORMATETC *)&c_feInitPropAct, &stg)); // Einlesen des CComVariants aus den erhaltenen STGMEDIUM-Stream stg.pstm THROW_FAILED_HRESULT(CreateStringFromStream (stg.pstm, lpstr, iLen)); // Freigeben Storagemedium ReleaseStgMedium (&stg); } catch (_com_error& e) { if (TYMED_NULL != stg.tymed) ReleaseStgMedium (&stg); return _COM_ERROR(e); } return hr; }
// Dient zum Lesen der Daten (EnumLONG) vom Stream im Datenobjekt HRESULT GetEnumLONGData (IDataObject *pIDataObj, IEnum<LONG> **ppIEnumOut) { if (NULL == pIDataObj) return S_FALSE; HRESULT hr = ResultFromScode (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_feSelectedObjects)); // Daten vom DataObject geben lassen THROW_FAILED_HRESULT(pIDataObj -> GetData ((FORMATETC *)&c_feSelectedObjects, &stg)); // Einlesen des Enumerators aus den erhaltenen STGMEDIUM THROW_FAILED_HRESULT(CreateEnumLONGFromStream (stg.pstm, ppIEnumOut)); ReleaseStgMedium (&stg); } catch (_com_error &e) { if (TYMED_NULL != stg.tymed) ReleaseStgMedium (&stg); return _COM_ERROR(e); } return NOERROR; }
// -------------------------------------------------------------------------------------------- STDMETHODIMP CRegOperatPropAct::BeginAction (IProgressIndicator* pIProgInd) { #if _TRiAS_VER < 0x0300 m_hPr = 0; #else COM_TRY { // Zieldatenquelle aus KontextObjekt herausfinden WPropertyActionSequence wSeq; WDataObject CtxDO; CComVariant vData; m_hPr = 0; THROW_FAILED_HRESULT (GetSite (IID_IPropertyActionSequence, wSeq.ppv())); THROW_FAILED_HRESULT (wSeq->GetSequenceContext (CtxDO.ppi())); if (SUCCEEDED (GetVariantData (CtxDO, &c_feDataSourceHandle, &vData)) && SUCCEEDED (vData.ChangeType (VT_I4))) { m_hPr = reinterpret_cast<HPROJECT>(V_I4(&vData)); } } COM_CATCH; #endif // _TRiAS_VER < 0x0300 // Zustand des Dialogs retten (für evtl. späteres Save()) m_pRegOperDlg->GetSelectedInfo (&m_caSelInfo, m_bIsDirty); // Liste für Objekte, die an die PropertyPage übergeben werden, initialisieren m_InObjs.clear(); // Liste sicher leeren m_ObjsIter = m_InObjs.begin(); // auf Anfang stellen return S_OK; } // BeginAction
HRESULT CCoordTransService::FindCTF (void) { USES_CONVERSION; char cbCTFName[_MAX_PATH]; CComBSTR bstr (GetProperty (m_Props, g_cbCoordTransform, A2OLE(g_cbDefault))); strcpy (cbCTFName, OLE2A(bstr)); if (!stricmp (cbCTFName, g_cbDefault)) m_fIsDefault = true; // CTFService's über CATID enumerieren, CTFService wiederfinden try { WEnumGUID EnumGuids; // Enumerator der CTFService-Objekte WCatInformation CatInfo (CLSID_StdComponentCategoriesMgr); // throws hr GUID guidImpl[1]; guidImpl[0] = CATID_TRiASCoordsystem; THROW_FAILED_HRESULT(CatInfo -> EnumClassesOfCategories (1, guidImpl, 0, NULL, EnumGuids.ppi())); GUID guid; LPOLESTR lpGuid = NULL; bool fFoundGuid = false; for (EnumGuids -> Reset(); S_OK == EnumGuids -> Next (1, &guid, NULL); /**/) { THROW_FAILED_HRESULT(StringFromCLSID (guid, &lpGuid)); CClassesRoot regClsID (OLE2A(lpGuid)); char cbBuffer[_MAX_PATH]; LONG lSize = sizeof(cbBuffer); if (NULL != lpGuid) { CoTaskMemFree (lpGuid); lpGuid = NULL; } if (regClsID.isValid() && regClsID.GetSZ (g_cbOldName, cbBuffer, lSize)) { if (!stricmp (cbBuffer, cbCTFName)) { fFoundGuid = true; m_strCTF = cbBuffer; break; } } } if (!fFoundGuid) { TX_ASSERT(fFoundGuid); return E_FAIL; // snh! } } catch (_com_error &e) { TX_ASSERT(S_OK == _COM_ERROR(e)); return _COM_ERROR(e); } return S_OK; }
void PropertySequence_cmd_AddAction (ebHTHREAD hThread, int iNumArgs, ebARGS lpArgs) { BASIC_OP_TRACE(PropertySequence_cmd_AddAction); WPropertyActionSequence Seq ((IPropertyActionSequence *)ebGetObject (lpArgs, 1)); ebHSUB hStr = ebGetString (lpArgs, 2); if (NULL != hStr) { USES_CONVERSION; LPSTR lpstr = ebLockString (hThread, hStr); BASIC_OP_TRACE2(lpstr); CLSID clsID; HRESULT hr = CLSIDFromString (A2OLE(lpstr), &clsID); if (FAILED(hr)) hr = CLSIDFromProgID (A2OLE(lpstr), &clsID); if (SUCCEEDED(hr)) { CComVariant v2 (MakeVARIANT (hThread, iNumArgs, lpArgs, 3)); if (VT_ERROR == V_VT(&v2)) { // nur ein Parameter gegeben CALPCLSID cal; const CLSID *pClsID = &clsID; memset(&cal, '\0', sizeof(CALPCLSID)); cal.cElems = 1; cal.ppElems = &pClsID; Seq -> AddActionsByCLSID (&cal); } else { // 2. Parameter auswerten try { WPropertyAction WAct (clsID); // throws hr if (FAILED(InitFromData (WAct, v2))) { // kann nicht mit Daten initialisiert werden, also normales Init WPersistStreamInit Init (WAct); // throws hr THROW_FAILED_HRESULT(Init -> InitNew()); } THROW_FAILED_HRESULT(Seq -> AddAction (WAct)); } catch (_com_error&) { ; } } } ebUnlockString (hThread, hStr); } }
// -------------------------------------------------------------------------------------------- STDMETHODIMP CRegOperatPropAct::EndAction (DWORD, IDataObject** ppDataOut) { _ASSERTE (m_ObjsIter != m_InObjs.end()); *ppDataOut = 0; try { WEnumLONG wEnumInObj (*m_ObjsIter); // die zu bearbeitenden Objekte WEnumLONG wEnumOutObj; // Ergebnisobjekte der ausgewählten Operation // Optionen abfragen DWORD dwOptions = 0x00; if (SUCCEEDED(EnsureOptionsIF())) { _ASSERTE(m_wOperOptions.IsValid()); m_wOperOptions->GetOptions (&dwOptions); } // im Dialog ausgewählte Operation ausführen THROW_FAILED_HRESULT (m_pRegOperDlg->ExecuteOperation (m_hPr, wEnumInObj, dwOptions, wEnumOutObj.ppi())); m_ObjsIter++; if (wEnumOutObj.IsValid()) { // IDataObject abfragen WDataObject IDO (CLSID_DataTransferObject); // Ergebnisobjekte im DataObjekt IDO speichern THROW_FAILED_HRESULT (SetEnumLONGData ( (IEnum<LONG>*)(IEnumLONG*)wEnumOutObj, IDO)); // Resultat setzen *ppDataOut = IDO.detach(); if (0 == wEnumOutObj->Count()) { ResString resTitel (ResID (IDS_LONGCLASSNAME, pRF), 50); ResString resText (ResID (IDS_BOXTEXT1, pRF), 200); MessageBox (__hWndM, resText.Addr(), resTitel.Addr(), MB_ICONINFORMATION | MB_OK); } } } catch (_com_error& hr_result) // 23.09.99 { DELETE_OBJ (m_pRegOperDlg); // bei Fehler Dialog wieder freigeben return _COM_ERROR(hr_result); // 23.09.99 } if (m_ObjsIter != m_InObjs.end()) // es kommen noch weitere Daten return S_FALSE; DELETE_OBJ (m_pRegOperDlg); // es kommen keine Daten mehr return S_OK; } // EndAction
BOOL DatenBasisObjekt::EnumPBDDataIdent (HPROJECT hPr, ENUMLONGKEYPROC pFcn, void *pData) { TX_ASSERT(IsTRiASDBBased()); BOOL iRC = TRUE; COM_TRY { // Enumerieren aller Objektklassen einer Datenquelle if (HACTPROJECT != hPr) { if (HACTCONNECTION != hPr) // eine bestimmte Datenquelle auswerten return DB(hPr).EnumPBDDataIdent (pFcn, pData); // _alle_ Datenquellen auswerten CRing r (*m_pGeoDBs); for (r.First(); r.Valid(); r.Next()) { GeoDBLock l(r); TX_ASSERT(NULL != (GeoDB *)l); if (l -> isOpened()) { if (!l -> EnumPBDDataIdent (pFcn, pData)) return FALSE; } } return TRUE; } // Objektmengen (Tabellen) enumerieren WTRiASObjectsCollection ObjsDefs; THROW_FAILED_HRESULT(m_Prj -> get_ObjectsDefs (ObjsDefs.ppi())); WEnumVARIANT Enum; CComVariant v; THROW_FAILED_HRESULT(ObjsDefs -> _NewEnum (Enum.ppu())); for (Enum -> Reset(); S_OK == Enum -> Next (1, CLEARED(&v), NULL); /**/) { if (FAILED(v.ChangeType (VT_DISPATCH))) continue; WTRiASObjects Item (V_DISPATCH(&v)); INT_PTR lHandle = 0L; if (SUCCEEDED(Item -> get_Handle (&lHandle))) { iRC = EnumIdentsCallback (pFcn, lHandle, TRUE, pData); if (!iRC) break; // Enumeration abgebrochen } } } COM_CATCH_RETURN(FALSE); return iRC; }
STDMETHODIMP COleObjectPropertyDual::GetPropInfo (LPSTR pBuffer, WORD wLen, DWORD *pdwFlags) { HRESULT result = S_OK; try { // get_PropertyName if (NULL != pBuffer && wLen > 0) { CComBSTR bstrName; THROW_FAILED_HRESULT(m_ObjProp -> get_PropertyName(CLEARED(&bstrName))); ULONG ulT = min ((ULONG)wLen-1, (ULONG)SysStringLen(bstrName)); USES_CONVERSION; strncpy (pBuffer, OLE2A(bstrName), ulT); pBuffer[ulT] = '\0'; } } catch (_com_error& hr) { return _COM_ERROR(hr); } try { PROPERTYCAPS lFlags = PROPERTYCAPS_NONE; // get_PropertyFlags if (NULL != pdwFlags) { THROW_FAILED_HRESULT(m_ObjProp -> get_PropertyFlags(&lFlags)); if (m_fWriteAble) lFlags = PROPERTYCAPS(lFlags | PROPERTYCAPS_NOTREADONLY); else lFlags = PROPERTYCAPS(lFlags & ~PROPERTYCAPS_NOTREADONLY); if (m_fSearchAble) lFlags = PROPERTYCAPS(lFlags | PROPERTYCAPS_SEARCHABLE); else lFlags = PROPERTYCAPS(lFlags & ~PROPERTYCAPS_SEARCHABLE); *pdwFlags = DWORD(lFlags); } } catch (_com_error&) { *pdwFlags = DWORD(PROPERTYCAPS_NONE); if (m_fWriteAble) *pdwFlags |= DWORD(PROPERTYCAPS_NOTREADONLY); if (m_fSearchAble) *pdwFlags |= DWORD(PROPERTYCAPS_SEARCHABLE); } return S_OK; }
/////////////////////////////////////////////////////////////////////////////// // alle Objekte eines Bereiches suchen HRESULT CSpatialTree::TreeNodeSearch ( double *padfBoundsMin, double *padfBoundsMax, HRESULT (CALLBACK *pFcn)(_DGMGeometry *, UINT_PTR), UINT_PTR dwData, bool fExact) { // Perform the search for likely candidates. These are shapes // that fall into a tree node whose bounding box intersects our // area of interest. int nFeatureCount = 0; _DGMGeometry * *panHits = FindLikelyFeatures (padfBoundsMin, padfBoundsMax, &nFeatureCount); if (NULL == panHits) return S_OK; // nothing found // Read all of these shapes, and establish whether the shape's // bounding box actually intersects the area of interest. Note // that the bounding box could intersect the area of interest, // and the shape itself still not cross it but we don't try to // address that here. HRESULT hr = S_OK; COM_TRY { for (int i = 0; i < nFeatureCount && SUCCEEDED(hr); ++i) { W_DGMGeometry Object (panHits[i]); if (!Object) continue; WTRiASCSGeometryProperties Prop (Object); WTRiASSimpleRectangle Rect; double dBoundsMin[2]; double dBoundsMax[2]; THROW_FAILED_HRESULT(Prop -> get_Envelope(Rect.ppi())); THROW_FAILED_HRESULT(Rect -> GetRect(&dBoundsMin[0], &dBoundsMin[1], &dBoundsMax[0], &dBoundsMax[1])); if (CSpatialTreeNode::CheckBoundsOverlap (padfBoundsMin, padfBoundsMax, dBoundsMin, dBoundsMax)) { if (!fExact || S_OK == CheckRealOverlap (Object, padfBoundsMin, padfBoundsMax)) hr = pFcn (Object, dwData); } } } COM_CATCH_OP(free (panHits)); free (panHits); return hr; }
STDMETHODIMP COleObjectPropertyDual::HelpInfo ( LPSTR pBuffer, ULONG ulLen, LPSTR pHelpFile, ULONG *pulHelpCtx) { HRESULT result = S_OK; try { CComBSTR bstrInfo; CComVariant vHelpFile; CComVariant vHelpCtx; THROW_FAILED_HRESULT(m_ObjProp -> HelpInfo(&vHelpFile, &vHelpCtx, CLEARED(&bstrInfo))); USES_CONVERSION; if (NULL != pBuffer && ulLen > 0) { ULONG ulT = min (ulLen-1, (ULONG)SysStringLen(bstrInfo)); strncpy (pBuffer, OLE2A(bstrInfo), ulT); pBuffer[ulT] = '\0'; } if (NULL != pHelpFile && VT_BSTR == vHelpFile.vt) strcpy (pHelpFile, OLE2A(V_BSTR(&vHelpFile))); if (NULL != pulHelpCtx && VT_I4 == vHelpCtx.vt) *pulHelpCtx = V_I4(&vHelpCtx); } catch (_com_error& hr) { result = _COM_ERROR(hr); } return result; }
HRESULT COleObjectPropertyDual::FInit (DObjectProperty *pIObjProp) { if (NULL == pIObjProp) return E_POINTER; try { m_ObjProp = pIObjProp; // throws hr PROPERTYCAPS rgFlags = PROPERTYCAPS_NONE; THROW_FAILED_HRESULT(m_ObjProp -> get_PropertyFlags(&rgFlags)); WDWriteAbleObjectProperty ObjPropEx; if (SUCCEEDED(m_ObjProp->QueryInterface(ObjPropEx.ppi())) && rgFlags & PROPERTYCAPS_NOTREADONLY) { m_fWriteAble = true; // DWriteAbleObjectProperty wird unterstützt } WDSearchAbleObjectProperty ObjPropSrch; if (SUCCEEDED(m_ObjProp->QueryInterface(ObjPropSrch.ppi())) && rgFlags & PROPERTYCAPS_SEARCHABLE) { m_fSearchAble = true; // DSearchAbleObjectProperty wird unterstützt } } catch (_com_error& hr) { m_fWriteAble = false; m_fSearchAble = false; return _COM_ERROR(hr); } return InitDocumentDispatch(); }
/////////////////////////////////////////////////////////////////////////////////////////////// // Verbindung zur CObjectModify-Klasse über das Interface IModifyClassSite herstellen; // es wird KEINE (!!) Verbindung zu TRiAS über Interface ITriasExtension hergestellt, die // WindowsMessages werden vom CObjectModify-Objekt heruntergereicht STDMETHODIMP CVertexAdd::SetModifyClassSite (IEditExtensionSite* pIEdExSite, IModifyClassSite* pIModClSite) { try { if (pIEdExSite != NULL) { THROW_FAILED_HRESULT (pIEdExSite->CreateInterfaceTO (m_wTopObjs.ppi())); m_wEdExSite = pIEdExSite; } else { m_wTopObjs.Assign (NULL); // freigeben m_wEdExSite.Assign (NULL); // freigeben } m_wModClSite = pIModClSite; } catch (_com_error& e) { return _COM_ERROR (e); } return S_OK; } // SetModifyClassSite
HRESULT InitFromData (IPropertyAction *pIAct, CComVariant &rv) { try { // mit Daten aus 2. Parameter initialisieren WPropertyAction2 Init (pIAct); // throws hr WDataObject Data (CLSID_DataTransferObject); // throws hr THROW_FAILED_HRESULT(SetVariantData (rv, Data, &c_feInitPropAct)); THROW_FAILED_HRESULT(Init -> InitFromData (Data, false, 0L)); } catch (_com_error& hr) { return _COM_ERROR(hr); } return S_OK; }
/////////////////////////////////////////////////////////////////////////////// // Helperroutinen HRESULT LoadSearchEngine (IPropertyActionSequence *pISeq, LPCSTR pcKey) { // ClassID aus Registry besorgen CLSID clsID; HRESULT hr = CLSIDFromProgID (WideString(pcKey), &clsID); if (FAILED(hr)) return hr; // nichts gefunden COM_TRY { // Objekt instantiieren WPropertyAction WAct (clsID); // throws hr // Objekt initialisieren { WPersistStreamInit Init (WAct); // throws hr; HRESULT hr = Init -> InitNew(); if (FAILED(hr)) { if (hr != E_ABORT) return hr; return S_FALSE; // darf mit E_ABORT fehlschlagen } } // zur Sequence hinzufügen THROW_FAILED_HRESULT(pISeq -> AddAction (WAct)); } COM_CATCH; return S_OK; }
// -------------------------------------------------------------------------------------------- // GeoEdit informiert die IEditOperation über den aktuellen Zustand der Konstruktionslinien STDMETHODIMP CNewArea::InformRestrictLinesState (IRestrictLine* pRestrLine1, IRestrictLine* pRestrLine2) { m_wRestrLine1.Assign (NULL); m_wRestrLine2.Assign (NULL); m_wRestrLine1 = pRestrLine1; m_wRestrLine2 = pRestrLine2; m_wRestrictCursor.Assign (NULL); if (m_wRestrLine1.IsValid() || m_wRestrLine2.IsValid()) { if (m_wRestrLine1.IsValid()) m_wRestrLine1->Draw(); if (m_wRestrLine2.IsValid()) m_wRestrLine2->Draw(); try { // Verbindung zum CRestrictCursor-Objekt über dessen Interface IRestrictCursor herstellen WRestrictCursor wRestrictCursor (CLSID_RestrictCursor); // throws_com_error m_wRestrictCursor = wRestrictCursor; THROW_FAILED_HRESULT (m_wRestrictCursor->ConstructRestrictCursor()); } catch (_com_error& e) { return _COM_ERROR (e); } } return S_OK; } // InformRestrictLinesState
/////////////////////////////////////////////////////////////////////////////// // aus TRiASCS Wkt erzeugen STDMETHODIMP CTRiASCSWktService::ExportAsWkt(WKTFORMAT rgFormat, ITRiASCS *pCS, BSTR *pbstrWktCS) { CHECKOUTPOINTER(pbstrWktCS); CHECKINPOINTER(pCS); if (WKTFORMAT_OgcWkt != rgFormat) return E_INVALIDARG; COM_TRY { // ist's einprojektives System CComBSTR bstrWkt; CComBSTR bstr; TRIASCSTYPE rgType; WTRiASCSPCS PCS; THROW_FAILED_HRESULT(pCS -> get_CoordSystemType(&rgType)); if (tcsCS_Projected == rgType) { bstrWkt.Append(L"PROJCS[\""); // Namen der Projektion ausgeben THROW_FAILED_HRESULT(RetrieveProjectedName (pCS, CLEARED(&bstr))); bstrWkt.Append(bstr); } // Datumsbeschreibung ausgeben WTRiASCSGCS GCS; THROW_FAILED_HRESULT(pCS -> get_GeographicCS(GCS.ppi())); THROW_FAILED_HRESULT(ExportGeographicSystem(GCS, CLEARED(&bstr))); bstrWkt.Append(bstr); // ggf. Projektionsparameter ausgeben if (tcsCS_Projected == rgType) { _ASSERTE(PCS.IsValid()); THROW_FAILED_HRESULT(ExportProjectionParams(PCS, CLEARED(&bstr))); bstrWkt.Append(bstr); bstrWkt.Append(L"]"); } // Resultat liefern *pbstrWktCS = bstrWkt.Detach(); } COM_CATCH; return S_OK; }