public void Save_File(SettingsType type, string filename)
{
var dest = Result(filename);
type.Save(dest, CreatePerson());
Assert.That(File.Exists(dest), Is.True);
}
public void SelectTab(SettingsType tabType)
{
for (int i = 0; i < _settingTabsList.Length; i++)
{
_settingTabsList[i].SetTab(tabType);
}
}
private string getFileName(SettingsType pType, string pCompanyName, string pApplicationName)
{
string dirName;
if (pType == SettingsType.User)
{
dirName = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
}
else
{
dirName = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
}
if ((pCompanyName != null) && (pCompanyName.Length > 0))
{
dirName = Path.Combine(dirName, pCompanyName);
}
if ((pApplicationName != null) && (pApplicationName.Length > 0))
{
dirName = Path.Combine(dirName, pApplicationName);
}
if (pType == SettingsType.User)
{
return(Path.Combine(dirName, "UserSettings.config"));
}
else
{
return(Path.Combine(dirName, "AppSettings.config"));
}
}
/// <summary>
/// Load the mod settings. Loads the settings from {ModManager.PathSettings}/{Metadata.Name}.yaml by default.
/// </summary>
public virtual void LoadSettings()
{
if (SettingsType == null)
{
return;
}
_Settings = (ModSettings)SettingsType.GetConstructor(ModManager._EmptyTypeArray).Invoke(ModManager._EmptyObjectArray);
string extension = ".yaml";
string path = Path.Combine(ModManager.PathSettings, Metadata.Name + extension);
if (!File.Exists(path))
{
return;
}
try {
using (Stream stream = File.OpenRead(path))
using (StreamReader reader = new StreamReader(path))
_Settings = (ModSettings)YamlHelper.Deserializer.Deserialize(reader, SettingsType);
} catch {
}
}
protected MoonpigTestBase(LaunchPage launchTarget, SettingsType settingsType = SettingsType.ProjectBound)
: base((int)launchTarget)
{
TestBaseNamespace = "Ravitej.Automation.Sample.Ui.Tests";
TestResultsBaseFolder = "Moonpig";
_settingsType = settingsType;
}
/// <summary>
/// Save setting value
/// </summary>
/// <param name="settingsType">type of setting</param>
/// <param name="value">value you want to save</param>
public static void SetSetting(SettingsType settingsType, dynamic value)
{
if (settingTypes.TryGetValue(settingsType, out SettingsValueType valueType))
{
switch (valueType)
{
case SettingsValueType.FLOAT:
if (value is float || value is int)
{
PlayerPrefs.SetFloat(settingsType.ToString(), (float)value);
}
// TODO: log error
break;
case SettingsValueType.INT:
if (value is int || value is float)
{
PlayerPrefs.SetInt(settingsType.ToString(), (int)value);
}
// TODO: log error
break;
case SettingsValueType.STRING:
if (value is string)
{
PlayerPrefs.SetString(settingsType.ToString(), (string)value);
}
// TODO: log error
break;
}
}
}
private void SetGeneratorSettings()
{
string wrpSettingsPath = Utility.FindFabricResourceFile(Constant.WrpSettingsFilename);
SettingsType wrpSettings = System.Fabric.Interop.Utility.ReadXml <SettingsType>(wrpSettingsPath);
this.ClusterManifestGeneratorSettings = GenerateSettings(wrpSettings, this.Topology);
}
public void Write(SettingsType key, object value)
{
lock (locker)
{
dbService.SettingsSetValue(key, Converter.ToString(value));
}
}
public static void SaveConnection(CmsInstance value, SettingsType type)
{
// Save as the last session
var name = "lastsession" + (type == SettingsType.ForImport ? "Import" : "Export");
SetProperty(name, SerializeCmsInstance(value));
var found = false;
var sessions = GetConnections(type);
foreach (var session in sessions)
{
if (session.Server == value.Server && session.Instance == value.Instance)
{
session.Key = value.Key;
session.Username = value.Username;
SaveConnections(sessions, type);
found = true;
}
}
if (!found)
{
// Not found, so append our item
var list = sessions.ToList();
list.Add(value);
SaveConnections(list.ToArray(), type);
}
Settings.Default.Save();
}
public virtual void OnInputInitialize()
{
if (SettingsType == null)
{
return;
}
object settings = _Settings;
if (settings == null)
{
return;
}
foreach (PropertyInfo prop in SettingsType.GetProperties())
{
if (!prop.CanRead)
{
continue;
}
if (typeof(ButtonBinding).IsAssignableFrom(prop.PropertyType))
{
InitializeButtonBinding(settings, prop);
}
else if (false)
{
// TODO: JoystickBindings
}
}
}
// public DataSourceXml(): this(new XmlSerializerSettings())
/// <summary>
/// Initializes a new instance of the <see cref="DataSourceXml"/> class.
/// </summary>
/// <param name="type">The type.</param>
/// <exception cref="ArgumentOutOfRangeException">type - null</exception>
public DataSourceXml(SettingsType type)
{
switch (type)
{
case SettingsType.DataTransfer:
Settings = new XmlSerializerSettings()
{
Indent = false, NullValueHandling = XmlNullValueHandling.Ignore, OmitXmlDeclaration = true
};
break;
case SettingsType.ManualEditing:
Settings = new XmlSerializerSettings()
{
Indent = true, NullValueHandling = XmlNullValueHandling.Include, OmitXmlDeclaration = false
};
break;
case SettingsType.Both:
Settings = new XmlSerializerSettings()
{
Indent = true, NullValueHandling = XmlNullValueHandling.Ignore, OmitXmlDeclaration = false
};
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
/// <summary>
/// Deserializes the next block of data.
/// </summary>
/// <param name="serializedData">The serialized data.</param>
/// <param name="settings">The settings.</param>
/// <returns>The deserialization result.</returns>
private static DeserializationResult DeserializeBlock(BinaryData serializedData, Settings settings)
{
if (serializedData == null || serializedData.Left == 0)
{
return(DeserializationResult.EndOfData);
}
SettingsType settingsType = serializedData.PeekSettingsType();
Log.DevDebug(typeof(BinarySettings), "DeserializeBlock", applySettings, settingsType);
switch (settingsType)
{
case SettingsType.StandardService:
return(DeserializeStandardServiceSettings(serializedData, settings));
case SettingsType.HiddenService:
return(DeserializeHiddenServiceSettings(serializedData, settings));
case SettingsType.ServiceRanges:
return(DeserializeRangeSettings(serializedData, settings));
case SettingsType.Compatibility:
return(DeserializeCompatibilitySettings(serializedData, settings));
default:
throw new InvalidOperationException("Unknown settings type: " + settingsType.ToString());
}
}
public virtual void OnInputDeregister()
{
if (SettingsType == null)
{
return;
}
object settings = _Settings;
foreach (PropertyInfo prop in SettingsType.GetProperties())
{
if (!prop.CanRead)
{
continue;
}
if (typeof(ButtonBinding).IsAssignableFrom(prop.PropertyType))
{
if (!(prop.GetValue(settings) is ButtonBinding binding))
{
continue;
}
binding.Button?.Deregister();
}
else if (false)
{
// TODO: JoystickBindings
}
}
}
public static void OpenWindow(SettingsType _Settings)
{
m_CameraSettings = _Settings;
m_CameraWindow = (GeneralCameraSettings)GetWindow(typeof(GeneralCameraSettings));
m_CameraWindow.minSize = new Vector2(250, 250);
m_CameraWindow.Show();
}
/// <summary>
/// Fills all settings: SettingsStr, SettingsXml and DebugMode
/// InitSettings() should be the first line of code in Page_Load().
/// If settings is missing settingsExists is set to false
/// Note: It is not mandatory to use InitSettings() in the
/// Page_Load() - The programmer can just leave it out if he
/// decides that he is not going to use the setting system that
/// class OneFileModule provides.
/// </summary>
/// <param name="settingsType">Type of the settings.</param>
protected void InitSettings(SettingsType settingsType)
{
_settingsType = settingsType;
if (_settingsType == SettingsType.Off)
{
return;
}
_debugMode = "True" == Settings["Debug Mode"].ToString();
_xmlFileName = Settings["XML settings file"].ToString();
_settingsExists = true;
if (_settingsType == SettingsType.Str || _settingsType == SettingsType.StrAndXml)
{
_settingsStr = Settings["Settings string"].ToString();
if (_settingsStr == string.Empty)
{
_settingsExists = false;
Controls.Add(new LiteralControl("<br><span class='Error'>Settings string is missing</span><br>"));
}
}
if (_settingsType == SettingsType.Xml || _settingsType == SettingsType.StrAndXml)
{
_settingsXml = new XmlDocument();
if (GetSettingsXml(ref _settingsXml, _xmlFileName) == false)
{
_settingsExists = false;
Controls.Add(new LiteralControl("<br>" + "<span class='Error'>XML " + General.GetString("FILE_NOT_FOUND").Replace("%1%", _xmlFileName) + "<br>"));
}
}
}
public string Load_Stream(SettingsType type, string filename)
{
using (var reader = new StreamReader(Example(filename)))
{
return(type.Load <Person>(reader.BaseStream).Name);
}
}
public static void OpenWindow(SettingsType setting)
{
dataSetting = setting;
window = (GeneralSettings)GetWindow(typeof(GeneralSettings));
window.minSize = new Vector2(250, 200);
window.Show();
}
public void Clear()
{
d_settings = new SettingsType();
d_externalProjectFile = null;
d_filename = null;
}
/// <summary>
/// Populates a Panel with all available settings for a given SettingsType
/// </summary>
/// <param name="name"></param>
/// <param name="settingsType"></param>
/// <returns></returns>
private Panel CreateSettingsTabPagePanel(SettingsType settingsType)
{
FlowLayoutPanel pnlDisplay = new FlowLayoutPanel()
{
Size = tabSettingsGroups.ClientRectangle.Size,
FlowDirection = FlowDirection.TopDown,
};
var settings = Settings.GetSettingsByCategoryTag(settingsType);
foreach (var setting in settings)
{
// If the setting has a display condition attached and it is currently marked as NotDisplayed, skip
if (Attribute.IsDefined(setting, typeof(DisplaySettingConditionAttribute)) &&
!setting.GetCustomAttribute <DisplaySettingConditionAttribute>().Display)
{
continue;
}
var ctrl = PropertyControl(setting);
ctrl.Width = pnlDisplay.ClientRectangle.Width;
pnlDisplay.Controls.Add(ctrl);
}
return(pnlDisplay);
}
private void CreateFileWatcher(SettingsType a_SettingsType)
{
try
{
string _Path = EnumeratorParser.GetStringValue(a_SettingsType);
if (a_SettingsType.Equals(SettingsType.TraneObjectMaps))
{
_FullPath = string.IsNullOrEmpty(ConfigurationManager.AppSettings["TraneObjectMapFolder"]) ? Path.Combine(@"C:\SPGateway\Metadata\", _Path) : ConfigurationManager.AppSettings["TraneObjectMapFolder"] + _Path;
}
else
{
_FullPath = string.IsNullOrEmpty(ConfigurationManager.AppSettings["PersistenceDirectory"]) ? Path.Combine(@"C:\SPGateway\Settings\", _Path) : ConfigurationManager.AppSettings["PersistenceDirectory"] + _Path;
}
_FileDirectory = Path.GetDirectoryName(_FullPath);
_Filter = Path.GetFileName(_FullPath);
FileSystemWatcher a_FileWatcher = new FileSystemWatcher(_FileDirectory, _Filter);
a_FileWatcher.NotifyFilter = NotifyFilters.LastWrite;
a_FileWatcher.Changed += _FileChanged_Event;
a_FileWatcher.EnableRaisingEvents = true;
}
catch (Exception ex)
{
if (_Logger != null)
{
_Logger.LogIf(COMPONENT_NAME, TraceLevel.Error, ex);
}
}
}
protected override void ProcessRecord()
{
SettingsType type = SettingsType.General;
Enum.TryParse <SettingsType>(Type, out type);
switch (type)
{
case SettingsType.General:
ProcessImpl(
(filter, top, skip) => Api.Settings.GetSettings(filter: filter, top: top, skip: skip, count: false),
dto => Setting.FromDto(dto));
break;
case SettingsType.Authentication:
ProcessImpl(
filter => Api.Settings.GetAuthenticationSettings().Value,
dto => Setting.FromDto(dto));
break;
case SettingsType.Web:
ProcessImpl(
filter => Api.Settings.GetWebSettings().Value,
dto => Setting.FromDto(dto));
break;
}
}
/// <summary>
/// Task change
/// </summary>
/// <param name="taskType">Control, Reward or Punishment task</param>
/// <param name="settingsType">what is being changed</param>
/// <param name="newValue"></param>
public Change(TaskType taskType, SettingsType settingsType, int newValue)
{
IsTask = true;
TaskChange = taskType;
SettingsType = settingsType;
NewValue = newValue;
}
void OpenSetting(SettingsType settingType)
{
_selectedTab = settingType;
switch (settingType)
{
case SettingsType.Language:
_currentSettings.SaveLanguageSettings(_currentSettings.CurrentLocale);
break;
case SettingsType.Graphics:
_graphicsComponent.Setup();
break;
case SettingsType.Audio:
_audioComponent.Setup(_currentSettings.MusicVolume, _currentSettings.SfxVolume, _currentSettings.MasterVolume);
break;
default:
break;
}
_languageComponent.gameObject.SetActive(settingType == SettingsType.Language);
_graphicsComponent.gameObject.SetActive((settingType == SettingsType.Graphics));
_audioComponent.gameObject.SetActive(settingType == SettingsType.Audio);
_settingTabFiller.SelectTab(settingType);
}
/// <summary>
/// Saves the current settings
/// </summary>
/// <param name="Mode">mode to save settings as. Use zero to not change the mode</param>
/// <returns>this instance</returns>
public AppSettings SaveSettings(SettingsType Mode = 0)
{
var Data = Tools.ToXML(this);
//Auto detect mode
if (Mode == 0)
{
Restrictions = null;
if (File.Exists(PortableSettingsFile))
{
File.WriteAllText(PortableSettingsFile, Data);
Type = SettingsType.Portable;
KeyStorage = Path.Combine(Path.GetDirectoryName(PortableSettingsFile), "Keys");
}
else
{
//Create settings directory
var DirName = Path.GetDirectoryName(UserSettingsFile);
try
{
Directory.CreateDirectory(DirName);
}
catch
{
//Don't care
}
File.WriteAllText(UserSettingsFile, Data);
Type = SettingsType.Local;
KeyStorage = Path.Combine(Path.GetDirectoryName(UserSettingsFile), "Keys");
}
}
else
{
switch (Mode)
{
case SettingsType.Local:
Restrictions = null;
KeyStorage = Path.Combine(Path.GetDirectoryName(UserSettingsFile), "Keys");
File.WriteAllText(UserSettingsFile, Data);
break;
case SettingsType.Global:
KeyStorage = Path.Combine(Path.GetDirectoryName(GlobalSettingsFile), "Keys");
File.WriteAllText(GlobalSettingsFile, Data);
break;
case SettingsType.Portable:
Restrictions = null;
KeyStorage = Path.Combine(Path.GetDirectoryName(PortableSettingsFile), "Keys");
File.WriteAllText(PortableSettingsFile, Data);
break;
default:
throw new NotImplementedException($"The given {nameof(SettingsType)} value is invalid");
}
Type = Mode;
}
return(this);
}
static DataTable GetSettingsTable(int id, SettingsType type)
{
var modules = new ModuleController();
Hashtable settings = null;
DataTable returnValue = null;
switch (type)
{
case SettingsType.ModuleSettings:
settings = modules.GetModuleSettings(id);
returnValue = new DataTable(DataSetTableName.Settings);
break;
case SettingsType.TabModuleSettings:
settings = modules.GetTabModuleSettings(id);
returnValue = new DataTable(DataSetTableName.TabSettings);
break;
}
var sortedSettings = new SortedList <string, string>();
if (settings != null)
{
foreach (DictionaryEntry item in settings)
{
sortedSettings.Add(item.Key.ToString(), item.Value.ToString());
}
}
var dc = new DataColumn(SettingsTableColumn.Setting, typeof(string))
{
ColumnMapping = MappingType.Attribute
};
if (returnValue != null)
{
returnValue.Columns.Add(dc);
}
dc = new DataColumn(SettingsTableColumn.Value, typeof(string))
{
ColumnMapping = MappingType.Attribute
};
if (returnValue != null)
{
returnValue.Columns.Add(dc);
foreach (var key in sortedSettings.Keys)
{
var row = returnValue.NewRow();
row[SettingsTableColumn.Setting] = key;
row[SettingsTableColumn.Value] = sortedSettings[key];
returnValue.Rows.Add(row);
}
return(returnValue);
}
return(null);
}
public void BeginSaveSettings(SettingsType type)
{
_worker = new Thread(() => SaveSettings(type))
{
IsBackground = true
};
_worker.Start();
}
internal RTAntenna(Object a)
{
actualRTAntenna = a;
IsBrokenField = actualRTAntennaType.GetField("IsRTBroken");
ActivatedField = actualRTAntennaType.GetField("IsRTActive");
ConsumptionMultiplierField = SettingsType.GetField("ConsumptionMultiplier");
EnergyCostField = actualRTAntennaType.GetField("EnergyCost");
}
public ISetting For(SettingsType type)
{
if (_settingsModel.Settings.ContainsKey(type))
{
return(_settingsModel.Settings[type]);
}
return(null);
}
public static void SetBaselineField(SettingsType type, int newValue)
{
if (type != SettingsType.TaskNumber)
{
return;
}
Changes.Add(new Change(type, newValue));
}
public static void OpenWindow(SettingsType setting)
{
dataSetting = setting;
window = CreateInstance(typeof(GeneralSettings)) as GeneralSettings;
window.minSize = new Vector2(300, 300);
window.ShowUtility();
}
static DataTable GetSettingsTable(int id, SettingsType type)
{
var modules = new ModuleController();
Hashtable settings = null;
DataTable returnValue = null;
switch (type)
{
case SettingsType.ModuleSettings:
settings = modules.GetModuleSettings(id);
returnValue = new DataTable(DataSetTableName.Settings);
break;
case SettingsType.TabModuleSettings:
settings = modules.GetTabModuleSettings(id);
returnValue = new DataTable(DataSetTableName.TabSettings);
break;
}
var sortedSettings = new SortedList<string, string>();
if (settings != null)
foreach (DictionaryEntry item in settings)
{
sortedSettings.Add(item.Key.ToString(), item.Value.ToString());
}
var dc = new DataColumn(SettingsTableColumn.Setting, typeof (string))
{ColumnMapping = MappingType.Attribute};
if (returnValue != null) returnValue.Columns.Add(dc);
dc = new DataColumn(SettingsTableColumn.Value, typeof (string)) {ColumnMapping = MappingType.Attribute};
if (returnValue != null)
{
returnValue.Columns.Add(dc);
foreach (var key in sortedSettings.Keys)
{
var row = returnValue.NewRow();
row[SettingsTableColumn.Setting] = key;
row[SettingsTableColumn.Value] = sortedSettings[key];
returnValue.Rows.Add(row);
}
return returnValue;
}
return null;
}
/// <summary>
/// Creates a new instance of the Formatter class
/// </summary>
public XmlIts1Formatter ()
{
this.ValidateConformance = true;
this.CreateRequiredElements = false;
GenerateInMemory = true;
this.GraphAides = new List<IStructureFormatter>(4);
//this.Settings = SettingsType.DefaultLegacy;
#if WINDOWS_PHONE
this.Settings = SettingsType.AllowFlavorImposing | SettingsType.AllowSupplierDomainImposing | SettingsType.AllowUpdateModeImposing;
#else
this.Settings = Environment.ProcessorCount > 1 ? SettingsType.DefaultMultiprocessor : SettingsType.DefaultUniprocessor;
#if DEBUG
System.Diagnostics.Trace.TraceInformation("{0}", this.Settings);
#endif
#endif
}
/// <summary>
/// Fills all settings: SettingsStr, SettingsXml and DebugMode
/// InitSettings() should be the first line of code in Page_Load().
/// If settings is missing settingsExists is set to false
/// Note: It is not mandatory to use InitSettings() in the
/// Page_Load() - The programmer can just leave it out if he
/// decides that he is not going to use the setting system that
/// class OneFileModule provides.
/// </summary>
/// <param name="settingsType">
/// Type of the settings.
/// </param>
protected void InitSettings(SettingsType settingsType)
{
this._settingsType = settingsType;
if (this._settingsType == SettingsType.Off)
{
return;
}
this._debugMode = "True" == this.Settings["Debug Mode"].ToString();
this._xmlFileName = this.Settings["XML settings file"].ToString();
this._settingsExists = true;
if (this._settingsType == SettingsType.Str || this._settingsType == SettingsType.StrAndXml)
{
this._settingsStr = this.Settings["Settings string"].ToString();
if (this._settingsStr == string.Empty)
{
this._settingsExists = false;
this.Controls.Add(
new LiteralControl("<br /><span class='Error'>Settings string is missing</span><br />"));
}
}
if (this._settingsType == SettingsType.Xml || this._settingsType == SettingsType.StrAndXml)
{
this._settingsXml = new XmlDocument();
if (this.GetSettingsXml(ref this._settingsXml, this._xmlFileName) == false)
{
this._settingsExists = false;
this.Controls.Add(
new LiteralControl(
string.Format(
"<br /><span class='Error'>XML {0}<br />",
General.GetString("FILE_NOT_FOUND").Replace("%1%", this._xmlFileName))));
}
}
}
public SettingsProvider(SettingsType settingsType)
{
_settingsType = settingsType;
MaxValue = 100;
}
internal override void Initialize()
{
base.Initialize();
if (this.Arguments == null || this.Arguments.Count != 2)
{
throw new ParseException(Resource.SettingsMissingArguments);
}
this.settingsType = (SettingsType)Enum.Parse(typeof(SettingsType), this.Arguments[0]);
this.settingsValue = this.Arguments[1];
}
public ClientSettings GetSettings(SettingsType settingsType)
{
//TODO: Rewrite it to get from DB
return new ClientSettings();
}
/// <summary>
/// Returns a settings path updated with current deets
/// </summary>
/// <param name="weights">if it's a weights file or otherwise just a settings file</param>
/// <returns>path to settings</returns>
public static string GetSettingsPath(SettingsType type, bool pvp)
{
return Logging.ApplicationPath + "\\Settings\\EquipMe\\EquipMe_" + StyxWoW.Me.Name + "_" + EquipMe.GetSpecName() + (pvp && Styx.Logic.Battlegrounds.IsInsideBattleground ? "_PVP" : "") + "_" + type.ToString() + ".xml";
}
public ClientSettings GetSettings(SettingsType settingsType)
{
return _worker.GetSettings(settingsType);
}
public void UpdateSettings(SettingsType theType, object theSetting)
{
//collect them from the Application Resources Collection
theSettings = App.Current.Resources["UserPreferences"] as UserSettings;
switch (theType)
{
case SettingsType.AddCustomServer:
case SettingsType.RemoveCustomServer:
//don't all any duplicates
theSettings.CustomServers.RemoveAll(cs => cs.ServerId == ((CustomServer)theSetting).ServerId);
if (theType == SettingsType.AddCustomServer)
{
theSettings.CustomServers.Add(theSetting as CustomServer);
}
break;
case SettingsType.AddServerCredentials:
case SettingsType.RemoveServerCredentials:
//get a serverdetail object
ServerDetails addMe = theSetting as ServerDetails;
//don't allow duplicate username for this server
theSettings.Servers.RemoveAll(sd => sd.ServerId == addMe.ServerId && sd.Username.Equals(addMe.Username, StringComparison.InvariantCultureIgnoreCase));
if (theType == SettingsType.AddServerCredentials)
{
theSettings.Servers.Add(addMe);
}
break;
default:
//update the setting
theSettings.GetType().GetProperty(theType.ToString()).SetValue(theSettings, theSetting, null);
break;
}
App.Current.Resources["UserPreferences"] = theSettings;
BinaryFormatter bf = new BinaryFormatter();
LauncherEncryption myEncryption = new LauncherEncryption();
IsolatedStorageFile inFile = IsolatedStorageFile.GetUserStoreForAssembly();
//and save that into the file
using (MemoryStream msOut = new MemoryStream())
using (IsolatedStorageFileStream outStream = new IsolatedStorageFileStream("settings.cfg", FileMode.OpenOrCreate, System.IO.FileAccess.Write, inFile))
using (BinaryWriter bwOut = new BinaryWriter(outStream))
{
//serialize it
bf.Serialize(msOut, theSettings);
//encrypt it and write it out
bwOut.Write(myEncryption.Encrypt(msOut.ToArray()));
}
}