///<summary>
/// Fires the <see cref="SettingsChanged"/> event with the names of changeProperties
///</summary>
///<param name="settings"></param>
///<param name="changedProperties"></param>
protected void FireSettingsChanged(T settings, List <string> changedProperties)
{
SettingsChanged.Fire(settings, new SettingsChangedEventArgs
{
ChangedProperties = changedProperties
});
}
public void Reset()
{
CloneSettings();
SelectedProfile = _settings.GetProfileByName(_selectedProfile.Name);
SettingsChanged?.Invoke(this, EventArgs.Empty);
RaisePropertyChanged(nameof(Settings));
}
public void RestoreBackup(IApiContext apiContext)
{
if (apiContext.Request.Type == JTokenType.Object)
{
var settings = apiContext.Request.ToObject <Dictionary <string, JObject> >();
lock (_syncRoot)
{
foreach (var setting in settings)
{
_settings[setting.Key] = setting.Value;
}
SaveSettings();
}
foreach (var setting in settings)
{
SettingsChanged?.Invoke(this, new SettingsChangedEventArgs(setting.Key));
}
}
else
{
throw new NotSupportedException();
}
}
private void ApplyChangesBtn_Click(object sender, EventArgs e)
{
if (directionComboBox.SelectedIndex == 0)
{
Properties.Settings.Default.enterDataDownwards = true;
}
else
{
Properties.Settings.Default.enterDataDownwards = false;
}
Properties.Settings.Default.inputType = InputTypecomboBox.SelectedIndex;
if (InputTypecomboBox.SelectedIndex == 0)
{
Properties.Settings.Default.intminValue = (int)intminValueSelector.Value;
Properties.Settings.Default.intmaxValue = (int)intmaxValueSelector.Value;
}
else if (InputTypecomboBox.SelectedIndex == 1)
{
Properties.Settings.Default.roundDecimals = roundDecimal.Checked;
Properties.Settings.Default.doubleDecimalPlaces = (int)decimalPlacesSelector.Value;
Properties.Settings.Default.doubleminValue = fpMinValueSelector.Value;
Properties.Settings.Default.doubleMaxValue = fpMaxValueSelector.Value;
}
else if (InputTypecomboBox.SelectedIndex == 2)
{
Properties.Settings.Default.customSet = resultsDictionary;
Properties.Settings.Default.customSetPhrases = phrasesDictionary;
}
Properties.Settings.Default.Save();
SettingsChanged?.Invoke(this, EventArgs.Empty);
changesSavedLbl.Visible = true;
}
public void LoadSettings()
{
lock (SettingsLock)
{
string sPath = $"{workDir}\\settings.json";
if (!File.Exists(sPath))
{
SaveSettings(sPath);
return;
}
DateTime lastModDT = File.GetLastWriteTimeUtc(sPath);
// Don't load/reload unless changed
if (lastModDT == lastSettingsModDT)
{
return;
}
lastSettingsModDT = lastModDT;
Log(LogType.INF, "(Re-)loading settings.json");
jsonSettings = File.ReadAllText(sPath);
hostAppSettings = DeserializeJson <HostAppSettings>(jsonSettings);
}
SettingsChanged?.Invoke(this, null);
}
public void Store()
{
try
{
if (!writableSettingsStore.CollectionExists(Constants.SettingsCollectionPath))
{
writableSettingsStore.CreateCollection(Constants.SettingsCollectionPath);
}
writableSettingsStore.SetInt32(Constants.SettingsCollectionPath, "FilenameColor", this.FilenameColor.ToArgb());
writableSettingsStore.SetInt32(Constants.SettingsCollectionPath, "FoldersColor", this.FoldersColor.ToArgb());
writableSettingsStore.SetInt32(Constants.SettingsCollectionPath, "ProjectColor", this.ProjectColor.ToArgb());
writableSettingsStore.SetString(Constants.SettingsCollectionPath, "ViewFilename", this.ViewFilename.ToString());
writableSettingsStore.SetString(Constants.SettingsCollectionPath, "ViewFolders", this.ViewFolders.ToString());
writableSettingsStore.SetString(Constants.SettingsCollectionPath, "ViewProject", this.ViewProject.ToString());
writableSettingsStore.SetString(Constants.SettingsCollectionPath, "FilenameSize", this.FilenameSize.ToString());
writableSettingsStore.SetString(Constants.SettingsCollectionPath, "FoldersSize", this.FoldersSize.ToString());
writableSettingsStore.SetString(Constants.SettingsCollectionPath, "ProjectSize", this.ProjectSize.ToString());
writableSettingsStore.SetString(Constants.SettingsCollectionPath, "Position", this.Position.ToString());
writableSettingsStore.SetString(Constants.SettingsCollectionPath, "Opacity", this.Opacity.ToString());
writableSettingsStore.SetString(Constants.SettingsCollectionPath, "Theme", this.Theme.ToString());
SettingsChanged?.Invoke(this, EventArgs.Empty);
}
catch (Exception ex)
{
Debug.Fail(ex.Message);
}
}
public void Connect()
{
var endpoint = $"http://{Config.ServerHost}:{Config.ServerPort}/";
Console.WriteLine($"Connecting to {endpoint}");
_connection = new HubConnection(endpoint);
_proxy = _connection.CreateHubProxy("CameraHub");
_connection.Start().ContinueWith(task => {
if (task.IsFaulted)
{
Console.WriteLine("There was an error opening the connection:{0}", task.Exception.GetBaseException());
}
else
{
Console.WriteLine("Connected");
_connected = true;
}
}).Wait();
InformIp();
_proxy.On <ProcessingMode>("setMode", param => { SetMode?.Invoke(this, param); });
_proxy.On <PanTiltSettingCommand>("panTiltCommand", s => PanTiltCommand?.Invoke(this, s));
_proxy.On <PiSettings>("updateSettings", settings => SettingsChanged?.Invoke(this, settings));
_proxy.On <Rectangle>("setRegionOfInterest", r => SetRegionOfInterest?.Invoke(this, r));
_proxy.On <CaptureConfig>("updateCapture", c => UpdateCapture?.Invoke(this, c));
}
public void UpdateSettings(AppConfiguration settings, bool global)
{
if (global && GlobalCollection == null)
{
// This is very much an edge case, and we shouldn't ever get to here, but it does need to be handled
Logger.Warning("An attempt has been made to save a configuration change globally, when the global configuration database hasn't been created.");
Logger.Warning("No action will be taken, please check with your System Administrator.");
return;
}
var settingsCollection = global ? GlobalCollection : UserCollection;
if (settingsCollection.Exists(Query.EQ("_id", "v0.18.0")))
{
settingsCollection.Update("v0.18.0", settings);
}
else
{
try
{
settingsCollection.Insert(settings);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
SettingsChanged?.Invoke(GetEffectiveConfiguration(), EventArgs.Empty);
}
public void ImportSettingsToXML(string filename)
{
XmlSerializer formatter = new XmlSerializer(typeof(Settings));
if (!File.Exists(filename))
{
if (MessageBox.Show("Файл настроек " + filename + " не найден. Создать пустой файл настроек с этим именем?", "Ошибка", MessageBoxButton.YesNo, MessageBoxImage.Exclamation) == MessageBoxResult.Yes)
{
ExportSettingsToXML(filename);
}
return;
}
try
{
using (FileStream fs = new FileStream(filename, FileMode.Open))
{
var settings = (Settings)formatter.Deserialize(fs);
instance = settings;
}
}
catch (Exception e)
{
MessageBox.Show("Ошибка открытия файла настроек. Ошибка открытия файла." + e.Message);
}
finally
{
if (instance == null)
{
MessageBox.Show("Ошибка открытия файла настроек. Десериализатор вернул null.");
}
SettingsChanged?.Invoke();
}
}
public bool Load()
{
TextReader file = null;
bool success = false;
try
{
ResetToDefaults();
if (MyAPIGateway.Utilities.FileExistsInLocalStorage(FileName, typeof(Settings)))
{
file = MyAPIGateway.Utilities.ReadFileInLocalStorage(FileName, typeof(Settings));
ReadSettings(file);
SettingsLoaded?.Invoke();
success = true;
}
}
catch (Exception e)
{
Log.Error(e);
}
finally
{
file?.Dispose();
}
Main.LocalToolDescription.RefreshToolDescription();
SettingsChanged?.Invoke();
return(success);
}
public async Task SetInstalledTemplatePackagesAsync(IReadOnlyList <TemplatePackageData> packages, CancellationToken cancellationToken)
{
if (_disposed)
{
throw new ObjectDisposedException(nameof(GlobalSettings));
}
if (!(_mutex?.IsLocked ?? false))
{
throw new InvalidOperationException($"Before calling {nameof(SetInstalledTemplatePackagesAsync)}, {nameof(LockAsync)} must be called.");
}
var globalSettingsData = new GlobalSettingsData(packages);
for (int i = 0; i < FileReadWriteRetries; i++)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
_environmentSettings.Host.FileSystem.WriteObject(_globalSettingsFile, globalSettingsData);
SettingsChanged?.Invoke();
return;
}
catch (Exception)
{
if (i == (FileReadWriteRetries - 1))
{
throw;
}
}
await Task.Delay(20, cancellationToken).ConfigureAwait(false);
}
throw new InvalidOperationException();
}
public void OnSettingsChanged()
{
if (SettingsChanged != null)
{
SettingsChanged.Invoke(this, EventArgs.Empty);
}
}
public void SetManuallySetProxy(string manualProxy)
{
Settings.Default.ManuallySetProxy = manualProxy;
Settings.Default.Save();
_proxyManager.ManuallySetProxyServer = manualProxy;
SettingsChanged?.Invoke(null, EventArgs.Empty);
}
/// <summary>
/// 設定変更を伝播します
/// </summary>
public void DoSettingsChanged()
{
if (SettingsChanged != null)
{
SettingsChanged.Invoke(this, new EventArgs());
}
}
public static void SetUseDebugApi(bool value)
{
localSettings.Values["UseDebugApi"] = value.ToString();
ApplyUseDebugApi(value);
UseDebugApiChanged?.Invoke(value);
SettingsChanged?.Invoke("UseDebugApi", value);
}
public static void SetAppTheme(ElementTheme theme)
{
localSettings.Values["AppTheme"] = theme.ToString("g");
ApplyAppTheme(theme);
AppThemeChanged?.Invoke(theme);
SettingsChanged?.Invoke("AppTheme", theme);
}
private static void setSetting(Logger logger, CommandParameters p)
{
if (p.Args.Length != 2)
{
logger.Warn("Usage: \"setting [setting_name] [setting_value]\"");
return;
}
// Convert to JSON.
var splitSettingName = p.Args[0].Split('.');
var result = buildJson(splitSettingName, 0);
var json = result.Item1 + p.Args[1] + result.Item2;
try
{
serializer.Populate(new StringReader(json), Instance);
SettingsChanged?.Invoke();
}
catch (JsonReaderException e)
{
logger.Warn($"Problem with parsing your setting: {e.Message}");
return;
}
Save(logger);
}
private void OnSolutionOpenedOrClosed(object sender, EventArgs e)
{
ResetSolutionSettings();
// raises event SettingsChanged
SettingsChanged?.Invoke(this, EventArgs.Empty);
}
public void Save()
{
SaveSettings();
SettingsChanged?.Invoke();
DiagnosticsClient.ParticipateInTelemetry = Settings.GeneralSettings.ParticipateInTelemetry;
}
private void BtnSave_Click(object sender, EventArgs e)
{
Settings.SetObject("Firmware Type", CBCore.SelectedItem);
Settings.SetObject("Support Hardware PWM", CBSupportPWM.Checked);
Settings.SetObject("ComWrapper Protocol", CBProtocol.SelectedItem);
Settings.SetObject("Streaming Mode", CBStreamingMode.SelectedItem);
Settings.SetObject("Unidirectional Engraving", CbUnidirectional.Checked);
Settings.SetObject("Threading Mode", CbThreadingMode.SelectedItem);
Settings.SetObject("Do not show Issue Detector", !CbIssueDetector.Checked);
Settings.SetObject("Reset Grbl On Connect", CbSoftReset.Checked);
Settings.SetObject("HardReset Grbl On Connect", CbHardReset.Checked);
Settings.SetObject("Enable Continuous Jog", CbContinuosJog.Checked);
Settings.SetObject("Enale Z Jog Control", CbEnableZJog.Checked);
Settings.SetObject("AutoCooling", CbAutoCooling.Checked);
Settings.SetObject("AutoCooling TOn", MaxTs(TimeSpan.FromSeconds(10), new TimeSpan(0, (int)CbOnMin.SelectedItem, (int)CbOnSec.SelectedItem)));
Settings.SetObject("AutoCooling TOff", MaxTs(TimeSpan.FromSeconds(10), new TimeSpan(0, (int)CbOffMin.SelectedItem, (int)CbOffSec.SelectedItem)));
Settings.SetObject("GCode.CustomHeader", TBHeader.Text.Trim());
Settings.SetObject("GCode.CustomPasses", TBPasses.Text.Trim());
Settings.SetObject("GCode.CustomFooter", TBFooter.Text.Trim());
Settings.Save();
SettingsChanged?.Invoke(this, null);
Close();
if (Core.Type != (Firmware)Settings.GetObject("Firmware Type", Firmware.Grbl) && MessageBox.Show(Strings.FirmwareRequireRestartNow, Strings.FirmwareRequireRestart, MessageBoxButtons.OKCancel) == DialogResult.OK)
{
Application.Restart();
}
}
private void CreateEditables()
{
var factory = new SettingsFactory();
var editables = factory.Reflect(Configuration, out var changeTrackingManager).ToList();
var connectionEditables = new List <IEditableConfig>();
var projectsEditables = new List <IEditableConfig>();
foreach (var config in editables)
{
if (config.PropertyInfo.Name == nameof(IConfiguration.Connections))
{
connectionEditables.Add(config);
continue;
}
if (config.PropertyInfo.Name == nameof(IConfiguration.Projects))
{
projectsEditables.Add(config);
continue;
}
Configs.Add(config);
}
ConnectionsSubSet = new SettingsSubSetViewModel(connectionEditables);
ProjectsSubSet = new SettingsSubSetViewModel(projectsEditables);
changeTrackingManager.ConfigurationChanged += (sender, args) =>
{
_saveMethod.Invoke();
SettingsChanged?.Invoke(this, EventArgs.Empty);
};
}
/// <summary>
/// Updates the image information.
/// </summary>
/// <param name="img">Image to pull info from.</param>
public void UpdateImageInfo(Image img)
{
// remove old info
// remove individually because we need to unlink events
foreach (var csvm in Clears.ToArray())
{
Clears.Remove(csvm);
}
var newClears = img.Planes.Select(p => new PlaneClearStateViewModel(p.Plane)).ToArray();
// take old values if length is the same
if (_processor.Clears != null && newClears.Length == _processor.Clears.Length)
{
for (int i = 0; i < newClears.Length; i++)
{
newClears[i].Clear = _processor.Clears[i];
}
}
_processor.Clears = newClears.Select(i => i.Clear).ToArray();
foreach (var csvm in newClears)
{
Clears.Add(csvm);
}
SettingsChanged?.Invoke(this, EventArgs.Empty);
}
private void редагуватиТекстиToolStripMenuItem_Click(object sender, EventArgs e)
{
FormFormatText formAddText = new FormFormatText(this);
formAddText.Show();
this.Hide();
settings = SettingsChanged.None;
}
public void Save()
{
lock (lockable)
{
LocalSettingsHelper.GetContainer(SETTINGS_CONTAINER).WriteGroupSettings(this);
SettingsChanged?.Invoke(null, EventArgs.Empty);
}
}
private void SettingChanged(Settings o, Settings n, ulong sender)
{
MyDefinitionManager.Static.EnvironmentDefinition.LargeShipMaxSpeed = n.SpeedLimit;
MyDefinitionManager.Static.EnvironmentDefinition.SmallShipMaxSpeed = n.SpeedLimit;
n.CalculateCurve();
Settings.Instance = n;
SettingsChanged?.Invoke(n);
}
/// <summary>
/// Fires the <see cref="SettingsChanged"/> event when the
/// setting of a <see cref="Clears"/> entry changed.
/// </summary>
/// <param name="sender"><see cref="PlaneClearStateViewModel"/> whose settings changed.</param>
/// <param name="e">Ignored.</param>
private void PlaneClearStateViewModel_SettingsChanged(object sender, EventArgs e)
{
var csvm = sender as PlaneClearStateViewModel;
_processor.Clears[csvm.PlaneIndex] = csvm.Clear;
SettingsChanged?.Invoke(this, EventArgs.Empty);
}
private void AddTextToLibraryToolStripMenuItem_Click(object sender, EventArgs e)
{
FormAddText formAddText = new FormAddText(this);
formAddText.Show();
this.Hide();
settings = SettingsChanged.None;
}
void SaveSettings(SettingsEventArgs container)
{
_currentSettings = container;
SettingsChanged?.Invoke(container);
Save("MusicOn", container.MusicOn);
Save("SoundOn", container.SoundOn);
}
private void RaiseSettingsChanged(SettingsChangedEventArgs args)
{
if (args.ChangedSettingsType == SnapshotSettingsType.Schedule)
{
_settingsControls.OfType <SummaryColumnSettingsControl>().First().LoadContentData(_editedContent);
}
SettingsChanged?.Invoke(this, args);
}
internal void RestoreDefaultSettings()
{
var settings = new Settings();
instance = settings;
instance.ConfigurateMusicFiles();
SettingsChanged?.Invoke();
}
