///////////////////////////////////////////////////////////////////////////////////////////////
// Konstruktor / Destruktor
CNewArea::CNewArea (void)
{
m_dwCookieN = 0L;
m_dwCookieSN = 0L;
m_pVWnd = g_pTE->MVWind(); // TRiAS-ViewFenster
m_NewCP = CURSPOS_UNKNOWN;
m_OldCP = CURSPOS_UNKNOWN;
m_bIsPaint = false; // Hintergrund wird augenblicklich nicht gezeichnet
m_LeftButtonSem = false; // linke Maustaste bzw.
m_RightButtonSem = false; // rechte Maustaste noch nicht gedrückt
m_lParamOld = 0; // letzte Mausposition
m_bIsland = false; // der nächste editierte Punkt ist noch nicht Beginn einer
// neuen Insel
m_iGrabCnt = 0; // Anzahl der hintereinander gegrabten Punkte
m_pGrabPktX = NULL; // die in m_iGrabCnt gezählten GrabPunkte
m_pGrabPktY = NULL;
m_bMessBox = false; // keine MessageBox angezeigt
m_bWithDel = true; // beim Zeichnen einer nachgezogenen Linie die alte Lage löschen
m_pCT = new CoordTransX(); // KoordinatenTransformation
if (! m_pCT)
{
DEX_Error (RC_NewArea, EC_NOMEMORY);
return;
}
}
bool FAR PASCAL _XTENSN_EXPORT EnumMCodeProc (long lMCode, bool, void *pData)
{
ASSERT (0 != lMCode);
ASSERT (NULL != pData);
ASSERT (NULL != g_pHelper);
TRY {
CString cbBuffer ('\0', _MAX_PATH);
CString cbKText;
if (!g_pHelper -> GetKText (cbKText, 'm', lMCode))
return true; // trotzdem weitermachen
// Zeichenkette formatieren
if (DEX_GetMkBase() == 10) {
cbBuffer.Format ("%08ld:%s", lMCode, (LPCSTR)cbKText);
((CComboBox *)pData) -> AddString (cbBuffer);
}
else {
cbBuffer.Format ("%08lx:%s", lMCode, (LPCSTR)cbKText);
((CComboBox *)pData) -> AddString (cbBuffer);
}
}
CATCH (CMemoryException, e) {
DEX_Error (0, EC_NOMEMORY);
return false;
}
// --------------------------------------------------------------------------------------------
// Bildung einer Konstruktionshilfslinie in Form einer Geraden
bool CRestrictLine::BuildStraightLine (KoOrd lFixX, KoOrd lFixY, double dAngle)
{
Window MWnd(__hWndM); // TRiAS-Hauptfenster
Dimension dimMWin = MWnd.GetSize(); // Größe (im Point-Format) des Hauptfensters
Point FixPt = BSKoordinaten (lFixX, lFixY);
// obwohl die Hilfslinie eine Gerade ist, braucht sie zum Zeichnen auf dem Bildschirm zwei
// Endpunkte (m_EPt1, m_EPt2), welche sich aus der Bildschirmbegrenzung ergeben
if (Pi/2. != dAngle)
{
CoOrd b = dimMWin.Width(); // Breite des TRiAS-Hauptfensters
CoOrd h = dimMWin.Height(); // Höhe des TRiAS-Hauptfensters
double dTanAngle = tan (dAngle);
m_EPt1.X() = 0;
m_EPt1.Y() = DtoL (-FixPt.X()*dTanAngle + FixPt.Y());
// evtl. Clipping an der Bildschirmbegrenzung (ist für das Zeichnen der Gerade nicht
// erforderlich; ich mache es aber trotzdem, damit das Rechteck für UnDraw() nicht
// unnötig groß wird)
// für m_EPt1.Y() < 0 || m_EPt1.Y() > h kann eigentlich dTanAngle nicht 0 werden (d.h.
// eine waagerechte Gerade), sollte der Fall aber unerwartet doch eintreten, mache ich
// eben kein Clipping (geht ja auch ohne)
if ((m_EPt1.Y() < 0 || m_EPt1.Y() > h) && dTanAngle != 0)
{
(m_EPt1.Y() < 0) ? (m_EPt1.Y() = 0) : (m_EPt1.Y() = h);
m_EPt1.X() = DtoL ((m_EPt1.Y()-FixPt.Y())/dTanAngle + FixPt.X());
}
m_EPt2.X() = b;
m_EPt2.Y() = DtoL ((b-FixPt.X())*dTanAngle + FixPt.Y());
if ((m_EPt2.Y() < 0 || m_EPt2.Y() > h) && dTanAngle != 0)
{
(m_EPt2.Y() < 0) ? (m_EPt2.Y() = 0) : (m_EPt2.Y() = h);
m_EPt2.X() = DtoL ((m_EPt2.Y()-FixPt.Y())/dTanAngle + FixPt.X());
}
}
else
{
m_EPt1.X() = FixPt.X();
m_EPt1.Y() = 0;
m_EPt2.X() = FixPt.X();
m_EPt2.Y() = dimMWin.Height();
}
m_pKHL = new LineObject (m_EPt1, m_EPt2, &m_MyPen1);
if (! m_pKHL)
{
DEX_Error (RC_RestrictLine, EC_NOMEMORY);
return false;
}
return true;
} // BuildStraightLine
// --------------------------------------------------------------------------------------------
// Ermittlung der Cursorposition bei 1 Strecke und 1 Gerade
HRESULT CRestrictLine::CursorToSegmentStraight (Point MSPt, Point EPt11, Point EPt21,
Point EPt12, Point EPt22, POINT* pPTCur)
{
Point SectPt1, SectPt2;
SectScreen ssRet = SegmentStraightIntersection (EPt11, EPt21, EPt12, EPt22, SectPt1,
SectPt2);
if (INSECT == ssRet)
{
*pPTCur = (POINT&)SectPt1;
return S_OK;
}
ResString rsCapt (ResID (IDS_LONGCLASSNAME, pRF), 50);
if (OUTSECT == ssRet)
{
ResString rsText (ResID (IDS_OUTSECTPOINT, pRF), 200);
if (IDYES == MessageBox (__hWndM, rsText.Addr(), rsCapt.Addr(),
MB_ICONQUESTION | MB_YESNO))
{
ExpandingSreenSection (SectPt1);
pPTCur->x = 0; // an dieser Stelle könnte mehr Aufwand getrieben werden, damit die NEUE Position
pPTCur->y = 0; // von SectPt nach der Vergrößerung des Sichtausschnittes ermittelt wird !!!!!!!
return S_OK;
}
return S_FALSE; // IDNO
}
if (INFISECT == ssRet) // Strecke liegt vollständig auf der Geraden
{
double dLotPX, dLotPY;
GeradenLotPunkt (MSPt.X(), MSPt.Y(), m_EPt1.X(), m_EPt1.Y(), m_EPt2.X(), m_EPt2.Y(),
dLotPX, dLotPY);
CursorToStraight (MSPt, dLotPX, dLotPY, SectPt1, SectPt2, pPTCur);
return S_OK;
}
if (NOSECT == ssRet)
{
ResString rsText (ResID (IDS_NOSECTPOINT, pRF), 250);
MessageBox (__hWndM, rsText.Addr(), rsCapt.Addr(), MB_ICONEXCLAMATION | MB_OK);
pPTCur->x = -1;
pPTCur->y = -1;
return S_FALSE;
}
DEX_Error (RC_RestrictLine, EC_NOINTERSECTION);
return E_FAIL;
} // CursorToSegmentStraight
void CLBIterator :: Reset (void)
{
m_iCnt = 0;
m_iCntItems = m_rlb.GetCount();
TRY {
m_pItem = m_sItem.GetBuffer(STRLENGTH);
}
CATCH ( CMemoryException, e ) {
DEX_Error (0, EC_NOMEMORY);
}
BOOL CViewLongVar::OnInitDialog()
{
CDialog::OnInitDialog();
// Speicher für Text anfordern
uint MaxCnt = (uint) m_pCLongBinary -> m_dwDataLength;
if (MaxCnt >= MaxCharCount)
{
MaxCnt = MaxCharCount;
DEX_Error (RC_ctViewLongChar, WC_TEXTTRUNCATED);
}
char *pDest = NULL;
TRY
{
pDest = new char [MaxCnt + 1];
}
CATCH (CMemoryException, cme)
{
DEX_Error (RC_ctViewLongChar, EC_NOMEMORY);
return FALSE;
}
// --------------------------------------------------------------------------------------------
// Ermittlung der Cursorposition bei 2 Geraden
HRESULT CRestrictLine::CursorToStraightStraight (LPARAM lParam, Point EPt11, Point EPt21,
Point EPt12, Point EPt22, POINT* pPTCur)
{
Point SectPt;
SectScreen ssRet = StraightStraightIntersection (EPt11, EPt21, EPt12, EPt22, SectPt);
if (INSECT == ssRet)
{
*pPTCur = (POINT&)SectPt;
return S_OK;
}
ResString rsCapt (ResID (IDS_LONGCLASSNAME, pRF), 50);
if (OUTSECT == ssRet)
{
ResString rsText (ResID (IDS_OUTSECTPOINT, pRF), 200);
if (IDYES == MessageBox (__hWndM, rsText.Addr(), rsCapt.Addr(),
MB_ICONQUESTION | MB_YESNO))
{
ExpandingSreenSection (SectPt);
pPTCur->x = 0; // an dieser Stelle könnte mehr Aufwand getrieben werden, damit die NEUE Position
pPTCur->y = 0; // von SectPt nach der Vergrößerung des Sichtausschnittes ermittelt wird !!!!!!!
return S_OK;
}
return S_FALSE; // IDNO
}
if (INFISECT == ssRet) // beide Geraden sind deckungsgleich
return CursorTo1RestrictLine (lParam, pPTCur);
if (NOSECT == ssRet)
{
ResString rsText (ResID (IDS_NOSECTPOINT, pRF), 250);
MessageBox (__hWndM, rsText.Addr(), rsCapt.Addr(), MB_ICONEXCLAMATION | MB_OK);
pPTCur->x = -1;
pPTCur->y = -1;
return S_FALSE;
}
DEX_Error (RC_RestrictLine, EC_NOINTERSECTION);
return E_FAIL;
} // CursorToStraightStraight
void OdbcError :: Show (short RoutCode)
{
/*
if (m_sRetCode > AFX_SQL_ERROR && // wenn für diesen Fehlerkode
m_sRetCode < AFX_SQL_ERROR_MAX) // eine Meldung existiert
{ // durch MFC generierter Fehler
// m_sRetCode = m_sRetCode - AFX_SQL_ERROR + AFX_IDP_SQL_FIRST;
TRY
{
CString strError, strCaption;
strError.LoadString (m_sRetCode);
strCaption.LoadString (IDS_ODBCERROR);
:: MessageBox (g_pCOdbcExtension -> hWnd (), m_strError,
strCaption, MB_OK | MB_ICONSTOP);
}
CATCH (CMemoryException, cme)
{
}
END_CATCH
return;
}
*/
// Dieser Fehler weist auf "Ungereimtheiten" im Programm hin
if (m_sRetCode == SQL_INVALID_HANDLE)
{
DEX_Error (RoutCode, EC_SYSERROR);
return;
}
// "echter" ODBC-Error
TRY
{
if (NULL != g_pCOdbcExtension)
g_pCOdbcExtension->Show(m_strErrText);
}
CATCH (CMemoryException, cme)
{
}
END_CATCH
}
/////////////////////////////////////////////////////////////////////////////
// CFeldInfoDialog dialog
CFeldInfoDialog::CFeldInfoDialog(CWnd* pParent, CColumnObjArray *pCA)
: CDialog(CFeldInfoDialog::IDD, pParent)
{
//{{AFX_DATA_INIT(CFeldInfoDialog)
// NOTE: the ClassWizard will add member initialization here
m_bResult = FALSE; // noch nichts getan
m_pCA = NULL;
//}}AFX_DATA_INIT
// prüfe Parameter
if (!pParent || !pCA || !pCA -> Count ())
{
DEX_Error (RC_ctCFeldInfo, EC_ILLPARS);
return;
}
m_sNameSort = m_sTypeSort = m_sLenSort = NotSorted;
m_pCA = pCA; // Zeiger speichern
m_bResult = TRUE; // alles OK
}
void CDsnPage::OnSelchangeTable()
{
// TODO: Add your control notification handler code here
int iSel = m_lbTable.GetCurSel ();
if (iSel < 0)
{
m_strTableName.Empty ();
return;
}
TRY
{
// Table-Bschreibung ausgeben
m_lbTable.GetText (iSel, m_strTableName);
ASSERT (g_pCParams != NULL);
g_pCParams -> m_strTableName = m_strTableName;
}
CATCH (CMemoryException, me)
{
DEX_Error (RC_OdbcImport, EC_NOMEMORY);
}
// --------------------------------------------------------------------------------------------
// Bildung einer Konstruktionshilfslinie in Form einer Strecke
bool CRestrictLine::BuildSegmentLine (KoOrd lFixX, KoOrd lFixY, double dAngle, double dLength)
{
KoOrd lKorr1 = DtoL (m_dUFX * dLength * cos (dAngle));
KoOrd lKorr2 = DtoL (m_dUFY * dLength * sin (dAngle));
KoOrd EPktX = lFixX + lKorr1;
KoOrd EPktY = lFixY + lKorr2;
m_EPt1 = BSKoordinaten (EPktX, EPktY);
EPktX = lFixX - lKorr1;
EPktY = lFixY - lKorr2;
m_EPt2 = BSKoordinaten (EPktX, EPktY);
m_pKHL = new LineObject (m_EPt1, m_EPt2, &m_MyPen1);
if (! m_pKHL)
{
DEX_Error (RC_RestrictLine, EC_NOMEMORY);
return false;
}
return true;
} // BuildSegmentLine
// --------------------------------------------------------------------------------------------
// Bildung einer Konstruktionshilfslinie in Form eines Kreises
bool CRestrictLine::BuildCircleLine (KoOrd lFixX, KoOrd lFixY, double dLength)
{
Point FixPt = BSKoordinaten (lFixX, lFixY);
Point EPt = BSKoordinaten (lFixX + m_dUFX*dLength, lFixY);
_ASSERTE (EPt.X() - FixPt.X() > 0);
m_iRad = EPt.X() - FixPt.X(); // Radius und
CoOrd d = 2 * m_iRad; // Durchmesser der kreisförmigen Hilfslinie
m_RefPt.X() = FixPt.X() - m_iRad;
m_RefPt.Y() = FixPt.Y() - m_iRad;
m_pKHL = new EllipseObject (m_RefPt, Dimension(d, d), &m_MyPen1, &m_MyBrush);
if (! m_pKHL)
{
DEX_Error (RC_RestrictLine, EC_NOMEMORY);
return false;
}
return true;
} // BuildCircleLine
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;
}
AND_CATCH (CUserException, me)
{
DEX_Error (RC_ctCFeldInfo, EC_SYSERROR);
return FALSE;
}
// --------------------------------------------------------------------------------------------
// Ermittlung der Cursorposition bei 2 Kreisen
HRESULT CRestrictLine::CursorToCircleCircle (LPARAM lParam, Point MSPt, Point MPt1, int iRad1,
Point MPt2, int iRad2, POINT* pPTCur)
{
bool bTwice; // 2 Schnittpunkte (true) bzw. 1 Berührungspunkt (false)
Point SectPt1, SectPt2;
SectScreen ssRet = CircleCircleIntersection (MPt1, iRad1, MPt2, iRad2, bTwice, SectPt1,
SectPt2);
if (INSECT == ssRet)
{
if (bTwice)
CursorToNearbyPoint (MSPt, SectPt1, SectPt2, pPTCur);
else
*pPTCur = (POINT&)SectPt1;
return S_OK;
}
ResString rsCapt (ResID (IDS_LONGCLASSNAME, pRF), 50);
if (OUTSECT == ssRet)
{
ResString rsText (ResID (IDS_OUTSECTPOINT, pRF), 200);
if (IDYES == MessageBox (__hWndM, rsText.Addr(), rsCapt.Addr(),
MB_ICONQUESTION | MB_YESNO))
{
if (bTwice)
ExpandingSreenSection (SectPt1, SectPt2);
else
ExpandingSreenSection (SectPt1);
pPTCur->x = 0; // an dieser Stelle könnte mehr Aufwand getrieben werden, damit die NEUE Position
pPTCur->y = 0; // von SectPt nach der Vergrößerung des Sichtausschnittes ermittelt wird !!!!!!!
return S_OK;
}
return S_FALSE; // IDNO
}
if (INOUTSECT == ssRet)
{
ResString rsText (ResID (IDS_OUTSECTPOINT, pRF), 200);
if (IDYES == MessageBox (__hWndM, rsText.Addr(), rsCapt.Addr(),
MB_ICONQUESTION | MB_YESNO))
{
ExpandingSreenSection (SectPt1, SectPt2);
CursorToNearbyPoint (MSPt, SectPt1, SectPt2, pPTCur);
return S_OK;
}
CursorToNearbyPoint (MSPt, SectPt1, SectPt2, pPTCur);
return S_FALSE; // IDNO
}
if (INFISECT == ssRet) // beide Kreise sind deckungsgleich
return CursorTo1RestrictLine (lParam, pPTCur);
if (NOSECT == ssRet)
{
ResString rsText (ResID (IDS_NOSECTPOINT, pRF), 250);
MessageBox (__hWndM, rsText.Addr(), rsCapt.Addr(), MB_ICONEXCLAMATION | MB_OK);
pPTCur->x = -1;
pPTCur->y = -1;
return S_FALSE;
}
DEX_Error (RC_RestrictLine, EC_NOINTERSECTION);
return E_FAIL;
} // CursorToCircleCircle
// Daten importieren
void CImportOdbcData :: ImportData (void)
{
// prüfe externe Parameter
ASSERT (g_pCOdbcExtension != NULL);
// prüfe Import-Parameter
if (!CanImport ())
{
DEX_Error (RC_OdbcImport, EC_ILLPARS);
return;
}
// Voreinstellungen machen
CActivateWindow aw (g_pCOdbcExtension -> hWnd ()); // Parent-Fenster deakt.
// ODBC-Infos
CDataBaseExt *pCDataBase = NULL; // DataSource-Objekt
CColumnObjArray *pCColList = NULL; // Container mit Spalten-Infos
CRecSet *pCRecSet = NULL; // Record-Container
#ifdef WIN32
IProgressIndicator *pIStatus = NULL;
TRY
{
// Status-Fenster erzeugen
HRESULT hr = g_pCOdbcExtension -> m_pXtnSite -> CreateInstance (NULL, CLSID_ProgressIndicator,
IID_IProgressIndicator, (LPVOID*)&pIStatus);
if (FAILED (hr))
AfxThrowUserException ();
HWND hNewWnd = pIStatus -> InitNew (g_pCOdbcExtension -> hWnd (), 0L);
if (NULL == hNewWnd)
AfxThrowUserException ();
hr = pIStatus -> Restart (0L, 1L, PIFLAG_CAPTION | PIFLAG_FILENAME | PIFLAG_FILE | PIFLAG_STATUS);
// 1. Tabellen-Objekte Recherche durchführen
CString strInfo;
strInfo.LoadString (IDS_IMP_SEL_REC);
pIStatus -> ChangeText (PIFLAG_CAPTION, strInfo);
// Tabellen-Namen
strInfo.LoadString (IDS_IMP_TABLE);
pIStatus -> ChangeText (PIFLAG_FILE, strInfo);
pIStatus -> ChangeText (PIFLAG_FILENAME, m_pCImportParams -> m_strTableName);
// Anzeige akt.
pIStatus -> SetPosition (1);
// DataSource-Objekt erzeugen
pCDataBase = new CDataBaseExt (m_pCImportParams -> m_strDataSource);
if (! pCDataBase -> Open ())
{
DEX_Error (RC_OdbcImport, EC_NOOPENDSN);
AfxThrowNotSupportedException ();
}
// DatenSätze aus Tabelle lesen
long lMaxCnt = 0; // Anzahl der Sätze oder Trias-Objekte
if (!GetTableRecords (pCDataBase, pCColList, pCRecSet, lMaxCnt) || pIStatus -> WasCanceled ())
AfxThrowNotSupportedException (); // bereits ausgewerteter Fehler oder Nutzer-Abbruch
// hr = pIStatus -> Restart (0L, 20, PIFLAG_CAPTION | PIFLAG_STATUS | PIFLAG_FILENAME | PIFLAG_RESULT |
// PIFLAG_TIME | PIFLAG_ADJUSTPERCENT | PIFLAG_FILE);
// strInfo.LoadString (IDS_IMP_STAT_PERCENT); // Prozent-Anzeige
// pIStatus -> ChangeText (PIFLAG_ADJUSTPERCENT, strInfo);
// lese Trias-Objekte
// führe Abgleich durch
// lösche ggf. nicht existierende Objekte/Datensätze
// schreibe ODBC-Anbindungen
// zeige ImportErgebnis
// Definition-Page
}
CATCH (CMemoryException, me)
{
DEX_Error (RC_OdbcImport, EC_NOMEMORY);
}
AND_CATCH (CUserException, ue)
{
DEX_Error (RC_OdbcImport, EC_SYSERROR);
}
// --------------------------------------------------------------------------------------------
// Folgende Funktion wird einmalig nach der erfolgreichen Installation der Erweiterung durch
// TRiAS gerufen. Hier erfolgen alle notwendigen Initialisierungen.
STDMETHODIMP_(BOOL) CGeoEditExtension::InitExtension (short iMode)
{
// globale Parameter initialisieren
pRF = &RF();
char cSichtName[MAXVIEWNAMESIZE+1] = { '\0' }; // Name der Sicht (NICHT mit "string")
if (DEX_TestActiveProject() && // ein Projekt ist schon geöffnet
0 != DEX_GetActiveSight (cSichtName))
m_bSight = true; // eine Sicht ist schon ausgewählt
else
m_bSight = false; // noch keine Sicht ausgewählt
// eigene Windows-Message anmelden (2 Parameter)
RegisterNotification (WM_MOUSEMOVE, false);
RegisterNotification (WM_WM_DESIGNBUILDEND, false);
// TRiAS-Messages anfordern (nur 1 Parameter)
// ich interessiere mich für die von TRiAS verschickten Meldungen, für
RegisterNotification (DEX_SETACTIVETOOL); // neues Werkzeug selektiert
RegisterNotification (DEX_PROJECTOPEN); // Projekt wird geöffnet
RegisterNotification (DEX_SIGHTSELECTED); // eine Sicht wird ausgewählt
RegisterNotification (DEX_PROJECTCLOSE); // Projekt wird geschlossen
RegisterNotification (DEX_OBJECTDEACTIVATED);
RegisterNotification (DEX_DELOBJECT);
// Cursoren anlegen
DELETE_OBJ (m_EditCursor);
DELETE_OBJ (m_VertexCursor);
DELETE_OBJ (m_LineCursor);
DELETE_OBJ (m_DeleteCursor);
DELETE_OBJ (m_InsideCursor);
DELETE_OBJ (m_GrabCursor);
m_EditCursor = new Pointer (ResID (IDC_CUREDIT, pRF));
m_VertexCursor = new Pointer (ResID (IDC_CURVERTEX, pRF));
m_LineCursor = new Pointer (ResID (IDC_CURLINE, pRF));
m_DeleteCursor = new Pointer (ResID (IDC_CURDELETE, pRF));
m_InsideCursor = new Pointer (ResID (IDC_CURINSIDE, pRF));
m_GrabCursor = new Pointer (ResID (IDC_CURGRAB, pRF));
if (!m_EditCursor || !m_VertexCursor || !m_LineCursor || !m_DeleteCursor ||
!m_InsideCursor || !m_GrabCursor)
{
DELETE_OBJ (m_EditCursor);
DELETE_OBJ (m_VertexCursor);
DELETE_OBJ (m_LineCursor);
DELETE_OBJ (m_DeleteCursor);
DELETE_OBJ (m_InsideCursor);
DEX_Error (RC_geoedit, EC_NOMEMORY);
return false;
}
try
{
// Objekt erzeugen, welches die ausgewählten TRiAS-GeometrieObjekte enthält
m_wTopObjs = WTopicalObjects (CLSID_TopicalObjects);
m_wTopObjs->SetXtensionSite (m_pXtnSite);
}
catch (...)
{
return false;
}
// neue Werkzeuge installieren
if (!m_bEditTBarInst) {
if (SUCCEEDED(InstallEditToolbar()))
m_bEditTBarInst = true;
}
if (!m_bDesignTBarInst) {
// #HK000906: TRiAS4 hat Konstruktionswerkzeuge standardmäßig
#if _TRiAS_VER < 0x0400
CCurrentUser regCfg (KEY_READ, g_cbRegConfig);
DWORD dwVer4 = 0;
if (regCfg.GetDWORD (TEXT("FakeTRiAS4"), dwVer4) && 0 != dwVer4) {
// schon jetzt so tun, als obs die TRiAS4 wäre
if (SUCCEEDED(InstallDesignToolbar()))
m_bDesignTBarInst = true;
}
else {
// wie bisher nach speziellem Registryeintrag suchen
ResString rsDesignMode (ResID (IDS_DESIGNMODE, pRF), 30);
CCurrentUser cuExtConfig (KEY_READ, RegistryExtPathEdit);
DWORD dwKey = -1;
if (cuExtConfig.GetDWORD (rsDesignMode.Addr(), dwKey) &&
DESIGNKEY == dwKey) // 08.06.99
{
InstallDesignToolbar();
m_bDesignTBarInst = true;
}
}
#else
if (SUCCEEDED(InstallDesignToolbar()))
m_bDesignTBarInst = true;
#endif // _TRiAS_VER < 0x0400
}
// GeoRein.ext automatisch nachladen
ResString resGeoRein (ResID (IDS_GEOREIN, pRF), 20);
DEX_ExternalLoadExtension (resGeoRein.Addr());
// bei BScript anmelden
RegisterBScriptExtension();
return CTriasExtension::InitExtension(iMode);
} // InitExtension
BOOL CWherePage::OnInitDialog()
{
CPropertyPage::OnInitDialog();
TRY
{
// TODO: Add extra initialization here
// Font fnr Beschreibungsfeld einstellen
m_stDescription.InitFont ();
// DataSource-Dialoge erzeugen
CString strCaption;
VERIFY (strCaption.LoadString (IDS_USER_DSN_CAPT));
m_dlgUserDsn.m_tType = UserDataSource;
VERIFY (0 == m_tbDsn.AddDialog (&m_dlgUserDsn, IDD_USER_DSN, strCaption));
VERIFY (strCaption.LoadString (IDS_SYSTEM_DSN_CAPT));
m_dlgSystemDsn.m_tType = SystemDataSource;
VERIFY (1 == m_tbDsn.AddDialog (&m_dlgSystemDsn, IDD_USER_DSN, strCaption));
VERIFY (strCaption.LoadString (IDS_FILE_DSN_CAPT));
m_dlgFileDsn.m_tType = FileDataSource;
VERIFY (2 == m_tbDsn.AddDialog (&m_dlgFileDsn, IDD_FILE_DSN, strCaption));
// Eingabelänge begrenzen
m_edFilter.LimitText (KlauselSize);
uint uActResID = IDS_AND_OP;
CString strText;
ASSERT (NULL != m_pOperatorsArray);
for (short sIndex = 0; sIndex < MaxOperators; sIndex++, uActResID += 2)
{
// akt. String laden
if (strText.LoadString (uActResID) && // String aus Resource laden
(m_cbOperators.AddString (strText) >= 0)) // String in ListBox
m_pOperatorsArray [sIndex] = uActResID + 1; // ResID speichern
else
AfxThrowUserException ();
}
// Filter ausgeben
m_edFilter.SetWindowText (m_strFilter);
// evtl. übergebenen DataSource einstellen
if (ReadOdbcInfos (m_strDataSource, m_tpDataSource))
{
switch (m_tpDataSource)
{
case UserDataSource:
{
VERIFY (m_tbDsn.SetActiveDialog (&m_dlgUserDsn));
VERIFY (m_dlgUserDsn.SelectDataSource (m_strDataSource));
}
break;
case FileDataSource:
{
VERIFY (m_tbDsn.SetActiveDialog (&m_dlgFileDsn));
VERIFY (m_dlgFileDsn.SelectDataSource (m_strDataSource));
}
break;
case SystemDataSource:
{
VERIFY (m_tbDsn.SetActiveDialog (&m_dlgSystemDsn));
VERIFY (m_dlgSystemDsn.SelectDataSource (m_strDataSource));
}
break;
default:
ASSERT (FALSE);
}
// wenn Tabelle übergeben, dann Feldnamen ausgeben
if (!m_strTable.IsEmpty ())
{
int iIndex = m_cbTables.FindStringExact (-1, m_strTable);
if (iIndex >= 0)
{
m_cbTables.SetCurSel (iIndex);
m_OdbcInfos.OutputColumnNames (m_strTable, m_cbFields);
}
else
m_strTable.Empty ();
}
}
else // übergebene Werte sind ungültig
{
m_tbDsn.SetActiveDialog (0);
m_strDataSource.Empty ();
m_tpDataSource = NoDataSource;
m_strTable.Empty ();
}
VERIFY (m_btContents.Create ());
VERIFY (S_OK == CoCreateInstance (CLSID_EnumObjectsByNumber, NULL, CLSCTX_INPROC_SERVER,
IID_IEnumObjectsByNumber, (LPVOID *)&m_pIEnumObjs));
}
CATCH (CMemoryException, me)
{
me -> ReportError ();
}
AND_CATCH (CUserException, me)
{
DEX_Error (RC_CCreateWhereKlDlg, EC_SYSERROR);
}
// --------------------------------------------------------------------------------------------
// Grabben des letzten editierten Punktes;
// return-Wert: S_OK es wurde gegrabt
// S_FALSE es wurde nicht gegrabt
// E_OUTOFMEMORY dynamischer Speicher nicht ausreichend
HRESULT CNewArea::Grabbing (void)
{
if (m_wRestrLine1.IsValid() || m_wRestrLine2.IsValid())
return S_FALSE; // es ist wenigstens 1 Konstruktionshilfslinie vorgegeben
// m_LastPkt evtl. durch Grabben noch modifizieren und alle Linien- bzw. Flächenobjekte der
// m_wAllTObjs-Objekte in wActGrabObjs einsammeln, die den (falls vorhanden) GrabPunkt als
// Stützpunkt besitzen
WEnumObjektGeometrie wActGrabObjs;
HRESULT hrRet = m_wTopObjs->NewVertexWithGrab ((POINT*)&m_LastPt, m_wDragObj, &m_LastPkt.X(),
&m_LastPkt.Y(), wActGrabObjs.ppi());
if (S_OK != hrRet) // es wurde nicht gegrabt
{
m_iGrabCnt = 0;
m_hrComBorder = S_FALSE;
}
else // es wurde gegrabt
{
if (0 == m_iGrabCnt) // der 1. von mehreren hintereinander editierten GrabPunkten
{
DELETE_VEC (m_pGrabPktX);
DELETE_VEC (m_pGrabPktY);
m_pGrabPktX = new KoOrd[iComCnt]; // iComCnt ist in EditKonst.h definiert
m_pGrabPktY = new KoOrd[iComCnt];
if (!m_pGrabPktX || !m_pGrabPktY)
{
DELETE_VEC (m_pGrabPktX);
DEX_Error (RC_NewArea, EC_NOMEMORY);
return E_OUTOFMEMORY;
}
}
m_lComONr = 0; // Objektnummer des Objektes, von dem die gemeinsamen Stützpunkte bei
// CommonBorder übernommen werden können
m_hrComBorder = IsCommonBorderAllowable (m_iGrabCnt, wActGrabObjs, m_wGrabObjs,
m_lComONr);
if (0 != m_lComONr && -1 != m_lComONr)
{
int iOT = DEX_GetObjectType (m_lComONr);
if ((OT_FLAECHE == iOT || S_OK == IsClosedLine (m_lComONr)) && m_iGrabCnt > 3)
{
m_pGrabPktX[0] = m_pGrabPktX[1];
m_pGrabPktY[0] = m_pGrabPktY[1];
m_pGrabPktX[1] = m_pGrabPktX[2];
m_pGrabPktY[1] = m_pGrabPktY[2];
m_iGrabCnt--;
}
else if (OT_KANTE == iOT && S_FALSE == IsClosedLine (m_lComONr) && m_iGrabCnt > 2)
{
m_pGrabPktX[0] = m_pGrabPktX[1];
m_pGrabPktY[0] = m_pGrabPktY[1];
m_iGrabCnt--;
}
}
_ASSERTE (m_iGrabCnt <= iComCnt);
m_pGrabPktX[m_iGrabCnt-1] = m_LastPkt.X();
m_pGrabPktY[m_iGrabCnt-1] = m_LastPkt.Y();
// es wurde gegrabt, deshalb m_dAktDreieck korrigieren (25.03.98)
m_dAktDreieck = DreieckInhalt (m_LastPt, m_FirstPkt, m_LastPkt, m_pCT);
}
return hrRet;
} // Grabbing