// Besorgen des Tabellennamens (sofern einer exitiert)
HRESULT DatenBasisObjekt::GetTableName (TABLENAME *pTableName)
{
// Rückgabewerte initialisieren
int iLen = pTableName -> iLen;
pTableName -> pBuffer[0] = '\0';
pTableName -> iLen = 0;
// Objektmenge aus globaler Tabelle lesen
WTRiASObjects Objs;
HRESULT hr = S_OK;
if (FAILED(hr = GetObjectsFromMap (pTableName -> lIdent, Objs)))
return hr;
CComBSTR bstrName;
RETURN_FAILED_HRESULT(hr = Objs -> get_TableName (CLEARED(&bstrName)));
int iToCopy = min ((int)bstrName.Length(), iLen -1);
USES_CONVERSION;
strncpy (pTableName -> pBuffer, OLE2A(bstrName), iToCopy);
pTableName -> pBuffer[iToCopy] = '\0';
pTableName -> iLen = iToCopy;
return hr;
}
bool operator()( WTRiASCS cs )
{
CComBSTR strDescription;
cs->get_Description( CLEARED(strDescription) );
return strDescription == m_strSearch;
}
IMPLEMENT_DEBUG_FUNCENTRY_4(CGDODatabase,get_ObjectsDef,VARIANT, vIndex, VARIANT_BOOL, fCreate, BSTR, Type, ITRiASObjects**, ppIObjectsDef)
{
CHECKOUTPOINTER(ppIObjectsDef);
COM_TRY {
CHECK_INITIALIZED();
WTRiASObjects pTRiASObjects;
CComVariant vItem;
RETURN_FAILED_HRESULT(EnsureObjectsColl());
HRESULT hr = m_pGDOObjectsCollection -> Item (vIndex, CLEARED(vItem));
if (SUCCEEDED(hr))
pTRiASObjects = V_DISPATCH(&vItem);
else if (TRIASDB_E_UNKNOWN_OBJECTS == hr && fCreate) {
WTRiASObjectsCollection pTRiASObjectsCollection;
ERROR_FAILED_HRESULT(m_pGDOObjectsCollection -> QueryInterface (pTRiASObjectsCollection.ppi()), E_FAIL);
ERROR_FAILED_HRESULT(pTRiASObjectsCollection -> Add (V_BSTR(&vIndex), Type, pTRiASObjects.ppi()), E_FAIL);
} else
return hr;
*ppIObjectsDef = pTRiASObjects.detach();
} COM_CATCH;
return S_OK;
}
HRESULT CFastdbFeature::OnChangedName()
{
USES_CONVERSION;
COM_TRY {
// neuen Namen vom Bezugsobjekt besorgen
CComBSTR bstrName;
WTRiASFeature BaseFeat;
THROW_FAILED_HRESULT(m_BaseUnk -> QueryInterface (BaseFeat.ppi()));
THROW_FAILED_HRESULT(BaseFeat -> get_Name(CLEARED(&bstrName)))
// zugehöriges DB-Objekt referenzieren
LONG lCursor (GetPropertyFrom (BaseFeat, g_cbFeatureCursor, 0L));
if (0 != lCursor) { // Objekt fertig initialisiert
dbCursor<CDBFeatureDesc> cursor (GetRelatedDatabase(GetUnknown()), dbCursorForUpdate);
CDBFeatureDesc *pFeatDesc = cursor.at (dbReference<CDBFeatureDesc>(oid_t(lCursor)));
if (NULL == pFeatDesc || cursor.isEmpty())
THROW_FAILED_HRESULT(FASTDB_E_FEATURE_BADREFERENCE);
cursor -> m_pName = OLE2A(bstrName);
cursor.update();
}
} COM_CATCH;
return S_OK;
}
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;
}
///////////////////////////////////////////////////////////////////////////////
// aus TRiASCS Wkt erzeugen
STDMETHODIMP CTRiASCSWktService::ExportAsWkt(WKTFORMAT rgFormat, ITRiASCS *pCS, BSTR *pbstrWktCS)
{
CHECKOUTPOINTER(pbstrWktCS);
CHECKINPOINTER(pCS);
if (WKTFORMAT_OgcWkt != rgFormat)
return E_INVALIDARG;
COM_TRY {
// ist's einprojektives System
CComBSTR bstrWkt;
CComBSTR bstr;
TRIASCSTYPE rgType;
WTRiASCSPCS PCS;
THROW_FAILED_HRESULT(pCS -> get_CoordSystemType(&rgType));
if (tcsCS_Projected == rgType) {
bstrWkt.Append(L"PROJCS[\"");
// Namen der Projektion ausgeben
THROW_FAILED_HRESULT(RetrieveProjectedName (pCS, CLEARED(&bstr)));
bstrWkt.Append(bstr);
}
// Datumsbeschreibung ausgeben
WTRiASCSGCS GCS;
THROW_FAILED_HRESULT(pCS -> get_GeographicCS(GCS.ppi()));
THROW_FAILED_HRESULT(ExportGeographicSystem(GCS, CLEARED(&bstr)));
bstrWkt.Append(bstr);
// ggf. Projektionsparameter ausgeben
if (tcsCS_Projected == rgType) {
_ASSERTE(PCS.IsValid());
THROW_FAILED_HRESULT(ExportProjectionParams(PCS, CLEARED(&bstr)));
bstrWkt.Append(bstr);
bstrWkt.Append(L"]");
}
// Resultat liefern
*pbstrWktCS = bstrWkt.Detach();
} COM_CATCH;
return S_OK;
}
HRESULT COpenNewPropertySheet::HandleConnectString (void)
{
if (!m_ExtPages && !m_Pairs)
return S_FALSE;
USES_CONVERSION;
CComBSTR bstrPairs;
RETURN_FAILED_HRESULT(m_Pairs -> get_ComposedData (CComBSTR(g_cbPattern), CLEARED(&bstrPairs)));
m_Params.m_strConnect = OLE2A(bstrPairs);
return S_OK;
}
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;
}
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;
}
// ----------------------------------------------------------------------------
// Helptext_ToolBarButton_propget
// ----------------------------------------------------------------------------
void Helptext_ToolBarButton_propget (ebHTHREAD hThread, int iNumArgs, ebARGS lpArgs)
{
BASIC_OP_TRACE(Helptext_ToolBarButton_propget);
// Test for typemismatch
if (g_fDebugScript && isTypeMismatch (hThread, lpArgs, RTTI_ToolBarButton))
return;
CComBSTR bstr;
HRESULT hr = ((DControlToolBarButton *)ebGetObject (lpArgs, 1)) -> get_HelpText (CLEARED(&bstr));
if (FAILED(hr)) {
ebSetString (lpArgs, 0, NULL);
return;
}
USES_CONVERSION;
ebSetString (lpArgs, 0, ebCreateString (hThread, OLE2A(bstr)));
}
HRESULT CDispUIOwner::OnSelect (ITRiASBar *pIBar, UINT uiID, LPSTR pBuffer, ULONG ulLen, ULONG *pulWritten)
{
if (/*NULL == pIBar ||*/ NULL == pBuffer || 0 == ulLen)
return E_POINTER;
CComBSTR bstrDesc;
HRESULT hr = m_TargetUIOwner -> GetDescription (uiID, CLEARED(&bstrDesc));
if (SUCCEEDED(hr)) {
USES_CONVERSION;
string strDesc (!bstrDesc ? g_cbNil : OLE2A(bstrDesc));
if (NPOS == strDesc.find('\n'))
strDesc += "\n" + strDesc;
strcpy (pBuffer, strDesc.c_str());
if (pulWritten)
*pulWritten = strlen (pBuffer);
return NOERROR;
}
return hr;
}
// Lesen der Metadaten für eine Objektmenge
HRESULT DatenBasisObjekt::GetPBDDataMerkmal (HPROJECT hPr, PBDDATA *pData)
{
TX_ASSERT(IsTRiASDBBased());
VARIANT_BOOL fNameIsDefault = VARIANT_TRUE;
USES_CONVERSION;
{
// wenns ein Ansichtsmerkmal sein soll, dann einfach wieder raus
if ((sizeof(PBDMERKMAL) == pData -> dwSize || sizeof(PBDMERKMALEX) == pData -> dwSize) &&
MPViewFeature == (((PBDMERKMAL *)pData) -> ipbdMTyp & 0x7F))
{
return HRESULT_FROM_ERRCODE(WC_NOTFOUND);
}
// Objekteigenschaft aus globaler Tabelle lesen
WTRiASFeature Feat;
HRESULT hr = S_OK;
if (FAILED(hr = GetFeatureFromMap (pData -> pbdCode, Feat)))
return hr;
// Testen, ob das gefundene Feature zur geforderten Datenquelle paßt
if (HACTCONNECTION != hPr) {
HPROJECT hPrTarget = NULL;
RETURN_FAILED_HRESULT(GetDatabaseHandle (Feat, &hPrTarget));
if (hPrTarget != hPr) // MCode aus anderer Datenquelle
return HRESULT_FROM_ERRCODE(WC_NOTFOUND);
}
// Namen lesen und in Rückgabestruktur setzen
CComBSTR bstr;
RETURN_FAILED_HRESULT(Feat -> get_Name (CLEARED(&bstr)));
fNameIsDefault = GetPropertyFrom (Feat, g_cbNameIsDefault, VARIANT_FALSE);
char *pStr = OLE2A(bstr);
if (pData -> pbdKTextLen > 0 && NULL != pData -> pbdKText) {
if (pStr) {
int iLen = strlen (pStr);
iLen = min(iLen, pData -> pbdKTextLen-1);
strncpy (pData -> pbdKText, pStr, iLen);
pData -> pbdKText[iLen] = '\0';
pData -> pbdKTextLen = iLen;
} else {
*pData -> pbdKText = '\0';
pData -> pbdKTextLen = 0;
}
} else
pData -> pbdKTextLen = (NULL != pStr) ? strlen(pStr)+1 : 0; // benötigte Buffergröße liefern
// BeschreibungsInfo lesen und in Rückgabestruktur setzen
CComBSTR bstrLT;
if (SUCCEEDED(Feat -> get_Description (CLEARED(&bstrLT)))) {
// möglicherweise wird 'get_Description' nicht unterstützt
char *pStr = OLE2A(bstrLT);
if (pData -> pbdLTextLen > 0 && NULL != pData -> pbdLText) {
if (pStr) {
int iLen = strlen (pStr);
iLen = min(iLen, pData -> pbdLTextLen-1);
strncpy (pData -> pbdLText, pStr, iLen);
pData -> pbdLText[iLen] = '\0';
pData -> pbdLTextLen = iLen;
} else {
*pData -> pbdLText = '\0';
pData -> pbdLTextLen = 0;
}
} else
pData -> pbdLTextLen = (NULL != pStr) ? strlen(pStr)+1 : 0; // benötigte Buffergröße liefern
} else
pData -> pbdLTextLen = 0;
// evtl. zusätzliche Infos liefern
if (sizeof(PBDMERKMAL) == pData -> dwSize || sizeof(PBDMERKMALEX) == pData -> dwSize) {
PBDMERKMAL *pPbdM = (PBDMERKMAL *)pData;
FEATURETYPE rgType = FEATURETYPE_Unknown;
pPbdM -> ipbdMTyp = 'a'; // Objektmerkmal
if (SUCCEEDED(Feat -> get_Type (&rgType))) {
// Typ der Objekteigenschaft festellen
switch (VT_FROM_DATATYPE(rgType)) {
case VT_I4:
case VT_I2:
case VT_I1:
case VT_INT:
case VT_UI4:
case VT_UI2:
case VT_UI1:
case VT_UINT:
case VT_BOOL:
case VT_ERROR:
pPbdM -> ipbdMTyp = 'i';
break;
case VT_R4:
case VT_R8:
case VT_DATE:
pPbdM -> ipbdMTyp = 'f';
break;
default:
break; // VT_BSTR --> 'a'
}
// zusätzliche
if (rgType & FEATURETYPE_System)
pPbdM -> ipbdMTyp |= PBDMERKMAL_SYSTEMFLAG;
if (rgType & FEATURETYPE_ReadOnly)
pPbdM -> ipbdMTyp |= PBDMERKMAL_READONLY;
}
// Platzbedarf der Objekteigenschaft feststellen
long lLen = 0;
if (SUCCEEDED(Feat -> get_Length (&lLen)))
pPbdM -> ipbdMLen = lLen;
else
pPbdM -> ipbdMLen = _MAX_PATH; // doch recht willkürlich
}
}
return fNameIsDefault ? S_FALSE : S_OK;
}
// Lesen der Metadaten für eine Objektmenge
HRESULT DatenBasisObjekt::GetPBDDataIdent (HPROJECT hPr, PBDDATA *pData)
{
TX_ASSERT(IsTRiASDBBased());
VARIANT_BOOL fNameIsDefault = VARIANT_TRUE;
USES_CONVERSION;
{
// Objektmenge aus globaler Tabelle lesen
WTRiASObjects Objs;
HRESULT hr = S_OK;
if (FAILED(hr = GetObjectsFromMap (pData -> pbdCode, Objs)))
return hr;
// Testen, ob das gefundene Objektmenge zur geforderten Datenquelle paßt
if (HACTCONNECTION != hPr) {
HPROJECT hPrTarget = NULL;
RETURN_FAILED_HRESULT(GetDatabaseOrProjectHandle (Objs, &hPrTarget));
if (hPrTarget != hPr) // Ident aus anderer Datenquelle
return HRESULT_FROM_ERRCODE(WC_NOTFOUND);
}
// Namen lesen und in Rückgabestruktur setzen
CComBSTR bstr;
RETURN_FAILED_HRESULT(Objs -> get_Name (CLEARED(&bstr)));
fNameIsDefault = GetPropertyFrom (Objs, g_cbNameIsDefault, VARIANT_TRUE);
char *pStr = OLE2A(bstr);
if (pData -> pbdKTextLen > 0 && NULL != pData -> pbdKText) {
if (pStr) {
int iLen = strlen (pStr);
iLen = min(iLen, pData -> pbdKTextLen-1);
strncpy (pData -> pbdKText, pStr, iLen);
pData -> pbdKText[iLen] = '\0';
pData -> pbdKTextLen = iLen;
} else {
*pData -> pbdKText = '\0';
pData -> pbdKTextLen = 0;
}
} else
pData -> pbdKTextLen = (NULL != pStr) ? strlen(pStr)+1 : 0; // benötigte Buffergröße liefern
// BeschreibungsInfo lesen und in Rückgabestruktur setzen
CComBSTR bstrLT;
if (SUCCEEDED(Objs -> get_Description (CLEARED(&bstrLT)))) {
// möglicherweise wird 'get_Description' nicht unterstützt
char *pStr = OLE2A(bstrLT);
if (pData -> pbdLTextLen > 0 && NULL != pData -> pbdLText) {
if (pStr) {
int iLen = strlen (pStr);
iLen = min(iLen, pData -> pbdLTextLen-1);
strncpy (pData -> pbdLText, pStr, iLen);
pData -> pbdLText[iLen] = '\0';
pData -> pbdLTextLen = iLen;
} else {
*pData -> pbdLText = '\0';
pData -> pbdLTextLen = 0;
}
} else
pData -> pbdLTextLen = (NULL != pStr) ? strlen(pStr)+1 : 0; // benötigte Buffergröße liefern
} else
pData -> pbdLTextLen = 0;
}
return fNameIsDefault ? S_FALSE : S_OK;
}
HRESULT CTRiASMIObjectsCollection::CreateObject (
VARIANT NameOrHandle, DWORD dwType, const CLSID *pClsId, ITRiASObjects **ppIObjs)
{
_ASSERTE(NULL != pClsId);
if (NULL == pClsId)
return E_POINTER;
// diverse Vorbereitungen treffen
WDispatch App;
WDispatch Parent;
WTRiASObjectsCollection BaseObjs;
RETURN_FAILED_HRESULT(m_BaseUnk -> QueryInterface (BaseObjs.ppi()));
RETURN_FAILED_HRESULT(BaseObjs -> get_Application (App.ppi())); // für neue Objektklasse
RETURN_FAILED_HRESULT(BaseObjs -> get_Parent(Parent.ppi()));
// ZugriffsHandle/Namen oder OKS aus NameOrHandle bestimmen
LONG lHandle = 0;
CComVariant v;
bool fHasName = false;
bool fHasOKS = false;
CComBSTR bstrApp, bstrOKS;
if (VT_BSTR != V_VT(&NameOrHandle) && SUCCEEDED(v.ChangeType (VT_I4, &NameOrHandle)))
lHandle = V_I4(&v);
else if (SUCCEEDED(v.ChangeType(VT_BSTR, &NameOrHandle))) {
// feststellen, ob es ein OKS ist, evtl. Namen isolieren
if (StringIsOKS(V_BSTR(&v), CLEARED(&bstrOKS), CLEARED(&bstrApp))) {
if (bstrOKS.Length() > 0)
fHasOKS = true;
} else
bstrApp = V_BSTR(&v);
if (bstrApp.Length() > 0)
fHasName = true;
} else
return E_INVALIDARG;
// Objektklasse aus Handle/Name/OKS erzeugen
HRESULT hr = S_OK;
COM_TRY {
WTRiASObjects Objs (*pClsId); // zu liefernde Objektklasse erzeugen
THROW_FAILED_HRESULT(Objs -> put_Parent (Parent));
#pragma TODO("Neue Objektklasse in Datenbank erzeugen.")
if (fHasName) // S_FALSE heißt: Objekt existiert bereits
RETURN_FAILED_HRESULT(Objs -> put_Name (bstrApp));
if (fHasOKS)
RETURN_FAILED_HRESULT(Objs -> put_OKS (bstrOKS));
// wenn Objektklasse bereits zu dieser Menge von Objektklassen gehört, dann liefert _Add den Wert S_FALSE
hr = BaseObjs -> _Add (Objs, VARIANT_TRUE);
if (SUCCEEDED(hr) && NULL != ppIObjs)
*ppIObjs = Objs.detach(); // evtl. neue/gefundene Objektklasse liefern
} COM_CATCH;
return hr;
}
BOOL CPpgSelDataSource::FillDataSources()
{
LONG lCntOpen = 0;
int iSelItem = CB_ERR;
USES_CONVERSION;
COM_TRY {
// alle Connections durchgehen und feststellen:
// aktuelle Connection, ob beschreibbare Connection existiert
WTRiASProject Prj;
if (!DEX_GetActiveProjectPtr (*Prj.ppi()))
_com_issue_error(E_UNEXPECTED); // snh
WTRiASConnections Conns;
long lCnt = 0;
THROW_FAILED_HRESULT(Prj -> get_Connections (Conns.ppi()));
THROW_FAILED_HRESULT(Conns -> get_Count(&lCnt));
CComboEntryMap Entries;
for (long i = 1; i <= lCnt; i++) {
CComVariant vIndex (i);
WTRiASConnection Conn;
THROW_FAILED_HRESULT(Conns -> Item (vIndex, Conn.ppi()));
CONNECTSTATUS rgStatus = CONNECTSTATUS_Closed;
THROW_FAILED_HRESULT(Conn -> get_Status (&rgStatus));
if (CONNECTSTATUS_Opened == rgStatus) {
CONNECTMODE rgRW = CONNECTMODE_OpenReadOnly;
THROW_FAILED_HRESULT(Conn -> get_Mode (&rgRW));
if (CONNECTMODE_OpenReadWrite ==
CONNECTMODE(rgRW & ~CONNECTMODE_ResolutionFlags))
{
// R/W geöffnet
CComBSTR bstrName;
THROW_FAILED_HRESULT(Conn -> get_Name (CLEARED(bstrName)));
// wenns die aktuelle ist, dann den Index speichern
WTRiASDatabase DBase;
HPROJECT lHandle = 0;
THROW_FAILED_HRESULT(Conn -> get_Database(DBase.ppi()));
THROW_FAILED_HRESULT(DBase -> get_Handle ((INT_PTR *)&lHandle));
Entries.insert(CComboEntryMap::value_type(OLE2A(bstrName),
pair<DWORD, HPROJECT>(datasource_icon::GetBitmapIndex(lHandle), lHandle)));
}
}
}
// jetzt in ComboBox einfügen (in alphabetischer Reihenfolge)
CComboEntryMap::iterator end = Entries.end();
for (CComboEntryMap::iterator it = Entries.begin(); it !=end; ++it) {
COMBOBOXEXITEM item;
item.mask = CBEIF_IMAGE|CBEIF_SELECTEDIMAGE|CBEIF_LPARAM|CBEIF_TEXT;
item.iItem = -1;
item.pszText = (LPTSTR)(LPCTSTR)(*it).first;
item.iImage = item.iSelectedImage = (*it).second.first;
item.lParam = (LPARAM)(*it).second.second; // ProjectHandle zuordnen
m_cbDataSources.InsertItem(&item);
lCntOpen++;
if ((*it).second.second == m_pParent->m_hPr)
iSelItem = item.iItem;
}
} COM_CATCH_RETURN(FALSE);
_ASSERTE(0 != lCntOpen);
if (0 == lCntOpen) // keine Datenquellen vorhanden
return FALSE;
if (CB_ERR != iSelItem)
m_cbDataSources.SetCurSel(iSelItem);
else
m_cbDataSources.SetCurSel(0);
return TRUE;
}
