Esempio n. 1
0
///////////////////////////////////////////////////////////////////////////////////////////////
// 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;
    }
}
Esempio n. 2
0
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;
    }
Esempio n. 3
0
// --------------------------------------------------------------------------------------------
// 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
Esempio n. 4
0
// --------------------------------------------------------------------------------------------
// 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
Esempio n. 5
0
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); 
	}                  
Esempio n. 6
0
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;
	}               
Esempio n. 7
0
// --------------------------------------------------------------------------------------------
// 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
Esempio n. 8
0
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
}	
Esempio n. 9
0
/////////////////////////////////////////////////////////////////////////////
// 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
}
Esempio n. 10
0
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);
	}
Esempio n. 11
0
// --------------------------------------------------------------------------------------------
// 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
Esempio n. 12
0
// --------------------------------------------------------------------------------------------
// 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
Esempio n. 13
0
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;
	}
Esempio n. 14
0
	AND_CATCH (CUserException, me)
	{
		DEX_Error (RC_ctCFeldInfo, EC_SYSERROR);		
		return FALSE;
	}		
Esempio n. 15
0
// --------------------------------------------------------------------------------------------
// 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
Esempio n. 16
0
//	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);
	}
Esempio n. 17
0
	AND_CATCH (CUserException, ue)
	{
		DEX_Error (RC_OdbcImport, EC_SYSERROR);
	}
Esempio n. 18
0
// --------------------------------------------------------------------------------------------
// 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
Esempio n. 19
0
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);
    }
Esempio n. 20
0
// --------------------------------------------------------------------------------------------
// 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