///////////////////////////////////////////////////////////////////////////////
// MerkmalsCodes enumerieren
BOOL DatenBasisObjekt::EnumPBDDataMerkmal (HPROJECT hPr, ENUMLONGKEYPROC pFcn, void *pData)
{
TX_ASSERT(IsTRiASDBBased());
// Enumerieren aller Objekteigenschaften einer bestimmten Datenquelle
if (HACTCONNECTION != hPr) { // eine bestimmte Datenquelle auswerten
// return DB(hPr).EnumPBDDataMerkmal (pFcn, pData);
TX_ASSERT(DB(hPr).isOpened());
return DB(hPr).EnumAllFeatures ((ENUMNOKEYLONGPROC)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 -> EnumPBDDataMerkmal (pFcn, pData))
if (!l -> EnumAllFeatures ((ENUMNOKEYLONGPROC)pFcn, pData))
return FALSE;
}
}
return TRUE;
}
Bool TextMerkmalsListe :: operator += (TextMerkmalsListe& Liste)
{
// prüfe Parameter
assert (&Liste != this);
if (&Liste == this)
{
yyerror (IDS_SYSERROR);
return False;
}
// prüfe Anzahl Einträge
if (Liste.Count () < 1)
return True;
// Einträge umkopieren
CRing r (Liste);
for (r.First(); r.Valid(); r.Next())
{
TextMerkmalLock l (r);
if (l)
{
if (!AddMerkmal (l -> GetName (), l -> GetValue (), False))
return False;
}
else
{
yyerror (IDS_SYSERROR);
return False;
}
}
return True;
}
static void OutputGI (CRing &r, long Cnt) {
long i;
if (Cnt > 0)
fprintf (yyout, "G ");
for (i = 0, r.First(); i < Cnt && r.Valid(); i++, r.Next()) {
double dX = -1.0, dY = -1.0;
{
DPunktLock l(r);
if (l) {
dX = l -> X();
dY = l -> Y();
}
}
fprintf (yyout, "%12.5lf %12.5lf ", dX, dY);
if ((i + 1) % 3 == 0) {
fprintf (yyout, "\n");
if (i + 1 < Cnt)
fprintf (yyout, "G ");
}
}
if (i % 3 != 0)
fprintf (yyout, "\n");
// fflush (yyout);
}
// alle Merkmale des übergebenen Objekts ausgeben
Bool MerkmalsBaum :: OutputMerkmale (long ObjNr, TextMerkmalsListe* pML)
{
// prüfe Parameter
if (!pML || ObjNr <= 0)
{
yyerror (IDS_SYSERROR);
return False;
}
// Werte in Liste vorhanden ?
if (!pML -> Count ()) // wenn keine Einträge
return True; // vorh., zurück
// alle Merkmale ausgeben
CRing r (*pML);
ulong ulMK = 0;
Bool bRet = True; // bisher alles Ok
for (r.First (); bRet && r.Valid (); r.Next ())
{
TextMerkmalLock pTM (r);
// if (pTM && GetMerkmalsKode (pTM -> GetName (), ulMK) &&
if (pTM && GetMerkmalsKode (pTM -> GetName (), ulMK, ObjNr) &&
(OutputMerkmal (ObjNr, ulMK, pTM -> GetValue ()) == EC_OKAY))
continue;
else
bRet = False;
}
// ggf. Fehler ausgeben
if (bRet == False)
yyerror (IDS_SYSERROR);
return bRet;
}
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;
}
// Liefert die Anzahl der St�tzpunkte eines/aller Polygone einer Fl�che
long DFlaeche :: Count (int i) {
CRing rF (*_pDLL);
if (i == -1) {
// Gesamtanzahl der St�tzpunkte liefern
long Val = 0L;
for (rF.First(); rF.Valid(); rF.Next()) {
DLinieLock l(rF);
if (l)
Val += l -> Count();
}
return Val;
} else if (i >= 0 && i < (int)_pDLL -> Count()) {
// St�tzpunktanzahl einer einzelnen DPunktListe liefern
int j;
for (j = 0, rF.First(); j < i && rF.Valid(); j++, rF.Next())
;
if (rF.Valid() && j == i) {
DLinieLock l(rF);
if (l)
return l -> Count();
}
}
return 0L;
}
Bool AppendReverse (DPunktListe &DPL, CRing &R, Bool iSecond) {
R.Last();
if (iSecond)
R.Prev(); // evtl. beim 2. von hinten beginnen
for ( ; R.Valid(); R.Prev()) {
DPunktLock l(R);
if (!l || !DPL.AddDPunkt (*(DPunkt *)l))
return FALSE;
}
return TRUE;
}
Bool Append (DPunktListe &DPL, CRing &R, Bool iSecond) {
R.First();
if (iSecond)
R.Next(); // evtl erst beim 2. beginnen
for ( ; R.Valid(); R.Next()) {
DPunktLock l(R);
if (!l || !DPL.AddDPunkt (*(DPunkt *)l))
return FALSE;
}
return TRUE;
}
Bool DFlaeche :: OutPut (void) {
long locEnum = Enum();
long locEnum2 = Enum2();
long Cnt = Count();
long locEbene = Ebene() + FLAECHENEBENE0;
DGeoObj *plocDGO = r_flag ? this : NULL;
if (h_flag && pGDBElemente -> FindOrEnter (locEnum, locEnum2, plocDGO))
return FALSE; // bereits ausgegeben
// nur alles bis zu einer vorgegebenen Stufe ausgeben
if (Stufe() > MaxFlaechenStufe)
return FALSE;
if (!s_flag) {
fprintf (stderr, "GDB-Element(FL): %7ld/%ld \r", cntEl++, locEnum);
fflush (stderr);
}
#if defined(EWU)
// spezialFall f�r EWU
if (_Pointer[0] != '\0') {
long Ident = atol (_Pointer);
fprintf (yyout, "F %10ld 00910%3ld %5ld\n", locEnum, Ident/1000, Cnt);
} else
#endif
// IdentifikatorSatz ausgeben
fprintf (yyout, "F %10ld %08ld %5ld\n", locEnum, locEbene, Cnt);
// Merkmale Ausgeben
if (_Text)
OutputMK (MKFTEXT, _Text); // eigentlicher Text
if (_XKoord != -1.0 || _YKoord != -1.0) {
// Bezugspunkt der F�che ausgeben
OutputMK (MKFXKOORD, _XKoord);
OutputMK (MKFYKOORD, _YKoord);
}
if (_SWinkel != -1.0 && _SWinkel != 0.0)
OutputMK (MKFSWINKEL, _SWinkel); // Schraffurwinkel
if (_SAbstand != -1.0 && _SAbstand != 0.0)
OutputMK (MKFSABSTAND, _SAbstand); // Schraffurabstand
if (_Code)
OutputMK (MKFCODE, _Code); // DB-AnkopplungsCode
if (_Pointer[0] != '\0') // #JB921506
OutputMK (MKFPOINTER, _Pointer);// dBase-AnkopplungsCode
if (_Name)
OutputMK (MKFNAME, _Name);
// auf evtl. Begleitobjekt beziehen
if (_RelSatz) {
fprintf (yyout, "R B %08ld\n", _RelSatz);
_RelSatz = 0;
}
// Geometrie ausgeben
CRing rF (*_pDLL);
int i = 0;
for (i = 0, rF.First(); rF.Valid(); i++, rF.Next()) {
DLinieLock l(rF);
if (l) {
CRing r(*(l -> _pDPL));
OutputGI (r, l -> _pDPL -> Count());
fprintf (yyout, "T\n"); //TrennSatz einf�gen
} else
break;
}
return TRUE;
}
void CBKInfEngine::BackwardFixLag()
{
//////////////////////////////////////////////////////////////////////////
// Backward step for fixed-lag smoothing procedure
//////////////////////////////////////////////////////////////////////////
PNL_CHECK_LEFT_BORDER(m_CurrentTime, m_Lag);
if( m_Lag )
{
int currentTimeTmp = GetTime();
CRing<CJtreeInfEngine *>::iterator tmpInfIter = m_JTreeInfIter;
CRing< distrPVector >::iterator tmpDistrIter = m_CDistrOnSepIter;
CRing<CJtreeInfEngine*> ringEng;
ringEng.assign( 2 , NULL );
CRing<CJtreeInfEngine *>::iterator ringEngIter = ringEng.begin();
*ringEngIter = CJtreeInfEngine::Copy(*m_JTreeInfIter);
ringEngIter++;
BackwardT();
distrPVector tmpDistr(GetNumOfClusters(), (CDistribFun* const)NULL);
int i;
for( i = 0; i < GetLag(); i++ )
{
if( i < GetLag() - 1 )
{
*ringEngIter = CJtreeInfEngine::Copy(*(m_JTreeInfIter-1));
int j;
for( j = 0; j < GetNumOfClusters(); j++ )
{
tmpDistr[j] = (*m_CDistrOnSepIter)[j]->Clone();
}
}
Backward();
//CJtreeInfEngine::Release(&(*(m_JTreeInfIter + 1)));
delete (*(m_JTreeInfIter + 1));
ringEngIter++;
*(m_JTreeInfIter + 1) = *ringEngIter;
if( i < GetLag() - 1 )
{
int j;
for( j = 0; j < GetNumOfClusters(); j++ )
{
delete (*(m_CDistrOnSepIter+1))[j];
(*(m_CDistrOnSepIter+1))[j]=tmpDistr[j];
}
}
}
m_CDistrOnSepIter = tmpDistrIter;
m_JTreeInfIter = tmpInfIter;
m_CurrentTime = currentTimeTmp;
}
else
{
BackwardT();
}
}
// Block-Geometrie und übergebenen Merkmale an TRiAS ausgeben
Bool CBlock::Output (long lIdent, // Identifikator
TextMerkmalsListe *pListe, // Merkmalsliste
double dXInsert, double dYInsert, // Einfügepunkt
double dXMasstab, double dYMasstab, // Maßstab
double dDrehWinkel, // Drehwinkel
double dXOffset, double dYOffset, // zusätz. Verschiebung
CDGeoObjListe *pGeoListe) // Objekte an akt. Liste anhängen
{
// prüfe Parameter
assert ((lIdent != 0) && pListe && (pListe->Count() > 0)); // wenigstens Blockname
assert (m_pObjectListe);
if ((lIdent == 0) || (!pListe) || (pListe->Count () < 1) || (!m_pObjectListe))
{
yyerror (IDS_PARAM_ERROR);
return False;
}
// hat dieser Block Geometrien ?
if (m_pObjectListe->Count () < 1)
return True; // weiter parsen
// soll der Block zerlegt werden ?
if (!OptParams.m_bImpBlocks)
{
// erstelle Punkt-Symbol für den gesamten Block
DGeoObj Punkt;
if (!Punkt.Init (DGT_Punkt, lIdent, pListe) || // Init.
!Punkt.AddPunkt (dXInsert - m_dXBasis + dXOffset,
dYInsert - m_dYBasis + dYOffset))// Punkt hinzufügen
return False;
// ggf. Drehwinkel ausgeben
Punkt.SetWinkel (dDrehWinkel);
// Punkt ausgeben oder speichern (bzw. zuvor kopieren
if (pGeoListe)
return pGeoListe->AddObject (Punkt);
else
return Punkt.Output ();
}
// Block soll zerlegt ausgegeben werden: alle graphischen Elemente ausgeben
CRing r (*m_pObjectListe);
for (r.First (); r.Valid (); r.Next ())
{
CDGeoObjPtrLock pDGeoObjPtr (r);
if (!pDGeoObjPtr)
{
yyerror (IDS_SYSERROR);
return False;
}
// lese Zeiger auf das DGeoObjekt
DGeoObj *pObj = pDGeoObjPtr -> GetDGeoObj ();
if (!pObj)
{
yyerror (IDS_SYSERROR);
return False;
}
// Objekt an TRiAS ausgeben
if (pObj -> OutputExt (lIdent, pListe,
m_dXBasis, // Blockbasispunkt,
m_dYBasis,
dXInsert, dYInsert, // akt. Einfügepunkt
dXMasstab, dYMasstab,
dDrehWinkel,
dXOffset, dYOffset,
pGeoListe) == 0)
return False;
}
return True;
}
BOOL CFeldInfoDialog::OnInitDialog()
{
CDialog::OnInitDialog();
// TODO: Add extra initialization here
CWaitCursor wc; // Sanduhr einschalten
m_bResult = FALSE; // noch nichts getan
TRY
{
CString strText;
// "Name"
if ((strText.LoadString (IDS_IMP_FELDNAME) == FALSE) ||
(m_lcFeldInfo.InsertColumn (0, strText) != 0))
AfxThrowUserException ();
// "Typ"
if ((strText.LoadString (IDS_IMP_FELDTYP) == FALSE) ||
(m_lcFeldInfo.InsertColumn (1, strText) != 1))
AfxThrowUserException ();
// "Länge"
if ((strText.LoadString (IDS_IMP_FELDLAENGE) == FALSE) ||
(m_lcFeldInfo.InsertColumn (2, strText) != 2))
AfxThrowUserException ();
// Spaltenbreiten setzen
m_lcFeldInfo.SetColumnWidth (0, LVSCW_AUTOSIZE_USEHEADER);
m_lcFeldInfo.SetColumnWidth (1, LVSCW_AUTOSIZE_USEHEADER);
m_lcFeldInfo.SetColumnWidth (2, LVSCW_AUTOSIZE_USEHEADER);
// alle Feldinformationen ausgeben
CString strMemo;
CString strVariabel;
CString strTypeName;
if (! strMemo.LoadString (IDS_MEMO) || !strVariabel.LoadString (IDS_VARIABEL))
AfxThrowUserException ();
CRing ri (*m_pCA);
int iIndex = 0; // aktueller SpaltenIndex
char szLenBuffer [20] = ""; // Längenpuffer
CFeldInfExt *pFeldInf = NULL; // ItemData
for (ri.First (); ri.Valid (); ri.Next ())
{
CColumnObjLock pCO (ri);
if (! pCO)
AfxThrowUserException ();
// Länge bei Memo ändern ?
if (strMemo.CompareNoCase (pCO -> SQLTypeName ()) == 0)
{
lstrcpy (szLenBuffer, strVariabel);
pFeldInf = new CFeldInfExt (pCO -> ColName (), pCO -> SQLTypeName (), 0,
(iIndex + 1));
}
else
{
ltoa (pCO -> FieldLen (), szLenBuffer, 10); // Länge bestimmen
pFeldInf = new CFeldInfExt (pCO -> ColName (), pCO -> SQLTypeName (),
pCO -> FieldLen (), (iIndex + 1));
}
if ((m_lcFeldInfo.InsertItem (iIndex, pCO -> ColName ()) == iIndex) &&
m_lcFeldInfo.SetItemText (iIndex, 1, pCO -> SQLTypeName ()) &&
m_lcFeldInfo.SetItemText (iIndex, 2, szLenBuffer) &&
m_lcFeldInfo.SetItemData (iIndex, (DWORD) pFeldInf))
iIndex++;
else
AfxThrowUserException ();
} // end for
}
CATCH (CMemoryException, me)
{
DEX_Error (RC_ctCFeldInfo, EC_NOMEMORY);
return FALSE;
}
