HRESULT CCoordTransService::FindCTF (void)
{
USES_CONVERSION;
char cbCTFName[_MAX_PATH];
CComBSTR bstr (GetProperty (m_Props, g_cbCoordTransform, A2OLE(g_cbDefault)));
strcpy (cbCTFName, OLE2A(bstr));
if (!stricmp (cbCTFName, g_cbDefault))
m_fIsDefault = true;
// CTFService's über CATID enumerieren, CTFService wiederfinden
try {
WEnumGUID EnumGuids; // Enumerator der CTFService-Objekte
WCatInformation CatInfo (CLSID_StdComponentCategoriesMgr); // throws hr
GUID guidImpl[1];
guidImpl[0] = CATID_TRiASCoordsystem;
THROW_FAILED_HRESULT(CatInfo -> EnumClassesOfCategories (1, guidImpl, 0, NULL, EnumGuids.ppi()));
GUID guid;
LPOLESTR lpGuid = NULL;
bool fFoundGuid = false;
for (EnumGuids -> Reset(); S_OK == EnumGuids -> Next (1, &guid, NULL); /**/)
{
THROW_FAILED_HRESULT(StringFromCLSID (guid, &lpGuid));
CClassesRoot regClsID (OLE2A(lpGuid));
char cbBuffer[_MAX_PATH];
LONG lSize = sizeof(cbBuffer);
if (NULL != lpGuid) {
CoTaskMemFree (lpGuid);
lpGuid = NULL;
}
if (regClsID.isValid() && regClsID.GetSZ (g_cbOldName, cbBuffer, lSize))
{
if (!stricmp (cbBuffer, cbCTFName)) {
fFoundGuid = true;
m_strCTF = cbBuffer;
break;
}
}
}
if (!fFoundGuid) {
TX_ASSERT(fFoundGuid);
return E_FAIL; // snh!
}
} catch (_com_error &e) {
TX_ASSERT(S_OK == _COM_ERROR(e));
return _COM_ERROR(e);
}
return S_OK;
}
HRESULT COleObjectPropertyDual::FInit (DObjectProperty *pIObjProp)
{
if (NULL == pIObjProp) return E_POINTER;
try {
m_ObjProp = pIObjProp; // throws hr
PROPERTYCAPS rgFlags = PROPERTYCAPS_NONE;
THROW_FAILED_HRESULT(m_ObjProp -> get_PropertyFlags(&rgFlags));
WDWriteAbleObjectProperty ObjPropEx;
if (SUCCEEDED(m_ObjProp->QueryInterface(ObjPropEx.ppi())) &&
rgFlags & PROPERTYCAPS_NOTREADONLY)
{
m_fWriteAble = true; // DWriteAbleObjectProperty wird unterstützt
}
WDSearchAbleObjectProperty ObjPropSrch;
if (SUCCEEDED(m_ObjProp->QueryInterface(ObjPropSrch.ppi())) &&
rgFlags & PROPERTYCAPS_SEARCHABLE)
{
m_fSearchAble = true; // DSearchAbleObjectProperty wird unterstützt
}
} catch (_com_error& hr) {
m_fWriteAble = false;
m_fSearchAble = false;
return _COM_ERROR(hr);
}
return InitDocumentDispatch();
}
STDMETHODIMP CPropertyChoice::AddActionsByCLSID (CALPCLSID *pcaClsIds)
{
HRESULT hr = E_FAIL;
if (!m_fIsInitialized) {
hr = InitNew();
if (FAILED(hr)) return hr;
}
// hinzufügen der einzelnen Aktionen
for (ULONG i = 0; i < pcaClsIds -> cElems; i++) {
try {
WPropertyAction WAct (*(pcaClsIds -> ppElems[i])); // throws hr
{
WPersistStreamInit Init = WAct; // throws hr
hr = Init -> InitNew();
if (FAILED(hr)) _com_issue_error(hr);
}
hr = AddAction (WAct);
if (FAILED(hr)) _com_issue_error(hr);
} catch (_com_error& hr) {
return _COM_ERROR(hr);
}
}
return NOERROR;
}
char * CCoordTransService::CoordTransToStringEx (
double dX, double dY, bool isX, char *pBuffer, int iLen)
{
if (m_fIsInitialized) {
try {
CComBSTR bstr;
CCSPoint pt (dX, dY);
if (isX) {
THROW_FAILED_HRESULT(m_CTF -> ToStrings (&pt, &bstr, NULL, NULL));
} else {
THROW_FAILED_HRESULT(m_CTF -> ToStrings (&pt, NULL, &bstr, NULL));
}
USES_CONVERSION;
iLen = min(bstr.Length(), iLen-1);
strncpy (pBuffer, OLE2A(bstr), iLen);
pBuffer[iLen] = '\0';
return pBuffer;
} catch (_com_error &e) {
ShowError (_COM_ERROR(e), IDS_CSSERRORCAPTION, g_cbCoordTransToStringEx);
return NULL;
}
}
ShowError (TRIAS02_E_CSSNOTINITIALIZED, IDS_CSSERRORCAPTION, g_cbCoordTransToStringEx);
return NULL;
}
// die folgende Funktion ist das konkrete äquivalent für 'OleLoadFromStream' --
HRESULT CreateStringFromStream (IStream *pIStream, LPSTR lpstr, int iLen)
{
ASSERT(pIStream);
ASSERT(lpstr);
ASSERT(0 < iLen);
if (NULL == lpstr) return E_POINTER;
if (0 == iLen) return E_INVALIDARG;
USES_CONVERSION;
*lpstr = '\0';
try
{ // Variant liest sich selbst vom Stream
CComVariant cv;// VariantInit()
HRESULT hr = cv.ReadFromStream (pIStream);
if (FAILED(hr)) _com_issue_error(hr);
// Richtigen Typ rausholen
hr = cv.ChangeType (VT_BSTR);
if (FAILED(hr)) _com_issue_error(hr);
// Wert lesen
CComBSTR bstr = cv.bstrVal; // SysAllocString(...
LPSTR lpstrName = OLE2A(bstr.m_str);
if (iLen < strlen(lpstrName)) _com_issue_error(E_INVALIDARG);
strcpy(lpstr, lpstrName);
// in ~CComVariant() VariantClear()
} // in ~CComBSTR() SysFreeString(m_str)
catch (_com_error& e)
{
return _COM_ERROR(e);
}
return NOERROR;
}
STDMETHODIMP COleObjectPropertyDual::HelpInfo (
LPSTR pBuffer, ULONG ulLen, LPSTR pHelpFile, ULONG *pulHelpCtx)
{
HRESULT result = S_OK;
try {
CComBSTR bstrInfo;
CComVariant vHelpFile;
CComVariant vHelpCtx;
THROW_FAILED_HRESULT(m_ObjProp -> HelpInfo(&vHelpFile, &vHelpCtx, CLEARED(&bstrInfo)));
USES_CONVERSION;
if (NULL != pBuffer && ulLen > 0) {
ULONG ulT = min (ulLen-1, (ULONG)SysStringLen(bstrInfo));
strncpy (pBuffer, OLE2A(bstrInfo), ulT);
pBuffer[ulT] = '\0';
}
if (NULL != pHelpFile && VT_BSTR == vHelpFile.vt)
strcpy (pHelpFile, OLE2A(V_BSTR(&vHelpFile)));
if (NULL != pulHelpCtx && VT_I4 == vHelpCtx.vt)
*pulHelpCtx = V_I4(&vHelpCtx);
} catch (_com_error& hr) {
result = _COM_ERROR(hr);
}
return result;
}
// Serialisieren/DeSerialisieren eines IUnknowns
// in diesem Falle ein IDataObject
HRESULT CreateStreamOnHGlobalFromIUnknown (
IUnknown *pIUnk, REFCLSID rClsID, IStream **ppIStream)
{
ASSERT(NULL != pIUnk);
ASSERT(NULL != ppIStream);
*ppIStream = NULL;
try {
// neuen Stream anlegen, kreiert eine neuen Memoryblock der Größe NULL
// wird selbstständig wieder freigegen (true)
WStream IStream;
THROW_FAILED_HRESULT(CreateStreamOnHGlobal (NULL, true, IStream.ppi()));
// den Enumerator wegschreiben
WPersistStream IPersStr (pIUnk); // throws hr
THROW_FAILED_HRESULT(OleSaveToStream (IPersStr, IStream));
// wieder zurück positionieren
LARGE_INTEGER li;
LISet32 (li, 0L);
THROW_FAILED_HRESULT(IStream -> Seek (li, STREAM_SEEK_SET, NULL));
*ppIStream = IStream.detach();
}
catch (_com_error &e)
{
return _COM_ERROR(e);
}
return S_OK;
}
HRESULT GetVariantData (IDataObject *pIDO, const FORMATETC *pcfe, CComVariant *pv)
{
if (NULL == pIDO) return E_POINTER;
STGMEDIUM stg;
memset (&stg, 0, sizeof(STGMEDIUM));
try {
// Testen, ob das gewünschte Format überhaupt da ist
HRESULT hr = pIDO -> QueryGetData ((FORMATETC *)pcfe);
if (S_OK != hr) return hr; // Format nicht vorhanden
if (NULL == pv) return S_OK; // nur nachfragen
// Daten vom DataObject geben lassen
THROW_FAILED_HRESULT(pIDO -> GetData ((FORMATETC *)pcfe, &stg));
// einlesen des Enumerators aus den erhaltenen STGMEDIUM
THROW_FAILED_HRESULT(pv -> ReadFromStream (stg.pstm));
ReleaseStgMedium (&stg);
} catch (_com_error& hr_result) {
if (TYMED_NULL != stg.tymed)
ReleaseStgMedium (&stg);
return _COM_ERROR(hr_result);
}
return S_OK;
}
// Dient zum Lesen der Daten (EnumLONG) vom Stream im Datenobjekt
HRESULT GetStringData (IDataObject *pIDataObj, LPSTR lpstr, int iLen)
{
HRESULT hr = NOERROR;
STGMEDIUM stg;
memset (&stg, 0, sizeof(STGMEDIUM));
try
{
// Testen, ob das gewünschte Format überhaupt da ist
THROW_FAILED_HRESULT(pIDataObj -> QueryGetData ((FORMATETC *)&c_feInitPropAct));
// Daten vom DataObject geben lassen
THROW_FAILED_HRESULT(pIDataObj -> GetData ((FORMATETC *)&c_feInitPropAct, &stg));
// Einlesen des CComVariants aus den erhaltenen STGMEDIUM-Stream stg.pstm
THROW_FAILED_HRESULT(CreateStringFromStream (stg.pstm, lpstr, iLen));
// Freigeben Storagemedium
ReleaseStgMedium (&stg);
}
catch (_com_error& e)
{
if (TYMED_NULL != stg.tymed)
ReleaseStgMedium (&stg);
return _COM_ERROR(e);
}
return hr;
}
// Lesen eines EnumLONG aus einem DataObjekt ----------------------------------
HRESULT GetHWNDData (IDataObject *pIDataObj, HWND *phWnd)
{
HRESULT hr = E_FAIL;
STGMEDIUM stg;
memset (&stg, 0, sizeof(STGMEDIUM));
try {
// Testen, ob das gewünschte Format überhaupt da ist
THROW_FAILED_HRESULT(pIDataObj -> QueryGetData ((FORMATETC *)&c_feObjectWindow));
// Daten vom DataObject geben lassen
THROW_FAILED_HRESULT(pIDataObj -> GetData ((FORMATETC *)&c_feObjectWindow, &stg));
// HWND aus STGMEDIUM herauskopieren
HWND *phWndGlobal = (HWND *)GlobalLock (stg.hGlobal);
if (NULL == phWndGlobal)
_com_issue_error(E_UNEXPECTED);
*phWnd = *phWndGlobal;
ReleaseStgMedium (&stg);
} catch (_com_error &e) {
if (TYMED_NULL != stg.tymed)
ReleaseStgMedium (&stg);
return _COM_ERROR(e);
}
return NOERROR;
}
// --------------------------------------------------------------------------------------------
// GeoEdit informiert die IEditOperation über den aktuellen Zustand der Konstruktionslinien
STDMETHODIMP CNewArea::InformRestrictLinesState (IRestrictLine* pRestrLine1,
IRestrictLine* pRestrLine2)
{
m_wRestrLine1.Assign (NULL);
m_wRestrLine2.Assign (NULL);
m_wRestrLine1 = pRestrLine1;
m_wRestrLine2 = pRestrLine2;
m_wRestrictCursor.Assign (NULL);
if (m_wRestrLine1.IsValid() || m_wRestrLine2.IsValid())
{
if (m_wRestrLine1.IsValid()) m_wRestrLine1->Draw();
if (m_wRestrLine2.IsValid()) m_wRestrLine2->Draw();
try
{
// Verbindung zum CRestrictCursor-Objekt über dessen Interface IRestrictCursor herstellen
WRestrictCursor wRestrictCursor (CLSID_RestrictCursor); // throws_com_error
m_wRestrictCursor = wRestrictCursor;
THROW_FAILED_HRESULT (m_wRestrictCursor->ConstructRestrictCursor());
}
catch (_com_error& e)
{
return _COM_ERROR (e);
}
}
return S_OK;
} // InformRestrictLinesState
// Dient zum Lesen der Daten (EnumLONG) vom Stream im Datenobjekt
HRESULT GetEnumLONGData (IDataObject *pIDataObj, IEnum<LONG> **ppIEnumOut)
{
if (NULL == pIDataObj)
return S_FALSE;
HRESULT hr = ResultFromScode (E_FAIL);
STGMEDIUM stg;
memset (&stg, 0, sizeof(STGMEDIUM));
try {
// Testen, ob das gewünschte Format überhaupt da ist
THROW_FAILED_HRESULT(pIDataObj -> QueryGetData ((FORMATETC *)&c_feSelectedObjects));
// Daten vom DataObject geben lassen
THROW_FAILED_HRESULT(pIDataObj -> GetData ((FORMATETC *)&c_feSelectedObjects, &stg));
// Einlesen des Enumerators aus den erhaltenen STGMEDIUM
THROW_FAILED_HRESULT(CreateEnumLONGFromStream (stg.pstm, ppIEnumOut));
ReleaseStgMedium (&stg);
} catch (_com_error &e) {
if (TYMED_NULL != stg.tymed)
ReleaseStgMedium (&stg);
return _COM_ERROR(e);
}
return NOERROR;
}
HRESULT CAddFunctionDlg::FillComboBox()
{
HRESULT hr = NOERROR;
int iResID = IDR_NOTIFCLOSING;
try
{
while (iResID != IDR_NOTIFEND)
{
CTemplateManagement *pTM = new CTemplateManagement;
THROW_FAILED_HRESULT(pTM -> Load(iResID, "Notification"));
char str[MAXSTRLENGTH];
THROW_FAILED_HRESULT(pTM -> GetName(str, MAXSTRLENGTH));
int i = m_cbxNotification.AddString(str);
if (i == CB_ERRSPACE) _com_issue_error(E_OUTOFMEMORY);
if (i == CB_ERR) _com_issue_error(E_FAIL);
m_cbxNotification.SetItemData(i, (DWORD) pTM);
iResID++;
}
}
catch(_com_error& e)
{
hr = _COM_ERROR(e);
}
return hr;
}
HRESULT CRunBreakPoint::OnDemandBreakpoint(CebScript *pScript, CebThread *pThread, IObjectManagement *pIOM, IStreamInfo *pISI)
{
ASSERT(NULL != pScript);
ASSERT(NULL != pThread);
if (pScript == NULL || pThread == NULL) return E_POINTER;
ASSERT(NULL != pThread->GetHandle());
ASSERT(NULL != pScript->GetHandle());
if (NULL == pScript->GetHandle() || NULL == pThread->GetHandle()) return E_HANDLE;
HRESULT hr = NOERROR;
try
{// evtl. Debuggerfenster erzeugen
hr = CreateDebugger(WM_CLOSEBREAKPOINTDEBUGGERDIALOG, false, 0, pIOM, pISI);
if (FAILED(hr)) _com_issue_error(hr);
// Fertzigen Script und Thread unterschieben
if (!ebDebugger_SetScript(GetDebuggerWnd(), pScript->GetHandle())) _com_issue_error(E_FAIL);
if (!ebDebugger_SetThread(GetDebuggerWnd(), pThread->GetHandle())) _com_issue_error(E_FAIL);
// jetzt Debugger anzeigen
hr = m_pScriptDebugger -> RunModal();
if (FAILED(hr)) _com_issue_error(hr);
}
catch(_com_error& e)
{
if (m_pScriptDebugger)
m_pScriptDebugger -> DestroyWindow();
m_pScriptDebugger = NULL;
return _COM_ERROR(e);
}
return S_OK;
}
///////////////////////////////////////////////////////////////////////////////////////////////
// Verbindung zur CObjectModify-Klasse über das Interface IModifyClassSite herstellen;
// es wird KEINE (!!) Verbindung zu TRiAS über Interface ITriasExtension hergestellt, die
// WindowsMessages werden vom CObjectModify-Objekt heruntergereicht
STDMETHODIMP CVertexAdd::SetModifyClassSite (IEditExtensionSite* pIEdExSite,
IModifyClassSite* pIModClSite)
{
try
{
if (pIEdExSite != NULL)
{
THROW_FAILED_HRESULT (pIEdExSite->CreateInterfaceTO (m_wTopObjs.ppi()));
m_wEdExSite = pIEdExSite;
}
else
{
m_wTopObjs.Assign (NULL); // freigeben
m_wEdExSite.Assign (NULL); // freigeben
}
m_wModClSite = pIModClSite;
}
catch (_com_error& e)
{
return _COM_ERROR (e);
}
return S_OK;
} // SetModifyClassSite
// --------------------------------------------------------------------------------------------
// linke Maustaste wurde losgelassen
HRESULT CNewArea::LeftMouseUp (void)
{
if (!m_LeftButtonSem) // linke Maustaste wurde nicht gedrückt
return S_FALSE;
m_LeftButtonSem = false; // linke Maustaste wurde losgelassen
if (S_FALSE == EPunktAtCursor (m_lParam, m_wRestrLine1, m_wRestrLine2, m_LastPt, m_LastPkt))
return S_FALSE;
HRESULT hr;
if (FAILED (hr = NeueFlaeche()))
{
m_wDragObj->DragTerminate();
m_wDragObj.Assign (NULL);
return hr;
}
if (m_wRestrLine1.IsValid() || m_wRestrLine2.IsValid())
DEX_ChangeActiveTool (ID_TOOL_DESIGNSTOP); // DesignMode beenden
// Verbindung zum CDragMultiLine-Objekt über dessen Interface IDragObject herstellen
try
{
WDragObject wDragObj (CLSID_DragMultiLine); // throws_com_error (ab zum Konstruktor)
m_wDragObj.Assign (NULL);
m_wDragObj = wDragObj;
m_iSPCnt = 0;
if (S_OK == m_wDragObj->AddStartPoint ((POINT&)m_FirstPt))
{
m_pStartPkt[m_iSPCnt] = DBKoordinaten (m_FirstPt);
m_iSPCnt++;
}
if (S_OK == m_wDragObj->AddStartPoint ((POINT&)m_LastPt))
{
m_pStartPkt[m_iSPCnt] = DBKoordinaten (m_LastPt);
m_iSPCnt++;
}
m_wDragObj->ConstructDragLines();
}
catch (_com_error& e)
{
return _COM_ERROR (e);
}
// wenn die aktuell editierte Kontur zusammen mit dem soeben hinzugekommenen Punkt aus
// wenigstens 3 Stützpunkten besteht, dann die Hilfslinie, die diesen letzten Punkt mit dem
// ersten Punkt dieser Kontur verbindet, beim nächsten MouseMove() löschen
if (m_lKSize >= 3 && !m_wRestrLine1.IsValid() && !m_wRestrLine2.IsValid())
m_bCloseLineDelete = true;
else
m_bCloseLineDelete = false;
return S_OK;
} // LeftMouseUp
// --------------------------------------------------------------------------------------------
// Ermittlung des Startindex lStartInd aus einer (evtl.) gemeinsamen Strecke mit einem schon
// rechtwinklig gemachten Objekt, das aus zur gleichen Objektklasse wie das lONr-Objekt gehört;
// gibt es kein solches Objekt, dann ist der return-Wert "S_FALSE", lStartInd ist in
// diesem Fall unbestimmt
HRESULT CGeoEditExtension::CommonLineWithRectObject (long lONr, KoOrd* plXK, KoOrd* plYK,
long lCnt0, long& lStartInd)
{
KoOrd x0, y0, x1, y1; // Anfangs- und Endkoordinaten des längsten Konturabschnitts
try {
// Objektnummern aller Objekte der Objektklasse des lONr-Objektes bereitstellen
WEnumLONG wEnumIn (CLSID_EnumObjectsByNumber); // throws_com_error
ENUMLONGKEY ELK;
ELK.eKey = DEX_GetObjIdentEx (lONr);
ELK.eFcn = (ENUMLONGKEYPROC) GetRectObjects;
ELK.ePtr = wEnumIn;
DEX_EnumIdentObjects (ELK);
if (0 == wEnumIn->Count()) // kein Objekt gefunden, das schon rechtwinklig gemacht
return S_FALSE; // wurde
ulong ulIdent = 0; // Identifikator für die Ergebnisobjekte (wird hier nicht
// weiter benötigt)
DWORD dwLageAusw = LAUSS; // nur die wEnumIn-Flächen für Vergleich heranziehen, die
// außerhalb der lONr-Fläche liegen
SpForm sfSForm = SFORM_TEMP; // temporäre Abspeicherung
WEnumLONG wComCont (CLSID_EnumObjectsByNumber); // Objektnummern der gemeinsamen
// Konturabschnitte
if (! m_wObjOper.IsValid()) // (wenn noch nicht, dann) IExtendObjOper-Interface für
{ // CommonContour_ONr() zuschalten
WUnknown wObjOper;
ObjOperInterface (wObjOper.ppi());
m_wObjOper = wObjOper;
}
if (m_wObjOper.IsValid())
m_wObjOper->CommonContour_ONr (lONr, ulIdent, wEnumIn, dwLageAusw, sfSForm,
wComCont.ppi());
else
_ASSERTE (false);
if (0 == wComCont->Count()) // keines der schon rechtwinklig gemachten Objekte hat
return S_FALSE; // einen gemeinsamen Konturabschnitt mit dem lONr-Objekt
// wenn es mindestens 1 gemeinsamen Konturabschnitt gibt, dann die längste Strecke
// bestimmen
THROW_FAILED_HRESULT (GiveLongestLine (wComCont, x0, y0, x1, y1));
VisualCommonContour (wComCont);
}
catch (_com_error& e)
{
return _COM_ERROR (e);
}
return StartIndex (plXK, plYK, lCnt0, x0, y0, x1, y1, lStartInd);
} // CommonLineWithRectObject
// --------------------------------------------------------------------------------------------
STDMETHODIMP CRegOperatPropAct::EndAction (DWORD, IDataObject** ppDataOut)
{
_ASSERTE (m_ObjsIter != m_InObjs.end());
*ppDataOut = 0;
try {
WEnumLONG wEnumInObj (*m_ObjsIter); // die zu bearbeitenden Objekte
WEnumLONG wEnumOutObj; // Ergebnisobjekte der ausgewählten Operation
// Optionen abfragen
DWORD dwOptions = 0x00;
if (SUCCEEDED(EnsureOptionsIF())) {
_ASSERTE(m_wOperOptions.IsValid());
m_wOperOptions->GetOptions (&dwOptions);
}
// im Dialog ausgewählte Operation ausführen
THROW_FAILED_HRESULT (m_pRegOperDlg->ExecuteOperation (m_hPr, wEnumInObj, dwOptions,
wEnumOutObj.ppi()));
m_ObjsIter++;
if (wEnumOutObj.IsValid())
{
// IDataObject abfragen
WDataObject IDO (CLSID_DataTransferObject);
// Ergebnisobjekte im DataObjekt IDO speichern
THROW_FAILED_HRESULT (SetEnumLONGData (
(IEnum<LONG>*)(IEnumLONG*)wEnumOutObj, IDO));
// Resultat setzen
*ppDataOut = IDO.detach();
if (0 == wEnumOutObj->Count()) {
ResString resTitel (ResID (IDS_LONGCLASSNAME, pRF), 50);
ResString resText (ResID (IDS_BOXTEXT1, pRF), 200);
MessageBox (__hWndM, resText.Addr(), resTitel.Addr(),
MB_ICONINFORMATION | MB_OK);
}
}
}
catch (_com_error& hr_result) // 23.09.99
{
DELETE_OBJ (m_pRegOperDlg); // bei Fehler Dialog wieder freigeben
return _COM_ERROR(hr_result); // 23.09.99
}
if (m_ObjsIter != m_InObjs.end()) // es kommen noch weitere Daten
return S_FALSE;
DELETE_OBJ (m_pRegOperDlg); // es kommen keine Daten mehr
return S_OK;
} // EndAction
// Erzeugen und initialisieren eines PropertyActionChoice-Objektes, welches die
// vorgegebenen PropertyActions enthält
HRESULT InitPropertyActionChoice (
LPCSTR pcDesc, CALPCLSID *pcaClsIds, IPropertyActionSequence **ppISeq)
{
USES_CONVERSION;
if (NULL == ppISeq) return E_POINTER;
*ppISeq = NULL; // für alle Fälle
WPropertyActionSequence ISeq;
HRESULT hr = E_FAIL;
WStorage IStg;
GetSubPropSeqStorage (IStg.ppi());
if (NULL != (IStorage *)IStg) { // evtl. gespeicherten Status laden
WStream IStm;
string strName = MakeStreamName(pcDesc);
// Stream erzeugen
hr = IStg -> OpenStream (A2OLE(strName.c_str()), NULL,
STGM_READ|STGM_SHARE_EXCLUSIVE, 0L, IStm.ppi());
if (SUCCEEDED(hr)) {
hr = OleLoadFromStream (IStm, IID_IPropertyActionSequence, ISeq.ppv());
if (SUCCEEDED(hr)) {
*ppISeq = ISeq.detach();
return S_OK;
}
}
}
// wenn Status nicht geladen werden kann, dann neu initialisieren
try {
// Objekt erzeugen
ISeq = WPropertyActionSequence (CLSID_PropertyChoice); // throws hr
ISeq -> SetDescription (pcDesc);
// Rücksetzen der AktionsFolge
WPersistStreamInit Init = ISeq; // throws hr
hr = Init -> InitNew();
if (FAILED(hr)) _com_issue_error(hr);
} catch (_com_error& hr) {
return _COM_ERROR(hr);
}
// hinzufügen der einzelnen Aktionen
hr = ISeq -> AddActionsByCLSID (pcaClsIds);
if (FAILED(hr)) return hr;
*ppISeq = ISeq.detach();
return NOERROR;
}
HRESULT COleTRiASNotificationSinkDual::FInit (DTRiASNotificationSink *pISinkDual)
{
TEST_E_POINTER("COleTRiASNotificationSinkDual::FInit", pISinkDual);
try {
m_Sink = pISinkDual; // throws hr
} catch (_com_error& hr) {
return _COM_ERROR(hr);
}
return S_OK;
}
STDMETHODIMP COleObjectPropertyDual::GetPropInfo (LPSTR pBuffer, WORD wLen, DWORD *pdwFlags)
{
HRESULT result = S_OK;
try {
// get_PropertyName
if (NULL != pBuffer && wLen > 0) {
CComBSTR bstrName;
THROW_FAILED_HRESULT(m_ObjProp -> get_PropertyName(CLEARED(&bstrName)));
ULONG ulT = min ((ULONG)wLen-1, (ULONG)SysStringLen(bstrName));
USES_CONVERSION;
strncpy (pBuffer, OLE2A(bstrName), ulT);
pBuffer[ulT] = '\0';
}
} catch (_com_error& hr) {
return _COM_ERROR(hr);
}
try {
PROPERTYCAPS lFlags = PROPERTYCAPS_NONE;
// get_PropertyFlags
if (NULL != pdwFlags) {
THROW_FAILED_HRESULT(m_ObjProp -> get_PropertyFlags(&lFlags));
if (m_fWriteAble)
lFlags = PROPERTYCAPS(lFlags | PROPERTYCAPS_NOTREADONLY);
else
lFlags = PROPERTYCAPS(lFlags & ~PROPERTYCAPS_NOTREADONLY);
if (m_fSearchAble)
lFlags = PROPERTYCAPS(lFlags | PROPERTYCAPS_SEARCHABLE);
else
lFlags = PROPERTYCAPS(lFlags & ~PROPERTYCAPS_SEARCHABLE);
*pdwFlags = DWORD(lFlags);
}
} catch (_com_error&) {
*pdwFlags = DWORD(PROPERTYCAPS_NONE);
if (m_fWriteAble)
*pdwFlags |= DWORD(PROPERTYCAPS_NOTREADONLY);
if (m_fSearchAble)
*pdwFlags |= DWORD(PROPERTYCAPS_SEARCHABLE);
}
return S_OK;
}
///////////////////////////////////////////////////////////////////////////////////////////////
// IPropertyAction methods
// PropertyPages einhängen
// diese Stelle wird bei DoActions() erreicht
STDMETHODIMP CRegOperatPropAct::AddConfigPages (LPFNADDPROPSHEETPAGE lpfnAddPage,
LPARAM lParam, LPCSTR pcDesc, UINT *puiCnt)
{
char cbCaption[_MAX_PATH];
try
{
if (NULL != pcDesc) // Caption ist gegeben
strcpy (cbCaption, pcDesc);
else // von zugehöriger ClassProperty unseren Namen besorgen
GetPropInfo (cbCaption, sizeof(cbCaption), NULL);
// zugehörigen ConfigDialog (PropertyPage(s)) anlegen
DELETE_OBJ (m_pRegOperDlg); // evtl. vorherigen freigeben
m_pRegOperDlg = CRegardOperatDlg::CreateInstance (ResID(IDD_REGOPERATPROPACT, pRF),
cbCaption, this, m_caSelInfo, *pRF);
if (NULL == m_pRegOperDlg) _com_issue_error (E_OUTOFMEMORY);
if (!IsNoShow())
{
// Seite hinzufügen, wenn selbige angezeigt werden soll
HPROPSHEETPAGE hPSP = m_pRegOperDlg -> CreatePage();
if (NULL == hPSP) return E_HANDLE;
if (!(*lpfnAddPage) (hPSP, lParam))
return E_UNEXPECTED;
}
// Initialisierungsdaten für den Dialog wurden von Load() bereitgestellt, konnten aber
// noch nicht an diesen weitergereicht werden
if (m_bHasInitData)
{
// Initialisierungsdaten jetzt an den Dialog weiterreichen
HRESULT hr = m_pRegOperDlg->SetSelectedInfo (&m_caSelInfo, IsNoShow());
if (FAILED(hr)) _com_issue_error(hr);
}
if (NULL != puiCnt)
*puiCnt = IsNoShow() ? 0 : 1; // "1" ist die Anzahl der einzuhängenden Pages
}
catch (_com_error& e)
{
DELETE_OBJ (m_pRegOperDlg);
if (puiCnt) *puiCnt = 0;
return _COM_ERROR (e);
}
return S_OK;
} // AddConfigPages
HRESULT CAddFunctionDlg::SetTemplatePieces()
{
HRESULT hr = NOERROR;
CTemplateManagement *pTM = NULL;
BOOL fDelete = false;
try
{
// Wenn Notification, dann alle Funktionselemente aus diesem Item holen
if (1 == m_chckNotification.GetCheck())
{ // Istein Text im EditCtrl ?
CString str;
m_cbxNotification.GetWindowText(str);
if (str.IsEmpty()) _com_issue_error(E_INVALIDARG);
// Wenn je, liefere den Index
int iFind = m_cbxNotification.FindString(-1, str);
if (CB_ERR == iFind) _com_issue_error(E_FAIL);
// Den Templtemenager geben lassen
DWORD dw = m_cbxNotification.GetItemData(iFind);
if (CB_ERR == dw) _com_issue_error(E_FAIL);
pTM = (CTemplateManagement *)dw;
}
else
{
fDelete = true;
THROW_FAILED_HRESULT(MakeTemplate(&pTM));
}
char str [MAXSTRLENGTH]; *str = '\0';
char strType[MAXSTRLENGTH]; *strType = '\0';
char strPar [MAXSTRLENGTH]; *strPar = '\0';
char strName[MAXSTRLENGTH]; *strName = '\0';
char strComment[MAXSTRLENGTH]; *strComment = '\0';
THROW_FAILED_HRESULT(pTM -> GetComment(strComment, MAXSTRLENGTH));
THROW_FAILED_HRESULT(pTM -> GetDeclaration(str, MAXSTRLENGTH));
THROW_FAILED_HRESULT(pTM -> GetParams(strPar, MAXSTRLENGTH));
THROW_FAILED_HRESULT(pTM -> GetName(strName, MAXSTRLENGTH));
THROW_FAILED_HRESULT(pTM -> GetType(strType, MAXSTRLENGTH));
m_strTyp = strType;
m_strParams = strPar;
m_strDeclaration = str;
m_strName = strName;
m_strComment = strComment;
}
catch (_com_error& e)
{
hr = _COM_ERROR(e);
}
if (fDelete) DELETE_OBJ(pTM);
return hr;
}
// --------------------------------------------------------------------------------------------
// Toolbar für die Bildung von Konstruktionshilfslinien aus TRiAS entfernen
HRESULT CGeoEditExtension::RemoveDesignToolbar (void)
{
try {
WTRiASBarContainer BarCont (m_pXtnSite);
ResString strCap (ResID (IDS_DESIGNTOOLCAPTION, &RF()), 128);
// ToolBar beseitigen
return BarCont -> DeleteTRiASBar (strCap);
} catch (_com_error &hr) {
return _COM_ERROR(hr);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
// Ermittlung des Startindex lStartInd entsprechend dem vorgegebenen RefLine-Modus
HRESULT CGeoEditExtension::GetStartIndex (long lONr, RefLine rfLine, IEnumLONG* pEnumIn,
long& lStartInd)
{
WObjektGeometrie wObj; // ObjektGeometrie des lONr-Objektes
try
{
WInitObjektGeometrie wIObj (CLSID_ObjektGeometrie); // throws_com_error
THROW_FAILED_HRESULT (wIObj->InitObjGeometry (lONr));
wObj = wIObj;
}
catch (_com_error& e)
{
return _COM_ERROR (e);
}
KoOrd* plXK; KoOrd* plYK;
long* plCnt; // Anzahl der Stützpunkte in den Konturen
wObj->GetX ((void**)&plXK);
wObj->GetY ((void**)&plYK);
wObj->GetLPCnt (&plCnt);
switch (rfLine)
{
case EDIT_RECTANGULAR: // gemeinsame Strecke zu Objekten der lONr-Objektklasse, die
// schon rechtwinklig gemacht wurden
if (S_OK != CommonLineWithRectObject (lONr, plXK, plYK, plCnt[0], lStartInd))
LongestLine (plXK, plYK, plCnt[0], lStartInd);
break;
case EDIT_COMMON: // gemeinsame Strecke zu Objekten vorgebbarer Objektklassen
if (pEnumIn && // besagte Objektklassen sind tatsächlich vorgegeben
S_OK == CommonLine (lONr, plXK, plYK, plCnt[0], pEnumIn, lStartInd))
break;
case EDIT_LONGEST: // die längste Strecke
LongestLine (plXK, plYK, plCnt[0], lStartInd);
break;
case EDIT_SOUTHERN: // die südlichste Strecke
SouthernmostLine (plXK, plYK, plCnt[0], lStartInd);
break;
}
return S_OK;
} // GetStartIndex
// --------------------------------------------------------------------------------------------
// die längste gemeinsame pComCont-Konturstrecke feststellen und Anfangs- sowie Endpunkt
// (x0,y0) bzw. (x1,y1) zurückgeben
HRESULT CGeoEditExtension::GiveLongestLine (IEnumLONG* pComCont, KoOrd& x0, KoOrd& y0,
KoOrd& x1, KoOrd& y1)
{
_ASSERTE (pComCont != NULL);
WObjektGeometrie wObj; // ObjektGeometrie und
long lONr, lCnt; // Parameter des lONr-Objektes
KoOrd* plXK; KoOrd* plYK;
long lMaxLength = -1; // Startwert für maximale Länge
try
{
WInitObjektGeometrie wIObj (CLSID_ObjektGeometrie);
for (pComCont->Reset(); S_OK == pComCont->Next (1, &lONr, NULL); )
{
_ASSERTE (lONr != 0);
_ASSERTE (lONr != -1);
THROW_FAILED_HRESULT (wIObj->InitObjGeometry (lONr));
wObj = wIObj;
wObj->GetCnt (&lCnt);
wObj->GetX ((void**)&plXK);
wObj->GetY ((void**)&plYK);
for (long j = 0; j < lCnt-1; j++)
{
long lLength = DtoL (AbstandPktPktE (plXK[j], plYK[j], plXK[j+1], plYK[j+1]));
if (lLength > lMaxLength)
{
lMaxLength = lLength;
x0 = plXK[j];
y0 = plYK[j];
x1 = plXK[j+1];
y1 = plYK[j+1];
}
} // for
} // for
}
catch (_com_error& e)
{
return _COM_ERROR (e);
}
return S_OK;
} // GiveLongestLine
STDMETHODIMP CToolBarButton::UpdateUI (DTRiASCmdUI *pICmdUI)
{
if (NULL == (IUnknown *)m_EvtSink) return E_UNEXPECTED;
// nur einmal gleichzeitig barbeiten
CInterlockedSync Sync (&m_lMutex);
if (!Sync.IsFirst()) return E_FAIL;
// durchzuführende Aktion
ebPARAM Pars[2];
LPVOID cbParam[2];
Pars[0].wType = 0; // no return value
Pars[0].szExtType[0] = '\0';
cbParam[0] = NULL;
Pars[1].wType = TYP_APPOBJECT;
strcpy (Pars[1].szExtType, TEXT("ToolBarButton"));
DControlToolBarButton *pITB = (DControlToolBarButton *)this;
pITB -> AddRef(); // BUGBUG: BasicScript ruft Release() nach Routine
cbParam[1] = &pITB;
BSPARAM bs = { Pars, cbParam };
string str = m_strName + TEXT("_Update");
HRESULT hr = m_EvtSink -> FireEvent (str.c_str(), 1, &bs);
// if (S_OK != hr) // nur, wenn kein Erfolg (s.o.)
pITB -> Release(); // jetzt immer (#HK960926)
// in jedem Fall UI selbst richten
try {
// WDTRiASCmdUI DispUI (pICmdUI); // throws hr
BUTTONSTATE rgState;
hr = pITB -> get_State (&rgState);
if (FAILED(hr)) _com_issue_error(hr);
pICmdUI -> put_IsEnabled (rgState & BUTTONSTATE_ENABLED);
pICmdUI -> put_CheckState (rgState & BUTTONSTATE_CHECKED ? 1 : 0);
} catch (_com_error& hr) {
return _COM_ERROR(hr);
}
return hr;
}
STDMETHODIMP CTextSearchEngine::Load(LPSTREAM pStm)
{
if (m_fIsInitialized)
return E_UNEXPECTED; // already initialized with InitNew
HRESULT hr = CPropertyAction::Load (pStm);
if (FAILED(hr)) return hr;
try {
TX_ASSERT(sizeof(int) == sizeof(long));
THROW_FAILED_HRESULT(LoadLong(pStm, (long &)m_Status.m_fCapital));
THROW_FAILED_HRESULT(LoadLong(pStm, (long &)m_Status.m_fPartialMatch));
THROW_FAILED_HRESULT(LoadLong(pStm, (long &)m_Status.m_fFuzzyMatch));
THROW_FAILED_HRESULT(LoadLong(pStm, (long &)m_Status.m_fUseRegExpr));
m_Status.erase();
THROW_FAILED_HRESULT(LoadString(pStm, m_Status.m_strFindWhat));
CSearchList::size_type lCnt = 0;
THROW_FAILED_HRESULT(LoadLong(pStm, (long &)lCnt));
for (CSearchList::size_type i = 0; i < lCnt; i++) {
os_string str;
THROW_FAILED_HRESULT(LoadString(pStm, str));
m_Status.m_lstFindWhat.push_back(str);
}
THROW_FAILED_HRESULT(LoadString(pStm, m_Status.m_strObjProp));
// folgende Einträge sind optional, da später dazugekommen
if (FAILED(LoadLong(pStm, (long &)m_Status.m_fTestBOB)))
m_Status.m_fTestBOB = false;
if (FAILED(LoadLong(pStm, (long &)m_Status.m_fExistsOnly)))
m_Status.m_fExistsOnly = false;
if (FAILED(LoadLong(pStm, (long &)m_Status.m_fNegate)))
m_Status.m_fNegate = false;
} catch (_com_error& hr) {
return _COM_ERROR(hr);
}
m_fIsInitialized = true;
m_fIsDirty = false;
return S_OK;
}
static HRESULT SavePropSeq (
LPCSTR pcDesc, IPropertyActionSequence *pISeq, IStorage *pIStg)
{
HRESULT hr = E_FAIL;
WStorage IStg (pIStg);
USES_CONVERSION;
if (NULL == pIStg) { // SubStorage anlegen, da es noch nicht existiert
WStorage IRootStg;
if (!DEX_GetProjectStorage(*IRootStg.ppv()))
return E_FAIL;
hr = IRootStg -> CreateStorage (A2OLE(g_cbPropertyChoices),
STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_TRANSACTED,
0L, 0L, IStg.ppi());
if (FAILED(hr)) return hr;
hr = WriteClassStg (IStg, CLSID_PropertyChoice);
if (FAILED(hr)) return hr;
}
try {
WStream IStm;
WPersistStream IPersistStm (pISeq); // throws hr
string strName = MakeStreamName(pcDesc);
// Stream erzeugen
hr = IStg -> CreateStream (A2OLE(strName.c_str()),
STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_CREATE,
0L, 0L, IStm.ppi());
if (FAILED(hr)) _com_issue_error(hr);
hr = OleSaveToStream (IPersistStm, IStm); // und wegschreiben
if (FAILED(hr)) _com_issue_error(hr);
hr = IStm -> Commit (STGC_DEFAULT);
if (FAILED(hr)) _com_issue_error(hr);
} catch (_com_error& hr) {
return _COM_ERROR(hr);
}
hr = IStg -> Commit (STGC_DEFAULT);
if (SUCCEEDED(hr))
DEX_SetDirtyGeoDB(true);
return hr;
}
// --------------------------------------------------------------------------------------------
// Ermittlung des Startindex lStartInd aus einer (evtl.) gemeinsamen Strecke mit einem
// pEnumIn-Objekt; gibt es kein solches Objekt, dann ist der return-Wert "S_FALSE", lStartInd
// ist in diesem Fall unbestimmt
HRESULT CGeoEditExtension::CommonLine (long lONr, KoOrd* plXK, KoOrd* plYK, long lCnt0,
IEnumLONG* pEnumIn, long& lStartInd)
{
if (NULL == pEnumIn) return S_FALSE;
KoOrd x0, y0, x1, y1; // Anfangs- und Endkoordinaten des längsten Konturabschnitts
try
{
ulong ulIdent = 0; // Identifikator für die Ergebnisobjekte (wird hier nicht
// weiter benötigt)
DWORD dwLageAusw = LINAU; // nur die pEnumIn-Flächen für Vergleich heranziehen, die
// sowohl innerhalb als auch außerhalb der lONr-Fläche
// liegen
SpForm sfSForm = SFORM_TEMP; // temporäre Abspeicherung
WEnumLONG wComCont (CLSID_EnumObjectsByNumber); // Objektnummern der gemeinsamen
// Konturabschnitte
if (! m_wObjOper.IsValid()) // (wenn noch nicht, dann) IExtendObjOper-Interface für
{ // CommonContour_ONr() zuschalten
WUnknown wObjOper;
ObjOperInterface (wObjOper.ppi());
m_wObjOper = wObjOper;
}
if (m_wObjOper.IsValid())
m_wObjOper->CommonContour_ONr (lONr, ulIdent, pEnumIn, dwLageAusw, sfSForm,
wComCont.ppi());
else
_ASSERTE (false);
if (0 == wComCont->Count()) // keines der pEnumIn-Objekt hat einen gemeinsamen
return S_FALSE; // Konturabschnitt mit dem lONr-Objekt
// wenn es mindestens 1 gemeinsamen Konturabschnitt gibt, dann die längste Strecke
// bestimmen
THROW_FAILED_HRESULT (GiveLongestLine (wComCont, x0, y0, x1, y1));
VisualCommonContour (wComCont);
}
catch (_com_error& e)
{
return _COM_ERROR (e);
}
return StartIndex (plXK, plYK, lCnt0, x0, y0, x1, y1, lStartInd);
} // CommonLine