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