private bool AddProjectLayer(ResTBRiskMapLayer resTBRiskMapLayer, bool visible = true)
{
if (!MapControlTools.Layers.Where(m => m.Name == resTBRiskMapLayer.Name).Any())
{
var pointlayer = ds.RunQuery(resTBRiskMapLayer.SQL_Point);
var linelayer = ds.RunQuery(resTBRiskMapLayer.SQL_Line);
var polygonlayer = ds.RunQuery(resTBRiskMapLayer.SQL_Polygon);
if ((pointlayer == null) || (linelayer == null) || (polygonlayer == null))
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.FailedToRunSQLQuery, InMethod = "AddPostGISLayer", AxMapError = ds.GdalLastErrorMsg
};
On_Error(error);
return(false);
}
else
{
int pointhandle = AxMap.AddLayer(pointlayer, visible);
int linehandle = AxMap.AddLayer(linelayer, visible);
int polygonhandle = AxMap.AddLayer(polygonlayer, visible);
if ((pointhandle == -1) || (linehandle == -1) || (polygonhandle == -1))
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.CouldNotLoadLayer, InMethod = "AddPostGISLayer", AxMapError = AxMap.FileManager.get_ErrorMsg(AxMap.FileManager.LastErrorCode)
};
On_Error(error);
return(false);
}
else
{
resTBRiskMapLayer.PointHandle = pointhandle;
resTBRiskMapLayer.LineHandle = linehandle;
resTBRiskMapLayer.PolygonHandle = polygonhandle;
resTBRiskMapLayer.ApplyStyle(AxMap);
MapControlTools.Layers.Add(resTBRiskMapLayer);
Events.MapControl_LayerChange layerchange = new Events.MapControl_LayerChange()
{
LayerChangeReason = Events.LayerChangeReason.AddLayer, Layer = resTBRiskMapLayer
};
On_LayerChange(layerchange);
}
return(true);
}
}
return(false);
}
private void UnselectAllLayer()
{
foreach (ILayer layer in MapControlTools.Layers)
{
Shapefile sf = AxMap.get_Shapefile(layer.Handle);
if (sf != null)
{
sf.Identifiable = false;
sf.Selectable = false;
sf.SelectionColor = utils.ColorByName(tkMapColor.Yellow);
if (layer.GetType() == typeof(ResTBDamagePotentialLayer))
{
ResTBDamagePotentialLayer resTBDamagePotentialLayer = (ResTBDamagePotentialLayer)layer;
sf = AxMap.get_Shapefile(resTBDamagePotentialLayer.PointHandle);
sf.Identifiable = false;
sf.Selectable = false;
sf = AxMap.get_Shapefile(resTBDamagePotentialLayer.LineHandle);
sf.Identifiable = false;
sf.Selectable = false;
sf = AxMap.get_Shapefile(resTBDamagePotentialLayer.PolygonHandle);
sf.Identifiable = false;
sf.Selectable = false;
}
else if (layer.GetType() == typeof(ResTBRiskMapLayer))
{
ResTBRiskMapLayer resTBRiskMapLayer = (ResTBRiskMapLayer)layer;
sf = AxMap.get_Shapefile(resTBRiskMapLayer.PointHandle);
sf.Identifiable = false;
sf.Selectable = false;
sf = AxMap.get_Shapefile(resTBRiskMapLayer.LineHandle);
sf.Identifiable = false;
sf.Selectable = false;
sf = AxMap.get_Shapefile(resTBRiskMapLayer.PolygonHandle);
sf.Identifiable = false;
sf.Selectable = false;
}
}
}
}
public bool AddProjectLayer(int Project, ResTBPostGISType resTBPostGISType)
{
ResTBPostGISLayer resTBPostGISLayer = new ResTBPostGISLayer();
bool visibleAtStartup = false;
switch (resTBPostGISType)
{
case ResTBPostGISType.Perimeter:
resTBPostGISLayer = new ResTBPerimeterLayer(Project);
visibleAtStartup = true;
break;
case ResTBPostGISType.MitigationMeasure:
resTBPostGISLayer = new ResTBMitigationMeasureLayer(Project);
break;
case ResTBPostGISType.DamagePotential:
resTBPostGISLayer = new ResTBDamagePotentialLayer(Project);
break;
case ResTBPostGISType.ResilienceBefore:
resTBPostGISLayer = new ResTBResilienceLayer(Project, true);
break;
case ResTBPostGISType.ResilienceAfter:
resTBPostGISLayer = new ResTBResilienceLayer(Project, false);
break;
case ResTBPostGISType.RiskMap:
resTBPostGISLayer = new ResTBRiskMapLayer(Project);
break;
case ResTBPostGISType.RiskMapAfter:
resTBPostGISLayer = new ResTBRiskMapLayer(Project, false);
break;
}
return(AddProjectLayer(resTBPostGISLayer, visibleAtStartup));
}
public static LayersModel CreateLayersModel(List <ILayer> layers, LayersModel selectedLayer, ObservableCollection <LayersModel> oldModel = null)
{
LayersModel allLayers = new LayersModel(Resources.Layers);
LayersModel projects = new LayersModel(Resources.Project_Layers);
LayersModel rasters = new LayersModel(Resources.Rasters);
LayersModel hazardMaps = new LayersModel(Resources.Hazard_Map);
LayersModel resilience = new LayersModel(Resources.Resilience);
LayersModel riskmap = new LayersModel(Resources.RiskMap);
ObservableCollection <ILayer> orderedLayers = new ObservableCollection <ILayer>();
foreach (var customlayer in layers.Where(m => m.LayerType == LayerType.CustomLayerRaster))
{
orderedLayers.Add(customlayer);
}
foreach (var customlayer in layers.Where(m => m.LayerType == LayerType.ProjectLayer).Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.Perimeter))
{
orderedLayers.Add(customlayer);
}
foreach (var customlayer in layers.Where(m => m.LayerType == LayerType.ProjectLayer).Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.HazardMapBefore))
{
orderedLayers.Add(customlayer);
}
foreach (var customlayer in layers.Where(m => m.LayerType == LayerType.ProjectLayer).Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.HazardMapAfter))
{
orderedLayers.Add(customlayer);
}
foreach (var customlayer in layers.Where(m => m.LayerType == LayerType.ProjectLayer).Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.DamagePotential))
{
orderedLayers.Add(customlayer);
}
foreach (var customlayer in layers.Where(m => m.LayerType == LayerType.ProjectLayer).Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.ResilienceBefore))
{
orderedLayers.Add(customlayer);
}
foreach (var customlayer in layers.Where(m => m.LayerType == LayerType.ProjectLayer).Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.ResilienceAfter))
{
orderedLayers.Add(customlayer);
}
foreach (var customlayer in layers.Where(m => m.LayerType == LayerType.ProjectLayer).Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.MitigationMeasure))
{
orderedLayers.Add(customlayer);
}
foreach (var customlayer in layers.Where(m => m.LayerType == LayerType.ProjectLayer).Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.RiskMap))
{
orderedLayers.Add(customlayer);
}
foreach (var customlayer in layers.Where(m => m.LayerType == LayerType.ProjectLayer).Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.RiskMapAfter))
{
orderedLayers.Add(customlayer);
}
foreach (var item in orderedLayers)
{
if (item.LayerType == LayerType.CustomLayerRaster)
{
rasters.Children.Add(new LayersModel(item));
}
if (item.LayerType == LayerType.ProjectLayer)
{
if ((item.GetType() == typeof(ResTBResilienceLayer)) && (item.ShapeCount > 0))
{
ResTBResilienceLayer resLayer = (ResTBResilienceLayer)item;
if (projects.Children?.Where(m => m.Name == Resources.Resilience).Count() == 0)
{
projects.Children.Add(resilience);
}
resilience.Children.Add(new LayersModel(item));
resilience.VerifyCheckState();
}
else if ((item.GetType() == typeof(ResTBRiskMapLayer)) && (item.ShapeCount > 0))
{
ResTBRiskMapLayer rmLayer = (ResTBRiskMapLayer)item;
if (projects.Children?.Where(m => m.Name == Resources.RiskMap).Count() == 0)
{
projects.Children.Add(riskmap);
}
riskmap.Children.Add(new LayersModel(item));
riskmap.VerifyCheckState();
}
else if (item.GetType() == typeof(ResTBHazardMapLayer))
{
ResTBHazardMapLayer hazardMapLayer = (ResTBHazardMapLayer)item;
if (projects.Children?.Where(m => m.Name == Resources.Hazard_Map).Count() == 0)
{
projects.Children.Add(hazardMaps);
}
// Add or create Before Mitigation or After Mitigation LayerGroup
LayersModel beforeOrAfter = new LayersModel();
if (hazardMapLayer.ResTBPostGISType == ResTBPostGISType.HazardMapBefore)
{
beforeOrAfter = hazardMaps.Children.Where(m => m.Name == Resources.Before_Mitigation).FirstOrDefault();
}
else if (hazardMapLayer.ResTBPostGISType == ResTBPostGISType.HazardMapAfter)
{
beforeOrAfter = hazardMaps.Children.Where(m => m.Name == Resources.After_Mitigation).FirstOrDefault();
}
if (beforeOrAfter == null)
{
if (hazardMapLayer.ResTBPostGISType == ResTBPostGISType.HazardMapBefore)
{
beforeOrAfter = new LayersModel(Resources.Before_Mitigation);
}
else if (hazardMapLayer.ResTBPostGISType == ResTBPostGISType.HazardMapAfter)
{
beforeOrAfter = new LayersModel(Resources.After_Mitigation);
}
hazardMaps.Children.Add(beforeOrAfter);
}
// Add or create NatHazard Group
LayersModel natHazardGroup = beforeOrAfter.Children.Where(m => m.Name == hazardMapLayer.NatHazard.Name).FirstOrDefault();
if (natHazardGroup == null)
{
natHazardGroup = new LayersModel(hazardMapLayer.NatHazard.Name);
beforeOrAfter.Children.Add(natHazardGroup);
}
natHazardGroup.Children.Add(new LayersModel(hazardMapLayer.Index.ToString(), hazardMapLayer));
natHazardGroup.VerifyCheckState();
beforeOrAfter.VerifyCheckState();
hazardMaps.VerifyCheckState();
}
else
{
if ((item.GetType() == typeof(ResTBPerimeterLayer)) || (item.ShapeCount > 0))
{
projects.Children.Add(new LayersModel(item));
}
}
}
}
if ((projects.Children != null) && (projects.Children.Count > 0))
{
//projects.VerifyManuallyCheckState();
projects.VerifyCheckState();
if (allLayers.Children?.Count() > 0)
{
allLayers.Children.Add(projects);
}
else
{
allLayers.Children = new ObservableCollection <LayersModel>()
{
projects
}
};
}
if ((rasters.Children != null) && (rasters.Children.Count > 0))
{
rasters.VerifyCheckState();
if (allLayers.Children?.Count() > 0)
{
allLayers.Children.Add(rasters);
}
else
{
allLayers.Children = new ObservableCollection <LayersModel>()
{
rasters
}
};
}
allLayers.Initialize(selectedLayer);
allLayers.VerifyCheckState();
if ((oldModel != null) && (oldModel.Count > 0))
{
var layerList = oldModel.First()?.getAllChildren(new List <LayersModel>()).Where(m => m._manuallyChecked == true).ToList();
//var newLayers = allLayers.getAllChildren(new List<LayersModel>());
foreach (LayersModel lmOld in layerList)
{
allLayers.PutAllChildrenToManually(lmOld.Layer);
}
}
return(allLayers);
}
#region INotifyPropertyChanged Members
void OnPropertyChanged(string prop)
{
if (this.PropertyChanged != null)
{
this.PropertyChanged(this, new PropertyChangedEventArgs(prop));
}
}
