bool TextRecherche (HWND hWnd, bool fORWnd)
{
TX_ASSERT(_countof(cbRechClsIds) == _countof(cbRechPropActs));
TX_ASSERT(_countof(cbRechObjWnd) == _countof(cbRechPropActs));
// RecherchePages zu PropertyChoice zusammenfügen
COM_TRY {
WPropertyActionSequence Choice (CLSID_PropertyChoice);
THROW_FAILED_HRESULT(AddSearchEngines (Choice));
WPropertyAction Action (Choice); // throws hr
cbRechPropActs[1] = Action;
// gesamte Sequence erzeugen und abarbeiten
HRESULT hr = S_OK;
if (!fORWnd) {
ResString resCap (IDS_SEARCHCAP, 128);
hr = RunPropertyActionSequence (hWnd, resCap, &calRechClsIds, NULL, NULL, NULL);
} else {
ResString resCap (IDS_SEARCHCAP_OR, 128);
hr = RunPropertyActionSequence (hWnd, resCap, &calRechObjWnd, NULL, NULL, NULL);
}
if (hr == E_ABORT)
return false;
THROW_FAILED_HRESULT(hr);
} COM_CATCH_RETURN(false);
return true;
}
bool CObjGeometrie::AdjustAreaGeometryKontur(int iKontur)
{
// Anfangsindex der zu untersuchenden Kontur bestimmen
_ASSERTE(iKontur < GetKCnt());
long l1st = 0;
for (int iCont = 0; iCont < iKontur; ++iCont)
l1st += GetplCnt(iCont);
// die Koordinate bestimmen, die der Schloßpunkt der neuen Kontur werden soll
double dXStart = X(l1st);
double dYStart = Y(l1st);
long lStart = l1st;
for (long i = l1st+1; i < l1st+GetplCnt(iKontur); ++i) {
if (dXStart < X(i))
continue;
if (dXStart == X(i) && dYStart < Y(i))
continue;
dXStart = X(i);
dYStart = Y(i);
lStart = i;
}
if (l1st == lStart)
return true;
// jetzt die Kontur der Fläche so drehen, das sie mit dem gefundenen
// Schloßpunkt anfängt
COM_TRY {
// Kontur muß geschlossen sein
long lCnt = lStart-l1st;
long lLast = l1st+GetplCnt(iKontur)-1;
_ASSERTE(X(l1st) == X(lLast));
_ASSERTE(Y(l1st) == Y(lLast));
auto_ptr<double> pdX (new double[lCnt]);
auto_ptr<double> pdY (new double[lCnt]);
long lDelta = lLast-lStart; // Keine doppelte Koordinate !
memcpy (pdX.get(), &X(l1st), lCnt*sizeof(double));
memcpy (pdY.get(), &Y(l1st), lCnt*sizeof(double));
memmove (&X(l1st), &X(lStart), lDelta*sizeof(double));
memmove (&Y(l1st), &Y(lStart), lDelta*sizeof(double));
memcpy (&X(l1st+lDelta), pdX.get(), lCnt*sizeof(double));
memcpy (&Y(l1st+lDelta), pdY.get(), lCnt*sizeof(double));
X(lLast) = X(l1st); // Fläche wieder schließen
Y(lLast) = Y(l1st);
} COM_CATCH_RETURN(false);
return true;
}
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;
}
///////////////////////////////////////////////////////////////////////////////
// Zählen, wieviele Datenserver auf der nächsten Seite angezeigt werden sollen
long COpenNewPropertySheet::CountAvailableDataServers (void)
{
long lCount = 0;
// DBEngines über CATID enumerieren
COM_TRY {
// gecachte GUID's verwenden
GUID guid;
_ASSERTE(CFakeMFCExtension::s_DBEngineGUIDs.IsValid());
for (CFakeMFCExtension::s_DBEngineGUIDs.Reset();
S_OK == CFakeMFCExtension::s_DBEngineGUIDs.Next (1, &guid, NULL);
/**/)
{
if (CLASS_E_NOTLICENSED == CountAvailableDataServers (guid, lCount))
CFakeMFCExtension::s_DBEngineGUIDs.RemoveActiveItem();
}
// alles, was nicht (wirklich) gebraucht wird, wieder rauswerfen
::CoFreeUnusedLibraries();
} COM_CATCH_RETURN(0);
return lCount;
}
RETCODE __declspec(dllexport) xp_AsText(SRV_PROC *pSrvProc)
{
#ifdef _DEBUG
// In a debug build, look up the data type name for assistance.
DBCHAR *pdbcDataType = NULL;
int cbDataType = 0;
#endif
COM_TRY {
// Count up the number of input parameters. There should be exactly two.
if (2 != srv_rpcparams(pSrvProc))
return PRINTUSAGE (pSrvProc); // Send error message and return
// Use srv_paraminfo to get data type and length information.
BYTE bType1, bType2;
ULONG cbMaxLen1, cbMaxLen2;
ULONG cbActualLen1, cbActualLen2;
BOOL fNull1, fNull2;
// check 1st parameter
if (FAIL == srv_paraminfo(pSrvProc, 1, &bType1, &cbMaxLen1, &cbActualLen1, NULL, &fNull1))
return PRINTERROR(pSrvProc, "srv_paraminfo for parameter 1 failed...");
#ifdef _DEBUG
// A debugging aid. Get the name of the data type of the parameter.
pdbcDataType = srv_symbol(SRV_DATATYPE, (int)bType1, &cbDataType);
#endif
// make sure first parameter is of image datatype (should be geometry)
if (bType1 != SRVIMAGE)
return PRINTUSAGE(pSrvProc);
// check 2nd parameter
if (FAIL == srv_paraminfo(pSrvProc, 2, &bType2, &cbMaxLen2, &cbActualLen2, NULL, &fNull2))
return PRINTERROR(pSrvProc, "srv_paraminfo for parameter 2 failed...");
#ifdef _DEBUG
// A debugging aid. Get the name of the data type of the parameter.
pdbcDataType = srv_symbol(SRV_DATATYPE, (int)bType2, &cbDataType);
#endif
// make sure second parameter is of ntext datatype
if (bType2 != SRVNVARCHAR && bType2 != SRVBIGVARCHAR)
return PRINTUSAGE(pSrvProc);
// make sure second parameter is a return (OUTPUT) parameter
if (!(srv_paramstatus(pSrvProc, 2) & SRV_PARAMRETURN))
return PRINTUSAGE(pSrvProc);
// retrieve geometry
std::auto_ptr<BYTE> Geometry (new BYTE[cbActualLen1]);
if (FAIL == srv_paraminfo(pSrvProc, 1, &bType1, &cbMaxLen1, &cbActualLen1, Geometry.get(), &fNull1))
return PRINTERROR(pSrvProc, "srv_paraminfo(data) for parameter 1 failed...");
// convert geometry to wkt format
CComBSTR bstrWKT;
WUnknown Unk (*(GUID *)Geometry.get());
WPersistMemoryWks PM (Unk);
THROW_FAILED_HRESULT(PM -> Load (Geometry.get() + sizeof(GUID), cbActualLen1 - sizeof(GUID)));
THROW_FAILED_HRESULT(PM -> SaveWkt (&bstrWKT, false));
// set output parameter
ULONG ulLen = 0;
BYTE *pOutData = NULL;
USES_CONVERSION;
if (SRVNVARCHAR == bType2) {
pOutData = (BYTE *)bstrWKT.m_str;
ulLen = min(cbMaxLen2, ULONG(bstrWKT.Length()*sizeof(OLECHAR)));
} else {
pOutData = (BYTE *)OLE2A(bstrWKT);
ulLen = min(cbMaxLen2, ULONG(bstrWKT.Length()));
}
if (FAIL == srv_paramsetoutput(pSrvProc, 2, pOutData, ulLen, FALSE))
return PRINTERROR(pSrvProc, "srv_paramsetoutput for parameter 2 failed...");
srv_senddone(pSrvProc, SRV_DONE_MORE, 0, 0);
} COM_CATCH_RETURN(XP_ERROR);
return XP_NOERROR;
}
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;
}
// Inseln sortieren nach dem Schlosspunkt der am weitesten links unten liegt;
// bei Übereinstimmung in den Schloßpunkten wird der nächste Stützpunkt zum Vergleich
// herangezogen.
// Voraussetzung: Die Insel sind so gedreht, dass der Schlosspunkt links unten liegt
// (#WM021218)
bool CObjGeometrie::AdjustIslands()
{
short iKCnt = GetKCnt();
if (iKCnt <= 2) return true;
long l1st = 0; // erster Stützpunktindex einer Insel
COM_TRY
{
vector <int> piKCnt; // Feld für die Reihenfolge der Inselindizes
vector <long> pl1st; // Feld für die ersten Stützpunktindizes der betreffenden Inseln
piKCnt.resize (iKCnt-1); // Größe der Felder anlegen
pl1st.resize (iKCnt-1);
// die Felder piKCnt[] und pl1st[] füllen
for (int i = 0; i < iKCnt-1; ++i)
{
l1st += GetplCnt(i);
piKCnt.at(i) = i + 1;
pl1st.at(i) = l1st;
}
// die Felder piKCnt[] und pl1st[] sortieren
for (i = 0; i < iKCnt-1; ++i)
for (int ii = i+1; ii < iKCnt-1; ++ii)
{
// zuerst Vergleich der ersten Stützpunkte zweier Inseln
if (X(pl1st.at(i)) < X(pl1st.at(ii)))
continue;
if (X(pl1st.at(i)) == X(pl1st.at(ii)) &&
Y(pl1st.at(i)) < Y(pl1st.at(ii)))
continue;
// sind diese gleich, dann Vergleich der jeweils zweiten Stützpunkte
if (X(pl1st.at(i)) == X(pl1st.at(ii)) &&
Y(pl1st.at(i)) == Y(pl1st.at(ii)) &&
X(pl1st.at(i)+1) < X(pl1st.at(ii)+1))
continue;
if (X(pl1st.at(i)) == X(pl1st.at(ii)) &&
Y(pl1st.at(i)) == Y(pl1st.at(ii)) &&
X(pl1st.at(i)+1) == X(pl1st.at(ii)+1) &&
Y(pl1st.at(i)+1) < Y(pl1st.at(ii)+1))
continue;
swap (piKCnt.at(i), piKCnt.at(ii));
swap (pl1st.at(i), pl1st.at(ii));
}
long lACCnt = GetlCnt() - GetplCnt(0); // Gesamtanzahl der Stützpunkte aller Inseln
auto_ptr<double> pdX (new double[lACCnt]);
auto_ptr<double> pdY (new double[lACCnt]);
l1st = 0; // Index des erstern Stützpunktes für die neue Inselreihenfolge
// die Inseln sortieren
for (i = 0; i < iKCnt-1; ++i)
{
long lInd = pl1st.at(i);
long lKCnt = GetplCnt(piKCnt.at(i)); // Anzahl der Stützpunkte einer Insel
memcpy (pdX.get()+l1st, &X(lInd), lKCnt*sizeof(double));
memcpy (pdY.get()+l1st, &Y(lInd), lKCnt*sizeof(double));
l1st += lKCnt;
}
// Stützpunkte der sortierten Inseln zurückschreiben
memcpy (&X(GetplCnt(0)), pdX.get(), lACCnt*sizeof(double));
memcpy (&Y(GetplCnt(0)), pdY.get(), lACCnt*sizeof(double));
}
COM_CATCH_RETURN(false);
return true;
}
