public bool AddShape(bool saveAndStopWhenFinish = false)
{
if (CurrentEditingLayer == null)
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.UseStartEditing, InMethod = "AddLayer", AxMapError = ""
};
On_Error(error);
return(false);
}
this.saveAndCloseWhenFinish = saveAndStopWhenFinish;
AxMap.CursorMode = tkCursorMode.cmAddShape;
AxMap.MapCursor = tkCursor.crsrMapDefault;
isAdding = true;
Events.MapControl_EditingStateChange editingStateChange = new Events.MapControl_EditingStateChange()
{
EditingState = Events.EditingState.AddShape, EditingLayer = CurrentEditingLayer
};
On_EditingStateChange(editingStateChange);
return(true);
}
public DBConnectionTool(AxMapWinGIS.AxMap axMap, MapControlTools mapControlTool) : base(axMap, mapControlTool)
{
try
{
if (ConfigurationManager.AppSettings["UseOfflineDB"] == "true")
{
ConfigDBConnectionName = "ResTBLocalDB";
}
else
{
ConfigDBConnectionName = "ResTBOnlineDB";
}
string appconnection = ConfigurationManager.ConnectionStrings[ConfigDBConnectionName].ConnectionString;
ParseEFConnectionString(appconnection);
}
catch (Exception e)
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.MissingDBConfiguration, InMethod = "DBConnectionTool", InnerException = e
};
On_Error(error);
}
}
public bool AddProjectLayer(ResTBPostGISLayer resTBPostGISLayer, bool visible = true)
{
if (!MapControlTools.Layers.Where(m => m.Name == resTBPostGISLayer.Name).Any())
{
Type t = resTBPostGISLayer.GetType();
// Handle the damage potential differently
if (resTBPostGISLayer.GetType() == typeof(ResTBDamagePotentialLayer))
{
return(AddProjectLayer((ResTBDamagePotentialLayer)resTBPostGISLayer, visible));
}
if (resTBPostGISLayer.GetType() == typeof(ResTBRiskMapLayer))
{
return(AddProjectLayer((ResTBRiskMapLayer)resTBPostGISLayer, visible));
}
var layer = ds.RunQuery(resTBPostGISLayer.SQL);
if (layer == 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 handle = AxMap.AddLayer(layer, visible);
if (handle == -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
{
resTBPostGISLayer.Handle = handle;
resTBPostGISLayer.ApplyStyle(AxMap);
MapControlTools.Layers.Add(resTBPostGISLayer);
Events.MapControl_LayerChange layerchange = new Events.MapControl_LayerChange()
{
LayerChangeReason = Events.LayerChangeReason.AddLayer, Layer = resTBPostGISLayer
};
On_LayerChange(layerchange);
}
return(true);
}
}
return(false);
}
public bool AddSHPLayer()
{
string filename = @"c:\users\suter\documents\test.shp";
Shapefile sf = new Shapefile();
if (sf.Open(filename))
{
int m_layerHandle = AxMap.AddLayer(sf, true);
sf = AxMap.get_Shapefile(m_layerHandle); // in case a copy of shapefile was created by GlobalSettings.ReprojectLayersOnAdding
ShpLayer sl = new ShpLayer();
sl.LayerType = LayerType.CustomLayerSHP;
sl.Name = "Gefahrenkarte";
sl.Shapefile = sf;
sl.Handle = m_layerHandle;
MapControlTools.Layers.Add(sl);
Events.MapControl_LayerChange layerchange = new Events.MapControl_LayerChange()
{
LayerChangeReason = Events.LayerChangeReason.AddLayer, Layer = sl
};
On_LayerChange(layerchange);
return(true);
}
else
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.CouldNotLoadLayer, InMethod = "AddShpLayer", AxMapError = sf.ErrorMsg[sf.LastErrorCode]
};
On_Error(error);
return(false);
}
}
public int ImportProject(string filename)
{
try
{
Events.MapControl_BusyStateChange bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ImportProject";
bc.Percent = 0;
bc.Message = Resources.Project_Import;
MapControlTools.On_BusyStateChange(bc);
if (System.IO.Directory.Exists(localDirectory + "\\ImportMap"))
{
DeleteDirectory(localDirectory + "\\ImportMap");
}
System.IO.Directory.CreateDirectory(localDirectory + "\\ImportMap");
MapControlTools.On_BusyStateChange(bc);
return(ImportProjectThread(filename));
}
catch (Exception e)
{
Events.MapControl_Error export_error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.ImportExportError, InMethod = "ImportProject", AxMapError = e.ToString()
};
On_Error(export_error);
}
return(-1);
}
private bool RunGdalImport(string inputFilename, string newTableName = null, string tablename = null)
{
DBConnectionTool db = new DBConnectionTool(this.AxMap, this.MapControlTools);
string outputFilename = db.GetGdalConnectionString();
var gdalUtils = new GdalUtils();
var options = new[] { "-append" };
if ((newTableName != null))
{
options = new[]
{ "-nln", newTableName, "-overwrite", tablename }
}
;
ExportImportCallback callback = new ExportImportCallback(MapControlTools);
callback.GdalFinished += Callback_GdalFinished;
gdalUtils.GlobalCallback = callback;
openTasks++;
if (!gdalUtils.GdalVectorTranslate(inputFilename, outputFilename, options, true))
{
Events.MapControl_Error export_error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.ImportExportError, InMethod = "ImportProject", AxMapError = gdalUtils.ErrorMsg[gdalUtils.LastErrorCode] + " Detailed error: " + gdalUtils.DetailedErrorMsg
};
On_Error(export_error);
return(false);
}
return(true);
}
public bool ExportProject(int Project, string filename)
{
try
{
if (System.IO.Directory.Exists(localDirectory + "\\ExportMap"))
{
DeleteDirectory(localDirectory + "\\ExportMap");
}
System.IO.Directory.CreateDirectory(localDirectory + "\\ExportMap");
Thread exportProjectThread = new Thread(() => ExportProjectThread(Project, filename));
Events.MapControl_BusyStateChange bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ExportProject";
bc.Percent = 0;
bc.Message = Resources.Project_Export;
MapControlTools.On_BusyStateChange(bc);
exportProjectThread.Start();
return(true);
}
catch (Exception e)
{
Events.MapControl_Error export_error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.ImportExportError, InMethod = "ExportProject", AxMapError = e.ToString()
};
On_Error(export_error);
return(false);
}
}
private void Callback_MapControl_RasterReprojected(object sender, Events.MapControl_RasterReprojected e)
{
Console.WriteLine("Finished");
Image img = new Image();
if (img.Open(e.rasterLayer.FileName))
{
string proj = img.GetProjection();
int layerHandle = AxMap.AddLayer(img, true);
if (layerHandle == -1)
{
Events.MapControl_Error imghandle_error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.CouldNotLoadLayer, InMethod = "AddRasterLayer", AxMapError = new GlobalSettings().GdalLastErrorMsg
};
On_Error(imghandle_error);
}
e.rasterLayer.Handle = layerHandle;
MapControlTools.Layers.Add(e.rasterLayer);
Events.MapControl_LayerChange layerchange = new Events.MapControl_LayerChange()
{
LayerChangeReason = Events.LayerChangeReason.AddLayer, Layer = e.rasterLayer
};
On_LayerChange(layerchange);
}
}
public void Error(string KeyOfSender, string ErrorMsg)
{
Events.MapControl_Error export_error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.ImportExportError, InMethod = "ExportProject", AxMapError = ErrorMsg
};
MapControlTool.On_Error(export_error);
}
private void _map_ShapeValidationFailed(object sender, _DMapEvents_ShapeValidationFailedEvent e)
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.ShapeInvalid, InMethod = "_map_ShapeValidationFailed", AxMapError = e.errorMessage
};
On_Error(error);
}
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);
}
public bool IsRasterGoogleMercator(string fileLocation)
{
Image img = new Image();
if (!img.Open(fileLocation))
{
Events.MapControl_Error errorFileNotOpen = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.CouldNotLoadLayer, InMethod = "AddRasterLayer", AxMapError = img.ErrorMsg[img.LastErrorCode]
};
On_Error(errorFileNotOpen);
}
return(IsRasterGoogleMercator(img));
}
public DBConnectionTool(AxMapWinGIS.AxMap axMap, MapControlTools mapControlTool, string configDBConnectionName) : base(axMap, mapControlTool)
{
try
{
ConfigDBConnectionName = configDBConnectionName;
string appconnection = ConfigurationManager.ConnectionStrings[ConfigDBConnectionName].ConnectionString;
ParseEFConnectionString(appconnection);
}
catch (Exception e)
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.MissingDBConfiguration, InMethod = "DBConnectionTool", InnerException = e
};
On_Error(error);
}
}
public void Run(string filename, string fileLocation, RasterLayer r)
{
string localData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
var output = localData + "\\ResTBDesktop\\temp\\" + filename;
var options = new[]
{
"-t_srs", "EPSG:3857",
"-overwrite"
};
var gdalUtils = new GdalUtils();
RasterReprojectCallback callback = new RasterReprojectCallback(r, MapControlTools);
gdalUtils.GlobalCallback = callback;
if (!gdalUtils.GdalRasterWarp(fileLocation, output, options))
{
Events.MapControl_Error imghandle_error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.GdalWarpError, InMethod = "AddRasterLayer", AxMapError = "GdalWarp failed: " + gdalUtils.ErrorMsg[gdalUtils.LastErrorCode] + " Detailed error: " + gdalUtils.DetailedErrorMsg
};
MapControlTools.On_Error(imghandle_error);
}
if (MapControl_RasterReprojected != null)
{
Events.MapControl_RasterReprojected eventArgs = new Events.MapControl_RasterReprojected();
eventArgs.rasterLayer = r;
MapControl_RasterReprojected(this, eventArgs);
}
Events.MapControl_BusyStateChange bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Idle;
bc.KeyOfSender = "Rasterreprojected";
bc.Percent = 100;
bc.Message = "";
MapControlTools.On_BusyStateChange(bc);
}
private bool RunGdalTranslate(string inputFilename, string outputFilename, string outputType, string sql, bool append = false, string newTableName = null)
{
var gdalUtils = new GdalUtils();
var options = new[]
{
"-f", outputType,
"-sql", sql, "-overwrite"
};
if (append)
{
List <string> newOptions = options.ToList();
newOptions.Add("-append");
options = newOptions.ToArray();
}
if (newTableName != null)
{
List <string> newOptions = options.ToList();
newOptions.Add("-nln");
newOptions.Add(newTableName);
options = newOptions.ToArray();
}
ExportImportCallback callback = new ExportImportCallback(MapControlTools);
callback.GdalFinished += Callback_GdalFinished;
gdalUtils.GlobalCallback = callback;
openTasks++;
if (!gdalUtils.GdalVectorTranslate(inputFilename, outputFilename, options, true))
{
Events.MapControl_Error export_error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.ImportExportError, InMethod = "ExportProject", AxMapError = gdalUtils.ErrorMsg[gdalUtils.LastErrorCode] + " Detailed error: " + gdalUtils.DetailedErrorMsg
};
On_Error(export_error);
return(false);
}
return(true);
}
public bool DeleteAllShapes()
{
isAdding = false;
if (CurrentEditingLayer == null)
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.UseStartEditing, InMethod = "StopEditingLayer", AxMapError = ""
};
On_Error(error);
return(false);
}
var sf = AxMap.get_Shapefile(CurrentEditingLayer.Handle);
for (int i = 0; i < sf.NumShapes; i++)
{
sf.Shape[i].Clear();
}
return(true);
}
/// <summary>
/// On_Error called when an Error occurred
/// </summary>
public void On_Error(Events.MapControl_Error e)
{
MapControlTools.On_Error(e);
}
public void ExportProjectThread(int Project, string filename)
{
try
{
Events.MapControl_BusyStateChange bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ExportProjectThread";
bc.Percent = 0;
bc.Message = Resources.MapControl_Exporting_Layers;
MapControlTools.On_BusyStateChange(bc);
if (!ExportProjectLayer((ResTBPostGISLayer)MapControlTools.Layers.Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.Perimeter).FirstOrDefault()))
{
return;
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ExportProjectThread";
bc.Percent = 10;
bc.Message = Resources.MapControl_Exporting_Layers + "(" + Resources.Perimeter + ")";
MapControlTools.On_BusyStateChange(bc);
if (!ExportProjectLayer((ResTBPostGISLayer)MapControlTools.Layers.Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.MitigationMeasure).FirstOrDefault()))
{
return;
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ExportProjectThread";
bc.Percent = 20;
bc.Message = Resources.MapControl_Exporting_Layers + "(" + Resources.MitigationMeasure + ")";
MapControlTools.On_BusyStateChange(bc);
if (!ExportProjectLayer((ResTBPostGISLayer)MapControlTools.Layers.Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.DamagePotential).FirstOrDefault()))
{
return;
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ExportProjectThread";
bc.Percent = 30;
bc.Message = Resources.MapControl_Exporting_Layers + "(" + Resources.DamagePotential + ")";
MapControlTools.On_BusyStateChange(bc);
if (!ExportProjectLayer((ResTBPostGISLayer)MapControlTools.Layers.Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.HazardMapBefore).FirstOrDefault()))
{
return;
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ExportProjectThread";
bc.Percent = 40;
bc.Message = Resources.MapControl_Exporting_Layers + "(" + Resources.Hazard_Maps_before_Measure + ")";
MapControlTools.On_BusyStateChange(bc);
if (!ExportProjectLayer((ResTBPostGISLayer)MapControlTools.Layers.Where(m => ((ResTBPostGISLayer)m).ResTBPostGISType == ResTBPostGISType.HazardMapAfter).FirstOrDefault()))
{
return;
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ExportProjectThread";
bc.Percent = 50;
bc.Message = Resources.MapControl_Exporting_Layers + "(" + Resources.Hazard_Maps_after_Measure + ")";
MapControlTools.On_BusyStateChange(bc);
DBConnectionTool db = new DBConnectionTool(this.AxMap, this.MapControlTools);
if (!RunGdalTranslate(db.GetGdalConnectionString(), localDirectory + "\\ExportMap\\database.sqlite", "SQLite", "select * from \"Project\" where \"Id\" = " + Project, false, "Project"))
{
return;
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ExportProjectThread";
bc.Percent = 60;
bc.Message = Resources.MapControl_Exporting_Database;
MapControlTools.On_BusyStateChange(bc);
if (!RunGdalTranslate(db.GetGdalConnectionString(), localDirectory + "\\ExportMap\\database.sqlite", "SQLite", "select * from \"ProtectionMeasure\" where \"ProjectID\" = " + Project, true, "ProtectionMeasure"))
{
return;
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ExportProjectThread";
bc.Percent = 70;
bc.Message = Resources.MapControl_Exporting_Database;
MapControlTools.On_BusyStateChange(bc);
if (!RunGdalTranslate(db.GetGdalConnectionString(), localDirectory + "\\ExportMap\\database.sqlite", "SQLite", "select o.* from \"Objectparameter\" o inner join \"MappedObject\" mo on (mo.\"FreeFillParameter_ID\" = o.\"ID\" ) where mo.\"Project_Id\" = " + Project + " union select o.* from \"Objectparameter\" o inner join \"MappedObject\" mo on (mo.\"Objectparameter_ID\" = o.\"ID\" ) where o.\"IsStandard\" = false and mo.\"Project_Id\" = " + Project, true, "Objectparameter"))
{
return;
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ExportProjectThread";
bc.Percent = 70;
bc.Message = Resources.MapControl_Exporting_Database;
MapControlTools.On_BusyStateChange(bc);
if (!RunGdalTranslate(db.GetGdalConnectionString(), localDirectory + "\\ExportMap\\database.sqlite", "SQLite", "select o.* from \"ResilienceValues\" o inner join \"MappedObject\" mo on (mo.\"ID\" = o.\"MappedObject_ID\" ) where mo.\"Project_Id\" = " + Project, true, "ResilienceValues"))
{
return;
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ExportProjectThread";
bc.Percent = 70;
bc.Message = Resources.MapControl_Exporting_Database;
MapControlTools.On_BusyStateChange(bc);
if (!RunGdalTranslate(db.GetGdalConnectionString(), localDirectory + "\\ExportMap\\database.sqlite", "SQLite", "select * from \"PrA\" where \"ProjectId\" = " + Project, true, "PrA"))
{
return;
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ExportProjectThread";
bc.Percent = 70;
bc.Message = Resources.MapControl_Exporting_Database;
MapControlTools.On_BusyStateChange(bc);
while (openTasks != finishedTasks)
{
}
// Now Zip it...
if (System.IO.File.Exists(filename))
{
System.IO.File.Delete(filename);
}
ZipFile.CreateFromDirectory(localDirectory + "\\ExportMap", filename);
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Idle;
bc.KeyOfSender = "ExportProjectThread";
bc.Percent = 100;
bc.Message = Resources.MapControl_Exporting_ExportetTo + " " + filename;
MapControlTools.On_BusyStateChange(bc);
DeleteDirectory(localDirectory + "\\ExportMap");
}
catch (Exception e)
{
Events.MapControl_Error export_error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.ImportExportError, InMethod = "ExportProject", AxMapError = e.ToString()
};
On_Error(export_error);
}
return;
}
public int ImportProjectThread(string filename)
{
try
{
ZipFile.ExtractToDirectory(filename, localDirectory + "\\ImportMap");
// import the project, add it to the database as a new project with new id
if (File.Exists(localDirectory + "\\ImportMap\\database.sqlite"))
{
RunGdalImport(localDirectory + "\\ImportMap\\database.sqlite", "projectimport", "project");
}
using (var context = new DB.ResTBContext())
{
List <Project> importproject = context.Projects
.SqlQuery("Select * from projectimport")
.ToList <Project>();
if ((importproject != null) && (importproject.Count > 0))
{
Project p = new Project();
p.Description = importproject[0].Description;
p.CoordinateSystem = importproject[0].CoordinateSystem;
// check if name is already there...
string name = importproject[0].Name;
Project pold = context.Projects.Where(m => m.Name == name).FirstOrDefault();
if (pold != null)
{
name = name + " (import " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + ")";
}
p.Name = name;
p.Number = importproject[0].Number;
context.Projects.Add(p);
context.SaveChanges();
Events.MapControl_BusyStateChange bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ImportProject";
bc.Percent = 10;
bc.Message = Resources.MapControl_Importing;
MapControlTools.On_BusyStateChange(bc);
// we have a new project id
//import all new Objectparameters
RunGdalImport(localDirectory + "\\ImportMap\\database.sqlite", "objectparameterimport", "objectparameter");
RunGdalImport(localDirectory + "\\ImportMap\\database.sqlite", "resiliencevaluesimport", "resiliencevalues");
RunGdalImport(localDirectory + "\\ImportMap\\database.sqlite", "praimport", "pra");
List <PrA> importpra = context.PrAs
.SqlQuery("Select * from praimport")
.ToList <PrA>();
foreach (PrA praImp in importpra)
{
PrA pra = (PrA)praImp.Clone();
pra.Project = p;
p.PrAs.Add(pra);
context.PrAs.Add(pra);
}
context.SaveChanges();
RunGdalImport(localDirectory + "\\ImportMap\\database.sqlite", "protectionmeasureimport", "ProtectionMeasure");
List <ProtectionMeasure> importpm = context.ProtectionMeasurements
.SqlQuery("Select * from protectionmeasureimport")
.ToList <ProtectionMeasure>();
if (importpm?.Count > 0)
{
ProtectionMeasure pm = (ProtectionMeasure)importpm[0].Clone();
pm.Project = p;
p.ProtectionMeasure = pm;
context.ProtectionMeasurements.Add(pm);
context.SaveChanges();
}
// create the ids of old objectparameters, so foreign constraint will work.
// But don't override existing
List <Objectparameter> importop = context.Objektparameter
.SqlQuery("Select * from objectparameterimport")
.ToList <Objectparameter>();
//
foreach (Objectparameter o in importop)
{
if (context.Objektparameter.Where(m => m.ID == o.ID).ToList().Count == 0)
{
context.Database.ExecuteSqlCommand("INSERT INTO public.\"Objectparameter\" (\"ID\",\"FeatureType\",\"Value\",\"Floors\",\"Personcount\",\"Presence\",\"NumberOfVehicles\",\"Velocity\",\"Staff\",\"IsStandard\",\"ObjectClass_ID\")\tVALUES (" + o.ID + ",1,0,0,0,0.0,0,0,0,false,1); ");
}
}
ResTBPostGISLayer tempLayer = new ResTBMitigationMeasureLayer(0);
if (File.Exists(localDirectory + "\\ImportMap\\" + tempLayer.ExportImportFileName + ".shp"))
{
RunGdalImport(localDirectory + "\\ImportMap\\" + tempLayer.ExportImportFileName + ".shp", "protectionmeasuregeometryimport");
context.Database.ExecuteSqlCommand("insert into \"ProtectionMeasureGeometry\" (project_fk, geometry) select " + p.Id + ", wkb_geometry from protectionmeasuregeometryimport;");
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ImportProject";
bc.Percent = 30;
bc.Message = Resources.MapControl_Importing;
MapControlTools.On_BusyStateChange(bc);
tempLayer = new ResTBPerimeterLayer(0);
if (File.Exists(localDirectory + "\\ImportMap\\" + tempLayer.ExportImportFileName + ".shp"))
{
RunGdalImport(localDirectory + "\\ImportMap\\" + tempLayer.ExportImportFileName + ".shp", "perimeterimport");
context.Database.ExecuteSqlCommand("insert into \"Perimeter\" (project_fk, geometry) select " + p.Id + ", wkb_geometry from perimeterimport;");
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ImportProject";
bc.Percent = 40;
bc.Message = Resources.MapControl_Importing;
MapControlTools.On_BusyStateChange(bc);
tempLayer = new ResTBHazardMapLayer(0, false, context.NatHazards.ToList().First(), 0);
if (File.Exists(localDirectory + "\\ImportMap\\" + tempLayer.ExportImportFileName + ".shp"))
{
RunGdalImport(localDirectory + "\\ImportMap\\" + tempLayer.ExportImportFileName + ".shp", "hazardmapimport");
context.Database.ExecuteSqlCommand("insert into \"HazardMap\" (\"Project_Id\", \"Index\",\"BeforeAction\",\"NatHazard_ID\",geometry) select " + p.Id + ",\"index\",CASE WHEN beforeacti IS NULL THEN false WHEN beforeacti = 0 THEN false ELSE true END beforeaction ,\"nathazard_\", wkb_geometry from hazardmapimport;");
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ImportProject";
bc.Percent = 50;
bc.Message = Resources.MapControl_Importing;
MapControlTools.On_BusyStateChange(bc);
tempLayer = new ResTBDamagePotentialLayer(0);
if (File.Exists(localDirectory + "\\ImportMap\\" + tempLayer.ExportImportFileName + "_Points.shp"))
{
RunGdalImport(localDirectory + "\\ImportMap\\" + tempLayer.ExportImportFileName + "_Points.shp", "damagepotentialpoints");
context.Database.ExecuteSqlCommand("insert into \"MappedObject\" (\"Project_Id\", \"FreeFillParameter_ID\",\"Objectparameter_ID\",point) select " + p.Id + ", freefillpa, objectpara, wkb_geometry from damagepotentialpoints;");
}
if (File.Exists(localDirectory + "\\ImportMap\\" + tempLayer.ExportImportFileName + "_Lines.shp"))
{
RunGdalImport(localDirectory + "\\ImportMap\\" + tempLayer.ExportImportFileName + "_Lines.shp", "damagepotentiallines");
context.Database.ExecuteSqlCommand("insert into \"MappedObject\" (\"Project_Id\", \"FreeFillParameter_ID\",\"Objectparameter_ID\",line) select " + p.Id + ", freefillpa, objectpara, wkb_geometry from damagepotentiallines;");
}
List <int> importrvsMOID = context.Database.SqlQuery <int>("select distinct mappedobject_id from resiliencevaluesimport")
.ToList <int>();
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ImportProject";
bc.Percent = 60;
bc.Message = Resources.MapControl_Importing;
MapControlTools.On_BusyStateChange(bc);
if (File.Exists(localDirectory + "\\ImportMap\\" + tempLayer.ExportImportFileName + "_Polygones.shp"))
{
RunGdalImport(localDirectory + "\\ImportMap\\" + tempLayer.ExportImportFileName + "_Polygones.shp", "damagepotentialpolygones");
context.Database.ExecuteSqlCommand("insert into \"MappedObject\" (\"Project_Id\", \"FreeFillParameter_ID\",\"Objectparameter_ID\",polygon) select " + p.Id + ", freefillpa, objectpara, wkb_geometry from damagepotentialpolygones;");
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "ImportProject";
bc.Percent = 70;
bc.Message = Resources.MapControl_Importing;
MapControlTools.On_BusyStateChange(bc);
foreach (int moID in importrvsMOID)
{
string sql = "insert into \"ResilienceValues\" (\"OverwrittenWeight\", \"Value\", \"MappedObject_ID\", \"ResilienceWeight_ID\") " +
"select r.overwrittenweight, r.value, (select \"ID\" " +
"from \"MappedObject\" mo where polygon = ( " +
"select wkb_geometry from damagepotentialpolygones d " +
"where d.id = " + moID + ") " +
"and \"Project_Id\" = " + p.Id + "), r.resilienceweight_id from resiliencevaluesimport r where r.mappedobject_id = " + moID + "; ";
context.Database.ExecuteSqlCommand(sql);
}
List <MappedObject> mos = context.MappedObjects.Where(m => m.Project.Id == p.Id).ToList();
// Insert FreeFills and Objectparameters
foreach (MappedObject mo in mos)
{
if (mo.FreeFillParameter != null)
{
Objectparameter o = importop.Where(m => m.ID == mo.FreeFillParameter.ID).FirstOrDefault();
Objectparameter oCopy = ShallowCopyEntity <Objectparameter>(o);
context.Objektparameter.Add(oCopy);
mo.FreeFillParameter = oCopy;
context.SaveChanges();
}
if (mo.Objectparameter != null)
{
Objectparameter o = importop.Where(m => m.ID == mo.Objectparameter.ID).FirstOrDefault();
// not a standard objectparameter
if (o != null)
{
Objectparameter oCopy = ShallowCopyEntity <Objectparameter>(o);
// get the objectclass
int objClassID = context.Database.SqlQuery <int>("select objectclass_id from objectparameterimport where id = " + o.ID).First();
ObjectClass oc = context.ObjektKlassen.Find(objClassID);
oCopy.ObjectClass = oc;
// get the motherobject
int motherObjID = context.Database.SqlQuery <int>("select motherotbjectparameter_id from objectparameterimport where id = " + o.ID).First();
Objectparameter motherObj = context.Objektparameter.Find(motherObjID);
oCopy.MotherOtbjectparameter = motherObj;
context.Objektparameter.Add(oCopy);
mo.Objectparameter = oCopy;
context.SaveChanges();
}
}
}
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Idle;
bc.KeyOfSender = "ImportProject";
bc.Percent = 100;
bc.Message = Resources.MapControl_Importing_Success;
MapControlTools.On_BusyStateChange(bc);
return(p.Id);
}
}
}
catch (Exception e)
{
Events.MapControl_Error export_error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.ImportExportError, InMethod = "ImportProject", AxMapError = e.ToString()
};
On_Error(export_error);
}
return(-1);
}
public void AddProjectLayersThread(int Project)
{
var gdalUtils = new GdalUtils();
RasterReprojectCallback callback = new RasterReprojectCallback(null, MapControlTools);
gdalUtils.GlobalCallback = callback;
ds = new OgrDatasource();
if (!ds.Open(dBConnection.GetGdalConnectionString()))
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.CouldNotConnectDatabase, InMethod = "AddPostGISLayer", AxMapError = ds.GdalLastErrorMsg
};
On_Error(error);
return;
}
else
{
Events.MapControl_BusyStateChange bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "AddProjectLayersThread";
bc.Percent = 10;
bc.Message = Resources.MapControl_AddedPerimeter;
MapControlTools.On_BusyStateChange(bc);
// RiskMap
if (!AddProjectLayer(Project, ResTBPostGISType.RiskMap))
{
return;
}
if (!AddProjectLayer(Project, ResTBPostGISType.RiskMapAfter))
{
return;
}
// Perimeter
if (!AddProjectLayer(Project, ResTBPostGISType.Perimeter))
{
return;
}
if (MapControlTools.ShapesCount(MapControlTools.GetLayerNamesFromPostGISType(ResTBPostGISType.Perimeter).First()) > 0)
{
MapControlTools.ZoomToLayer(MapControlTools.GetLayerNamesFromPostGISType(ResTBPostGISType.Perimeter).First());
}
// Hazard Maps
DB.ResTBContext db = new DB.ResTBContext();
List <HazardMap> hazardMaps = db.HazardMaps.Where(m => m.Project.Id == Project).Include(m => m.NatHazard).OrderBy(m => m.Index).ToList();
double percentadd = 50.0 / hazardMaps.Count;
int currentpercent = 10;
foreach (HazardMap hazardMap in hazardMaps.OrderByDescending(m => m.BeforeAction))
{
ResTBHazardMapLayer hazardLayer;
if (hazardMap.BeforeAction)
{
hazardLayer = new ResTBHazardMapLayer(Project, true, hazardMap.NatHazard, hazardMap.Index);
}
else
{
hazardLayer = new ResTBHazardMapLayer(Project, false, hazardMap.NatHazard, hazardMap.Index);
}
currentpercent += (int)percentadd;
if (!MapControlTools.Layers.Where(m => m.Name == hazardLayer.Name).Any())
{
AddProjectLayer(hazardLayer, false);
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "AddProjectLayersThread";
bc.Percent = currentpercent;
bc.Message = Resources.MapControl_AddingHazardMaps;
MapControlTools.On_BusyStateChange(bc);
}
}
// Damage Potential
if (!AddProjectLayer(Project, ResTBPostGISType.DamagePotential))
{
return;
}
// Resiliences
if (!AddProjectLayer(Project, ResTBPostGISType.ResilienceBefore))
{
return;
}
if (!AddProjectLayer(Project, ResTBPostGISType.ResilienceAfter))
{
return;
}
currentpercent += 30;
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Busy;
bc.KeyOfSender = "AddProjectLayersThread";
bc.Percent = currentpercent;
bc.Message = Resources.MapControl_AddedDamagePotentials;
MapControlTools.On_BusyStateChange(bc);
// Mitigation Measure
if (!AddProjectLayer(Project, ResTBPostGISType.MitigationMeasure))
{
return;
}
currentpercent += 10;
bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.Idle;
bc.KeyOfSender = "Project";
bc.Percent = 100;
bc.Message = Resources.MapControl_ProjectLoaded;// "Project loaded";
MapControlTools.On_BusyStateChange(bc);
return;
}
}
public bool EditShape(int shapeIndex = -1)
{
if (CurrentEditingLayer == null)
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.UseStartEditing, InMethod = "EditingLayer", AxMapError = ""
};
On_Error(error);
return(false);
}
AxMap.CursorMode = tkCursorMode.cmEditShape;
AxMap.MapCursor = tkCursor.crsrMapDefault;
isAdding = false;
if ((CurrentEditingLayer.GetType() == typeof(ResTBPostGISLayer)) || ((CurrentEditingLayer.GetType().BaseType != null && CurrentEditingLayer.GetType().BaseType == typeof(ResTBPostGISLayer))))
{
var sf = AxMap.get_Shapefile(((ResTBPostGISLayer)CurrentEditingLayer).EditingLayerHandle);
// look for the selectedShape in the editing layer
var sfOriginal = AxMap.get_Shapefile(((ResTBPostGISLayer)CurrentEditingLayer).Handle);
var selectedShape = sfOriginal.Shape[shapeIndex];
Shape selectedPointShape = null;
Shape selectedLineShape = null;
Shape selectedPolygonShape = null;
int toSelectShape = -1;
if (((ResTBPostGISLayer)CurrentEditingLayer).GetType() == typeof(ResTBDamagePotentialLayer))
{
sfOriginal = AxMap.get_Shapefile(((ResTBDamagePotentialLayer)CurrentEditingLayer).PointHandle);
selectedPointShape = sfOriginal.Shape[shapeIndex];
sfOriginal = AxMap.get_Shapefile(((ResTBDamagePotentialLayer)CurrentEditingLayer).LineHandle);
selectedLineShape = sfOriginal.Shape[shapeIndex];
sfOriginal = AxMap.get_Shapefile(((ResTBDamagePotentialLayer)CurrentEditingLayer).PolygonHandle);
selectedPolygonShape = sfOriginal.Shape[shapeIndex];
}
var project_index = sf.FieldIndexByName[((ResTBPostGISLayer)CurrentEditingLayer).ProjectID];
List <int> visibleShapes = new List <int>();
for (int i = 0; i < sf.NumShapes; i++)
{
if (sf.CellValue[project_index, i] == ((ResTBPostGISLayer)CurrentEditingLayer).Project)
{
visibleShapes.Add(i);
}
if (sf.Shape[i].Equals(selectedShape))
{
// we could have the exact same polygone in before and after. So have a look, if before is the same
if (CurrentEditingLayer.GetType() == typeof(ResTBHazardMapLayer))
{
var before_index = sf.FieldIndexByName["BeforeAction"];
var isBefore = sf.CellValue[before_index, i];
if (((ResTBHazardMapLayer)CurrentEditingLayer).ResTBPostGISType == ResTBPostGISType.HazardMapBefore)
{
if (isBefore == 1)
{
toSelectShape = i;
}
}
else if (((ResTBHazardMapLayer)CurrentEditingLayer).ResTBPostGISType == ResTBPostGISType.HazardMapAfter)
{
if (isBefore == 0)
{
toSelectShape = i;
}
}
}
else
{
toSelectShape = i;
}
}
if (sf.Shape[i].Equals(selectedPointShape))
{
toSelectShape = i;
}
if (sf.Shape[i].Equals(selectedLineShape))
{
toSelectShape = i;
}
if (sf.Shape[i].Equals(selectedPolygonShape))
{
toSelectShape = i;
}
}
// if we have only one shape, mark it as active
if (visibleShapes.Count == 1)
{
AxMap.ShapeEditor.Clear();
bool isok = AxMap.ShapeEditor.StartEdit(((ResTBPostGISLayer)CurrentEditingLayer).EditingLayerHandle, visibleShapes[0]);
}
else if (shapeIndex > -1)
{
AxMap.ShapeEditor.Clear();
bool isok = AxMap.ShapeEditor.StartEdit(((ResTBPostGISLayer)CurrentEditingLayer).EditingLayerHandle, toSelectShape);
}
}
Events.MapControl_EditingStateChange editingStateChange = new Events.MapControl_EditingStateChange()
{
EditingState = Events.EditingState.EditSshape, EditingLayer = CurrentEditingLayer
};
On_EditingStateChange(editingStateChange);
return(true);
}
public bool AddRasterLayer(string fileLocation, string layerName, bool autoReproject = true, bool overwriteExistingReprojectedFiles = false)
{
Image img = new Image();
if (autoReproject)
{
if (!img.Open(fileLocation))
{
Events.MapControl_Error errorFileNotOpen = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.CouldNotLoadLayer, InMethod = "AddRasterLayer", AxMapError = img.ErrorMsg[img.LastErrorCode]
};
On_Error(errorFileNotOpen);
}
if (!IsRasterGoogleMercator(img))
{
// Image is not WGS84, so use GdalWrap for reprojection
string localData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
if (!System.IO.Directory.Exists(localData + "\\ResTBDesktop"))
{
System.IO.Directory.CreateDirectory(localData + "\\ResTBDesktop");
}
string filename = Path.GetFileName(fileLocation);
if (!Directory.Exists(localData + "\\ResTBDesktop\\temp"))
{
Directory.CreateDirectory(localData + "\\ResTBDesktop\\temp");
}
// check if file already transformed
if ((File.Exists(localData + "\\ResTBDesktop\\temp\\" + filename)) && (!overwriteExistingReprojectedFiles))
{
}
else
{
string fileLocationThreadSave = (string)fileLocation.Clone();
fileLocation = localData + "\\ResTBDesktop\\temp\\" + filename;
RasterLayer r = new RasterLayer()
{
FileName = fileLocation, LayerType = LayerType.CustomLayerRaster, Name = layerName
};
RasterProjectionWorker rpw = new RasterProjectionWorker();
rpw.MapControlTools = MapControlTools;
rpw.MapControl_RasterReprojected += Callback_MapControl_RasterReprojected;
reprojectThread = new Thread(() => rpw.Run(filename, fileLocationThreadSave, r));
Events.MapControl_BusyStateChange bc = new Events.MapControl_BusyStateChange();
bc.BusyState = Events.BusyState.BackgroundBusy;
bc.KeyOfSender = Resources.MapControl_Busy_RasterReprojection;
bc.Percent = 0;
bc.Message = Resources.MapControl_Busy_StartRasterReprojection;;
MapControlTools.On_BusyStateChange(bc);
reprojectThread.Start();
return(false);
}
fileLocation = localData + "\\ResTBDesktop\\temp\\" + filename;
}
}
if (img.Open(fileLocation))
{
string proj = img.GetProjection();
int layerHandle = AxMap.AddLayer(img, true);
if (layerHandle == -1)
{
Events.MapControl_Error imghandle_error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.CouldNotLoadLayer, InMethod = "AddRasterLayer", AxMapError = new GlobalSettings().GdalLastErrorMsg
};
On_Error(imghandle_error);
return(false);
}
RasterLayer r = new RasterLayer()
{
FileName = fileLocation, Handle = layerHandle, LayerType = LayerType.CustomLayerRaster, Name = layerName
};
MapControlTools.Layers.Add(r);
MapControlTools.LayerHandlingTool.SetLayerPosition(r.Name, LayerMoveType.BOTTOM);
Events.MapControl_LayerChange layerchange = new Events.MapControl_LayerChange()
{
LayerChangeReason = Events.LayerChangeReason.AddLayer, Layer = r
};
On_LayerChange(layerchange);
return(true);
}
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.CouldNotLoadLayer, InMethod = "AddRasterLayer", AxMapError = img.ErrorMsg[img.LastErrorCode]
};
On_Error(error);
return(false);
}
public bool SaveEdits()
{
if (CurrentEditingLayer == null)
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.UseStartEditing, InMethod = "StopEditingLayer", AxMapError = ""
};
On_Error(error);
return(false);
}
Events.MapControl_EditingStateChange editingStateChange = new Events.MapControl_EditingStateChange()
{
EditingState = Events.EditingState.SaveEditing, EditingLayer = CurrentEditingLayer
};
On_EditingStateChange(editingStateChange);
var sf = AxMap.get_Shapefile(CurrentEditingLayer.Handle);
var ogrLayer = AxMap.get_OgrLayer(CurrentEditingLayer.Handle);
bool success = false;
if (ogrLayer != null)
{
ogrLayer = ((ResTBPostGISLayer)CurrentEditingLayer).EditingLayer;
((ResTBPostGISLayer)CurrentEditingLayer).SaveAttributes(AxMap);
int savedCount;
tkOgrSaveResult saveResult = ogrLayer.SaveChanges(out savedCount);
success = saveResult == tkOgrSaveResult.osrAllSaved || saveResult == tkOgrSaveResult.osrNoChanges;
// if hazard map before --> copy to hazardmap after
if ((success) && (((ResTBPostGISLayer)CurrentEditingLayer).ResTBPostGISType == ResTBPostGISType.HazardMapBefore) && (isAdding))
{
string newName = ((ResTBHazardMapLayer)CurrentEditingLayer).CopyToAfter(MapControlTools);
ILayer HMAfter = MapControlTools.Layers.Where(m => m.Name == newName).FirstOrDefault();
if (HMAfter != null)
{
ogrLayer = AxMap.get_OgrLayer(HMAfter.Handle);
ogrLayer.ReloadFromSource();
}
}
ogrLayer = AxMap.get_OgrLayer(CurrentEditingLayer.Handle);
ogrLayer.ReloadFromSource();
}
if (success)
{
sf.InteractiveEditing = false;
AxMap.ShapeEditor.Clear();
AxMap.UndoList.ClearForLayer(CurrentEditingLayer.Handle);
Events.MapControl_EditingStateChange editingStateChangeStop = new Events.MapControl_EditingStateChange()
{
EditingState = Events.EditingState.StopEditing, EditingLayer = CurrentEditingLayer
};
On_EditingStateChange(editingStateChangeStop);
Events.MapControl_LayerChange layerChange = new Events.MapControl_LayerChange()
{
Layer = this.CurrentEditingLayer, LayerChangeReason = Events.LayerChangeReason.EditedLayer
};
On_LayerChange(layerChange);
return(true);
}
AxMap.Redraw();
return(false);
}
public bool StartEditingLayer(string name, bool saveAndStopWhenFinish = false, FeatureType featureType = FeatureType.Any)
{
ILayer editLayer = MapControlTools.Layers.Where(m => m.Name == name).FirstOrDefault();
if (editLayer == null)
{
return(false);
}
this.saveAndCloseWhenFinish = saveAndStopWhenFinish;
Shapefile sf;
var ogrLayer = AxMap.get_OgrLayer(editLayer.Handle);
sf = AxMap.get_Shapefile(editLayer.Handle);
_currentEditingLayer = editLayer;
if (ogrLayer != null)
{
// Add the editing layer
DBConnectionTool dBConnection = new DBConnectionTool(AxMap, MapControlTools);
OgrDatasource ds = new OgrDatasource();
if (!ds.Open(dBConnection.GetGdalConnectionString()))
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.CouldNotConnectDatabase, InMethod = "AddPostGISLayer", AxMapError = ds.GdalLastErrorMsg
};
On_Error(error);
return(false);
}
OgrLayer editlayer = null;
if (featureType == FeatureType.Point)
{
editlayer = ds.GetLayerByName(((ResTBPostGISLayer)editLayer).SQL_Layer + "(point)", true);
if (editLayer.GetType() == typeof(ResTBDamagePotentialLayer))
{
editLayer.Handle = ((ResTBDamagePotentialLayer)editLayer).PointHandle;
}
}
else if (featureType == FeatureType.Line)
{
editlayer = ds.GetLayerByName(((ResTBPostGISLayer)editLayer).SQL_Layer + "(line)", true);
if (editLayer.GetType() == typeof(ResTBDamagePotentialLayer))
{
editLayer.Handle = ((ResTBDamagePotentialLayer)editLayer).LineHandle;
}
}
else if (featureType == FeatureType.Polygon)
{
editlayer = ds.GetLayerByName(((ResTBPostGISLayer)editLayer).SQL_Layer + "(polygon)", true);
if (editLayer.GetType() == typeof(ResTBDamagePotentialLayer))
{
editLayer.Handle = ((ResTBDamagePotentialLayer)editLayer).PolygonHandle;
}
}
else
{
editlayer = ds.GetLayerByName(((ResTBPostGISLayer)editLayer).SQL_Layer, true);
}
int editinghandle = AxMap.AddLayer(editlayer, false);
((ResTBPostGISLayer)editLayer).EditingLayer = editlayer;
((ResTBPostGISLayer)editLayer).EditingLayerHandle = editinghandle;
_currentEditingLayer = editLayer;
OgrLayer ogrLayer2 = ((ResTBPostGISLayer)editLayer).EditingLayer;
if (ogrLayer2.DynamicLoading)
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.EditingNotAllowed, InMethod = "StartEditingLayer", AxMapError = ""
};
On_Error(error);
return(false);
}
if (!ogrLayer2.SupportsEditing[tkOgrSaveType.ostSaveAll])
{
Events.MapControl_Error error = new Events.MapControl_Error()
{
ErrorCode = Events.ErrorCodes.EditingNotSupported, InMethod = "StartEditingLayer", AxMapError = ogrLayer2.ErrorMsg[ogrLayer.LastErrorCode]
};
On_Error(error);
return(false);
}
AxMap.set_LayerVisible(editLayer.Handle, false);
AxMap.set_LayerVisible(((ResTBPostGISLayer)editLayer).EditingLayerHandle, true);
sf = AxMap.get_Shapefile(((ResTBPostGISLayer)editLayer).EditingLayerHandle);
Utils utils = new Utils();
if (featureType == FeatureType.Point)
{
sf.DefaultDrawingOptions.PointSize = 15;
sf.DefaultDrawingOptions.FillColor = utils.ColorByName(tkMapColor.Blue);
}
else
{
sf.DefaultDrawingOptions.LineWidth = 7;
sf.DefaultDrawingOptions.FillColor = utils.ColorByName(tkMapColor.Blue);
sf.DefaultDrawingOptions.LineColor = utils.ColorByName(tkMapColor.Blue);
AxMap.ShapeEditor.FillColor = utils.ColorByName(tkMapColor.Blue);
}
//AxMap.ShapeEditor.LineWidth = 20;
AxMap.ShapeEditor.LineColor = utils.ColorByName(tkMapColor.Blue);
sf.VisibilityExpression = ((ResTBPostGISLayer)editLayer).VisibilityExpression;
}
AxMap.SendMouseDown = true;
AxMap.SendMouseUp = true;
AxMap.ChooseLayer += AxMap_ChooseLayer;
AxMap.AfterShapeEdit += _map_AfterShapeEdit;
AxMap.BeforeDeleteShape += _map_BeforeDeleteShape;
AxMap.BeforeShapeEdit += _map_BeforeShapeEdit;
AxMap.ShapeValidationFailed += _map_ShapeValidationFailed;
AxMap.ValidateShape += _map_ValidateShape;
AxMap.ShapeEditor.IndicesVisible = false;
AxMap.ShapeEditor.ShowLength = false;
AxMap.ShapeEditor.ShowArea = false;
AxMap.ShapeEditor.ValidationMode = tkEditorValidation.evFixWithGeos;
if ((featureType == FeatureType.Point) || (featureType == FeatureType.Line))
{
AxMap.ShapeEditor.SnapBehavior = tkLayerSelection.lsNoLayer;
}
else
{
AxMap.ShapeEditor.SnapBehavior = tkLayerSelection.lsAllLayers;
}
sf.InteractiveEditing = true;
Events.MapControl_EditingStateChange editingStateChange = new Events.MapControl_EditingStateChange()
{
EditingState = Events.EditingState.StartEditing, EditingLayer = editLayer
};
On_EditingStateChange(editingStateChange);
return(true);
}
