//protected override OutputWindow GetExportFeatureLayerUICore()
//{
// CreateFileGeodatabaseWindow outputWindow = new CreateFileGeodatabaseWindow(string.Empty);
// outputWindow.DefaultPrefix = "ExportResult";
// outputWindow.ExtensionFilter = "FileGeodatabase file *.gdb|*.gdb";
// outputWindow.Extension = ".gdb";
// outputWindow.OutputMode = OutputMode.ToTemporary;
// return outputWindow;
//}
protected override ConfigureFeatureLayerParameters GetCreateFeatureLayerParametersCore(IEnumerable <FeatureSourceColumn> columns)
{
CreateFileGeodatabaseWindow outputWindow = new CreateFileGeodatabaseWindow();
outputWindow.OutputMode = OutputMode.ToFile;
outputWindow.DefaultPrefix = "ExportResult";
outputWindow.ExtensionFilter = "FileGeodatabase file *.gdb|*.gdb";
outputWindow.Extension = ".gdb";
outputWindow.OutputMode = OutputMode.ToTemporary;
outputWindow.Proj4ProjectionParametersString = GisEditor.ActiveMap.DisplayProjectionParameters;
outputWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
outputWindow.Owner = Application.Current.MainWindow;
ConfigureFeatureLayerParameters configureFeatureLayerParameters = null;
if (outputWindow.ShowDialog().GetValueOrDefault())
{
configureFeatureLayerParameters = new ConfigureFeatureLayerParameters(outputWindow.LayerUri);
configureFeatureLayerParameters.Proj4ProjectionParametersString = outputWindow.Proj4ProjectionParametersString;
foreach (var item in outputWindow.CustomData)
{
configureFeatureLayerParameters.CustomData[item.Key] = item.Value;
}
}
return(configureFeatureLayerParameters);
}
protected override ConfigureFeatureLayerParameters GetCreateFeatureLayerParametersCore(IEnumerable <FeatureSourceColumn> columns)
{
ConfigureFeatureLayerParameters configureFeatureLayerParameters = null;
var featureLayer = GisEditor.LayerListManager.SelectedLayerListItem.ConcreteObject as FeatureLayer;
if (featureLayer != null)
{
WellKnownType wellKnownType =
featureLayer.FeatureSource.GetFirstFeaturesWellKnownType();
OutputWindow outputWindow = new CsvOutputWindow(wellKnownType);
outputWindow.OutputMode = OutputMode.ToFile;
outputWindow.Extension = ".csv";
outputWindow.ExtensionFilter = "Csv Files|*.csv";
if (string.IsNullOrEmpty(OutputWindow.SavedProj4ProjectionParametersString))
{
outputWindow.Proj4ProjectionParametersString = GisEditor.ActiveMap.DisplayProjectionParameters;
}
else
{
outputWindow.Proj4ProjectionParametersString = OutputWindow.SavedProj4ProjectionParametersString;
}
if (outputWindow.ShowDialog().GetValueOrDefault())
{
configureFeatureLayerParameters = new ConfigureFeatureLayerParameters(outputWindow.LayerUri);
configureFeatureLayerParameters.Proj4ProjectionParametersString = outputWindow.Proj4ProjectionParametersString;
OutputWindow.SavedProj4ProjectionParametersString = outputWindow.Proj4ProjectionParametersString;
foreach (var item in outputWindow.CustomData)
{
configureFeatureLayerParameters.CustomData[item.Key] = item.Value;
}
}
}
return(configureFeatureLayerParameters);
}
private static void Window_OkButtonClicking(object sender, RoutedEventArgs e)
{
GeneralWindow window = (GeneralWindow)sender;
CreateFeatureLayerUserControl userControl = (CreateFeatureLayerUserControl)window.Tag;
string message = userControl.InvalidMessage;
if (!string.IsNullOrEmpty(message))
{
MessageBox.Show(message, "Warning", MessageBoxButton.OK, MessageBoxImage.Warning);
e.Handled = true;
}
ConfigureFeatureLayerParameters parameters = userControl.GetFeatureLayerInfo();
if (Directory.Exists(parameters.LayerUri.LocalPath))
{
string name = Path.GetFileName(parameters.LayerUri.LocalPath);
string existMessage = string.Format(CultureInfo.InvariantCulture, "The destination already has a file named {0}, do you want to replace the file in destination?", name);
MessageBoxResult result = MessageBox.Show(existMessage, "Warning", MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (result == MessageBoxResult.No)
{
e.Handled = true;
}
else
{
try
{
Directory.Delete(parameters.LayerUri.LocalPath, true);
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
}
}
}
}
protected override ConfigureFeatureLayerParameters GetCreateFeatureLayerParametersCore(IEnumerable <FeatureSourceColumn> columns)
{
OutputWindow outputWindow = GisEditor.ControlManager.GetUI <OutputWindow>();
outputWindow.OutputMode = OutputMode.ToFile;
outputWindow.Extension = ".tgeo";
outputWindow.ExtensionFilter = "TinyGeo Files|*.tgeo";
if (string.IsNullOrEmpty(OutputWindow.SavedProj4ProjectionParametersString))
{
outputWindow.Proj4ProjectionParametersString = GisEditor.ActiveMap.DisplayProjectionParameters;
}
else
{
outputWindow.Proj4ProjectionParametersString = OutputWindow.SavedProj4ProjectionParametersString;
}
outputWindow.CustomData["Columns"] = new Collection <FeatureSourceColumn>(columns.ToList());
ConfigureFeatureLayerParameters configureFeatureLayerParameters = null;
if (outputWindow.ShowDialog().GetValueOrDefault())
{
configureFeatureLayerParameters = new ConfigureFeatureLayerParameters(outputWindow.LayerUri);
configureFeatureLayerParameters.Proj4ProjectionParametersString = outputWindow.Proj4ProjectionParametersString;
OutputWindow.SavedProj4ProjectionParametersString = outputWindow.Proj4ProjectionParametersString;
foreach (var item in outputWindow.CustomData)
{
configureFeatureLayerParameters.CustomData[item.Key] = item.Value;
}
}
return(configureFeatureLayerParameters);
}
protected override ConfigureFeatureLayerParameters GetFeatureLayerInfoCore()
{
ConfigureFeatureLayerParameters parameters = new ConfigureFeatureLayerParameters();
if (featureLayer != null)
{
IEnumerable <FeatureSourceColumn> addedColumns = viewModel.CsvColumns.Where(c => c.ChangedStatus == FeatureSourceColumnChangedStatus.Added).Select(l => l.ToFeatureSourceColumn());
IEnumerable <AddNewCsvColumnViewModel> updatedColumnItems = viewModel.CsvColumns.Where(c => c.ChangedStatus == FeatureSourceColumnChangedStatus.Updated);
IEnumerable <FeatureSourceColumn> deletedColumns = viewModel.CsvColumns.Where(c => c.ChangedStatus == FeatureSourceColumnChangedStatus.Deleted).Select(l => l.ToFeatureSourceColumn());
foreach (var item in deletedColumns)
{
parameters.DeletedColumns.Add(item);
}
foreach (var item in updatedColumnItems)
{
parameters.UpdatedColumns[item.OriginalColumnName] = item.ToFeatureSourceColumn();
}
foreach (var item in addedColumns)
{
parameters.AddedColumns.Add(item);
}
}
else
{
foreach (var item in viewModel.CsvColumns.Where(c => c.ChangedStatus != FeatureSourceColumnChangedStatus.Deleted).Select(c => c.ToFeatureSourceColumn()))
{
parameters.AddedColumns.Add(item);
}
}
string pathFileName = string.Format(@"{0}\{1}.{2}", ViewModel.OutputFolder, ViewModel.FileName, "csv");
parameters.LayerUri = new Uri(Path.GetFullPath(pathFileName));
switch (ViewModel.SelectedShapeType)
{
case GeneralShapeFileType.Point:
parameters.WellKnownType = WellKnownType.Point;
break;
case GeneralShapeFileType.Line:
parameters.WellKnownType = WellKnownType.Line;
break;
case GeneralShapeFileType.Area:
parameters.WellKnownType = WellKnownType.Polygon;
break;
default:
parameters.WellKnownType = WellKnownType.Invalid;
break;
}
return(parameters);
}
protected override ConfigureFeatureLayerParameters GetFeatureLayerInfoCore()
{
ConfigureFeatureLayerParameters featureLayerInfo = new ConfigureFeatureLayerParameters();
FeatureLayer featureLayer = lbxFeatureLayers.SelectedItem as FeatureLayer;
if (featureLayer != null)
{
featureLayerInfo.CustomData["SourceLayer"] = featureLayer;
featureLayerInfo.WellKnownType = featureLayer.FeatureSource.GetFirstFeaturesWellKnownType();
}
featureLayerInfo.LayerUri = new Uri(string.Format(@"{0}\{1}.tgeo", txtOutput.Text, txtLayerName.Text));
return(featureLayerInfo);
}
protected override ConfigureFeatureLayerParameters GetConfigureFeatureLayerParametersCore(FeatureLayer featureLayer)
{
CreateFeatureLayerUserControl userControl = new ConfigTinyGeoFileUserControl(featureLayer);
GeneralWindow window = new GeneralWindow();
window.Tag = userControl;
window.OkButtonClicking += OKButtonClicking;
window.Title = GisEditor.LanguageManager.GetStringResource("TinyGeoWindowTitle");
window.Owner = Application.Current.MainWindow;
window.HelpContainer.Content = HelpResourceHelper.GetHelpButton("CreateNewShapefileHelp", HelpButtonMode.NormalButton);
window.WindowStartupLocation = WindowStartupLocation.CenterOwner;
window.ResizeMode = ResizeMode.NoResize;
window.SizeToContent = SizeToContent.WidthAndHeight;
window.ContentUI.Content = userControl;
ConfigureFeatureLayerParameters parameters = null;
if (window.ShowDialog().GetValueOrDefault())
{
parameters = userControl.GetFeatureLayerInfo();
}
return(parameters);
}
protected override ConfigureFeatureLayerParameters GetConfigureFeatureLayerParametersCore(FeatureLayer featureLayer)
{
ConfigCsvFileUserControl userControl = new ConfigCsvFileUserControl(featureLayer);
GeneralWindow window = new GeneralWindow();
window.Tag = userControl;
window.OkButtonClicking += Window_OkButtonClicking;
window.Title = GisEditor.LanguageManager.GetStringResource("CSVLayerWindowTitle");
window.Owner = Application.Current.MainWindow;
window.HelpContainer.Content = HelpResourceHelper.GetHelpButton("CreateNewShapefileHelp", HelpButtonMode.NormalButton);
window.WindowStartupLocation = WindowStartupLocation.CenterOwner;
window.ResizeMode = ResizeMode.NoResize;
window.SizeToContent = SizeToContent.WidthAndHeight;
window.ContentUI.Content = userControl;
ConfigureFeatureLayerParameters parameters = null;
if (window.ShowDialog().GetValueOrDefault())
{
parameters = userControl.GetFeatureLayerInfo();
parameters.CustomData["Delimiter"] = userControl.ViewModel.Delimiter;
parameters.CustomData["MappingType"] = userControl.ViewModel.MappingType;
parameters.CustomData["X"] = GetSpecificColumnName(userControl.ViewModel.CsvColumns, CsvColumnType.Longitude);
parameters.CustomData["Y"] = GetSpecificColumnName(userControl.ViewModel.CsvColumns, CsvColumnType.Latitude);
parameters.CustomData["WKT"] = GetSpecificColumnName(userControl.ViewModel.CsvColumns, CsvColumnType.WKT);
CsvFeatureLayer csvFeatureLayer = featureLayer as CsvFeatureLayer;
if (csvFeatureLayer != null)
{
csvFeatureLayer.XColumnName = parameters.CustomData["X"].ToString();
csvFeatureLayer.YColumnName = parameters.CustomData["Y"].ToString();
csvFeatureLayer.WellKnownTextColumnName = parameters.CustomData["WKT"].ToString();
}
}
return(parameters);
}
protected override FeatureLayer CreateFeatureLayerCore(ConfigureFeatureLayerParameters featureLayerStructureParameters)
{
string layerPath = LayerPluginHelper.GetLayerUriToSave(featureLayerStructureParameters.LayerUri, ExtensionFilter);
if (string.IsNullOrEmpty(layerPath))
{
return(null);
}
featureLayerStructureParameters.LayerUri = new Uri(layerPath);
Collection <TabDbfColumn> tabDbfColumns = new Collection <TabDbfColumn>();
foreach (var column in featureLayerStructureParameters.AddedColumns)
{
var columnLenght = column.MaxLength;
var decimalLength = 0;
DbfColumnType columnType = DbfColumnType.Character;
switch (column.TypeName.ToUpperInvariant())
{
case "DOUBLE":
columnLenght = columnLenght == 0 ? 10 : columnLenght;
decimalLength = 4;
columnType = DbfColumnType.Float;
break;
case "DATE":
case "DATETIME":
columnLenght = columnLenght == 0 ? 10 : columnLenght;
decimalLength = 0;
columnType = DbfColumnType.Date;
break;
case "INTEGER":
case "INT":
columnLenght = columnLenght == 0 ? 10 : columnLenght;
decimalLength = 0;
columnType = DbfColumnType.Numeric;
break;
case "STRING":
case "CHARACTER":
columnLenght = columnLenght == 0 ? 255 : columnLenght;
decimalLength = 0;
columnType = DbfColumnType.Character;
break;
default:
break;
}
tabDbfColumns.Add(new TabDbfColumn(column.ColumnName, columnType, columnLenght, decimalLength, false, false));
}
if (featureLayerStructureParameters.CustomData.ContainsKey("SourceLayer"))
{
FeatureLayer sourcefeatureLayer = featureLayerStructureParameters.CustomData["SourceLayer"] as FeatureLayer;
double precisionInMeter = TinyGeoFeatureLayer.GetOptimalPrecision(sourcefeatureLayer, GisEditor.ActiveMap.MapUnit, DistanceUnit.Meter, TinyGeoPrecisionMode.PreventSplitting);
TinyGeoFeatureLayer.CreateTinyGeoFile(featureLayerStructureParameters.LayerUri.OriginalString, sourcefeatureLayer, GisEditor.ActiveMap.MapUnit, featureLayerStructureParameters.AddedColumns.Select(f => f.ColumnName).ToList(), "", precisionInMeter, Encoding.Default, featureLayerStructureParameters.WellKnownType);
string prjPath = Path.ChangeExtension(featureLayerStructureParameters.LayerUri.OriginalString, "prj");
File.WriteAllText(prjPath, Proj4Projection.ConvertProj4ToPrj(featureLayerStructureParameters.Proj4ProjectionParametersString));
}
var resultLayer = new TinyGeoFeatureLayer(featureLayerStructureParameters.LayerUri.OriginalString);
return(resultLayer);
}
protected override ConfigureFeatureLayerParameters GetFeatureLayerInfoCore()
{
ConfigFileGeoLayerStructureViewMode viewModel = DataContext as ConfigFileGeoLayerStructureViewMode;
ConfigureFeatureLayerParameters parameters = new ConfigureFeatureLayerParameters();
Collection <FeatureSourceColumn> originalColumns = new Collection <FeatureSourceColumn>();
if (configLayerStructureViewModel.FeatureLayer != null)
{
configLayerStructureViewModel.FeatureLayer.SafeProcess(() =>
{
originalColumns = configLayerStructureViewModel.FeatureLayer.FeatureSource.GetColumns();
});
}
IEnumerable <FeatureSourceColumn> addedColumns = viewModel.ColumnListItemSource.Where(c => c.ChangedStatus == FeatureSourceColumnChangedStatus.Added).Select(l => l.FeatureSourceColumn);
IEnumerable <FeatureSourceColumnItem> updatedColumnItems = viewModel.ColumnListItemSource.Where(c => c.ChangedStatus == FeatureSourceColumnChangedStatus.Updated);
IEnumerable <FeatureSourceColumn> deletedColumns = originalColumns.Where(o => viewModel.ColumnListItemSource.All(c => c.ColumnName != o.ColumnName) && updatedColumnItems.All(u => u.OrignalColumnName != o.ColumnName));
foreach (var item in deletedColumns)
{
parameters.DeletedColumns.Add(item);
}
foreach (var item in updatedColumnItems)
{
parameters.UpdatedColumns[item.OrignalColumnName] = item.FeatureSourceColumn;
}
foreach (var item in addedColumns)
{
parameters.AddedColumns.Add(item);
}
string pathFileName = string.Format(@"{0}\{1}.{2}", viewModel.LayerUri.OriginalString, viewModel.LayerName, "tab");
parameters.LayerUri = new Uri(Path.GetFullPath(pathFileName));
switch (viewModel.ShpFileType)
{
case GeneralShapeFileType.Point:
parameters.WellKnownType = WellKnownType.Point;
break;
case GeneralShapeFileType.Multipoint:
parameters.WellKnownType = WellKnownType.Multipoint;
break;
case GeneralShapeFileType.Line:
parameters.WellKnownType = WellKnownType.Line;
break;
case GeneralShapeFileType.Area:
parameters.WellKnownType = WellKnownType.Polygon;
break;
default:
parameters.WellKnownType = WellKnownType.Invalid;
break;
}
return(parameters);
}
protected override FeatureLayer CreateFeatureLayerCore(ConfigureFeatureLayerParameters featureLayerStructureParameters)
{
string layerPath = LayerPluginHelper.GetLayerUriToSave(featureLayerStructureParameters.LayerUri, ExtensionFilter);
string fileName = Path.GetFileNameWithoutExtension(layerPath);
if (string.IsNullOrEmpty(layerPath))
{
return(null);
}
if (fileName.FirstOrDefault() != null && Char.IsNumber(fileName.FirstOrDefault()))
{
MessageBox.Show("Table name can not start with number.");
return(null);
}
featureLayerStructureParameters.LayerUri = new Uri(layerPath);
Collection <FeatureSourceColumn> columns = new Collection <FeatureSourceColumn>();
System.Text.RegularExpressions.Regex regx = new System.Text.RegularExpressions.Regex(@"\W");
foreach (var column in featureLayerStructureParameters.AddedColumns)
{
FeatureSourceColumn newColumn = column;
if (newColumn.ColumnName.Equals("Null", StringComparison.Ordinal))
{
newColumn.ColumnName = "Null_";
}
newColumn.ColumnName = regx.Replace(newColumn.ColumnName, string.Empty);
columns.Add(newColumn);
}
string tableName = string.Empty;
if (featureLayerStructureParameters.CustomData.ContainsKey("TableName"))
{
//if (createFeatureLayerParameters.Tag != null)
//tableName = createFeatureLayerParameters.Tag.ToString().Split('|').First();
tableName = featureLayerStructureParameters.CustomData["TableName"] as string;
}
else
{
tableName = Path.GetFileNameWithoutExtension(featureLayerStructureParameters.LayerUri.OriginalString);
}
FileGeoDatabaseFeatureLayer.CreateFileGeoDatabase(featureLayerStructureParameters.LayerUri.OriginalString);
FileGeoDatabaseFeatureLayer.CreateTable(featureLayerStructureParameters.LayerUri.OriginalString, tableName, featureLayerStructureParameters.WellKnownType, columns);
string prjPath = Path.ChangeExtension(featureLayerStructureParameters.LayerUri.OriginalString, "prj");
File.WriteAllText(prjPath, Proj4Projection.ConvertProj4ToPrj(featureLayerStructureParameters.Proj4ProjectionParametersString));
FileGeoDatabaseFeatureLayer fileGeoDatabaseFeatureLayer = new FileGeoDatabaseFeatureLayer(featureLayerStructureParameters.LayerUri.LocalPath, tableName);
if (featureLayerStructureParameters.AddedFeatures.Count > 0)
{
fileGeoDatabaseFeatureLayer.Open();
fileGeoDatabaseFeatureLayer.EditTools.BeginTransaction();
foreach (var feature in featureLayerStructureParameters.AddedFeatures)
{
fileGeoDatabaseFeatureLayer.EditTools.Add(feature);
}
fileGeoDatabaseFeatureLayer.EditTools.CommitTransaction();
fileGeoDatabaseFeatureLayer.Close();
}
return(fileGeoDatabaseFeatureLayer);
}
private static void ExportToShapeFile(Collection <Feature> resultFeatures, Collection <FeatureSourceColumn> columns, FeatureLayerPlugin sourceLayerPlugin, WellKnownType type)
{
int count = resultFeatures.Count;
if (count > 0)
{
ShapeFileFeatureLayerPlugin targetLayerPlugin = GisEditor.LayerManager.GetActiveLayerPlugins <ShapeFileFeatureLayerPlugin>().FirstOrDefault();
FeatureLayer resultLayer = null;
GetLayersParameters getLayerParameters = new GetLayersParameters();
if (targetLayerPlugin != null)
{
ConfigureFeatureLayerParameters parameters = targetLayerPlugin.GetCreateFeatureLayerParameters(columns);
if (parameters != null && sourceLayerPlugin != null)
{
bool needColumns = false;
Collection <string> tempColumns = new Collection <string>();
if (parameters.CustomData.ContainsKey("Columns"))
{
tempColumns = parameters.CustomData["Columns"] as Collection <string>;
}
else
{
needColumns = true;
}
var featureColumns = columns.Where(c => needColumns || tempColumns.Contains(c.ColumnName));
if (targetLayerPlugin.CanCreateFeatureLayerWithSourceColumns(sourceLayerPlugin))
{
foreach (var item in featureColumns)
{
FeatureSourceColumn column = new FeatureSourceColumn(item.ColumnName, item.TypeName, item.MaxLength);
if (column.TypeName.Equals("c", StringComparison.InvariantCultureIgnoreCase))
{
column.TypeName = "Character";
}
parameters.AddedColumns.Add(column);
}
}
else
{
var geoColumns = sourceLayerPlugin.GetIntermediateColumns(featureColumns);
foreach (var item in geoColumns)
{
if (item.TypeName.Equals("c", StringComparison.InvariantCultureIgnoreCase))
{
item.TypeName = "Character";
}
parameters.AddedColumns.Add(item);
}
}
parameters.WellKnownType = type;
//parameters.CustomData["SourceLayer"] = featureLayer;
getLayerParameters.LayerUris.Add(parameters.LayerUri);
foreach (var item in parameters.CustomData)
{
getLayerParameters.CustomData[item.Key] = item.Value;
}
Proj4Projection proj4 = new Proj4Projection();
proj4.InternalProjectionParametersString = parameters.Proj4ProjectionParametersString;
proj4.ExternalProjectionParametersString = GisEditor.ActiveMap.DisplayProjectionParameters;
proj4.SyncProjectionParametersString();
proj4.Open();
foreach (var item in resultFeatures)
{
Feature feature = proj4.ConvertToInternalProjection(item);
parameters.AddedFeatures.Add(feature);
}
if (parameters.MemoColumnConvertMode == MemoColumnConvertMode.ToCharacter)
{
foreach (var item in parameters.AddedColumns.Where(c => c.TypeName.Equals("Memo", StringComparison.InvariantCultureIgnoreCase)).ToList())
{
//parameters.AddedColumns.Remove(item);
item.TypeName = "Character";
item.MaxLength = 254;
DbfColumn tmpDbfColumn = item as DbfColumn;
if (tmpDbfColumn != null)
{
tmpDbfColumn.ColumnType = DbfColumnType.Character;
tmpDbfColumn.Length = 254;
}
}
}
resultLayer = targetLayerPlugin.CreateFeatureLayer(parameters);
resultLayer.FeatureSource.Projection = proj4;
resultLayer = targetLayerPlugin.GetLayers(getLayerParameters).FirstOrDefault() as FeatureLayer;
}
}
if (resultLayer != null)
{
GisEditorMessageBox messageBox = new GisEditorMessageBox(MessageBoxButton.YesNo);
messageBox.Owner = Application.Current.MainWindow;
messageBox.WindowStartupLocation = WindowStartupLocation.CenterOwner;
messageBox.Title = GisEditor.LanguageManager.GetStringResource("NavigatePluginAddToMap");
messageBox.Message = GisEditor.LanguageManager.GetStringResource("DoYouWantToAddToMap");
messageBox.ErrorMessage = string.Empty;
if (messageBox.ShowDialog().Value)
{
GisEditor.ActiveMap.AddLayerToActiveOverlay(resultLayer);
GisEditor.ActiveMap.RefreshActiveOverlay();
RefreshArgs refreshArgs = new RefreshArgs(null, "LoadToMapCore");
InvokeRefreshPlugins(GisEditor.UIManager, refreshArgs);
GisEditor.ActiveMap.Refresh();
}
}
}
else
{
System.Windows.Forms.MessageBox.Show("There's no features in this layer.", "Export File");
}
}
protected override ConfigureFeatureLayerParameters GetCreateFeatureLayerParametersCore(IEnumerable <FeatureSourceColumn> columns)
{
MemoColumnConvertMode memoColumnMode = MemoColumnConvertMode.None;
LongColumnTruncateMode longColumnNameMode = LongColumnTruncateMode.None;
List <FeatureSourceColumn> memoColumns = columns.Where(c => c.TypeName.Equals("Memo", StringComparison.InvariantCultureIgnoreCase)).ToList();
bool hasLongColumn = columns.Any(c => c.ColumnName.Length > 10);
bool isColumnCheckCanceled = false;
if (memoColumns.Count > 0)
{
MemoColumnModeWarningWindow memoColumnModeWarningWindow = new MemoColumnModeWarningWindow(GisEditor.LanguageManager.GetStringResource("ExportToShapefileLongColumnNameWarningCaption"), "There're one or more memo type columns, which might not be supported by other products. Click 'Convert and Save' would convert memo type to character type, click 'Save' would keep memo types.");
if (memoColumnModeWarningWindow.ShowDialog().GetValueOrDefault())
{
memoColumnMode = memoColumnModeWarningWindow.MemoColumnMode;
}
else
{
isColumnCheckCanceled = true;
}
}
if (!isColumnCheckCanceled && hasLongColumn)
{
LongColumnNameWarningWindow longColumnNameWarningWindow = new LongColumnNameWarningWindow(GisEditor.LanguageManager.GetStringResource("ExportToShapefileLongColumnNameWarningCaption"), GisEditor.LanguageManager.GetStringResource("ExportToShapefileLongColumnNameWarning"));
if (longColumnNameWarningWindow.ShowDialog().GetValueOrDefault())
{
longColumnNameMode = longColumnNameWarningWindow.LongColumnNameMode;
}
else
{
isColumnCheckCanceled = true;
}
}
ConfigureFeatureLayerParameters configureFeatureLayerParameters = null;
if (!isColumnCheckCanceled)
{
var outputWindow = GisEditor.ControlManager.GetUI <OutputWindow>();
outputWindow.OutputMode = OutputMode.ToFile;
outputWindow.Extension = ".shp";
outputWindow.CustomData["Columns"] = new Collection <FeatureSourceColumn>(columns.ToList());
if (longColumnNameMode == LongColumnTruncateMode.Truncate)
{
outputWindow.CustomData["CustomizeColumnNames"] = true;
}
if (string.IsNullOrEmpty(OutputWindow.SavedProj4ProjectionParametersString))
{
outputWindow.Proj4ProjectionParametersString = GisEditor.ActiveMap.DisplayProjectionParameters;
}
else
{
outputWindow.Proj4ProjectionParametersString = OutputWindow.SavedProj4ProjectionParametersString;
}
if (outputWindow.ShowDialog().GetValueOrDefault())
{
configureFeatureLayerParameters = new ConfigureFeatureLayerParameters(outputWindow.LayerUri);
configureFeatureLayerParameters.MemoColumnConvertMode = memoColumnMode;
configureFeatureLayerParameters.LongColumnTruncateMode = longColumnNameMode;
configureFeatureLayerParameters.Proj4ProjectionParametersString = outputWindow.Proj4ProjectionParametersString;
OutputWindow.SavedProj4ProjectionParametersString = outputWindow.Proj4ProjectionParametersString;
foreach (var item in outputWindow.CustomData)
{
configureFeatureLayerParameters.CustomData[item.Key] = item.Value;
}
}
}
return(configureFeatureLayerParameters);
}
protected override ConfigureFeatureLayerParameters GetFeatureLayerInfoCore()
{
ConfigShapeFileViewModel viewModel = DataContext as ConfigShapeFileViewModel;
ConfigureFeatureLayerParameters parameters = new ConfigureFeatureLayerParameters();
Collection <FeatureSourceColumn> originalColumns = new Collection <FeatureSourceColumn>();
if (createNewShapeFileViewModel.ShpFileFeatureLayer != null)
{
createNewShapeFileViewModel.ShpFileFeatureLayer.SafeProcess(() =>
{
originalColumns = createNewShapeFileViewModel.ShpFileFeatureLayer.FeatureSource.GetColumns();
});
}
IEnumerable <DbfColumn> addedColumns = viewModel.ColumnListItemSource.Where(c => isSorted || c.ChangedStatus == FeatureSourceColumnChangedStatus.Added).Select(l => l.DbfColumn);
IEnumerable <DbfColumnItem> updatedColumnItems = viewModel.ColumnListItemSource.Where(c => c.ChangedStatus == FeatureSourceColumnChangedStatus.Updated);
IEnumerable <FeatureSourceColumn> deletedColumns = originalColumns.Where(o => isSorted || (viewModel.ColumnListItemSource.All(c => c.ColumnName != o.ColumnName) && updatedColumnItems.All(u => u.OrignalColumnName != o.ColumnName)));
foreach (var item in deletedColumns)
{
parameters.DeletedColumns.Add(item);
}
foreach (var item in updatedColumnItems)
{
parameters.UpdatedColumns[item.OrignalColumnName] = item.DbfColumn;
}
if (viewModel.TruncatedColumns.Count > 0)
{
viewModel.ShpFileFeatureLayer.SafeProcess(() =>
{
foreach (var feature in viewModel.ShpFileFeatureLayer.QueryTools.GetAllFeatures(ReturningColumnsType.AllColumns))
{
foreach (var truncatedColumn in viewModel.TruncatedColumns)
{
string tempValue = feature.ColumnValues[truncatedColumn.Key];
if (tempValue.Length > truncatedColumn.Value)
{
feature.ColumnValues[truncatedColumn.Key] = tempValue.Substring(0, truncatedColumn.Value);
}
}
parameters.UpdatedFeatures[feature.Id] = feature;
}
});
}
foreach (var item in addedColumns)
{
item.MaxLength = item.MaxLength;
parameters.AddedColumns.Add(item);
}
foreach (var item in viewModel.ColumnListItemSource)
{
if (item.AliasName != item.ColumnName)
{
parameters.CustomData[item.ColumnName] = item.AliasName;
}
}
string pathFileName = string.Format(@"{0}\{1}.shp", viewModel.FolderPath, viewModel.LayerName);
parameters.LayerUri = new Uri(Path.GetFullPath(pathFileName));
switch (viewModel.ShpFileType)
{
case GeneralShapeFileType.Point:
parameters.WellKnownType = WellKnownType.Point;
break;
case GeneralShapeFileType.Multipoint:
parameters.WellKnownType = WellKnownType.Multipoint;
break;
case GeneralShapeFileType.Line:
parameters.WellKnownType = WellKnownType.Line;
break;
case GeneralShapeFileType.Area:
parameters.WellKnownType = WellKnownType.Polygon;
break;
default:
parameters.WellKnownType = WellKnownType.Invalid;
break;
}
return(parameters);
}
protected override FeatureLayer CreateFeatureLayerCore(ConfigureFeatureLayerParameters featureLayerStructureParameters)
{
bool hasFeatures = featureLayerStructureParameters.AddedFeatures.Count > 0;
if (hasFeatures)
{
List <string> columns = featureLayerStructureParameters.AddedFeatures[0].ColumnValues.Keys.ToList();
WKTColumn = GetUniqueColumn(WKTColumn, columns, 0);
LongitudeColumn = GetUniqueColumn(LongitudeColumn, columns, 0);
LatitudeColumn = GetUniqueColumn(LatitudeColumn, columns, 0);
foreach (var feature in featureLayerStructureParameters.AddedFeatures)
{
PointShape pointBaseShape = feature.GetShape() as PointShape;
if (pointBaseShape != null)
{
feature.ColumnValues[WKTColumn] = pointBaseShape.GetWellKnownText();
}
else
{
feature.ColumnValues[LongitudeColumn] = "";
feature.ColumnValues[LatitudeColumn] = "";
}
}
}
string layerPath = LayerPluginHelper.GetLayerUriToSave(featureLayerStructureParameters.LayerUri, ExtensionFilter);
if (string.IsNullOrEmpty(layerPath))
{
return(null);
}
featureLayerStructureParameters.LayerUri = new Uri(layerPath);
Collection <string> csvColumns = new Collection <string>();
foreach (var column in featureLayerStructureParameters.AddedColumns)
{
csvColumns.Add(column.ColumnName);
}
string delimiter = ",";
if (featureLayerStructureParameters.CustomData.ContainsKey("Delimiter"))
{
delimiter = featureLayerStructureParameters.CustomData["Delimiter"].ToString();
}
else if (featureLayerStructureParameters.WellKnownType != WellKnownType.Point && featureLayerStructureParameters.WellKnownType != WellKnownType.Multipoint)
{
delimiter = "\t";
}
DelimitedSpatialColumnsType csvMappingType = DelimitedSpatialColumnsType.WellKnownText;
if (featureLayerStructureParameters.CustomData.ContainsKey("MappingType"))
{
csvMappingType = (DelimitedSpatialColumnsType)featureLayerStructureParameters.CustomData["MappingType"];
}
else
{
if (featureLayerStructureParameters.WellKnownType == WellKnownType.Point || featureLayerStructureParameters.WellKnownType == WellKnownType.Multipoint)
{
csvMappingType = DelimitedSpatialColumnsType.XAndY;
featureLayerStructureParameters.CustomData["X"] = LongitudeColumn;
featureLayerStructureParameters.CustomData["Y"] = LatitudeColumn;
csvColumns.Add(LongitudeColumn);
csvColumns.Add(LatitudeColumn);
if (hasFeatures)
{
csvColumns.Add(WKTColumn);
}
}
else
{
csvMappingType = DelimitedSpatialColumnsType.WellKnownText;
featureLayerStructureParameters.CustomData["WKT"] = WKTColumn;
if (hasFeatures)
{
csvColumns.Add(LongitudeColumn);
csvColumns.Add(LatitudeColumn);
}
csvColumns.Add(WKTColumn);
}
}
CsvFeatureLayer.CreateDelimitedFile(featureLayerStructureParameters.LayerUri.OriginalString, csvColumns, delimiter, OverwriteMode.Overwrite);
string prjPath = Path.ChangeExtension(featureLayerStructureParameters.LayerUri.OriginalString, "prj");
File.WriteAllText(prjPath, Proj4Projection.ConvertProj4ToPrj(featureLayerStructureParameters.Proj4ProjectionParametersString));
var resultLayer = new CsvFeatureLayer();
resultLayer.DelimitedPathFilename = featureLayerStructureParameters.LayerUri.LocalPath;
resultLayer.Delimiter = delimiter;
resultLayer.SpatialColumnType = csvMappingType;
resultLayer.RequireIndex = false;
if (featureLayerStructureParameters.CustomData.ContainsKey("X"))
{
resultLayer.XColumnName = featureLayerStructureParameters.CustomData["X"].ToString();
}
if (featureLayerStructureParameters.CustomData.ContainsKey("Y"))
{
resultLayer.YColumnName = featureLayerStructureParameters.CustomData["Y"].ToString();
}
if (featureLayerStructureParameters.CustomData.ContainsKey("WKT"))
{
resultLayer.WellKnownTextColumnName = featureLayerStructureParameters.CustomData["WKT"].ToString();
}
resultLayer.Open();
if (featureLayerStructureParameters.AddedFeatures.Count > 0)
{
resultLayer.EditTools.BeginTransaction();
foreach (var feature in featureLayerStructureParameters.AddedFeatures)
{
resultLayer.EditTools.Add(feature);
}
resultLayer.EditTools.CommitTransaction();
}
CSVModel.BuildDelimitedConfigurationFile(resultLayer);
resultLayer.Close();
return(resultLayer);
}
protected override FeatureLayer CreateFeatureLayerCore(ConfigureFeatureLayerParameters featureLayerStructureParameters)
{
string layerPath = LayerPluginHelper.GetLayerUriToSave(featureLayerStructureParameters.LayerUri, ExtensionFilterCore);
if (string.IsNullOrEmpty(layerPath))
{
return(null);
}
featureLayerStructureParameters.LayerUri = new Uri(layerPath);
ShapeFileType shapeFileType = ShapeFileType.Null;
switch (featureLayerStructureParameters.WellKnownType)
{
case WellKnownType.Multipoint:
shapeFileType = ShapeFileType.Multipoint;
break;
case WellKnownType.Point:
shapeFileType = ShapeFileType.Point;
break;
case WellKnownType.Line:
case WellKnownType.Multiline:
shapeFileType = ShapeFileType.Polyline;
break;
case WellKnownType.Polygon:
case WellKnownType.Multipolygon:
shapeFileType = ShapeFileType.Polygon;
break;
}
Dictionary <string, DbfColumn> dbfColumns = new Dictionary <string, DbfColumn>();
Collection <FeatureSourceColumn> addedColumns = featureLayerStructureParameters.AddedColumns;
Dictionary <string, string> oldNewNames = new Dictionary <string, string>();
Collection <Feature> addedFeatures = featureLayerStructureParameters.AddedFeatures;
bool truncateLongColumn = featureLayerStructureParameters.LongColumnTruncateMode == LongColumnTruncateMode.Truncate;
if (truncateLongColumn)
{
Dictionary <string, string> editColumns = new Dictionary <string, string>();
if (featureLayerStructureParameters.CustomData.ContainsKey("EditedColumns"))
{
editColumns = featureLayerStructureParameters.CustomData["EditedColumns"] as Dictionary <string, string>;
}
addedColumns = TruncateLongColumnNames(featureLayerStructureParameters.AddedColumns, oldNewNames, editColumns);
}
foreach (var column in addedColumns)
{
if (!string.IsNullOrEmpty(column.ColumnName))
{
DbfColumn dbfColumn = column as DbfColumn;
if (dbfColumn != null)
{
if (dbfColumn.ColumnType == DbfColumnType.DoubleInBinary || dbfColumn.ColumnType == DbfColumnType.DateTime)
{
dbfColumn.Length = 8;
dbfColumn.DecimalLength = 0;
}
else if (dbfColumn.ColumnType == DbfColumnType.IntegerInBinary)
{
dbfColumn.Length = 4;
dbfColumn.DecimalLength = 0;
}
}
else
{
int columnLenght = column.MaxLength;
int decimalLength = 0;
switch (column.TypeName.ToUpperInvariant())
{
case "DOUBLE":
case "NUMERIC":
columnLenght = columnLenght == 0 ? 10 : columnLenght;
if (columnLenght < 4)
{
columnLenght = 10;
}
decimalLength = 4;
break;
case "DATE":
case "DATETIME":
columnLenght = columnLenght == 0 ? 10 : columnLenght;
decimalLength = 0;
break;
case "INTEGER":
case "INT":
columnLenght = columnLenght == 0 ? 10 : columnLenght;
decimalLength = 0;
break;
case "STRING":
case "CHARACTER":
columnLenght = columnLenght == 0 ? characterTypeLength : columnLenght;
decimalLength = 0;
break;
case "LOGICAL":
columnLenght = 5;
decimalLength = 0;
break;
}
DbfColumnType type = DbfColumnType.Character;
if (column.TypeName.Equals("DOUBLE", StringComparison.InvariantCultureIgnoreCase))
{
column.TypeName = DbfColumnType.Float.ToString();
}
if (column.TypeName.Equals("INT", StringComparison.InvariantCultureIgnoreCase))
{
column.TypeName = DbfColumnType.Numeric.ToString();
}
bool isSuccess = Enum.TryParse <DbfColumnType>(column.TypeName, true, out type);
if (!isSuccess)
{
type = DbfColumnType.Character;
}
dbfColumn = new DbfColumn(column.ColumnName, type, columnLenght, decimalLength);
dbfColumn.TypeName = column.TypeName;
dbfColumn.MaxLength = column.MaxLength;
}
//Feature firstFeature = featureLayerStructureParameters.AddedFeatures.FirstOrDefault();
////This is to fix that fox pro columns cannot write to dbf, convert all linked columns to character column type.
//string tempColumnName = column.ColumnName;
//if (oldNewNames.ContainsValue(column.ColumnName))
//{
// tempColumnName = oldNewNames.FirstOrDefault(f => f.Value == column.ColumnName).Key;
//}
//if (tempColumnName.Contains(".") && firstFeature != null && firstFeature.LinkColumnValues.ContainsKey(tempColumnName))
//{
// if (dbfColumn.ColumnType != DbfColumnType.Memo)
// {
// dbfColumn.ColumnType = DbfColumnType.Character;
// dbfColumn.Length = characterTypeLength;
// dbfColumn.DecimalLength = 0;
// }
//}
dbfColumns[dbfColumn.ColumnName] = dbfColumn;
}
}
bool convertMemoToCharacter = featureLayerStructureParameters.MemoColumnConvertMode == MemoColumnConvertMode.ToCharacter;
Dictionary <string, int> columnLength = new Dictionary <string, int>();
foreach (var feature in addedFeatures)
{
//foreach (var linkColumnValue in feature.LinkColumnValues)
//{
// if (!feature.ColumnValues.ContainsKey(linkColumnValue.Key))
// {
// string[] values = linkColumnValue.Value.Select(v =>
// {
// if (v.Value == null)
// {
// return string.Empty;
// }
// if (v.Value is DateTime)
// {
// return ((DateTime)v.Value).ToShortDateString();
// }
// return v.Value.ToString();
// }).ToArray();
// if (values.All(v => string.IsNullOrEmpty(v) || string.IsNullOrWhiteSpace(v)))
// {
// if (oldNewNames.ContainsKey(linkColumnValue.Key))
// feature.ColumnValues[oldNewNames[linkColumnValue.Key]] = string.Empty;
// else
// feature.ColumnValues[linkColumnValue.Key] = string.Empty;
// }
// else
// {
// string tempColumName = linkColumnValue.Key;
// if (oldNewNames.ContainsKey(linkColumnValue.Key))
// {
// tempColumName = oldNewNames[linkColumnValue.Key];
// }
// string linkValue = string.Join(",", values);
// feature.ColumnValues[tempColumName] = linkValue;
// //Choose the max length
// if (columnLength.ContainsKey(tempColumName))
// {
// if (columnLength[tempColumName] < linkValue.Length)
// {
// columnLength[tempColumName] = linkValue.Length;
// }
// }
// else
// {
// columnLength[tempColumName] = linkValue.Length > 254 ? 254 : linkValue.Length;
// }
// }
// }
//}
foreach (var item in oldNewNames)
{
if (feature.ColumnValues.ContainsKey(item.Key))
{
feature.ColumnValues[oldNewNames[item.Key]] = feature.ColumnValues[item.Key];
feature.ColumnValues.Remove(item.Key);
}
}
if (!convertMemoToCharacter)
{
foreach (var item in feature.ColumnValues)
{
if (item.Value.Length > characterTypeLength && dbfColumns[item.Key].ColumnType != DbfColumnType.Memo)
{
dbfColumns[item.Key].ColumnType = DbfColumnType.Memo;
dbfColumns[item.Key].Length = 4;
dbfColumns[item.Key].DecimalLength = 0;
}
}
}
}
foreach (var column in dbfColumns)
{
Feature firstFeature = featureLayerStructureParameters.AddedFeatures.FirstOrDefault();
//This is to fix that fox pro columns cannot write to dbf, convert all linked columns to character column type.
string tempColumnName = column.Key;
if (oldNewNames.ContainsValue(column.Key))
{
tempColumnName = oldNewNames.FirstOrDefault(f => f.Value == column.Key).Key;
}
//if (tempColumnName.Contains(".") && firstFeature != null && firstFeature.LinkColumnValues.ContainsKey(tempColumnName))
//{
// if (column.Value.ColumnType != DbfColumnType.Memo)
// {
// column.Value.ColumnType = DbfColumnType.Character;
// //column.Value.Length = characterTypeLength;
// column.Value.DecimalLength = 0;
// if (columnLength.ContainsKey(tempColumnName) && column.Value.Length < columnLength[tempColumnName])
// {
// column.Value.Length = columnLength[tempColumnName];
// }
// }
//}
}
ShapeFileFeatureLayer.CreateShapeFile(shapeFileType,
featureLayerStructureParameters.LayerUri.OriginalString,
dbfColumns.Values,
DefaultEncoding,
OverwriteMode.Overwrite);
string encodingPathFileName = Path.ChangeExtension(featureLayerStructureParameters.LayerUri.OriginalString, ".cpg");
if (File.Exists(encodingPathFileName))
{
File.Delete(encodingPathFileName);
}
File.WriteAllText(encodingPathFileName, DefaultEncoding.CodePage.ToString(CultureInfo.InvariantCulture));
string prjPath = Path.ChangeExtension(featureLayerStructureParameters.LayerUri.OriginalString, "prj");
File.WriteAllText(prjPath, Proj4Projection.ConvertProj4ToPrj(featureLayerStructureParameters.Proj4ProjectionParametersString));
ShapeFileFeatureLayer resultLayer = new ShapeFileFeatureLayer(featureLayerStructureParameters.LayerUri.LocalPath, GeoFileReadWriteMode.ReadWrite);
if (addedFeatures.Count > 0)
{
resultLayer.Open();
resultLayer.EditTools.BeginTransaction();
foreach (var feature in addedFeatures)
{
if (convertMemoToCharacter)
{
foreach (var item in dbfColumns)
{
if (feature.ColumnValues.ContainsKey(item.Key) && feature.ColumnValues[item.Key].Length > 254)
{
feature.ColumnValues[item.Key] = feature.ColumnValues[item.Key].Substring(0, 254);
}
if (feature.ColumnValues.ContainsKey(item.Key) && feature.ColumnValues[item.Key].Length > item.Value.MaxLength)
{
feature.ColumnValues[item.Key] = feature.ColumnValues[item.Key].Substring(0, item.Value.MaxLength);
}
}
}
resultLayer.EditTools.Add(feature);
}
resultLayer.EditTools.CommitTransaction();
resultLayer.Close();
}
return(resultLayer);
}
private void Export(IGrouping <ShapeFileType, Feature> group, FileExportInfo info)
{
string path = info.Path;
if (File.Exists(path))
{
if (info.Overwrite)
{
string[] suffixes = { ".shp", ".shx", ".ids", ".idx", ".dbf", ".prj" };
foreach (var suffix in suffixes)
{
string fileToRemove = Path.ChangeExtension(path, suffix);
if (File.Exists(fileToRemove))
{
File.Delete(fileToRemove);
}
}
}
else
{
string dir = Path.GetDirectoryName(path);
string fileName = Path.GetFileNameWithoutExtension(path);
string extension = Path.GetExtension(path);
path = Path.Combine(dir, fileName + group.Key.ToString() + extension);
}
}
var dbfColumns = info.Columns.Select(column =>
{
DbfColumnType columnType = DbfColumnType.Character;
try
{
columnType = (DbfColumnType)Enum.Parse(typeof(DbfColumnType), column.TypeName);
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
}
int length = column.MaxLength;
if (length > 254)
{
length = 254;
columnType = DbfColumnType.Memo;
}
else if (length <= 0)
{
length = 254;
}
DbfColumn dbfColumn = new DbfColumn(column.ColumnName, columnType, length, GetDecimalLength(columnType, column.MaxLength));
return(dbfColumn);
});
try
{
ConfigureFeatureLayerParameters parameters = new ConfigureFeatureLayerParameters();
foreach (var column in dbfColumns)
{
parameters.AddedColumns.Add(column);
}
foreach (var feature in group)
{
var newFeature = feature;
if (!feature.IsValid())
{
newFeature = feature.MakeValid();
}
Feature validFeature = new Feature(newFeature.GetWellKnownBinary(), newFeature.Id, feature.ColumnValues);
//foreach (var item in feature.LinkColumnValues)
//{
// validFeature.LinkColumnValues.Add(item.Key, item.Value);
//}
parameters.AddedFeatures.Add(validFeature);
}
parameters.LayerUri = new Uri(path);
parameters.LongColumnTruncateMode = LongColumnTruncateMode.Truncate;
parameters.MemoColumnConvertMode = MemoColumnConvertMode.ToCharacter;
switch (group.Key)
{
case ShapeFileType.Null:
case ShapeFileType.Multipatch:
default:
parameters.WellKnownType = WellKnownType.Invalid;
break;
case ShapeFileType.Point:
case ShapeFileType.PointZ:
case ShapeFileType.PointM:
case ShapeFileType.Multipoint:
case ShapeFileType.MultipointM:
case ShapeFileType.MultipointZ:
parameters.WellKnownType = WellKnownType.Point;
break;
case ShapeFileType.Polyline:
case ShapeFileType.PolylineZ:
case ShapeFileType.PolylineM:
parameters.WellKnownType = WellKnownType.Line;
break;
case ShapeFileType.Polygon:
case ShapeFileType.PolygonZ:
case ShapeFileType.PolygonM:
parameters.WellKnownType = WellKnownType.Polygon;
break;
}
parameters.CustomData["Columns"] = parameters.AddedColumns;
parameters.CustomData["CustomizeColumnNames"] = true;
parameters.CustomData["EditedColumns"] = info.CostomizedColumnNames;
parameters.Proj4ProjectionParametersString = info.ProjectionWkt;
var layerPlugin = GisEditor.LayerManager.GetActiveLayerPlugins <ShapeFileFeatureLayerPlugin>().FirstOrDefault();
var layer = layerPlugin.CreateFeatureLayer(parameters);
SavePrjFile(path, info.ProjectionWkt);
RebuildDbf(path);
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
string[] suffixes = { ".shp", ".shx", ".ids", ".idx", ".dbf", ".prj" };
foreach (var suffix in suffixes)
{
string fileToRemove = Path.ChangeExtension(path, suffix);
if (File.Exists(fileToRemove))
{
File.Delete(fileToRemove);
}
}
throw new OperationCanceledException("Shapefile generates failed.", ex);
}
}
protected override FeatureLayer CreateFeatureLayerCore(ConfigureFeatureLayerParameters featureLayerStructureParameters)
{
string layerPath = LayerPluginHelper.GetLayerUriToSave(featureLayerStructureParameters.LayerUri, ExtensionFilter);
if (string.IsNullOrEmpty(layerPath))
{
return(null);
}
featureLayerStructureParameters.LayerUri = new Uri(layerPath);
Collection <TabDbfColumn> tabDbfColumns = new Collection <TabDbfColumn>();
foreach (var column in featureLayerStructureParameters.AddedColumns)
{
var columnLenght = column.MaxLength;
var decimalLength = 0;
switch (column.TypeName.ToUpperInvariant())
{
case "DOUBLE":
columnLenght = columnLenght == 0 ? 10 : columnLenght;
decimalLength = 4;
break;
case "DATE":
case "DATETIME":
columnLenght = columnLenght == 0 ? 10 : columnLenght;
decimalLength = 0;
break;
case "INTEGER":
case "INT":
columnLenght = columnLenght == 0 ? 10 : columnLenght;
decimalLength = 0;
break;
case "STRING":
columnLenght = columnLenght == 0 ? 255 : columnLenght;
decimalLength = 0;
break;
}
tabDbfColumns.Add(new TabDbfColumn(column.ColumnName, (DbfColumnType)Enum.Parse(typeof(DbfColumnType), column.TypeName, true), columnLenght, decimalLength, false, false));
}
TabFeatureLayer.CreateTabFile(featureLayerStructureParameters.LayerUri.OriginalString, tabDbfColumns, new Collection <Feature>(), OverwriteMode.Overwrite);
TabFeatureLayer.BuildIndexFile(featureLayerStructureParameters.LayerUri.OriginalString);
string prjPath = Path.ChangeExtension(featureLayerStructureParameters.LayerUri.OriginalString, "prj");
File.WriteAllText(prjPath, Proj4Projection.ConvertProj4ToPrj(featureLayerStructureParameters.Proj4ProjectionParametersString));
var resultLayer = new TabFeatureLayer(featureLayerStructureParameters.LayerUri.LocalPath, GeoFileReadWriteMode.ReadWrite);
if (featureLayerStructureParameters.AddedFeatures.Count > 0)
{
resultLayer.Open();
resultLayer.EditTools.BeginTransaction();
foreach (var feature in featureLayerStructureParameters.AddedFeatures)
{
resultLayer.EditTools.Add(feature);
}
resultLayer.EditTools.CommitTransaction();
resultLayer.Close();
}
return(resultLayer);
}
