protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
if (settings.GlobalSettings.ContainsKey("Folders"))
{
try
{
RootDataRepositoryItem.Children.Clear();
XElement xElement = XElement.Parse(settings.GlobalSettings["Folders"]);
foreach (var item in xElement.Descendants("Item"))
{
if (Directory.Exists(item.Value))
{
var dataRepositoryItem = new FolderDataRepositoryItem(item.Value, true);
dataRepositoryItem.Parent = RootDataRepositoryItem;
RootDataRepositoryItem.Children.Add(dataRepositoryItem);
}
}
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
}
}
if (Directory.Exists(dataFolderPath) && RootDataRepositoryItem.Children.All(i => !((FolderDataRepositoryItem)i).FolderInfo.FullName.Equals(dataFolderPath, StringComparison.InvariantCultureIgnoreCase)))
{
RootDataRepositoryItem.Children.Add(new FolderDataRepositoryItem(dataFolderPath, true));
}
}
public void ApplySettings(StorableSettings settings)
{
if (settings.GlobalSettings.ContainsKey("BingMapType"))
{
bingMapType = (Layers.BingMapsMapType)Enum.Parse(typeof(Layers.BingMapsMapType), settings.GlobalSettings["BingMapType"]);
}
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
if (settings.ProjectSettings.ContainsKey("PrintedLayoutXml"))
{
printedLayoutXml = settings.ProjectSettings["PrintedLayoutXml"];
}
else
{
printedLayoutXml = null;
}
if (settings.GlobalSettings.ContainsKey("PreserveScale"))
{
PreserveScale = bool.Parse(settings.GlobalSettings["PreserveScale"]);
}
if (settings.GlobalSettings.ContainsKey("AutoSelectPageSize"))
{
AutoSelectPageSize = bool.Parse(settings.GlobalSettings["AutoSelectPageSize"]);
}
if (settings.GlobalSettings.ContainsKey("AllSignatures"))
{
allSignatures = settings.GlobalSettings["AllSignatures"];
}
if (settings.GlobalSettings.ContainsKey("SelectedSignatureName"))
{
selectedSignatureName = settings.GlobalSettings["SelectedSignatureName"];
}
}
public StorableSettings GetSettings()
{
var storableSettings = new StorableSettings();
storableSettings.GlobalSettings["Wms"] = ToXml().ToString();
return(storableSettings);
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
if (settings.GlobalSettings.ContainsKey("SQLServerTimeout"))
{
string timeoutString = settings.GlobalSettings["SQLServerTimeout"];
int timeout = 20;
int tempTimeout;
if (Int32.TryParse(timeoutString, out tempTimeout))
{
timeout = tempTimeout;
}
Singleton <ServerFeatureLayerSettingsUserControl> .Instance.SQLTimeoutInSecond = timeout;
GisEditor.GetMaps().SelectMany(m => m.Overlays.OfType <LayerOverlay>().SelectMany(lo => lo.Layers.OfType <MsSqlFeatureLayer>())).ForEach(l =>
{
l.CommandTimeout = timeout;
});
}
if (settings.GlobalSettings.ContainsKey("SQLServerHistoryServerName"))
{
string SQLServerHistoryServerNames = settings.GlobalSettings["SQLServerHistoryServerName"];
historyServerNames.Clear();
SQLServerHistoryServerNames.Split('|').ForEach(n => historyServerNames.Add(n));
}
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
CustomZoomLevelSets.Clear();
if (settings.GlobalSettings.ContainsKey("CustomZoomLevelSets"))
{
try
{
var xmlText = settings.GlobalSettings["CustomZoomLevelSets"];
var customZoomLevelSetsXElement = XElement.Parse(xmlText);
foreach (var item in customZoomLevelSetsXElement.Descendants("ZoomLevelSet"))
{
if (item.HasAttributes && item.FirstAttribute.Value != null)
{
var scales = new List <double>();
foreach (var scaleXElement in item.Descendants())
{
double scale;
if (double.TryParse(scaleXElement.Value, out scale))
{
scales.Add(scale);
}
}
CustomZoomLevelSets.Add(item.FirstAttribute.Value, scales);
}
}
FillDefaultZoomLevels();
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
}
}
}
protected override StorableSettings GetSettingsCore()
{
StorableSettings settings = base.GetSettingsCore();
settings.GlobalSettings["Timeout"] = Singleton <ServerFeatureLayerSettingsUserControl> .Instance.PostgreTimeoutInSecond.ToString(CultureInfo.InvariantCulture);
return(settings);
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
foreach (var item in RootDataRepositoryItem.Children.OfType <IStorableSettings>())
{
item.ApplySettings(settings);
}
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
if (settings.ProjectSettings.ContainsKey("ExportProjection"))
{
OutputWindow.SavedProj4ProjectionParametersString = settings.ProjectSettings["ExportProjection"];
}
}
public StorableSettings GetSettings()
{
var settings = new StorableSettings();
settings.GlobalSettings["BingMapsKey"] = BingMapsKey;
settings.GlobalSettings["BingMapType"] = BingMapType.ToString();
return(settings);
}
protected override StorableSettings GetSettingsCore()
{
StorableSettings settings = base.GetSettingsCore();
settings.GlobalSettings["SQLServerHistoryServerName"] = string.Join("|", historyServerNames);
settings.GlobalSettings["SQLServerTimeout"] = Singleton <ServerFeatureLayerSettingsUserControl> .Instance.SQLTimeoutInSecond.ToString(CultureInfo.InvariantCulture);
return(settings);
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
option.LoadState(settings.GlobalSettings);
if (settings.GlobalSettings.ContainsKey(emailKey))
{
Email = settings.GlobalSettings[emailKey];
}
}
private bool ApplyHintSettings(StorableSettings settings, string key)
{
bool result = false;
if (settings.GlobalSettings.ContainsKey(key))
{
bool.TryParse(settings.GlobalSettings[key], out result);
}
return(result);
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
Singleton <MeasureSetting> .Instance.LoadState(settings.GlobalSettings);
if (settings.GlobalSettings.ContainsKey(measureModeKeyName) && !measuringModeIsRestored)
{
measuringModeIsRestored = true;
measuringMode = MeasuringInMode.DecimalDegree;
Enum.TryParse(settings.GlobalSettings[measureModeKeyName], out measuringMode);
}
}
protected override StorableSettings GetSettingsCore()
{
XElement xElement = new XElement("Servers", rootItem.Children.OfType <PostgreServerDataRepositoryItem>().Select(item =>
{
string server = String.Format(CultureInfo.InvariantCulture, "{0}|{1}|{2}|{3}", item.Server, item.Port, item.UserName, item.Password);
return(new XElement("Server", StringProtector.Instance.Encrypt(server)));
}));
StorableSettings settings = base.GetSettingsCore();
settings.GlobalSettings.Add("Servers", xElement.ToString());
return(settings);
}
public void ApplySettings(StorableSettings settings)
{
if (settings.GlobalSettings.ContainsKey("Wms"))
{
try
{
var xElement = XElement.Parse(settings.GlobalSettings["Wms"]);
FromXml(xElement);
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
}
}
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
if (settings.GlobalSettings.ContainsKey("DataRepository"))
{
try
{
DataRepositoryContentViewModel.Current.ApplySettings(XElement.Parse(settings.GlobalSettings["DataRepository"]));
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
}
}
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
if (settings.ProjectSettings.ContainsKey("Setting"))
{
try
{
LoadProjectSettingInternal(XElement.Parse(settings.ProjectSettings["Setting"]));
LoadProjectExpandSettingInternal(XElement.Parse(settings.ProjectSettings["ExpandSettings"]));
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
}
}
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
if (settings.GlobalSettings.ContainsKey(addedScaleKey) && settings.GlobalSettings.ContainsKey(addedScaleIndexKey))
{
double value;
if (double.TryParse(settings.GlobalSettings[addedScaleKey], out value))
{
int index = int.Parse(settings.GlobalSettings[addedScaleIndexKey]);
if (GisEditor.ActiveMap != null)
{
GisEditor.ActiveMap.ZoomLevelSet.CustomZoomLevels.Insert(index, new PreciseZoomLevel(value));
}
}
}
}
protected override StorableSettings GetSettingsCore()
{
StorableSettings settings = base.GetSettingsCore();
if (GisEditor.ActiveMap != null)
{
Collection <ZoomLevel> zoomLevels = GisEditor.ActiveMap.ZoomLevelSet.CustomZoomLevels;
ZoomLevel zoomLevel = zoomLevels.FirstOrDefault(c => c is PreciseZoomLevel);
if (zoomLevel != null)
{
settings.GlobalSettings[addedScaleKey] = zoomLevel.Scale.ToString(CultureInfo.InvariantCulture);
settings.GlobalSettings[addedScaleIndexKey] = zoomLevels.IndexOf(zoomLevel).ToString(CultureInfo.InvariantCulture);
}
}
return(settings);
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
var allWms = settings.GlobalSettings.Where(s => s.Key.Contains("Wms")).ToArray();
if (allWms.Length > 0)
{
RootDataRepositoryItem.Children.Clear();
foreach (var item in allWms)
{
WmsDataRepositoryItem wmsDataItem = new WmsDataRepositoryItem();
var tmpSettings = new StorableSettings();
tmpSettings.GlobalSettings["Wms"] = item.Value;
wmsDataItem.ApplySettings(tmpSettings);
RootDataRepositoryItem.Children.Add(wmsDataItem);
}
}
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
if (settings.GlobalSettings.ContainsKey("Timeout"))
{
string timeoutString = settings.GlobalSettings["Timeout"];
int timeout = 20;
int tempTimeout;
if (Int32.TryParse(timeoutString, out tempTimeout))
{
timeout = tempTimeout;
}
Singleton <ServerFeatureLayerSettingsUserControl> .Instance.PostgreTimeoutInSecond = timeout;
GisEditor.GetMaps().SelectMany(m => m.Overlays.OfType <LayerOverlay>().SelectMany(lo => lo.Layers.OfType <PostgreSqlFeatureLayer>())).ForEach(l =>
{
l.CommandTimeout = timeout;
});
}
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
if (settings.GlobalSettings.ContainsKey("MsSqlServers"))
{
try
{
if (rootItem != null)
{
rootItem.Children.Clear();
XElement serversElement = XElement.Parse(settings.GlobalSettings["MsSqlServers"]);
serversElement.Elements("Server").ForEach(item =>
{
string serverString = item.Value;
serverString = StringProtector.Instance.Decrypt(serverString);
string[] server = serverString.Split('|');
MsSqlServerDataRepositoryItem serverItem = new MsSqlServerDataRepositoryItem();
serverItem.Name = server[0];
serverItem.Server = server[0];
serverItem.UserName = server[1];
serverItem.Password = server[2];
rootItem.Children.Add(serverItem);
MsSql2008FeatureLayerInfo configureInfo = new MsSql2008FeatureLayerInfo();
configureInfo.ServerName = serverItem.Server;
configureInfo.UserName = serverItem.UserName;
configureInfo.Password = serverItem.Password;
if (!string.IsNullOrEmpty(configureInfo.UserName) && !string.IsNullOrEmpty(configureInfo.Password))
{
configureInfo.UseTrustAuthority = false;
}
SyncToServerItem(configureInfo, serverItem);
});
}
}
catch (Exception)
{ }
}
}
public static void readSettings()
{
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.Converters.Add(new IPAddressConverter());
if (File.Exists(settingsFile))
{
using (StreamReader sR = new StreamReader(settingsFile))
{
StringBuilder sb = new StringBuilder();
sb.Append(sR.ReadToEnd());
StorableSettings appSettings = (StorableSettings)JsonConvert.DeserializeObject(sb.ToString(), typeof(StorableSettings), settings);
Settings.Instance.AutoAcceptFiles = appSettings.AutoAccept;
Settings.Instance.CurrentUsername = appSettings.CurrentUsername;
Settings.Instance.DefaultRecvPath = appSettings.DefaultPath;
Settings.Instance.DontShowSetup = appSettings.DontShowSetup;
Settings.Instance.IsInvisible = appSettings.IsInvisible;
Settings.Instance.PicturePath = appSettings.PicPath;
}
}
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
var viewMode = selectionAndQueryingGroup.DataContext as SelectionAndQueryingRibbonGroupViewModel;
if (viewMode != null)
{
GeoSerializer serializer = new GeoSerializer();
if (settings.GlobalSettings.ContainsKey("SelectionCompositeStyle"))
{
try
{
viewMode.SelectionCompositeStyle = (CompositeStyle)serializer.Deserialize(settings.GlobalSettings["SelectionCompositeStyle"]);
}
catch (Exception ex)
{
GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
}
}
}
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
if (settings.ProjectSettings.ContainsKey("ExportProjection"))
{
OutputWindow.SavedProj4ProjectionParametersString = settings.ProjectSettings["ExportProjection"];
}
foreach (var item in settings.ProjectSettings)
{
if (item.Key.StartsWith(featureIDColumnName))
{
GisEditor.LayerManager.FeatureIdColumnNames[item.Key.Replace(featureIDColumnName, string.Empty)] = item.Value;
}
}
if (settings.GlobalSettings.ContainsKey(defaultEncodingKey))
{
int codePage = -1;
string codePageString = settings.GlobalSettings[defaultEncodingKey];
if (int.TryParse(codePageString, out codePage))
{
DefaultEncoding = Encoding.GetEncoding(codePage);
}
}
else
{
DefaultEncoding = Encoding.UTF8;
}
foreach (var item in settings.GlobalSettings.Where(i => i.Key != defaultEncodingKey))
{
if (File.Exists(item.Key))
{
encodings[item.Key] = item.Value;
}
}
}
public static void writeSettings()
{
StorableSettings storable = new StorableSettings();
storable.IsInvisible = Settings.Instance.IsInvisible;
storable.AutoAccept = Settings.Instance.AutoAcceptFiles;
storable.CurrentUsername = Settings.Instance.CurrentUsername;
storable.DefaultPath = Settings.Instance.DefaultRecvPath;
storable.PicPath = Settings.Instance.PicturePath;
storable.DontShowSetup = Settings.Instance.DontShowSetup;
System.IO.DirectoryInfo di = new DirectoryInfo(Path.GetDirectoryName(settingsFile));
if (!di.Exists)
{
Directory.CreateDirectory(Path.GetDirectoryName(settingsFile));
}
using (StreamWriter sw = File.CreateText(settingsFile))
{
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.Converters.Add(new IPAddressConverter());
sw.WriteLine(JsonConvert.SerializeObject(storable, settings));
}
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
if (settings.GlobalSettings.ContainsKey("Servers"))
{
try
{
if (rootItem != null)
{
rootItem.Children.Clear();
XElement serversElement = XElement.Parse(settings.GlobalSettings["Servers"]);
serversElement.Elements("Server").ForEach(item =>
{
string serverString = item.Value;
serverString = StringProtector.Instance.Decrypt(serverString);
string[] server = serverString.Split('|');
PostgreServerDataRepositoryItem serverItem = new PostgreServerDataRepositoryItem();
serverItem.Name = server[0];
serverItem.Server = server[0];
serverItem.Port = Int32.Parse(server[1]);
serverItem.UserName = server[2];
serverItem.Password = server[3];
rootItem.Children.Add(serverItem);
PostgreConfigureInfo configureInfo = new PostgreConfigureInfo();
configureInfo.Server = serverItem.Server;
configureInfo.Port = serverItem.Port;
configureInfo.UserName = serverItem.UserName;
configureInfo.Password = serverItem.Password;
SyncToServerItem(configureInfo, serverItem, true);
});
}
}
catch { }
}
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
Singleton <EditorSetting> .Instance.LoadState(settings.GlobalSettings);
if (settings.ProjectSettings.ContainsKey("CalculatedColumns"))
{
string value = settings.ProjectSettings["CalculatedColumns"];
try
{
XElement root = XElement.Parse(value);
var featureSources = root.Elements("FeatureSource");
foreach (var featureSource in featureSources)
{
var id = featureSource.Attribute("ID");
Collection <CalculatedDbfColumn> columns = new Collection <CalculatedDbfColumn>();
var columnsX = featureSource.Elements("CalculatedDbfColumn");
foreach (var item in columnsX)
{
XmlSerializer s = new XmlSerializer(typeof(CalculatedDbfColumn));
object result = s.Deserialize(item.CreateReader());
CalculatedDbfColumn temp = result as CalculatedDbfColumn;
if (temp != null)
{
columns.Add(temp);
}
}
if (columns.Count > 0)
{
CalculatedColumns[id.Value] = columns;
}
}
}
catch { }
}
}
protected override void ApplySettingsCore(StorableSettings settings)
{
base.ApplySettingsCore(settings);
areaStyleOption.LoadState(settings.GlobalSettings);
}
