public CMoveablePointForLineSegment(CMapDatabase database, CGPSLine line, CGPSLineSegment segment)
: base(database, segment.PointDestination)
{
m_segment = segment;
m_line = line;
m_listeItems.AddRange(line.FindMapItems(database));
}
//--------------------------------------------------------------
public override IEnumerable <IMapItem> Delete(CMapDatabase database)
{
if (m_line != null)
{
return(m_line.DetailLigne.DeleteStartPoint(database));
}
return(new IMapItem[0]);
}
public CMoveablePointForGPSPoint(CMapDatabase database, CGPSPoint pt)
: base(database, new SLatLong(pt.Latitude, pt.Longitude))
{
m_gpsPoint = pt;
foreach (IMapItem item in pt.FindMapItems(database))
{
m_mapItem = item;
}
}
public CMoveablePointForLineStart(CMapDatabase database, CGPSLine line)
: base(database, line.DetailLigne.PointDepart)
{
m_line = line;
IEnumerable <IMapItem> items = line.FindMapItems(database);
if (items.Count() > 0)
{
m_mapItem = items.ElementAt(0);
}
}
//---------------------------------------------------------------------------
public IEnumerable <IMapItem> FindMapItems(CMapDatabase database)
{
CMapItemPoint mapItem = database.FindItemFromTag(this) as CMapItemPoint;
if (mapItem != null)
{
return new IMapItem[] { mapItem }
}
;
return(new IMapItem[0]);
}
//-----------------------------------------------------------------
public IEnumerable <CMoveablePoint> GetMoveablePoints(CMapDatabase database)
{
List <CMoveablePoint> lstPoints = new List <CMoveablePoint>();
CGPSLineTrace trace = DetailLigne;
lstPoints.Add(new CMoveablePointForLineStart(database, this));
foreach (CGPSLineSegment segment in trace.Segments)
{
lstPoints.Add(new CMoveablePointForLineSegment(database, this, segment));
}
return(lstPoints.AsReadOnly());
}
//--------------------------------------------------------------------
public IEnumerable <CMapLayer> GenereItems(CMapDatabase database)
{
List <CMapLayer> lstLayers = new List <CMapLayer>();
CMapLayer layer = database.GetLayer(IdUniversel, true);
layer.ClearItems();
lstLayers.Add(layer);
foreach (IElementDeGPSCarte element in ElementsDeCarte)
{
element.CreateMapItems(layer);
}
return(lstLayers);
}
//---------------------------------------------------------------------------
public IEnumerable <IMapItem> FindMapItems(CMapDatabase database)
{
CGPSLineTrace trace = DetailLigne;
List <IMapItem> lstPaths = new List <IMapItem>();
foreach (CGPSLineSegment segment in trace.Segments)
{
CMapItemPath path = database.FindItemFromTag(segment) as CMapItemPath;
if (path != null)
{
lstPaths.Add(path);
}
}
return(lstPaths.AsReadOnly());
}
//---------------------------------------------------------
public IEnumerable <IMapItem> DeleteSegment(CMapDatabase database, CGPSLineSegment segment)
{
if (segment != null && m_listeSegments.Count() > 1)
{
IMapItem item = database.FindItemFromTag(segment);
m_listeSegments.Remove(segment);
if (item != null)
{
return new IMapItem[] { item }
}
;
}
return(new IMapItem[0]);
}
}
//------------------------------------
public void SetMapDatabase(CMapDatabase database)
{
m_gMap.SuspendDrawing();
ClearDatabaseObjects();
foreach (CMapLayer layer in database.Layers)
{
if (layer.IsVisible)
{
foreach (IMapItem item in layer.Items)
{
AddMapItem(item);
}
}
}
m_gMap.ResumeDrawing();
}
//---------------------------------------------------------
public IEnumerable <IMapItem> DeleteStartPoint(CMapDatabase database)
{
if (m_listeSegments.Count() > 1)
{
//Trouve l'item correspondant au segment 0
CGPSLineSegment segment = m_listeSegments.ElementAt(0);
IMapItem item = database.FindItemFromTag(segment);
PointDepart = segment.PointDestination;
m_listeSegments.RemoveAt(0);
if (item != null)
{
return new IMapItem[] { item }
}
;
}
return(new IMapItem[0]);
}
//---------------------------------------------------------------------------
public IEnumerable <IMapItem> UpdateMapItems(CMapDatabase database, List <IMapItem> itemsToDelete)
{
CMapItemPoint mapItem = database.FindItemFromTag(this) as CMapItemPoint;
if (mapItem != null)
{
CMapLayer layer = mapItem.Layer;
//Vérifie le type du mapItem
if (TypePoint != null && TypePoint.Image != null)
{
if (!(mapItem is CMapItemImage))
{
itemsToDelete.Add(mapItem);
mapItem.Layer.RemoveItem(mapItem);
layer.Database.AddImage(TypePoint.IdUniversel, TypePoint.Image);
mapItem = new CMapItemImage(layer, Latitude, Longitude, TypePoint.IdUniversel);
}
((CMapItemImage)mapItem).ImageId = TypePoint.IdUniversel;
}
else
{
if (!(mapItem is CMapItemSimple))
{
itemsToDelete.Add(mapItem);
mapItem.Layer.RemoveItem(mapItem);
mapItem = new CMapItemSimple(layer, Latitude, Longitude, MarkerType);
}
((CMapItemSimple)mapItem).SimpleMarkerType = MarkerType == EMapMarkerType.none?EMapMarkerType.blue_dot:MarkerType;
}
mapItem.Tag = this;
mapItem.Latitude = Latitude;
mapItem.Longitude = Longitude;
mapItem.ToolTip = Libelle;
mapItem.PermanentToolTip = PermanentToolTip;
return(new IMapItem[] { mapItem });
}
return(new IMapItem[0]);
}
//---------------------------------------------------------------------------
public IEnumerable <IMapItem> UpdateMapItems(CMapDatabase database, List <IMapItem> itemsToDelete)
{
CGPSLineTrace trace = DetailLigne;
SLatLong lastPoint = trace.PointDepart;
List <IMapItem> lstPaths = new List <IMapItem>();
foreach (CGPSLineSegment segment in trace.Segments)
{
CMapItemPath path = database.FindItemFromTag(segment) as CMapItemPath;
if (path != null)
{
path.Points = new SLatLong[] { lastPoint, segment.PointDestination };
path.LineColor = segment.Couleur;
path.LineWidth = segment.Width;
path.Tag = segment;
path.ToolTip = segment.Libelle;
lstPaths.Add(path);
lastPoint = segment.PointDestination;
}
}
return(lstPaths.AsReadOnly());
}
//-------------------------------------------------
public CResultAErreur FillMapDatabase(
object objetSource,
CMapDatabase database,
CContexteDonnee ctxDonnee)
{
CResultAErreur result = CResultAErreur.True;
if (objetSource != null)
{
AssureVariablesSysteme();
SetValeurChamp(c_strIdVariableObjetSource, objetSource);
}
foreach (IMapItemGenerator generateur in ItemsGenerators)
{
result = generateur.GenereItems(database, ctxDonnee);
if (!result)
{
return(result);
}
}
return(result);
}
//---------------------------------------------------------------------------
public IEnumerable <CMoveablePoint> GetMoveablePoints(CMapDatabase database)
{
return(new CMoveablePoint[] { new CMoveablePointForGPSPoint(database, this) });
}
//-------------------------------------------------------------
public CResultAErreur GenereItems(CMapDatabase database, CContexteDonnee ctxDonnee)
{
CResultAErreur result = CResultAErreur.True;
//Calcule les éléments à générer
if (Filtre == null || Filtre.TypeElements == null)
{
return(result);
}
if (FormuleLatitude1 == null || FormuleLongitude1 == null || FormuleLatitude2 == null || FormuleLatitude2 == null)
{
return(result);
}
result = Filtre.GetFiltreData();
if (!result)
{
return(result);
}
CFiltreData filtre = result.Data as CFiltreData;
CListeObjetsDonnees lstObjets = new CListeObjetsDonnees(ctxDonnee, Filtre.TypeElements);
lstObjets.Filtre = filtre;
lstObjets.ModeSansTri = true;
CMapLayer layer = null;
if (lstObjets.Count > 0)
{
layer = database.GetLayer(Generator.LayerId, true);
}
else
{
return(result);
}
Dictionary <int, double> dicValeursLatitude = new Dictionary <int, double>();
Dictionary <int, double> dicValeursLongitude = new Dictionary <int, double>();
foreach (object obj in lstObjets)
{
DateTime dt = DateTime.Now;
m_currentGeneratedItem = obj;
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(obj);
double?fLat1 = null;
double?fLong1 = null;
double?fLat2 = null;
double?fLong2 = null;
result = FormuleLatitude1.Eval(ctxEval);
if (result)
{
try
{
fLat1 = Convert.ToDouble(result.Data);
}
catch { }
}
if (fLat1 != null)
{
result = FormuleLongitude1.Eval(ctxEval);
if (result)
{
try
{
fLong1 = Convert.ToDouble(result.Data);
}
catch { }
}
}
if (fLat1 != null && fLong1 != null)
{
result = FormuleLatitude2.Eval(ctxEval);
if (result)
{
try
{
fLat2 = Convert.ToDouble(result.Data);
}
catch { }
}
}
if (fLat1 != null && fLong1 != null && fLat2 != null)
{
result = FormuleLongitude2.Eval(ctxEval);
if (result)
{
try
{
fLong2 = Convert.ToDouble(result.Data);
}
catch { }
}
}
TimeSpan sp = DateTime.Now - dt;
if (obj is CObjetDonnee)
{
//Console.WriteLine("Coord "+((CObjetDonnee)obj).DescriptionElement + " : " + sp.TotalMilliseconds);
}
if (fLat1 != null && fLat2 != null && fLong1 != null && fLong2 != null)
{
foreach (CMapLineDessin mapLineDessin in LinesDessin)
{
if (mapLineDessin.GenereItem(
obj,
fLat1.Value,
fLong1.Value,
fLat2.Value,
fLong2.Value,
layer))
{
break;
}
}
}
sp = DateTime.Now - dt;
if (obj is CObjetDonnee)
{
//Console.WriteLine(((CObjetDonnee)obj).DescriptionElement + " : " + sp.TotalMilliseconds);
}
}
return(result);
}
//---------------------------------------------
public CResultAErreur GenereItems(CMapDatabase database, CContexteDonnee ctxDonnee)
{
CResultAErreur result = CResultAErreur.True;
//Calcule les éléments à générer
DataTable table = Query.GetTable(NomTableSource, m_listeSources);
double? fLastLat = null;
double? fLastLong = null;
CMapLayer layer = database.GetLayer(Generator.LayerId, true);
if (table != null)
{
DataColumn colLat = null;
DataColumn colLong = null;
DataColumn colLib = null;
DataColumn colElt = null;
foreach (DataColumn col in table.Columns)
{
if (col.ColumnName == ChampCleElement)
{
colElt = col;
}
if (col.ColumnName == ChampLatitude)
{
colLat = col;
}
if (col.ColumnName == ChampLibelle)
{
colLib = col;
}
if (col.ColumnName == ChampLongitude)
{
colLong = col;
}
}
if (colLong == null || colLat == null)
{
result.EmpileErreur(I.T("Can not find columns @1 and @2 in data source|20024",
ChampLongitude,
ChampLatitude));
}
Dictionary <object, List <DataRow> > dicRowsParElement = new Dictionary <object, List <DataRow> >();
if (colElt != null)
{
object lastElt = null;
List <DataRow> lstRows = null;
foreach (DataRow row in table.Rows)
{
object v = row[colElt];
if (v != lastElt || lstRows == null)
{
lastElt = v;
if (!dicRowsParElement.TryGetValue(v, out lstRows))
{
lstRows = new List <DataRow>();
dicRowsParElement[v] = lstRows;
}
}
lstRows.Add(row);
}
}
else
{
List <DataRow> lstRows = new List <DataRow>();
foreach (DataRow row in table.Rows)
{
lstRows.Add(row);
}
dicRowsParElement[DBNull.Value] = lstRows;
}
foreach (KeyValuePair <object, List <DataRow> > kv in dicRowsParElement)
{
List <DataRow> lstRows = kv.Value;
List <SLatLong> lstPoints = new List <SLatLong>();
int nNb = kv.Value.Count;
int nIndex = 0;
foreach (DataRow row in kv.Value)
{
try
{
double fLat = Convert.ToDouble(row[colLat]);
double fLong = Convert.ToDouble(row[colLong]);
string strLabel = colLib != null ?row[colLib] as string:null;
if (strLabel == null || strLabel.Length == 0)
{
strLabel = "";
}
bool bPrendre = true;
if (strLabel == "" && fLastLong != null && fLastLat != null && MetresEntrePoints > 0)
{
//contrôle la distance
double fDist = GetGpsDist(fLastLong.Value, fLong, fLastLat.Value, fLat);
bPrendre = fDist >= MetresEntrePoints;
}
if (nIndex == nNb - 1)
{
bPrendre = true;
}
if (bPrendre)
{
fLastLat = fLat;
fLastLong = fLong;
SLatLong pt = new SLatLong(fLat, fLong);
lstPoints.Add(pt);
}
if (strLabel != null && strLabel.Trim().Length > 0)
{
CMapItemSimple item = new CMapItemSimple(layer, fLat, fLong, EMapMarkerType.blue_dot);
item.ToolTip = strLabel;
layer.AddItem(item);
}
}
catch { }
}
CMapItemPath path = new CMapItemPath(layer);
path.Points = lstPoints.ToArray();
layer.AddItem(path);
}
}
return(result);
}
//-------------------------------------------------------------
public CResultAErreur GenereItems(CMapDatabase database, CContexteDonnee ctxDonnee)
{
CResultAErreur result = CResultAErreur.True;
//Calcule les éléments à générer
if (Filtre == null || Filtre.TypeElements == null)
{
return(result);
}
if (FormuleLatitude == null || FormuleLongitude == null)
{
return(result);
}
result = Filtre.GetFiltreData();
if (!result)
{
return(result);
}
CFiltreData filtre = result.Data as CFiltreData;
CListeObjetsDonnees lstObjets = new CListeObjetsDonnees(ctxDonnee, Filtre.TypeElements);
lstObjets.Filtre = filtre;
lstObjets.ModeSansTri = true;
CMapLayer layer = null;
if (lstObjets.Count > 0)
{
layer = database.GetLayer(Generator.LayerId, true);
}
else
{
return(result);
}
int?nIdChampLatitude = null;
int?nIdChampLongitude = null;
Dictionary <int, double> dicValeursLatitude = new Dictionary <int, double>();
Dictionary <int, double> dicValeursLongitude = new Dictionary <int, double>();
if (typeof(IObjetDonneeAChamps).IsAssignableFrom(lstObjets.TypeObjets))
{
nIdChampLatitude = GetIdChampOptimFromFormule(FormuleLatitude);
nIdChampLongitude = GetIdChampOptimFromFormule(FormuleLongitude);
List <int> lst = new List <int>();
if (nIdChampLatitude != null)
{
lst.Add(nIdChampLatitude.Value);
}
if (nIdChampLongitude != null)
{
lst.Add(nIdChampLongitude.Value);
}
if (lst.Count > 0)
{
CUtilElementAChamps.ReadChampsCustom(lstObjets, lst.ToArray());
}
DataTable table = ctxDonnee.Tables[((IObjetDonneeAChamps)lstObjets[0]).GetNomTableRelationToChamps()];
if (table != null && (nIdChampLatitude != null || nIdChampLatitude != null))
{
string strCle = ((CObjetDonneeAIdNumerique)lstObjets[0]).GetChampId();
string strFiltre = "";
if (nIdChampLatitude != null)
{
strFiltre = CChampCustom.c_champId + "=" + nIdChampLatitude.Value;
}
if (nIdChampLongitude != null)
{
if (strFiltre.Length > 0)
{
strFiltre += " or ";
}
strFiltre += CChampCustom.c_champId + "=" + nIdChampLongitude.Value;
}
DataRow[] rows = table.Select(strFiltre);
foreach (DataRow row in table.Rows)
{
if ((int)row[CChampCustom.c_champId] == nIdChampLatitude)
{
dicValeursLatitude[(int)row[strCle]] = (double)row[CRelationElementAChamp_ChampCustom.c_champValeurDouble];
}
else if ((int)row[CChampCustom.c_champId] == nIdChampLongitude)
{
dicValeursLongitude[(int)row[strCle]] = (double)row[CRelationElementAChamp_ChampCustom.c_champValeurDouble];
}
}
}
}
else
{
nIdChampLatitude = null;
nIdChampLongitude = null;
}
foreach (object obj in lstObjets)
{
DateTime dt = DateTime.Now;
m_currentGeneratedItem = obj;
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(obj);
double?fLat = null;
double?fLong = null;
if (nIdChampLatitude != null)
{
double fTmp = 0;
if (dicValeursLatitude.TryGetValue(((CObjetDonneeAIdNumerique)obj).Id, out fTmp))
{
fLat = fTmp;
}
}
else
{
result = FormuleLatitude.Eval(ctxEval);
if (result)
{
try
{
fLat = Convert.ToDouble(result.Data);
}
catch { }
}
}
if (fLat != null)
{
if (nIdChampLongitude != null)
{
double fTmp = 0;
if (dicValeursLongitude.TryGetValue(((CObjetDonneeAIdNumerique)obj).Id, out fTmp))
{
fLong = fTmp;
}
}
else
{
result = FormuleLongitude.Eval(ctxEval);
if (result)
{
try
{
fLong = Convert.ToDouble(result.Data);
}
catch { }
}
}
}
TimeSpan sp = DateTime.Now - dt;
if (obj is CObjetDonnee)
{
//Console.WriteLine("Coord "+((CObjetDonnee)obj).DescriptionElement + " : " + sp.TotalMilliseconds);
}
if (fLong != null && fLat != null)
{
foreach (CMapItemDessin mapItemDessin in ItemsDessin)
{
if (mapItemDessin.GenereItem(
obj,
fLat.Value,
fLong.Value,
layer))
{
break;
}
}
}
sp = DateTime.Now - dt;
if (obj is CObjetDonnee)
{
//Console.WriteLine(((CObjetDonnee)obj).DescriptionElement + " : " + sp.TotalMilliseconds);
}
}
return(result);
}
//------------------------------------------------------------------------
private void CreateDatabase()
{
m_mapDatabase = new CMapDatabase();
m_mapDatabase.AddImage(c_strLayerMoveOnMap, Resource.PointToMoveOnMap);
}
//-------------------------------------------------
public CMoveablePoint(CMapDatabase database)
{
m_database = database;
}
//-------------------------------------------------
public CMoveablePoint(CMapDatabase database, SLatLong latLong)
: this(database)
{
m_point = latLong;
}
//-------------------------------------------------
public virtual IEnumerable <IMapItem> Delete(CMapDatabase database)
{
return(new IMapItem[0]);
}
