HRESULT TxInitPropertySupportObject (
_PROPERTYSUPPORT_ENTRY* pEntry, ITRiASPropertyCallback *pobj, IUnknown *punk)
{
// Objekte, die den Parent brauchen, kriegen selbigen über das IObjectWithSite zugeschoben
CComPtr<IObjectWithSite> pSite;
if (NULL != punk && SUCCEEDED(pobj -> QueryInterface(IID_IObjectWithSite, (LPVOID *)&pSite.p)))
{
RETURN_FAILED_HRESULT(pSite -> SetSite(punk));
}
// Objekte, die Ihren Namen brauchen, kriegen selbigen
CComPtr<IObjectWithName> pName;
CComBSTR bstrName (pEntry->szKey);
if (SUCCEEDED(pobj -> QueryInterface(IID_IObjectWithName, (LPVOID *)&pName.p)))
{
RETURN_FAILED_HRESULT(pName -> put_Name(bstrName));
}
// Objekte, die initialisiert werden sollen, werden es hier
if (pEntry->dwFlags & PROPERTYSUPPORT_HASINITDATA)
{
if (NULL != pEntry -> pDefValProc) {
// Initialisierung erfolgt über gegebene Funktion
PROPERTY_TYPE rgType = PROPERTY_TYPE_Normal;
RETURN_FAILED_HRESULT((pEntry -> pDefValProc)(bstrName, &pEntry -> vInitData, &rgType));
RETURN_FAILED_HRESULT(pobj -> PutValueAndType (bstrName, pEntry -> vInitData, rgType));
} else {
RETURN_FAILED_HRESULT(pobj -> PutValue (bstrName, pEntry -> vInitData));
}
}
return S_OK;
}
HRESULT CTRiASPCSPpg::UpdateControls( ) {
WTRiASCS pCS;
WTRiASCSPCS pPCS;
TRIASCSPROJECTIONALGORITHM pa;
TRIASCSPROJECTIONPARAMETER pp;
RETURN_FAILED_HRESULT( m_ppUnk[0]->QueryInterface(IID_ITRiASCS, pCS.ppv()) );
RETURN_FAILED_HRESULT( pCS->get_ProjectedCS( pPCS.ppi() ) );
RETURN_FAILED_HRESULT( pPCS->get_ProjectionAlgorithm( &pa ) );
_ASSERTE( tcsPA_Undefined != pa );
PA_AttribsVector v;
int nParams = _EM.GetAttribs( pa, v );
sort( v.begin(), v.end() );
double param;
TCHAR buf[_MAX_PATH];
CSetLocale loc;
int nParam = 0;
for( PA_AttribsVector::iterator i = v.begin(); v.end() != i && nParam < _countof(CTRLS); i++, nParam++ ) {
pp = (*i);
RETURN_FAILED_HRESULT( pPCS->get_ProjectionParameter( pp, ¶m ) );
sprintf( buf, _T("%.7lf"), param );
::ShowWindow( GetDlgItem( CTRLS[nParam].ctrlName ), SW_SHOW );
::ShowWindow( GetDlgItem( CTRLS[nParam].ctrlValue ), SW_SHOW );
::SendMessage( GetDlgItem( CTRLS[nParam].ctrlName ), WM_SETTEXT, 0, (LPARAM) _EM.GetAttrib( pa, (*i) ) );
::SendMessage( GetDlgItem( CTRLS[nParam].ctrlValue ), WM_SETTEXT, 0, (LPARAM) buf );
}
for( ; nParam < _countof(CTRLS); nParam++ ) {
::ShowWindow( GetDlgItem( CTRLS[nParam].ctrlName ), SW_HIDE );
::ShowWindow( GetDlgItem( CTRLS[nParam].ctrlValue ), SW_HIDE );
}
_ASSERTE(nParams<nParam);
return S_OK;
}
///////////////////////////////////////////////////////////////////////////////
// Berechnen dieser Objekteigenschaft
STDMETHODIMP CSimpleAreaRadius::Eval (LONG lONr, LPSTR pBuffer, ULONG ulLen, ULONG *pulWritten)
{
// AFX_MANAGE_STATE(AfxGetAppModuleState())
if (NULL == pBuffer)
return E_POINTER;
_ASSERTE(0 != ulLen);
CGObject Obj (lONr);
if (Obj.FInit() && OGFlaeche == Obj.iObjTyp() && ulLen > 32) { // 32 Zeichen werden zumindest gebraucht
// nur für FlächenObjekte
double dObjArea = 0.0;
os_string strUnit;
RETURN_FAILED_HRESULT(Obj.AreaOfPolygon(&dObjArea, strUnit, true));
// muß als Längenmaßeinheit ausgewertet werden
si::Length dRadius (sqrt(dObjArea/si::pi)/2);
double dResult = dRadius.measuredIn(((CStatist *)g_pTE) -> GetUoL (dRadius, strUnit));
sprintf (pBuffer, "%f%s", dResult, strUnit.c_str());
if (pulWritten)
*pulWritten = strlen(pBuffer);
// Infos für Kumulation sammeln
RETURN_FAILED_HRESULT(m_CumPts -> AddValue (dResult, vtMissing));
IncrementCount(); // Zähler der erfolgreichen Aufrufe
return S_OK;
}
return E_FAIL; // ObjProperty existiert nicht
}
LRESULT CTRiASPCSPpg::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) {
TRIASCSPROJECTIONALGORITHM pa;
WTRiASCS pCS;
WTRiASCSPCS pPCS;
HRESULT hr;
CODENAME *pCode;
WTRiASCSTransformInfo pTI;
RETURN_FAILED_HRESULT( m_ppUnk[0]->QueryInterface(IID_ITRiASCS, pCS.ppv()) );
RETURN_FAILED_HRESULT( pCS->get_ProjectedCS( pPCS.ppi() ) );
try {
pTI = pPCS;
} catch(...) {
}
HWND hcombo = GetDlgItem( IDC_PROJECTIONALGORITHM );
int nItem;
/////////////////////////////////////////////////////////////
// Combobox füllen
for( pCode = _CT_TRIASCSPROJECTIONALGORITHM; -1 != pCode->code && NULL != pCode->name; pCode++ ) {
if( !!pTI && S_OK == pTI->CanTransform( pCode->code ) ) {
nItem = ::SendMessage( hcombo, CB_ADDSTRING, 0, (LPARAM) pCode->name );
::SendMessage( hcombo, CB_SETITEMDATA, nItem, (DWORD) pCode->code );
}
}
/////////////////////////////////////////////////////////////
// und Projektion einstellen
hr = pPCS->get_ProjectionAlgorithm( &pa );
if( tcsPA_Undefined == pa ) {
pa = tcsPA_GaussKrueger;
pPCS->put_ProjectionAlgorithm( pa );
}
LPCTSTR pName = _EM.Decode( tcsCType_PA, pa );
::SendMessage( hcombo, CB_SELECTSTRING, 0, (LPARAM) pName );
UpdateControls();
return 0;
}
HRESULT DatenBasisObjekt::DelPBDDataIdent (HPROJECT hPr, PBDDATA *pData)
{
TX_ASSERT(IsTRiASDBBased());
// Tabelle liegt in einer Datenquelle
if (HACTPROJECT != hPr) {
ErrCode RC = DB(GetIdentDBHandle (pData -> pbdCode, hPr)).DelPBDDataIdent (pData);
if (EC_OKAY != RC)
return HRESULT_FROM_ERRCODE(RC);
// Notifikation rumschicken
DEXN_FeatureSetModified(pData -> pbdCode);
}
else {
// KurzText muß gegeben sein
TX_ASSERT(pData -> pbdKTextLen > 0 && NULL != pData -> pbdKText);
// übergreifende Objektmenge löschen
WTRiASObjectsCollection ObjsDefs;
RETURN_FAILED_HRESULT(m_Prj -> get_ObjectsDefs (ObjsDefs.ppi()));
RETURN_FAILED_HRESULT(ObjsDefs -> Remove (CComVariant(pData -> pbdKText)));
}
return S_OK;
}
HRESULT _PROPERTYSUPPORT_ENTRY::GetDefaultSupportObject (
LPCOLESTR pcName, ITRiASPropertyCallback **ppOut, IUnknown *punk)
{
_ASSERTE(dwFlags & PROPERTYSUPPORT_DEFAULT);
WUnknown Unk;
HRESULT hr = E_FAIL;
if (dwFlags & PROPERTYSUPPORT_USECREATORFUNC)
hr = ((_ATL_CREATORFUNC *)dw)((dwFlags & PROPERTYSUPPORT_AGGREGATE) ? punk : NULL, IID_IUnknown, Unk.ppv());
else
hr = TxCreatePropertySupportObject((const CLSID *)dw, (dwFlags & PROPERTYSUPPORT_AGGREGATE) ? punk : NULL, Unk.ppv());
if (FAILED(hr)) return hr;
hr = Unk -> QueryInterface (IID_ITRiASPropertyCallback, (LPVOID *)ppOut);
if (FAILED(hr))
ReleaseSupportObjects();
else {
// zusätzliche Initialisierungen durchführen
RETURN_FAILED_HRESULT(TxInitPropertySupportObject(this, *ppOut, punk));
RETURN_FAILED_HRESULT(AddDefaultEntry (pcName, Unk));
}
return hr;
}
///////////////////////////////////////////////////////////////////////////////
// Berechnen dieser Objekteigenschaft
STDMETHODIMP CSimpleAreaFrame::Eval (LONG lONr, LPSTR pBuffer, ULONG ulLen, ULONG *pulWritten)
{
// AFX_MANAGE_STATE(AfxGetAppModuleState())
if (NULL == pBuffer) return E_POINTER;
_ASSERTE(0 != ulLen);
_ASSERTE(!IsBadWritePtr(pBuffer, ulLen));
if (pulWritten)
*pulWritten = 0;
CGObject Obj (lONr);
if (Obj.FInit() && OGFlaeche == Obj.iObjTyp() && ulLen > 32) { // 32 Zeichen werden zumindest gebraucht
// nur für FlächenObjekte
double dObjLength = 0.0;
os_string strUnit;
RETURN_FAILED_HRESULT(Obj.LengthOfPolyline (&dObjLength, strUnit));
sprintf (pBuffer, "%f%s", dObjLength, strUnit.c_str());
if (pulWritten)
*pulWritten = strlen(pBuffer);
// Infos für Kumulation sammeln
RETURN_FAILED_HRESULT(m_CumPts -> AddValue (dObjLength, vtMissing));
IncrementCount(); // Zähler der erfolgreichen Aufrufe
return S_OK;
}
return E_FAIL; // ObjProperty existiert nicht
}
// IObjectProperty sepcifics
STDMETHODIMP CCountLinePoints::Reset (void)
{
// AFX_MANAGE_STATE(AfxGetAppModuleState())
RETURN_FAILED_HRESULT(m_CumPts -> Reset());
RETURN_FAILED_HRESULT(CObjectPropertyBase::Reset());
return S_OK;
}
// IObjectProperty specifics
STDMETHODIMP CSimpleAreaRadius::Reset (void)
{
// AFX_MANAGE_STATE(AfxGetAppModuleState())
RETURN_FAILED_HRESULT(m_CumPts -> Reset())
RETURN_FAILED_HRESULT(CObjectPropertyBase::Reset());
return S_OK;
}
///////////////////////////////////////////////////////////////////////////////
// Berechnen dieser Objekteigenschaft
STDMETHODIMP CPointRefCoord::Eval (LONG lONr, LPSTR pBuffer, ULONG ulLen, ULONG *pulWritten)
{
// AFX_MANAGE_STATE(AfxGetAppModuleState())
if (NULL == pBuffer) return E_POINTER;
_ASSERTE(0 != ulLen);
_ASSERTE(!IsBadWritePtr(pBuffer, ulLen));
if (pulWritten)
*pulWritten = 0;
CGObject Obj (lONr);
if (Obj.FInit() && ulLen > 32) { // 32 Zeichen werden zumindest gebraucht
// nur für GeometrieObjekte
double dX = 0.0;
double dY = 0.0;
switch (Obj.iObjTyp()) {
case OGFlaeche:
// bei Flächen Außnahmeregelung
RETURN_FAILED_HRESULT(Obj.InitRealAreaPoint (&dX, &dY));
break;
case OGLinie:
{
long lCentre = Obj.lCnt()/2 -1;
if (0 == lCentre)
++lCentre;
dX = *(Obj.X() + lCentre);
dY = *(Obj.Y() + lCentre);
}
break;
case OGPunkt:
case OGText:
dX = *Obj.X();
dY = *Obj.Y();
break;
default:
return E_UNEXPECTED;
}
sprintf (pBuffer, "%f", (COORDTYPE_X == m_rgType) ? dX : dY);
if (pulWritten)
*pulWritten = strlen(pBuffer);
// Infos für Kumulation sammeln
RETURN_FAILED_HRESULT(m_CumPts -> AddValue ((COORDTYPE_X == m_rgType) ? dX : dY, vtMissing));
IncrementCount(); // Zähler der erfolgreichen Aufrufe
return S_OK;
}
return E_FAIL; // ObjProperty existiert nicht
}
STDMETHODIMP CTRiASMICursorProperty::PutValue (BSTR Name, VARIANT Value)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState())
_ASSERTE(NULL != Name);
_ASSERTE(!wcscmp (Name, m_bstrName)); // muß voreingestellter Name sein
RETURN_FAILED_HRESULT(m_Value.Copy(&Value)); // Wert setzen
RETURN_FAILED_HRESULT(SetCursor()); // Zuordnung in Map setzen bzw. entfernen
return S_OK;
}
STDMETHODIMP CConvertGuid::CreateGuid32String(BSTR *pbstrGuidStr)
{
if (NULL == pbstrGuidStr)
return E_POINTER;
*pbstrGuidStr = NULL;
GUID Guid;
RETURN_FAILED_HRESULT(CoCreateGuid(&Guid));
RETURN_FAILED_HRESULT(GuidToGuid32String(Guid, pbstrGuidStr));
return S_OK;
}
// --------------------------------------------------------------------------------------------
// neue Fläche editieren
HRESULT CNewArea::NeueFlaeche (void)
{
// m_LastPkt evtl. durch Grabben noch modifizieren, wenn ohne Konstruktionshilfslinien
// editiert wird
RETURN_FAILED_HRESULT (Grabbing());
if (! m_wObj.IsValid()) // aus dem 1. editierten Stützpunkt Anfang der Außenkontur aufbauen
{
m_dAktGesFlaeche = 0.0;
m_dAktInsel = 0.0;
RETURN_FAILED_HRESULT (CreateInterfaceOG (m_wObj.ppi(), m_LastPkt.X(), m_LastPkt.Y(),
OT_FLAECHE));
m_FirstPkt = m_LastPkt;
m_FirstPt = m_LastPt;
m_lKSize = 1; // Größe der aktuell editierten Kontur
m_wTopObjs->AddTopicalObjectGeometry (m_wObj);
}
else // weitere Stützpunkte wurden editiert
{
if (! m_bIsland) // keine neue Insel
{
m_wObj->GetKCnt (&m_iKCnt);
RETURN_FAILED_HRESULT (m_wObj->AddPunkt (m_LastPkt.X(), m_LastPkt.Y(), -1, m_iKCnt-1));
if (1 == m_iKCnt)
m_dAktGesFlaeche += m_dAktDreieck;
else
m_dAktInsel += m_dAktDreieck;
m_lKSize++; // Größe der aktuell editierten Kontur
}
else // (neue) Insel anfangen
{
m_wObj->AddKante (&m_LastPkt.X(), &m_LastPkt.Y(), 1, -1);
m_FirstPkt = m_LastPkt;
m_FirstPt = m_LastPt;
m_bIsland = false;
m_dAktGesFlaeche = fabs(m_dAktGesFlaeche) - fabs(m_dAktInsel);
m_dAktInsel = 0.0;
m_lKSize = 1; // Größe der aktuell editierten Kontur
}
}
return S_OK;
} // NeueFlaeche
// --------------------------------------------------------------------------------------------
// fClearDirty: Zustand im aktuellen Projekt und dessen Abspeicherung ist identisch (true) bzw.
// stimmt nicht überein (false); letzterer Fall tritt bei SaveAs() auf
STDMETHODIMP CRegOperatPropAct::Save (LPSTREAM pStm, BOOL fClearDirty)
{
// Bezeichner wegschreiben
HRESULT hr = CPropertyAction::Save (pStm, fClearDirty);
if (FAILED(hr)) return hr;
// Signatur und Version wegschreiben
DWORD dwSignature = REGOPERATPROPACT_SIGNATURE;
DWORD dwVersion = REGOPERATPROPACT_VERSION_1_0_2;
RETURN_FAILED_HRESULT (pStm->Write (&dwSignature, sizeof(DWORD), NULL));
RETURN_FAILED_HRESULT (pStm->Write (&dwVersion, sizeof(DWORD), NULL));
// dann selektierte Info der letzten Auswahl
// nachfolgende if-Bedingung für den Fall, daß m_pRegOperDlg-Seite "am Schluß" nicht oben
// lag, also BeginAction() und damit auch GetSelectedInfo() nicht ausgeführt wurden
if (m_pRegOperDlg)
m_pRegOperDlg->GetSelectedInfo (&m_caSelInfo, m_bIsDirty);
RETURN_FAILED_HRESULT (pStm->Write (&m_caSelInfo.bClassKey, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (pStm->Write (&m_caSelInfo.bInter, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (pStm->Write (&m_caSelInfo.bExter, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (pStm->Write (&m_caSelInfo.bBound, sizeof(BOOL), NULL));
if (!m_mkOperOptions.IsValid() && m_wOperOptions.IsValid()) {
// ggf. Moniker geben lassen
RETURN_FAILED_HRESULT (MkGetMoniker(m_wOperOptions,
OLEGETMONIKER_FORCEASSIGN, OLEWHICHMK_OBJFULL, m_mkOperOptions.ppi()));
}
// und Moniker wegschreiben
BOOL fHasMoniker;
if (m_mkOperOptions.IsValid()) {
fHasMoniker = TRUE;
RETURN_FAILED_HRESULT (pStm->Write (&fHasMoniker, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (OleSaveToStream(WPersistStream(m_mkOperOptions), pStm));
}
else {
fHasMoniker = FALSE;
RETURN_FAILED_HRESULT (pStm->Write (&fHasMoniker, sizeof(BOOL), NULL));
}
if (fClearDirty) m_bIsDirty = false;
return S_OK;
} // Save
///////////////////////////////////////////////////////////////////////////////
// Berechnen dieser Objekteigenschaft
STDMETHODIMP CCountLinePoints::Eval (LONG lONr, LPSTR pBuffer, ULONG ulLen, ULONG *pulWritten)
{
// AFX_MANAGE_STATE(AfxGetAppModuleState())
if (NULL == pBuffer) return E_POINTER;
_ASSERTE(0 != ulLen);
_ASSERTE(!IsBadWritePtr(pBuffer, ulLen));
int iOTyp = DEX_GetObjectType(lONr);
if (((OGLinie == iOTyp) ||
(OGPunkt == iOTyp) ||
(OGFlaeche == iOTyp) ||
(OGKreis == iOTyp) )
&& ulLen > 20) { // 20 Zeichen werden zumindest gebraucht
// nur für GeometrieObjekte
OBJSTATISTIK OG;
INITSTRUCT(OG, OBJSTATISTIK);
OG.lONr = lONr;
if (!DEX_GetObjStatistik(OG))
return E_FAIL; // irgend was ist faul
ltoa (OG.lCnt, pBuffer, 10);
if (pulWritten)
*pulWritten = strlen(pBuffer);
// Infos für Kumulation sammeln
RETURN_FAILED_HRESULT(m_CumPts -> AddValue (double(OG.lCnt), vtMissing));
IncrementCount(); // Zähler der erfolgreichen Aufrufe
return S_OK;
}
return E_FAIL; // ObjeProperty existiert nicht
}
// Besorgen des Tabellennamens (sofern einer exitiert)
HRESULT DatenBasisObjekt::GetTableName (TABLENAME *pTableName)
{
// Rückgabewerte initialisieren
int iLen = pTableName -> iLen;
pTableName -> pBuffer[0] = '\0';
pTableName -> iLen = 0;
// Objektmenge aus globaler Tabelle lesen
WTRiASObjects Objs;
HRESULT hr = S_OK;
if (FAILED(hr = GetObjectsFromMap (pTableName -> lIdent, Objs)))
return hr;
CComBSTR bstrName;
RETURN_FAILED_HRESULT(hr = Objs -> get_TableName (CLEARED(&bstrName)));
int iToCopy = min ((int)bstrName.Length(), iLen -1);
USES_CONVERSION;
strncpy (pTableName -> pBuffer, OLE2A(bstrName), iToCopy);
pTableName -> pBuffer[iToCopy] = '\0';
pTableName -> iLen = iToCopy;
return hr;
}
// --------------------------------------------------------------------------------------------
// rechte Maustaste wurde losgelassen
HRESULT CNewArea::RightMouseUp (void)
{
if (!m_RightButtonSem) // rechte Maustaste wurde nicht gedrückt
return S_FALSE;
m_RightButtonSem = false; // rechte Maustaste wurde losgelassen
if (m_wDragObj.IsValid())
{
m_wDragObj->DragTerminate();
m_wDragObj.Assign (NULL);
}
m_pVWnd->MouseTrap (FALSE);
if (S_FALSE == EPunktAtCursor (m_lParam, m_wRestrLine1, m_wRestrLine2, m_LastPt, m_LastPkt))
return S_FALSE;
RETURN_FAILED_HRESULT (NeueFlaeche());
if (m_wRestrLine1.IsValid() || m_wRestrLine2.IsValid()) // 08.06.99
DEX_ChangeActiveTool (ID_TOOL_DESIGNSTOP); // DesignMode beenden
// nach dem Hintergrundzeichnen nach einer möglichen Fehlermeldung wird wieder der
// vorhergehende Cursor eingeschaltet; da das auch der GrabCursor sein kann, wird hier
// einfach vorgebeugt
m_wEdExSite->SetCursor (CURSFORM_CROSS, TRUE);
return ShowDialogForArea();
} // RightMouseUp
///////////////////////////////////////////////////////////////////////////////
// Kumulativer Wert dieser Objekteigenschaft
STDMETHODIMP CSimpleAreaRadius::Cumulation (LPSTR pBuffer, ULONG ulLen, ULONG *pulWritten)
{
// AFX_MANAGE_STATE(AfxGetAppModuleState())
if (NULL == pBuffer) return E_POINTER;
_ASSERTE(0 != ulLen);
_ASSERTE(!IsBadWritePtr(pBuffer, ulLen));
if (pulWritten)
*pulWritten = 0;
// Mittelwert der bisher gezählten Längen als Zeichenkette liefern
if (ulLen > 32) {
double dAve = 0;
RETURN_FAILED_HRESULT(m_CumPts -> get_ArithmeticAverage (&dAve));
os_string strUnit;
si::Length dAveLength (dAve);
dAve = dAveLength.measuredIn(((CStatist *)g_pTE) -> GetUoL (dAveLength, strUnit));
sprintf (pBuffer, "%f%s", dAve, strUnit.c_str());
if (pulWritten)
*pulWritten = strlen (pBuffer);
return S_OK;
}
return E_INVALIDARG;
}
IMPLEMENT_DEBUG_FUNCENTRY_4(CGDODatabase,get_ObjectsDef,VARIANT, vIndex, VARIANT_BOOL, fCreate, BSTR, Type, ITRiASObjects**, ppIObjectsDef)
{
CHECKOUTPOINTER(ppIObjectsDef);
COM_TRY {
CHECK_INITIALIZED();
WTRiASObjects pTRiASObjects;
CComVariant vItem;
RETURN_FAILED_HRESULT(EnsureObjectsColl());
HRESULT hr = m_pGDOObjectsCollection -> Item (vIndex, CLEARED(vItem));
if (SUCCEEDED(hr))
pTRiASObjects = V_DISPATCH(&vItem);
else if (TRIASDB_E_UNKNOWN_OBJECTS == hr && fCreate) {
WTRiASObjectsCollection pTRiASObjectsCollection;
ERROR_FAILED_HRESULT(m_pGDOObjectsCollection -> QueryInterface (pTRiASObjectsCollection.ppi()), E_FAIL);
ERROR_FAILED_HRESULT(pTRiASObjectsCollection -> Add (V_BSTR(&vIndex), Type, pTRiASObjects.ppi()), E_FAIL);
} else
return hr;
*ppIObjectsDef = pTRiASObjects.detach();
} COM_CATCH;
return S_OK;
}
HRESULT DatenBasisObjekt::DelPBDDataMerkmal (HPROJECT hPr, PBDDATA *pData)
{
TX_ASSERT(IsTRiASDBBased());
TX_ASSERT(NULL == pData -> pbdKText || TIsValidString(pData -> pbdKText));
// wenns ein Ansichtsmerkmal sein soll, dann einfach wieder raus
if ((sizeof(PBDMERKMAL) == pData -> dwSize || sizeof(PBDMERKMALEX) == pData -> dwSize) &&
MPViewFeature == (((PBDMERKMAL *)pData) -> ipbdMTyp & 0x7F))
{
return S_FALSE;
}
TX_ASSERT(sizeof(PBDMERKMALEX) == pData -> dwSize && 0 != ((PBDMERKMALEX *)pData) -> lIdent); // Ident muß gegeben sein
// Feature entweder über Code oder Namen löschen
CComVariant v;
if (NULL == pData -> pbdKText)
v = pData -> pbdCode;
else
v = pData -> pbdKText;
// Wiederauffinden des Objects-Objektes
WTRiASFeatures Feats;
WTRiASObjects Objs;
INT_PTR lIdent = ((PBDMERKMALEX *)pData) -> lIdent;
RETURN_FAILED_HRESULT(GetObjectsFromMap (lIdent, Objs)); // Objektmenge muß existieren
RETURN_FAILED_HRESULT(Objs -> get_Features (Feats.ppi()));
// erstmal nachsehen, ob das Merkmal existiert
bool fExists = false;
{
WTRiASFeature Feat;
fExists = SUCCEEDED(Feats -> Item(v, Feat.ppi())) ? true : false;
}
if (fExists) {
// nur löschen, wenns wirklich (noch) existiert)
RETURN_FAILED_HRESULT(Feats -> Remove (v));
// Notifikation rumschicken
DEXN_FeatureSetModified(lIdent);
}
return fExists ? S_OK : S_FALSE; // S_FALSE heißt 'existiert nicht'
}
/*static*/
HRESULT CTRiASOGCDBEngine::UpdateRegistry(BOOL bRegister)
{
COGISDataProviderEnum Enum;
RETURN_FAILED_HRESULT(Enum.Open());
while (S_OK == Enum.MoveNext()) {
if (Enum.IsOGISProvider()) {
// OGC Data Provider
CComBSTR bstrProgId;
RETURN_FAILED_HRESULT(Enum.GetProgId(&bstrProgId));
RETURN_FAILED_HRESULT(UpdateRegistry(bRegister, Enum, bstrProgId));
}
}
return _Module.UpdateRegistryFromResource(IDR_TRIASOGCDBENGINE_RGS, bRegister);
}
STDMETHODIMP CPropertyAction::GetSizeMax (ULARGE_INTEGER FAR* pcbSize)
{
char cbBuffer[_MAX_PATH];
RETURN_FAILED_HRESULT(GetPropInfo (cbBuffer, sizeof(cbBuffer), NULL));
LISet32(*pcbSize, 2*sizeof(DWORD)+sizeof(ULONG)+strlen(cbBuffer)+1);
return S_OK;
}
STDMETHODIMP CPropertyActionJoin::BeginAction (IProgressIndicator *pIProgInd)
{
RETURN_FAILED_HRESULT(CPropertyActionImpl::BeginAction (pIProgInd));
// alle sekundären Geo-Komponenten durchgehen
for (CActionList::iterator it = m_Actions.begin(); it != m_Actions.end(); ++it)
{
RETURN_FAILED_HRESULT((*it) -> BeginAction(pIProgInd));
}
// Iteratoren Rücksetzen
m_itlist = m_listObjects.begin();
m_itact = m_Actions.begin();
m_iCurrAct = m_listObjects.size();
m_fHasDoAction = false;
return S_OK;
}
STDMETHODIMP CTRiASMICursorProperty::PutValueAndType(BSTR Name, VARIANT Value, PROPERTY_TYPE Type)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState())
_ASSERTE(NULL != Name);
_ASSERTE(!wcscmp (Name, m_bstrName)); // muß voreingestellter Name sein
// Wert setzen
RETURN_FAILED_HRESULT(m_Value.Copy(&Value));
return S_OK; // Typ wird nicht bearbeitet
}
IMPLEMENT_DEBUG_FUNCENTRY_1(CGDODatabase,get_ObjectsDefs,/*[out, retval]*/ ITRiASObjectsCollection**, ppVal) {
CHECKOUTPOINTER(ppVal);
COM_TRY {
ERROR_EXPR_FALSE( S_OK == IsInitialized(), DBE_E_DATABASE_NOT_OPENED );
RETURN_FAILED_HRESULT( EnsureObjectsColl() );
WTRiASObjectsCollection pTRiASObjectsCollection(m_pGDOObjectsCollection);
*ppVal = pTRiASObjectsCollection.Detach();
} COM_CATCH;
return S_OK;
}
STDMETHODIMP CSimpleAreaRadius::GetPropInfo (LPSTR pBuffer, WORD wLen, DWORD *pdwData)
{
// AFX_MANAGE_STATE(AfxGetAppModuleState())
// erstmal Basisklasse arbeiten lassen
RETURN_FAILED_HRESULT(CObjectPropertyBase::GetPropInfo (pBuffer, wLen, pdwData));
if (pdwData)
*pdwData |= PROPCAPS_OBJPROPTYPE_DOUBLE;
return S_OK;
}
inline
HRESULT _PROPERTYSUPPORT_ENTRY::SetDefaultSupportObject (
LPCOLESTR pcName, ITRiASPropertyCallback *pISupp, IUnknown *pIUnk)
{
_ASSERTE(dwFlags & PROPERTYSUPPORT_DEFAULT);
// zusätzliche Initialisierungen durchführen
RETURN_FAILED_HRESULT(TxInitPropertySupportObject(this, pISupp, pIUnk));
return AddDefaultEntry (pcName, pISupp);
}
// --------------------------------------------------------------------------------------------
STDMETHODIMP CRegOperatPropAct::Load (LPSTREAM pStm)
{
if (m_bIsInitialized) // m_bIsInitialized == true, wenn Page schon durch InitNew()
return E_UNEXPECTED; // initialisiert wurde
// Daten einlesen
// zuerst Bezeichner einlesen
HRESULT hr = CPropertyAction::Load (pStm);
if (FAILED(hr)) return hr;
// meine Versionsnummer und Signatur lesen und überprüfen
DWORD dwSignature = 0;
DWORD dwVersion = 0;
RETURN_FAILED_HRESULT(pStm->Read (&dwSignature, sizeof(DWORD), NULL));
if (REGOPERATPROPACT_SIGNATURE != dwSignature)
return E_UNEXPECTED;
RETURN_FAILED_HRESULT(pStm->Read (&dwVersion, sizeof(DWORD), NULL));
if ((dwVersion & ~ MINOR_VERSION_MASK) > REGOPERATPROPACT_ACTVERSION)
return STG_E_OLDDLL; // File was written with a newer version
// dann selektierte Info der letzten Auswahl
RETURN_FAILED_HRESULT (pStm->Read (&m_caSelInfo.bClassKey, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (pStm->Read (&m_caSelInfo.bInter, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (pStm->Read (&m_caSelInfo.bExter, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (pStm->Read (&m_caSelInfo.bBound, sizeof(BOOL), NULL));
// ggf. Moniker einlesen
BOOL fHasMoniker = TRUE;
if (dwVersion >= REGOPERATPROPACT_VERSION_1_0_2) {
RETURN_FAILED_HRESULT (pStm->Read (&fHasMoniker, sizeof(BOOL), NULL));
}
if (fHasMoniker) {
RETURN_FAILED_HRESULT (OleLoadFromStream(pStm, IID_IMoniker, m_mkOperOptions.ppv()));
}
if (NULL == m_pRegOperDlg)
// Initialisierungsdaten für den Dialog wurden zwar soeben von Load() bereitgestellt,
// können hier aber noch nicht an diesen weitergereicht werden
m_bHasInitData = true;
else
// Initialisierungsdaten an den Dialog weiterreichen
m_pRegOperDlg->SetSelectedInfo (&m_caSelInfo);
m_bIsInitialized = true; // Page wurde jetzt durch Load() initialisiert
m_bIsDirty = false; // Dialogparameter wurden (noch) nicht verändert
return S_OK;
} // Load
STDMETHODIMP CPointRefCoord::GetPropInfo (LPSTR pBuffer, WORD wLen, DWORD *pdwData)
{
// AFX_MANAGE_STATE(AfxGetAppModuleState())
// erstmal BasisKlasse arbeiten lassen
RETURN_FAILED_HRESULT(CObjectPropertyBase::GetPropInfo (pBuffer, wLen, pdwData));
if (pdwData) // evtl. eigene Werte ergänzen
*pdwData |= PROPCAPS_OBJPROPTYPE_DOUBLE;
return S_OK;
}
// BasisKlasse schreibt lediglich den Bezeichner weg
STDMETHODIMP CPropertyAction::Save (LPSTREAM pStm, BOOL fClearDirty)
{
// Versionsnummer wegschreiben
DWORD dwVersion = PROPACTB_VERSION_1_0_0;
RETURN_FAILED_HRESULT(pStm -> Write (&dwVersion, sizeof(DWORD), NULL));
// Bezeichner wegschreiben
char cbBuffer[_MAX_PATH];
DWORD dwFlags = 0L;
RETURN_FAILED_HRESULT(GetPropInfo (cbBuffer, sizeof(cbBuffer), &dwFlags));
ULONG ulLen = strlen(cbBuffer)+1;
RETURN_FAILED_HRESULT(pStm -> Write (&ulLen, sizeof(ULONG), NULL));
RETURN_FAILED_HRESULT(pStm -> Write (cbBuffer, ulLen, NULL));
RETURN_FAILED_HRESULT(pStm -> Write (&dwFlags, sizeof(DWORD), NULL));
return S_OK;
}
