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 DatenBasisObjekt::ModPBDDataIdent (HPROJECT hPr, PBDDATA *pData)
{
TX_ASSERT(IsTRiASDBBased());
HRESULT hr = S_OK;
USES_CONVERSION;
{
// wiederauffinden des Objects-Objektes
WTRiASObjects Objs;
if (FAILED(GetObjectsFromMap (pData -> pbdCode, Objs))) {
// Objektklasse existiert nicht, also neu erzeugen
TX_ASSERT(pData -> pbdKTextLen > 0 && NULL != pData -> pbdKText); // KurzText muß gegeben sein
// Objektmenge (Tabelle) muß neu angelegt werden
if (HACTPROJECT != hPr) { // neue Tabelle in einer Datenquelle anlegen
ErrCode RC = DB(hPr).ModPBDDataIdent (pData);
return (EC_OKAY == RC) ? S_OK : HRESULT_FROM_ERRCODE(RC);
}
// neue übergreifende Objektmenge ggf. erzeugen
RETURN_FAILED_HRESULT(m_Prj -> get_ObjectsDef (CComVariant(pData -> pbdKText), VARIANT_TRUE, CComBSTR(g_cbNil), Objs.ppi()));
// das neue Objekt wenigstens von seinem Handle informieren
if (0 != pData -> pbdCode)
{
RETURN_FAILED_HRESULT(Objs -> put_Handle (pData -> pbdCode));
}
// reales, vergebenes Handle zurückliefern
INT_PTR lHandle = 0;
RETURN_FAILED_HRESULT(Objs -> get_Handle (&lHandle));
if (lHandle != pData -> pbdCode) {
TX_TRACE2("TRiAS: ModPbdDataIdent: Changed IdentHandle %lx -> %lx !", pData -> pbdCode, lHandle);
pData -> pbdCode = lHandle;
// Notifikation rumschicken
DEXN_FeatureSetModified(lHandle);
return S_FALSE;
}
// Notifikation rumschicken
DEXN_FeatureSetModified(pData -> pbdCode);
}
else {
// Testen, ob der gegebene Ident zur geforderten Datenquelle paßt
#if defined(_DEBUG)
if (HACTCONNECTION != hPr) {
HPROJECT hPrTarget = NULL;
RETURN_FAILED_HRESULT(GetDatabaseOrProjectHandle (Objs, &hPrTarget));
TX_ASSERT(hPrTarget == hPr); // Ident aus anderer Datenquelle ?
}
#endif // defined(_DEBUG)
// hier nur neuen KurzText (Namen) einstellen
if (pData -> pbdKTextLen > 0 && NULL != pData -> pbdKText)
RETURN_FAILED_HRESULT(Objs -> put_Name (CComBSTR(pData -> pbdKText)));
}
// LangText (BeschreibungsInfo) einstellen
if (pData -> pbdLTextLen > 0 && NULL != pData -> pbdLText) {
RETURN_FAILED_HRESULT(Objs -> put_Description (CComBSTR(pData -> pbdLText)));
} else {
RETURN_FAILED_HRESULT(Objs -> put_Description (CComBSTR(g_cbNil)));
}
}
return hr;
}
// Lesen der Metadaten für eine Objektmenge
HRESULT DatenBasisObjekt::GetPBDDataIdent (HPROJECT hPr, PBDDATA *pData)
{
TX_ASSERT(IsTRiASDBBased());
VARIANT_BOOL fNameIsDefault = VARIANT_TRUE;
USES_CONVERSION;
{
// Objektmenge aus globaler Tabelle lesen
WTRiASObjects Objs;
HRESULT hr = S_OK;
if (FAILED(hr = GetObjectsFromMap (pData -> pbdCode, Objs)))
return hr;
// Testen, ob das gefundene Objektmenge zur geforderten Datenquelle paßt
if (HACTCONNECTION != hPr) {
HPROJECT hPrTarget = NULL;
RETURN_FAILED_HRESULT(GetDatabaseOrProjectHandle (Objs, &hPrTarget));
if (hPrTarget != hPr) // Ident aus anderer Datenquelle
return HRESULT_FROM_ERRCODE(WC_NOTFOUND);
}
// Namen lesen und in Rückgabestruktur setzen
CComBSTR bstr;
RETURN_FAILED_HRESULT(Objs -> get_Name (CLEARED(&bstr)));
fNameIsDefault = GetPropertyFrom (Objs, g_cbNameIsDefault, VARIANT_TRUE);
char *pStr = OLE2A(bstr);
if (pData -> pbdKTextLen > 0 && NULL != pData -> pbdKText) {
if (pStr) {
int iLen = strlen (pStr);
iLen = min(iLen, pData -> pbdKTextLen-1);
strncpy (pData -> pbdKText, pStr, iLen);
pData -> pbdKText[iLen] = '\0';
pData -> pbdKTextLen = iLen;
} else {
*pData -> pbdKText = '\0';
pData -> pbdKTextLen = 0;
}
} else
pData -> pbdKTextLen = (NULL != pStr) ? strlen(pStr)+1 : 0; // benötigte Buffergröße liefern
// BeschreibungsInfo lesen und in Rückgabestruktur setzen
CComBSTR bstrLT;
if (SUCCEEDED(Objs -> get_Description (CLEARED(&bstrLT)))) {
// möglicherweise wird 'get_Description' nicht unterstützt
char *pStr = OLE2A(bstrLT);
if (pData -> pbdLTextLen > 0 && NULL != pData -> pbdLText) {
if (pStr) {
int iLen = strlen (pStr);
iLen = min(iLen, pData -> pbdLTextLen-1);
strncpy (pData -> pbdLText, pStr, iLen);
pData -> pbdLText[iLen] = '\0';
pData -> pbdLTextLen = iLen;
} else {
*pData -> pbdLText = '\0';
pData -> pbdLTextLen = 0;
}
} else
pData -> pbdLTextLen = (NULL != pStr) ? strlen(pStr)+1 : 0; // benötigte Buffergröße liefern
} else
pData -> pbdLTextLen = 0;
}
return fNameIsDefault ? S_FALSE : S_OK;
}
// Lesen der Metadaten für eine Objektmenge
HRESULT DatenBasisObjekt::GetPBDDataMerkmal (HPROJECT hPr, PBDDATA *pData)
{
TX_ASSERT(IsTRiASDBBased());
VARIANT_BOOL fNameIsDefault = VARIANT_TRUE;
USES_CONVERSION;
{
// wenns ein Ansichtsmerkmal sein soll, dann einfach wieder raus
if ((sizeof(PBDMERKMAL) == pData -> dwSize || sizeof(PBDMERKMALEX) == pData -> dwSize) &&
MPViewFeature == (((PBDMERKMAL *)pData) -> ipbdMTyp & 0x7F))
{
return HRESULT_FROM_ERRCODE(WC_NOTFOUND);
}
// Objekteigenschaft aus globaler Tabelle lesen
WTRiASFeature Feat;
HRESULT hr = S_OK;
if (FAILED(hr = GetFeatureFromMap (pData -> pbdCode, Feat)))
return hr;
// Testen, ob das gefundene Feature zur geforderten Datenquelle paßt
if (HACTCONNECTION != hPr) {
HPROJECT hPrTarget = NULL;
RETURN_FAILED_HRESULT(GetDatabaseHandle (Feat, &hPrTarget));
if (hPrTarget != hPr) // MCode aus anderer Datenquelle
return HRESULT_FROM_ERRCODE(WC_NOTFOUND);
}
// Namen lesen und in Rückgabestruktur setzen
CComBSTR bstr;
RETURN_FAILED_HRESULT(Feat -> get_Name (CLEARED(&bstr)));
fNameIsDefault = GetPropertyFrom (Feat, g_cbNameIsDefault, VARIANT_FALSE);
char *pStr = OLE2A(bstr);
if (pData -> pbdKTextLen > 0 && NULL != pData -> pbdKText) {
if (pStr) {
int iLen = strlen (pStr);
iLen = min(iLen, pData -> pbdKTextLen-1);
strncpy (pData -> pbdKText, pStr, iLen);
pData -> pbdKText[iLen] = '\0';
pData -> pbdKTextLen = iLen;
} else {
*pData -> pbdKText = '\0';
pData -> pbdKTextLen = 0;
}
} else
pData -> pbdKTextLen = (NULL != pStr) ? strlen(pStr)+1 : 0; // benötigte Buffergröße liefern
// BeschreibungsInfo lesen und in Rückgabestruktur setzen
CComBSTR bstrLT;
if (SUCCEEDED(Feat -> get_Description (CLEARED(&bstrLT)))) {
// möglicherweise wird 'get_Description' nicht unterstützt
char *pStr = OLE2A(bstrLT);
if (pData -> pbdLTextLen > 0 && NULL != pData -> pbdLText) {
if (pStr) {
int iLen = strlen (pStr);
iLen = min(iLen, pData -> pbdLTextLen-1);
strncpy (pData -> pbdLText, pStr, iLen);
pData -> pbdLText[iLen] = '\0';
pData -> pbdLTextLen = iLen;
} else {
*pData -> pbdLText = '\0';
pData -> pbdLTextLen = 0;
}
} else
pData -> pbdLTextLen = (NULL != pStr) ? strlen(pStr)+1 : 0; // benötigte Buffergröße liefern
} else
pData -> pbdLTextLen = 0;
// evtl. zusätzliche Infos liefern
if (sizeof(PBDMERKMAL) == pData -> dwSize || sizeof(PBDMERKMALEX) == pData -> dwSize) {
PBDMERKMAL *pPbdM = (PBDMERKMAL *)pData;
FEATURETYPE rgType = FEATURETYPE_Unknown;
pPbdM -> ipbdMTyp = 'a'; // Objektmerkmal
if (SUCCEEDED(Feat -> get_Type (&rgType))) {
// Typ der Objekteigenschaft festellen
switch (VT_FROM_DATATYPE(rgType)) {
case VT_I4:
case VT_I2:
case VT_I1:
case VT_INT:
case VT_UI4:
case VT_UI2:
case VT_UI1:
case VT_UINT:
case VT_BOOL:
case VT_ERROR:
pPbdM -> ipbdMTyp = 'i';
break;
case VT_R4:
case VT_R8:
case VT_DATE:
pPbdM -> ipbdMTyp = 'f';
break;
default:
break; // VT_BSTR --> 'a'
}
// zusätzliche
if (rgType & FEATURETYPE_System)
pPbdM -> ipbdMTyp |= PBDMERKMAL_SYSTEMFLAG;
if (rgType & FEATURETYPE_ReadOnly)
pPbdM -> ipbdMTyp |= PBDMERKMAL_READONLY;
}
// Platzbedarf der Objekteigenschaft feststellen
long lLen = 0;
if (SUCCEEDED(Feat -> get_Length (&lLen)))
pPbdM -> ipbdMLen = lLen;
else
pPbdM -> ipbdMLen = _MAX_PATH; // doch recht willkürlich
}
}
return fNameIsDefault ? S_FALSE : S_OK;
}
/////////////////////////////////////////////////////////////////////////////
// Liest ein TextMerkmal für das vorgegebene Objekt
HRESULT GetTextMerkmal (HPROJECT hPr, long lMCode, long lFirst, short iTyp, char **ppMText)
{
struct vom VOMSatz;
struct mkl MKLSatz;
DB_ADDR dbaVOM(hPr);
DB_ADDR dbaMKL(hPr);
long iLen = 0;
long VOMPrev = 0; // vorhergehender VOMSatz
long VOMNext; // nächster Satz
long zvommi = 0; // Zeiger auf MISatz
long RC;
bool fText = false;
// sicherheitshalber NULL setzen
VOMNext = 0L;
// TextPointer ausnullen
*ppMText = NULL;
if (lFirst == -1L) return S_OK;
switch (iTyp) {
case OBL_OLD: // normales ObjektMerkmal
{
struct obl OBLSatz;
DB_ADDR_OBL dbaOBL(hPr);
// Objektsatz einlesen
dbaOBL.rec_no = lFirst;
__ReadHR (dbaOBL, OBLSatz);
if (LocGetDBVersion(hPr) < VERSION05000008 && OBLSatz.status & SB_TEXTOBJ)
// alte DB und Textobjekt
return S_FALSE;
if (OBLSatz.status & SB_TEXTOBJIND)
fText = true;
VOMNext = OBLSatz.zovom; // erster Satz
}
break;
case IDL_OLD: // IdentifikatorMerkmal
{
if (LocGetDBVersion(hPr) < VERSION05000007)
return S_FALSE; // noch nicht implementiert
struct idl IDLSatz;
DB_ADDR_IDL dbaIDL(hPr);
// dbaIDL.file_no = IDL;
dbaIDL.rec_no = lFirst;
__ReadHR (dbaIDL, IDLSatz);
VOMNext = IDLSatz.zmerki;
}
break;
case SICHT: // SichtMerkmal
{
if (LocGetDBVersion(hPr) < VERSION05000007)
return S_FALSE; // noch nicht implementiert
struct sicht SICHTSatz;
DB_ADDR dbaSICHT(hPr);
dbaSICHT.file_no = SICHT;
dbaSICHT.rec_no = lFirst;
__ReadHR (dbaSICHT, SICHTSatz);
VOMNext = SICHTSatz.zmerkm;
}
break;
default:
return E_INVALIDARG;
}
// Verbindungsdatei zu Merkmalen (VOM) lesen und entspr. Satz suchen
dbaVOM.file_no = VOM;
dbaMKL.file_no = MKL;
dbaVOM.rec_no = 0;
MKLSatz.mk = 0;
do {
// VOMSatz lesen
VOMPrev = dbaVOM.rec_no;
if ((dbaVOM.rec_no = VOMNext) == 0)
break; // Ende der Kette: MCode nicht vorhanden
__ReadHR (dbaVOM, VOMSatz);
// MKLSatz lesen
dbaMKL.rec_no = VOMSatz.zvommk;
__ReadHR (dbaMKL, MKLSatz);
// nächster VOMSatz
VOMNext = VOMSatz.znmk;
} while (MKLSatz.mk != lMCode); // bis lMCode gefunden
// wenn für dieses Objekt MCode nicht exitiert: wieder raus mit Warnung
if (MKLSatz.mk != lMCode)
return HRESULT_FROM_ERRCODE(WC_NOTFOUND);
// Prüfen, ob MerkmalsTyp stimmt
if (MKLSatz.typ != 0) // kein TextMerkmal
return HRESULT_FROM_ERRCODE(WC_BADMKTYP);
// TextInfo einlesen
DBASSERTHR (GetTextMerkmalLen (hPr, VOMSatz.zvommi, &iLen));
if (iLen == 0 || iLen == -1) {
// entweder kein Text oder Text aus Bezugsobjekt
if (iTyp != OBL_OLD && SICHT != iTyp && IDL_OLD != iTyp) // kein ObjektMerkmal
return HRESULT_FROM_ERRCODE(WC_BADMKTYP);
ATLTRY(*ppMText = new char [1]);
if (*ppMText == NULL)
return E_OUTOFMEMORY;
**ppMText = '\0';
return S_OK; // leerer TextString gegeben
} else if (iLen < 0)
iLen = -iLen; // indirektes Textobjekt
iLen = ((iLen + 3) / 4) * 4; // auf long Grenze aufrunden
ATLTRY(*ppMText = new char[iLen+1]);
if (NULL == *ppMText)
return E_OUTOFMEMORY;
memset (*ppMText, '\0', (size_t)(iLen+1));
DBASSERTHR (GetTextFromDBT (hPr, VOMSatz.zvommi, *ppMText, iLen, fText));
OemToAnsi (*ppMText, *ppMText);
return S_OK;
}
