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; }