protected override Collection <Layer> GetLayersCore(GetLayersParameters getLayersParameters)
{
Collection <Layer> resultLayers = new Collection <Layer>();
if (getLayersParameters.LayerUris.Count > 0)
{
foreach (Uri uri in getLayersParameters.LayerUris)
{
AddLayerByFileGeodatabaseWindow(resultLayers, uri.LocalPath, getLayersParameters);
}
}
else
{
FolderHelper.OpenFolderBrowserDialog((tmpDialog, tmpResult) =>
{
if (tmpResult == System.Windows.Forms.DialogResult.OK)
{
AddLayerByFileGeodatabaseWindow(resultLayers, tmpDialog.SelectedPath);
}
}, tmpDialog =>
{
tmpDialog.Description = GisEditor.LanguageManager.GetStringResource("FileGeoSelectFolderLabel");
});
}
return(resultLayers);
}
protected override Collection <Layer> GetLayersCore(GetLayersParameters getLayersParameters)
{
Collection <Layer> resultLayers = base.GetLayersCore(getLayersParameters);
Collection <Uri> uris = getLayersParameters.LayerUris;
foreach (Uri uri in uris)
{
var fileName = uri.LocalPath;
try
{
TobinBasFeatureLayer tobinBasFeatureLayer = new TobinBasFeatureLayer(fileName);
tobinBasFeatureLayer.Name = Path.GetFileNameWithoutExtension(fileName);
tobinBasFeatureLayer.DrawingExceptionMode = DrawingExceptionMode.DrawException;
((TobinBasFeatureSource)tobinBasFeatureLayer.FeatureSource).RequireIndex = false;
resultLayers.Add(tobinBasFeatureLayer);
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
System.Windows.Forms.MessageBox.Show(GisEditor.LanguageManager.GetStringResource("FileLayerPluginUsedByAnotherProcessText"), GisEditor.LanguageManager.GetStringResource("FileLayerPluginFilebeingusedCaption"));
}
}
return(resultLayers);
}
protected override void LoadToMapCore()
{
if (File.Exists(OutputPathFileName))
{
var getLayersParameters = new GetLayersParameters();
getLayersParameters.LayerUris.Add(new Uri(OutputPathFileName));
var layers = GisEditor.LayerManager.GetLayers <ShapeFileFeatureLayer>(getLayersParameters);
if (Application.Current != null)
{
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
GisEditor.ActiveMap.AddLayersBySettings(layers);
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.LoadToMapCoreDescription));
}));
}
else
{
GisEditor.ActiveMap.AddLayersBySettings(layers);
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.LoadToMapCoreDescription));
}
}
ShapeFileFeatureLayerExtension.RemoveShapeFiles(clippingLayerTempPath);
}
protected override void LoadCore()
{
if (matchingLayerPlugin == null || !matchingLayerPlugin.IsActive)
{
System.Windows.Forms.MessageBox.Show("The relevant layer plugin has been disabled, please enable it in Plugin Manager first", "Layer Plugin");
return;
}
if (GisEditor.ActiveMap != null && matchingLayerPlugin != null)
{
if (File.Exists(fileInfo.FullName))
{
var getLayersParameters = new GetLayersParameters();
getLayersParameters.LayerUris.Add(new Uri(fileInfo.FullName));
var layers = matchingLayerPlugin.GetLayers(getLayersParameters);
if (layers.Count > 0)
{
GisEditor.ActiveMap.AddLayersBySettings(layers, true);
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.LoadCoreDescription));
}
}
else
{
ShowFileNotFoundMessage();
}
}
}
protected override Collection <Layer> GetLayersCore(GetLayersParameters getLayersParameters)
{
Collection <Layer> resultLayers = base.GetLayersCore(getLayersParameters);
Collection <MsSqlFeatureLayer> newFeatureLayers = new Collection <MsSqlFeatureLayer>();
if (getLayersParameters.CustomData.ContainsKey("TableName") && getLayersParameters.CustomData.ContainsKey("DatabaseName") && getLayersParameters.CustomData.ContainsKey("IdColumn") && getLayersParameters.CustomData.ContainsKey("ServerName"))
{
MsSql2008FeatureLayerInfo layerInfo = new MsSql2008FeatureLayerInfo();
layerInfo.TableName = getLayersParameters.CustomData["TableName"].ToString();
layerInfo.SchemaName = getLayersParameters.CustomData["SchemaName"].ToString();
layerInfo.DatabaseName = getLayersParameters.CustomData["DatabaseName"].ToString();
layerInfo.FeatureIDColumnName = getLayersParameters.CustomData["IdColumn"].ToString();
layerInfo.ServerName = getLayersParameters.CustomData["ServerName"].ToString();
layerInfo.UserName = getLayersParameters.CustomData["UserName"].ToString();
layerInfo.Password = getLayersParameters.CustomData["Password"].ToString();
if (!string.IsNullOrEmpty(layerInfo.UserName) && !string.IsNullOrEmpty(layerInfo.Password))
{
layerInfo.UseTrustAuthority = false;
}
newFeatureLayers = GetLayers(layerInfo);
}
else
{
newFeatureLayers = GetFeatureLayersCore();
}
foreach (var layer in newFeatureLayers)
{
resultLayers.Add(layer);
}
return(resultLayers);
}
internal static void PlaceFilesOnMap(IEnumerable <string> allFiles)
{
List <Layer> resultsLayers = new List <Layer>();
var groupedFileDataItems = allFiles.GroupBy(item => Path.GetExtension(item));
foreach (var fileDataItems in groupedFileDataItems)
{
var extension = fileDataItems.Key.ToUpperInvariant();
var matchingLayerPlugin = GisEditor.LayerManager.GetActiveLayerPlugins <LayerPlugin>()
.FirstOrDefault(tmpPlugin => tmpPlugin.ExtensionFilter.ToUpperInvariant().Contains(extension));
if (matchingLayerPlugin != null)
{
var getLayersParameters = new GetLayersParameters();
foreach (var item in fileDataItems)
{
getLayersParameters.LayerUris.Add(new Uri(item));
}
var layers = matchingLayerPlugin.GetLayers(getLayersParameters);
resultsLayers.AddRange(layers);
}
else
{
System.Windows.Forms.MessageBox.Show(GisEditor.LanguageManager.GetStringResource("DataRepositoryCannotFindLayerProviderWarningLabel"), GisEditor.LanguageManager.GetStringResource("DataRepositoryWarningLabel"), System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Warning);
}
}
if (resultsLayers.Count > 0)
{
GisEditor.ActiveMap.AddLayersBySettings(resultsLayers, true);
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(resultsLayers, RefreshArgsDescription.PlaceFilesOnMapDescription));
}
}
private static void LoadNoaaLayer <T>(string uri, bool refresh = true) where T : Layer
{
NoaaWeatherOverlay weatherOverlay = GisEditor.ActiveMap.Overlays.OfType <NoaaWeatherOverlay>().FirstOrDefault();
if (weatherOverlay == null)
{
weatherOverlay = new NoaaWeatherOverlay();
GisEditor.ActiveMap.Overlays.Add(weatherOverlay);
GisEditor.ActiveMap.Refresh(weatherOverlay);
}
T layer = weatherOverlay.Layers.OfType <T>().FirstOrDefault();
if (layer == null)
{
GetLayersParameters parameters = new GetLayersParameters();
parameters.LayerUris.Add(new Uri(uri));
layer = GisEditor.LayerManager.GetLayers <T>(parameters).FirstOrDefault();
weatherOverlay.Layers.Add(layer);
}
layer.IsVisible = true;
if (refresh)
{
weatherOverlay.Refresh();
GisEditor.UIManager.RefreshPlugins();
}
}
protected override void LoadToMapCore()
{
if (File.Exists(OutputPathFileName))
{
var getLayersParameters = new GetLayersParameters();
getLayersParameters.LayerUris.Add(new Uri(OutputPathFileName));
var layers = GisEditor.LayerManager.GetLayers <ShapeFileFeatureLayer>(getLayersParameters);
if (layers != null)
{
if (Application.Current != null)
{
//we need to use the dispatcher here, because the "Buffer" method is called by another thread.
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
GisEditor.ActiveMap.AddLayersBySettings(layers);
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.LoadToMapCoreDescription));
}));
}
else
{
GisEditor.ActiveMap.AddLayersBySettings(layers);
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.LoadToMapCoreDescription));
}
}
}
}
private Collection <PostgreSqlFeatureLayer> GetPostgreSqlFeatureLayers()
{
PostgreSchemaDataRepositoryItem schemaItem = Parent.Parent as PostgreSchemaDataRepositoryItem;
if (schemaItem != null)
{
DatabaseDataRepositoryItem databaseItem = schemaItem.Parent.Parent as DatabaseDataRepositoryItem;
if (databaseItem != null)
{
PostgreServerDataRepositoryItem serverItem = databaseItem.Parent as PostgreServerDataRepositoryItem;
if (serverItem != null)
{
string connectionString = PostgreServerDataRepositoryPlugin.GetConnectionString(serverItem, databaseItem.Name);
if (string.IsNullOrEmpty(idColumnName))
{
try
{
PostgreSqlFeatureSource featureSource = new PostgreSqlFeatureSource(connectionString, Name, "oid");
featureSource.SchemaName = schemaItem.SchemaName;
featureSource.Open();
List <string> newColumnNames = featureSource.GetColumns().Select(c => c.ColumnName).ToList();
featureSource.Close();
FeatureIdColumnWindow featureIdColumnWindow = new FeatureIdColumnWindow(newColumnNames);
featureIdColumnWindow.Owner = Application.Current.MainWindow;
featureIdColumnWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
if (featureIdColumnWindow.ShowDialog().GetValueOrDefault())
{
IdColumnName = featureIdColumnWindow.FeatureIdColumn;
}
}
catch { }
}
if (string.IsNullOrEmpty(IdColumnName))
{
return(new Collection <PostgreSqlFeatureLayer>());
}
string[] tableInfo = tableName.Split(':');
string url = "postgreSqlFeatureLayer:{0}|{1}|{2}|{3}";
url = String.Format(CultureInfo.InvariantCulture, url, tableInfo[1], tableInfo[0], connectionString, idColumnName);
Uri layerUri = new Uri(url);
GetLayersParameters layerParameters = new GetLayersParameters();
layerParameters.LayerUris.Add(layerUri);
Collection <PostgreSqlFeatureLayer> newLayers = GisEditor.LayerManager.GetLayers <PostgreSqlFeatureLayer>(layerParameters);
if (newLayers.Count > 0)
{
return(newLayers);
}
}
}
}
return(new Collection <PostgreSqlFeatureLayer>());
}
protected override void LoadToMapCore()
{
///var gridPlugin = GisEditor.LayerManager.GetSortedPlugins<GridLayerPlugin>().FirstOrDefault();
var getLayersParameters = new GetLayersParameters();
getLayersParameters.LayerUris.Add(new Uri(OutputPathFileName));
var layers = GisEditor.LayerManager.GetLayers <GridFeatureLayer>(getLayersParameters);
//var layers = gridPlugin.GetLayers(getLayersParameters);
GisEditor.ActiveMap.AddLayersBySettings(layers);
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.LoadToMapCoreDescription));
}
protected override Collection <Layer> GetLayersCore(GetLayersParameters getLayersParameters)
{
Collection <Layer> resultLayers = base.GetLayersCore(getLayersParameters);
foreach (var fileName in getLayersParameters.LayerUris.Select(u => u.LocalPath))
{
TinyGeoFeatureLayer layer = new TinyGeoFeatureLayer(fileName);
layer.Name = Path.GetFileNameWithoutExtension(fileName);
resultLayers.Add(layer);
}
return(resultLayers);
}
protected override Collection <Layer> GetLayersCore(GetLayersParameters getLayersParameters)
{
NoaaRadarRasterLayer noaaRadarRasterLayer = new NoaaRadarRasterLayer();
noaaRadarRasterLayer.Transparency = 50 * 2.55f;
string wgs84Parameters = Proj4Projection.GetWgs84ParametersString();
noaaRadarRasterLayer.InitializeProj4Projection(wgs84Parameters);
return(new Collection <Layer> {
noaaRadarRasterLayer
});
}
protected override void LoadToMapCore()
{
var getLayersParameters = new GetLayersParameters();
getLayersParameters.LayerUris.Add(new Uri(OutputPathFileName));
var layers = GisEditor.LayerManager.GetLayers <ShapeFileFeatureLayer>(getLayersParameters);
if (layers.Count > 0)
{
GisEditor.ActiveMap.AddLayersBySettings(layers);
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.LoadToMapCoreDescription));
}
}
protected override Collection <Layer> GetLayersCore(GetLayersParameters getLayersParameters)
{
Collection <Layer> resultLayers = base.GetLayersCore(getLayersParameters);
foreach (var fileName in getLayersParameters.LayerUris.Select(u => u.LocalPath))
{
var layer = new GisEditorTabFeatureLayer(fileName);
layer.Name = Path.GetFileNameWithoutExtension(fileName);
layer.RequireIndex = false;
resultLayers.Add(layer);
}
return(resultLayers);
}
protected override Collection <Layer> GetLayersCore(GetLayersParameters getLayersParameters)
{
Collection <Layer> layers = new Collection <Layer>();
foreach (var uri in getLayersParameters.LayerUris.Where(u => u != null))
{
InMemoryFeatureLayer layer = new InMemoryFeatureLayer();
layer.Name = uri.LocalPath;
layers.Add(layer);
}
return(layers);
}
private Collection <ShapeFileFeatureLayer> GetShapeFileLayers(IEnumerable <string> fileNames)
{
GetLayersParameters getLayersParameters = new GetLayersParameters();
foreach (string item in fileNames)
{
if (File.Exists(item))
{
getLayersParameters.LayerUris.Add(new Uri(item));
}
}
return(GisEditor.LayerManager.GetLayers <ShapeFileFeatureLayer>(getLayersParameters));
}
private void AddToMap()
{
if (NeedAddToMap)
{
var getLayersParameters = new GetLayersParameters();
getLayersParameters.LayerUris.Add(new Uri(OutputPathFileName));
var newLayers = GisEditor.LayerManager.GetLayers <ShapeFileFeatureLayer>(getLayersParameters);
GisEditor.ActiveMap.Dispatcher.BeginInvoke(new Action(() =>
{
GisEditor.ActiveMap.AddLayersBySettings(newLayers);
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.AddToMapDescription));
}));
}
}
private void AddSimplifiedFileToMap()
{
var getLayersParameters = new GetLayersParameters();
getLayersParameters.LayerUris.Add(new Uri(OutputPathFileName));
var layers = GisEditor.LayerManager.GetLayers <ShapeFileFeatureLayer>(getLayersParameters);
if (layers != null)
{
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
GisEditor.ActiveMap.AddLayersBySettings(layers);
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.AddSimplifiedFileToMapDescription));
}));
}
}
private Collection <MsSqlFeatureLayer> GetMsSql2008FeatureLayers()
{
if (LayerInfo != null)
{
MsSqlServerDataRepositoryItem serverItem = Parent.Parent.Parent.Parent.Parent as MsSqlServerDataRepositoryItem;
if (serverItem != null)
{
LayerInfo.TableName = TableName;
LayerInfo.DatabaseName = DatabaseName;
LayerInfo.SchemaName = SchemaName;
Collection <string> newColumnNames = LayerInfo.CollectColumnsFromTable();
FeatureIdColumnWindow featureIdColumnWindow = new FeatureIdColumnWindow(newColumnNames);
featureIdColumnWindow.Owner = Application.Current.MainWindow;
featureIdColumnWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
if (featureIdColumnWindow.ShowDialog().GetValueOrDefault())
{
GetLayersParameters layerParameters = new GetLayersParameters();
layerParameters.CustomData["TableName"] = TableName;
layerParameters.CustomData["SchemaName"] = SchemaName;
layerParameters.CustomData["DatabaseName"] = DatabaseName;
layerParameters.CustomData["IdColumn"] = featureIdColumnWindow.FeatureIdColumn;
layerParameters.CustomData["ServerName"] = serverItem.Name;
layerParameters.CustomData["UserName"] = serverItem.UserName;
layerParameters.CustomData["Password"] = serverItem.Password;
Collection <MsSqlFeatureLayer> newLayers = new Collection <MsSqlFeatureLayer>();
try
{
newLayers = GisEditor.LayerManager.GetLayers <MsSqlFeatureLayer>(layerParameters);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Unable to Load Layer(s)", MessageBoxButton.OK, MessageBoxImage.Error);
}
if (newLayers != null && newLayers.Count > 0)
{
return(newLayers);
}
}
}
}
return(new Collection <MsSqlFeatureLayer>());
}
protected override Collection <Layer> GetLayersCore(GetLayersParameters getLayersParameters)
{
Collection <Layer> layers = new Collection <Layer>();
foreach (Uri uri in getLayersParameters.LayerUris)
{
string tableName = uri.LocalPath.Split('|')[0];
string schema = uri.LocalPath.Split('|')[1];
string connectionString = uri.LocalPath.Split('|')[2];
string featureIdColumn = uri.LocalPath.Split('|')[3];
PostgreSqlFeatureLayer postgreSqlFeatureLayer = new PostgreSqlFeatureLayer(connectionString, tableName, featureIdColumn);
postgreSqlFeatureLayer.SchemaName = schema;
postgreSqlFeatureLayer.Name = postgreSqlFeatureLayer.TableName;
postgreSqlFeatureLayer.CommandTimeout = Singleton <ServerFeatureLayerSettingsUserControl> .Instance.PostgreTimeoutInSecond;
layers.Add(postgreSqlFeatureLayer);
}
return(layers);
}
protected override Collection <Layer> GetLayersCore(GetLayersParameters getLayersParameters)
{
Collection <Layer> resultLayers = base.GetLayersCore(getLayersParameters);
Func <string, bool> checkGRIIsExist = fileName => File.Exists(Path.ChangeExtension(fileName, ".gri"));
if (getLayersParameters.LayerUris.Select(u => u.LocalPath).Any(checkGRIIsExist))
{
MessageBox.Show(GisEditor.LanguageManager.GetStringResource("GridFileLayerPluginFormatNotSupportedText"));
}
foreach (var gridFile in getLayersParameters.LayerUris.Select(u => u.LocalPath).Where(fileName => !checkGRIIsExist(fileName)))
{
GridFeatureLayer gridFeatureLayer = new GridFeatureLayer(gridFile);
gridFeatureLayer.Name = Path.GetFileNameWithoutExtension(gridFile);
resultLayers.Add(gridFeatureLayer);
}
return(resultLayers);
}
protected override Collection <Layer> GetLayersCore(GetLayersParameters getLayersParameters)
{
NoaaWeatherStationFeatureLayer noaaWeatherStationFeatureLayer = new NoaaWeatherStationFeatureLayer();
GisEditor.LayerManager.FeatureIdColumnNames[noaaWeatherStationFeatureLayer.FeatureSource.Id] = "StationId";
CompositeStyle compositeStyle = new CompositeStyle(new NoaaWeatherStationStyle());
foreach (ZoomLevel zoomLevel in GisEditor.ActiveMap.ZoomLevelSet.GetZoomLevels())
{
ZoomLevel newZoomLevel = new ZoomLevel(zoomLevel.Scale);
newZoomLevel.CustomStyles.Add(compositeStyle);
noaaWeatherStationFeatureLayer.ZoomLevelSet.CustomZoomLevels.Add(newZoomLevel);
}
return(new Collection <Layer> {
noaaWeatherStationFeatureLayer
});
}
protected override Collection <Layer> GetLayersCore(GetLayersParameters getLayersParameters)
{
Collection <Layer> layers = base.GetLayersCore(getLayersParameters);
foreach (var uri in getLayersParameters.LayerUris)
{
WorldFileInfo wInfo = GetWorldFileInfo(uri);
RasterLayer layer = GetRasterLayer(uri, wInfo);
if (layer != null)
{
layer.UpperThreshold = double.MaxValue;
layer.LowerThreshold = 0d;
layer.Name = Path.GetFileNameWithoutExtension(uri.LocalPath);
layer.Open();
if (!layer.HasProjectionText)
{
string proj4PathFileName = Path.ChangeExtension(uri.LocalPath, "prj");
string proj4Parameter = LayerPluginHelper.GetProj4ProjectionParameter(proj4PathFileName);
if (!string.IsNullOrEmpty(proj4Parameter))
{
layer.InitializeProj4Projection(proj4Parameter);
}
}
else
{
string proj = layer.GetProjectionText().Trim();
if (!string.IsNullOrEmpty(proj))
{
layer.InitializeProj4Projection(proj);
}
}
layer.Close();
layers.Add(layer);
}
}
return(layers);
}
protected override void LoadToMapCore()
{
var layerPathFileNames = SourceFiles.Select(s => Path.Combine(OutputFolder, s.ShortName));
//var shapeFileLayerPlugin = GisEditor.LayerManager.GetSortedPlugins<ShapeFileFeatureLayerPlugin>().FirstOrDefault();
//if (shapeFileLayerPlugin != null)
{
var getLayersParameters = new GetLayersParameters();
foreach (var item in layerPathFileNames.Where(f => File.Exists(f)))
{
getLayersParameters.LayerUris.Add(new Uri(item));
}
// var layers = shapeFileLayerPlugin.GetLayers(getLayersParameters);
var layers = GisEditor.LayerManager.GetLayers <ShapeFileFeatureLayer>(getLayersParameters);
GisEditor.ActiveMap.Dispatcher.BeginInvoke(new Action(() =>
{
GisEditor.ActiveMap.AddLayersBySettings(layers);
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.LoadToMapCoreDescription));
}));
}
}
public static void CopyToNewLayer(Collection <FeatureLayer> selectedFeaturesLayers)
{
Collection <FeatureLayer> existLayers = new Collection <FeatureLayer>();
foreach (var item in GisEditor.ActiveMap.GetFeatureLayers().OfType <InMemoryFeatureLayer>())
{
existLayers.Add(item);
}
GetLayersParameters parameters = new GetLayersParameters();
parameters.LayerUris.Add(new Uri("mem:Newlayer"));
InMemoryFeatureLayerPlugin plugin = GisEditor.LayerManager.GetActiveLayerPlugins <InMemoryFeatureLayerPlugin>().FirstOrDefault();
InMemoryFeatureLayer inMemoryFeatureLayer = null;
if (plugin != null)
{
inMemoryFeatureLayer = plugin.GetLayers(parameters).OfType <InMemoryFeatureLayer>().FirstOrDefault();
inMemoryFeatureLayer.Name = "New layer";
existLayers.Insert(0, inMemoryFeatureLayer);
}
if (selectedFeaturesLayers.Count > 1)
{
AddFeaturesToSelectedLayer(selectedFeaturesLayers, existLayers);
GisEditor.ActiveMap.Refresh(GisEditor.ActiveMap.ActiveOverlay);
RefreshArgs refreshArgs = new RefreshArgs(GisEditor.ActiveMap, RefreshArgsDescription.AddLayerGroupCommandDescription);
GisEditor.UIManager.BeginRefreshPlugins(refreshArgs);
LayerOverlay overlay = GisEditor.ActiveMap.ActiveOverlay as LayerOverlay;
if (overlay != null)
{
overlay.Invalidate();
}
}
else if (selectedFeaturesLayers.Count == 1)
{
AddFeatureToInMemoryFeatureLayer(null, selectedFeaturesLayers[0]);
}
}
protected override void LoadToMapCore()
{
if (File.Exists(OutputPathFileName))
{
var getLayersParameters = new GetLayersParameters();
getLayersParameters.LayerUris.Add(new Uri(OutputPathFileName));
var layers = GisEditor.LayerManager.GetLayers <ShapeFileFeatureLayer>(getLayersParameters);
GisEditor.ActiveMap.Dispatcher.BeginInvoke(new Action(() =>
{
GisEditor.ActiveMap.AddLayersBySettings(layers);
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.LoadToMapCoreDescription));
}));
}
try
{
ShapeFileFeatureLayerExtension.RemoveShapeFiles(tempFilePath);
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Error, ex.Message, ex);
}
}
protected override Collection <Layer> GetLayersCore(GetLayersParameters getLayersParameters)
{
Collection <Layer> layers = base.GetLayersCore(getLayersParameters);
WmsRasterLayerConfigWindow wmsWindow = new WmsRasterLayerConfigWindow();
wmsWindow.ViewModel.AddToDataRepositoryVisibility = Visibility.Visible;
if (wmsWindow.ShowDialog().GetValueOrDefault())
{
WmsRasterLayer wmsRasterlayer = wmsWindow.ViewModel.WmsRasterLayer;
wmsRasterlayer.InitializeProj4Projection(GisEditor.ActiveMap.DisplayProjectionParameters);
if (wmsRasterlayer != null && wmsRasterlayer.ActiveLayerNames.Count > 0)
{
WmsRasterLayer layer = wmsRasterlayer;
layers.Add(layer);
}
if (wmsWindow.ViewModel.DoesAddToDataRepository)
{
var wmsDataPlugin = GisEditor.DataRepositoryManager.GetPlugins().OfType <WmsDataRepositoryPlugin>().FirstOrDefault();
if (wmsDataPlugin != null)
{
wmsDataPlugin.RootDataRepositoryItem.Children.Add(new WmsDataRepositoryItem(
wmsWindow.ViewModel.Name,
new ObservableCollection <string>(wmsWindow.ViewModel.AvailableLayers.Select(l => l.Name)),
wmsWindow.ViewModel.WmsServerUrl,
wmsWindow.ViewModel.UserName,
wmsWindow.ViewModel.Password,
wmsWindow.ViewModel.Parameters,
wmsWindow.ViewModel.Formats,
wmsWindow.ViewModel.Styles,
wmsWindow.ViewModel.SelectedFormat,
wmsWindow.ViewModel.SelectedStyle));
}
}
}
return(layers);
}
protected override Collection <Layer> GetLayersCore(GetLayersParameters getLayersParameters)
{
Collection <Layer> resultLayers = base.GetLayersCore(getLayersParameters);
Collection <Uri> uris = getLayersParameters.LayerUris;
Collection <string> invalidFileNames = new Collection <string>();
foreach (Uri uri in uris)
{
var fileName = uri.LocalPath;
if (ValidShapeFile(fileName))
{
RemoveReadonlyAttribute(fileName);
try
{
var shapeFileFeatureLayer = new ShapeFileFeatureLayer(fileName, GeoFileReadWriteMode.Read);
shapeFileFeatureLayer.Name = Path.GetFileNameWithoutExtension(fileName);
shapeFileFeatureLayer.Encoding = GetEncoding(fileName);
shapeFileFeatureLayer.SimplificationAreaInPixel = 4;
shapeFileFeatureLayer.RequireIndex = false;
shapeFileFeatureLayer.DrawingExceptionMode = DrawingExceptionMode.DrawException;
resultLayers.Add(shapeFileFeatureLayer);
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
System.Windows.Forms.MessageBox.Show(GisEditor.LanguageManager.GetStringResource("FileLayerPluginUsedByAnotherProcessText"), GisEditor.LanguageManager.GetStringResource("FileLayerPluginFilebeingusedCaption"));
}
}
else
{
string shxPath = Path.ChangeExtension(fileName, ".shx");
string dbfPath = Path.ChangeExtension(fileName, ".dbf");
if (!File.Exists(fileName))
{
invalidFileNames.Add(fileName);
}
if (!File.Exists(shxPath))
{
invalidFileNames.Add(shxPath);
}
if (!File.Exists(dbfPath))
{
invalidFileNames.Add(dbfPath);
}
}
}
if (invalidFileNames.Count > 0)
{
StringBuilder sb = new StringBuilder();
foreach (var item in invalidFileNames)
{
sb.Append(item + ", ");
}
GisEditorMessageBox messageBox = new GisEditorMessageBox(MessageBoxButton.OK);
messageBox.Title = GisEditor.LanguageManager.GetStringResource("MissingShapefilesCaption");
messageBox.Message = GisEditor.LanguageManager.GetStringResource("SomeShapeFilesMissingMessage");
messageBox.ErrorMessage = string.Format(errorMessageFormat, sb.Remove(sb.Length - 2, 2).ToString());
messageBox.ShowDialog();
}
return(resultLayers);
}
public static Collection <Layer> AddDropFilesToActiveMap(DragEventArgs e, bool refreshPlugins = true)
{
Collection <Layer> layersToAdd = new Collection <Layer>();
var dropFiles = (string[])e.Data.GetData(DataFormats.FileDrop);
if (dropFiles != null)
{
var dropFileGroups = dropFiles.GroupBy(tmpFile => Path.GetExtension(tmpFile).ToUpperInvariant());
var unsupportedExtensions = new StringBuilder();
foreach (var fileGroup in dropFileGroups)
{
var ext = fileGroup.Key;
var matchingLayerProvider = GisEditor.LayerManager.GetActiveLayerPlugins <LayerPlugin>()
.FirstOrDefault(tmpPlugin => tmpPlugin.ExtensionFilter.ToUpperInvariant().Contains(ext));
if (matchingLayerProvider != null)
{
Collection <Layer> layers = new Collection <Layer>();
var getLayersParameters = new GetLayersParameters();
foreach (var item in fileGroup)
{
getLayersParameters.LayerUris.Add(new Uri(item));
}
try
{
layers = matchingLayerProvider.GetLayers(getLayersParameters);
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
System.Windows.Forms.MessageBox.Show(ex.Message, "Warning", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Warning);
}
finally
{
foreach (var tmpLayer in layers)
{
layersToAdd.Add(tmpLayer);
}
}
}
else
{
unsupportedExtensions.AppendFormat(CultureInfo.InvariantCulture, "{0}, ", fileGroup.Key);
}
}
if (layersToAdd.Count > 0 && GisEditor.ActiveMap != null)
{
GisEditor.ActiveMap.AddLayersBySettings(layersToAdd, true);
if (refreshPlugins)
{
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(null, RefreshArgsDescription.MapDropDescription));
}
}
if (unsupportedExtensions.Length > 0 && Application.Current != null)
{
System.Windows.Forms.MessageBox.Show(String.Format(CultureInfo.InvariantCulture, "The following data type is not supported:\r\n\r\n {0}", unsupportedExtensions.ToString().Trim(' ', ','))
, "Unsupported data type error"
, System.Windows.Forms.MessageBoxButtons.OK
, System.Windows.Forms.MessageBoxIcon.Error);
}
}
return(layersToAdd);
}
private static void AddLayerByFileGeodatabaseWindow(Collection <Layer> resultLayers, string fileName, GetLayersParameters getLayersParameters = null)
{
string tableName = string.Empty;
string featureIdColumn = "OBJECTID";
if (getLayersParameters != null)
{
if (getLayersParameters.CustomData.ContainsKey("TableName"))
{
tableName = getLayersParameters.CustomData["TableName"] as string;
}
if (getLayersParameters.CustomData.ContainsKey("ObjectId"))
{
featureIdColumn = getLayersParameters.CustomData["ObjectId"] as string;
}
}
if (string.IsNullOrEmpty(tableName))
{
FileGeoDatabaseWindow fileGeoDatabaseWindow = new FileGeoDatabaseWindow(fileName);
fileGeoDatabaseWindow.Owner = Application.Current.MainWindow;
fileGeoDatabaseWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
if (fileGeoDatabaseWindow.ShowDialog().GetValueOrDefault())
{
tableName = fileGeoDatabaseWindow.TableName;
featureIdColumn = fileGeoDatabaseWindow.FeatureIdColumn;
}
}
if (Directory.Exists(fileName) && fileName.EndsWith(".gdb"))
{
try
{
if (!string.IsNullOrEmpty(tableName))
{
FileGeoDatabaseFeatureLayer fileGeoDatabaseFeatureLayer = new FileGeoDatabaseFeatureLayer(fileName, tableName, featureIdColumn);
fileGeoDatabaseFeatureLayer.Name = char.ToUpper(tableName[0]) + tableName.Substring(1);
resultLayers.Add(fileGeoDatabaseFeatureLayer);
}
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
System.Windows.Forms.MessageBox.Show(GisEditor.LanguageManager.GetStringResource("FileLayerPluginUsedByAnotherProcessText"), GisEditor.LanguageManager.GetStringResource("FileLayerPluginFilebeingusedCaption"));
}
}
else
{
MessageBox.Show(GisEditor.LanguageManager.GetStringResource("FileGeoFormatInvalid"));
}
}
