public static string[] GetBlogIds()
{
string[] blogIds = SettingsKey.GetSubSettingNames();
for (int i = 0; i < blogIds.Length; i++)
{
if (!BlogIdIsValid(blogIds[i]))
{
blogIds[i] = null;
}
}
return((string[])ArrayHelper.Compact(blogIds));
}
public void Apply(SettingsKey key)
{
try
{
if (Retuner.StoreDefault(key, Clone().SetToDefault(null)))
{
PrivateApply(null);
}
}
catch (Exception e)
{
Common.Exception(ToString(), e);
}
}
public static bool IsIncluded(this IOperationService service, ISolutionProjectModel solutionProjectModel = null)
{
var settingsService = CheckoutAndBuild2Package.GetGlobalService <SettingsService>();
SettingsKey settingsKey = service.ServiceSettingsKey();
bool defaultValue = settingsService.Get(settingsKey, service.Order <= ServicePriorities.BuildServicePriority);
if (solutionProjectModel != null)
{
settingsKey = service.ServiceSettingsKey(solutionProjectModel);
}
bool isIncluded = settingsService.Get(settingsKey, defaultValue);
return(isIncluded);
}
private static UIElement GetUIElement(PropertyInfo propertyInfo, ISettingsProviderClass settingsProvider)
{
var settingsService = CheckoutAndBuild2Package.GetGlobalService <SettingsService>();
var attribute = propertyInfo.GetAttributes <SettingsPropertyAttribute>(false).First();
SettingsKey settingsKey = GetSettingsKey(propertyInfo, settingsProvider);
object defaultValue = null;
DefaultValueAttribute defaultValueAttribute = propertyInfo.GetAttributes <DefaultValueAttribute>(false).FirstOrDefault();
if (defaultValueAttribute != null)
{
defaultValue = defaultValueAttribute.Value;
}
return(EditorTemplates.GetUIElement(propertyInfo, settingsService, settingsKey, defaultValue, attribute));
}
public static void Load(SettingsKey Key)
{
BeginUpdate();
try
{
InsertedColor = Color.FromArgb(Key.GetInt("InsertedColor", s_DefaultInsertedColor.ToArgb()));
DeletedColor = Color.FromArgb(Key.GetInt("DeletedColor", s_DefaultDeletedColor.ToArgb()));
ChangedColor = Color.FromArgb(Key.GetInt("ChangedColor", s_DefaultChangedColor.ToArgb()));
SpacesPerTab = Key.GetInt("SpacesPerTab", s_iDefaultSpacesPerTab);
}
finally
{
EndUpdate();
}
}
public T GetData <T>(SettingsKey key)
{
try
{
if (ApplicationData.Current.LocalSettings.Values.ContainsKey(key.ToString()))
{
return((T)ApplicationData.Current.LocalSettings.Values[key.ToString()]);
}
return(default(T));
}
catch (Exception)
{
return(default(T));
}
}
public static bool StoreDefault(SettingsKey key, TunableStore store)
{
if (!key.IsActive)
{
return(false);
}
if (store == null)
{
return(false);
}
sDefaultSettings.AddTunable(store, false);
return(true);
}
public static T ReadSetting <T>(SettingsKey key, T defaultValue)
{
var keyString = key.ToString();
var localSettings = ApplicationData.Current.LocalSettings;
if (localSettings.Values.ContainsKey(keyString))
{
return((T)localSettings.Values[keyString]);
}
if (null != defaultValue)
{
return(defaultValue);
}
return(default);
public bool TryGetCategoryBy(SettingsKey settingsKey, out string category)
{
category = null;
foreach (var pair in myCategoryToKeys)
{
foreach (var type in pair.Value)
{
if (settingsKey.SettingsKeyClassClrType.Equals(type))
{
category = pair.Key;
return(true);
}
}
}
return(false);
}
public bool GetSettingsAsBool(SettingsKey Key)
{
string temp = GetSettingsAsString(Key);
if (temp == "1")
{
return(true);
}
else if (temp == "0")
{
return(false);
}
else
{
throw new Exception("Value can't convert to bool.");
}
}
static string GetSettingsAsString(SettingsKey Key)
{
XmlNodeList SettingsList = Settings.DocumentElement.SelectSingleNode("SETTINGS").ChildNodes;
string returnValue = string.Empty;
foreach (XmlNode Setting in SettingsList)
{
if (Setting.Attributes["NAME"].Value != Key.ToString())
{
continue;
}
returnValue = Setting.Attributes["VALUE"].Value;
break;
}
return(returnValue);
}
public void PutSettingsValues(string user, string instanceKey, IDictionary <string, string> dirtyValues)
{
IDictionary <string, string> settings;
var key = new SettingsKey(user, instanceKey);
if (_settings.TryGetValue(key, out settings))
{
foreach (var x in dirtyValues)
{
settings[x.Key] = x.Value;
}
}
else
{
_settings.Add(key, new Dictionary <string, string>(dirtyValues));
}
}
/// <inheritdoc cref="TableWorkerBase.DrawHeaders"/>
protected override void DrawHeaders(Rect region)
{
if (SettingsHelper.DrawTableHeader(_stateHeaderRect, _stateHeaderInnerRect, _stateKey == StateKey.Enable ? Widgets.CheckboxOnTex : Widgets.CheckboxOffTex))
{
_stateKey = _stateKey == StateKey.Enable ? StateKey.Disable : StateKey.Enable;
NotifyGlobalStateChanged(_stateKey);
}
if (SettingsHelper.DrawTableHeader(_expandedHeaderRect, _expandedHeaderInnerRect, Textures.Gear))
{
_settingsKey = _settingsKey == SettingsKey.Expand ? SettingsKey.Collapse : SettingsKey.Expand;
NotifyGlobalSettingsChanged(_settingsKey);
}
DrawSortableHeaders();
DrawSortableHeaderIcon();
}
private T GetSettingsValue <T>(SettingsKey key, int domainID)
{
if (domainID == 0)
{
var settings = SettingsRepository.GetValueByKey(key);
return((settings == null) ?
(T)Activator.CreateInstance(typeof(T), typeof(T) == typeof(string) ? new Char[1] : null) :
Parse <T>(settings.SE_Value, key));
}
else
{
var settings = SettingsValuesRepository.GetValueByKey(key, domainID);
return((settings == null) ?
(T)Activator.CreateInstance(typeof(T), typeof(T) == typeof(string) ? new Char[1] : null) :
Parse <T>(settings.SV_Value, key));
}
}
private CustomViewModel CreateEmailSettingsViewModel(CategoryTreeItemViewModel item)
{
SettingsKey
subjectKey = (SettingsKey)Enum.Parse(typeof(SettingsKey), item.Key + "Subject"),
bodyKey = (SettingsKey)Enum.Parse(typeof(SettingsKey), item.Key + "Body");
return(new TextViewModel
{
Title = item.Name,
Subject = this.repository.GetSettings(subjectKey),
Content = this.repository.GetSettings(bodyKey),
HasSubject = true,
HasRichText = false,
SubjectLabel = StringResource.admin_Settings_EmailSubject,
ContentLabel = StringResource.admin_Settings_EmailBody,
ViewName = "TextView"
});
}
public static CheckBox GetServiceSelector(this IOperationService service, ISolutionProjectModel solutionProjectModel = null)
{
SettingsKey settingsKey = service.ServiceSettingsKey();
if (solutionProjectModel != null)
{
settingsKey = service.ServiceSettingsKey(solutionProjectModel);
}
var settingsService = CheckoutAndBuild2Package.GetGlobalService <SettingsService>();
var isChecked = settingsService.Get(settingsKey, service.IsIncluded(solutionProjectModel));
var res = new CheckBox {
Content = service.OperationName, IsChecked = isChecked, Tag = service
};
res.Checked += (sender, args) => settingsService.Set(settingsKey, res.IsChecked ?? false);
res.Unchecked += (sender, args) => settingsService.Set(settingsKey, res.IsChecked ?? false);
return(res);
}
private string PrepareKey(SettingsKey key)
{
try
{
if (key.IsGlobal)
{
return(key.Key);
}
string profileKey = "";
string workSpaceName = defaultWorkSpaceName;
string serverName = defaultServerName;
string teamName = defaultTeamName;
TfsContext tfsContext = serviceContainer.Get <TfsContext>();
if (tfsContext != null && tfsContext.IsTfsConnected)
{
if (key.IsServerDepending)
{
serverName = tfsContext.VersionControlServer.ServerGuid.ToString();
}
if (key.IsTeamProjectDepending)
{
teamName = tfsContext.TeamProjectCollection.DisplayName;
}
if (tfsContext.SelectedWorkspace != null && key.IsWorkspaceDepending)
{
workSpaceName = tfsContext.SelectedWorkspace.Name;
}
if (!string.IsNullOrEmpty(tfsContext.SelectedGitBranch) && key.IsGitBranchDepending)
{
workSpaceName += $" ({tfsContext.SelectedGitBranch})";
}
if (key.IsProfileDepending && tfsContext.SelectedProfile != null && !tfsContext.SelectedProfile.IsDefault)
{
profileKey = tfsContext.SelectedProfile.Id.ToString();
}
}
return($"{profileKey}{serverName}{keySeperator}{teamName}{keySeperator}{workSpaceName}{keySeperator}{key.Key}");
}
catch (Exception e)
{
return(string.Empty);
}
}
/// <summary>
/// Delete this profile
/// </summary>
public void Delete()
{
// dispose the profile
Dispose();
using (MetaLock(APPLY_UPDATES_LOCK))
{
// delete the underlying settings tree
SettingsKey.UnsetSubsettingTree(_id);
}
// if we are the default profile then set the default to null
if (_id == DefaultBlogId)
{
DefaultBlogId = String.Empty;
}
OnBlogSettingsDeleted(_id);
}
public MRUAdditionalDataCollection(Func <SettingsProfile> loadLatestProfile, SettingsKey <List <MRUAdditionalData> > settingsKey, Action save)
{
if (loadLatestProfile == null)
{
throw new ArgumentNullException(nameof(loadLatestProfile));
}
if (settingsKey == null)
{
throw new ArgumentNullException(nameof(settingsKey));
}
if (save == null)
{
throw new ArgumentNullException(nameof(save));
}
this.loadLatestProfile = loadLatestProfile;
this.settingsKey = settingsKey;
this.save = save;
}
static StrideEditorSettings()
{
// Note: assignments cannot be moved to initializer, because category names need to be assigned first.
StartupSession = new SettingsKey <UFile>("Interface/StartupSession" + StrideGameStudio.EditorVersion, EditorSettings.SettingsContainer, "")
{
// Note: the name of this settings is based on the editor version, because we want to force displaying the release notes on a new version.
DisplayName = $"{EditorSettings.Interface}/{Tr._p("Settings", "Default session to load")}"
};
Host = new SettingsKey <string>("Remote/Credentials/Host", EditorSettings.SettingsContainer, "")
{
DisplayName = $"{Remote}/{Tr._p("Settings", "Host")}"
};
Port = new SettingsKey <int>("Remote/Credentials/Port", EditorSettings.SettingsContainer, 22)
{
DisplayName = $"{Remote}/{Tr._p("Settings", "Port")}"
};
Username = new SettingsKey <string>("Remote/Credentials/Username", EditorSettings.SettingsContainer, "")
{
DisplayName = $"{Remote}/{Tr._p("Settings", "Username")}"
};
Password = new SettingsKey <string>("Remote/Credentials/Password", EditorSettings.SettingsContainer, "")
{
DisplayName = $"{Remote}/{Tr._p("Settings", "Password")}"
};
Location = new SettingsKey <string>("Remote/Location", EditorSettings.SettingsContainer, "Projects")
{
DisplayName = $"{Remote}/{Tr._p("Settings", "Location")}"
};
AskForCredentials = new SettingsKey <bool>("Remote/Credentials/AskForCredentials", EditorSettings.SettingsContainer, true)
{
DisplayName = $"{Remote}/{Tr._p("Settings", "Ask for credentials when deploying game")}"
};
Display = new SettingsKey <string>("Remote/Display", EditorSettings.SettingsContainer, ":0.0")
{
DisplayName = $"{Remote}/{Tr._p("Settings", "X Display")}"
};
UseCoreCLR = new SettingsKey <bool>("Remote/UseCoreCLR", EditorSettings.SettingsContainer, false)
{
DisplayName = $"{Remote}/{Tr._p("Settings", "Use CoreCLR")}"
};
}
public void CreateKey(SettingsKey key)
{
var groupInfo = GetGroup(key.Group.DisplayName, key.Group.Category.Name);
var newKey = new SettingsKeyInfo
{
KeyDisplayName = key.KeyDisplayName,
KeyName = key.KeyName,
KeyDescription = key.KeyDescription,
KeyType = key.KeyType,
KeyValue = key.KeyDefaultValue,
KeyCategoryID = groupInfo.CategoryID,
KeyDefaultValue = key.KeyDefaultValue,
KeyEditingControlPath = key.KeyEditingControlPath,
KeyExplanationText = key.KeyExplanationText,
KeyFormControlSettings = key.KeyFormControlSettings,
KeyValidation = key.KeyValidation
};
SettingsKeyInfoProvider.SetSettingsKeyInfo(newKey);
}
public string StartXML(SettingsKey key)
{
string result = null;
string assemblyName = mParentType.Assembly.FullName;
if (!string.IsNullOrEmpty(assemblyName))
{
assemblyName = assemblyName.Split(',')[0];
}
result += " <XML>";
result += Common.NewLine + " <FullClassName>" + mParentType.FullName + "," + assemblyName + "</FullClassName>";
result += Common.NewLine + " <FieldName>" + mFieldName + "</FieldName>";
if (key != null)
{
result += key.ToXMLString();
}
return(result);
}
public void SetSettings(SettingsKey key, string value)
{
using (var context = new InstantStoreDataContext())
{
var keyString = key.ToString();
var setting = context.Settings.FirstOrDefault(x => x.Key == keyString);
if (setting != null)
{
setting.Value = value;
}
else
{
context.Settings.InsertOnSubmit(new Setting
{
Key = keyString,
Value = value
});
}
context.SubmitChanges();
}
}
static void ChangeSettings(SettingsKey Key, string Value)
{
XmlNode SettingsNode = Settings.DocumentElement.SelectSingleNode("SETTINGS");
foreach (XmlNode Setting in SettingsNode.ChildNodes)
{
if (Setting.Attributes["NAME"].Value != Key.ToString()) continue;
Setting.Attributes["VALUE"].Value = Value;
return;
}
XmlNode NewSetting = Settings.CreateElement("KEY");
XmlAttribute Attrib = Settings.CreateAttribute("NAME");
Attrib.Value = Key.ToString();
NewSetting.Attributes.Append(Attrib);
Attrib = Settings.CreateAttribute("NAME");
Attrib.Value = Value;
NewSetting.Attributes.Append(Attrib);
SettingsNode.AppendChild(NewSetting);
}
public static string GetTemplateSourceCode(SettingsKey settingsKey)
{
if (settingsKey == null)
{
throw new ArgumentNullException(nameof(settingsKey));
}
var key = settingsKey;
var codeLines = new[]
{
"/// <summary>",
$"/// { key.KeyDescription }",
"/// </summary>",
$"[{ nameof(CategoryAttribute) }(\"{ key.Group.Category.DisplayName }\", \"{ key.Group.Category.Name }\", \"{ key.Group.Category.CategoryParentName }\")]",
$"[{ nameof(GroupAttribute) }(\"{ key.Group.DisplayName }\")]",
$"[{ nameof(DefaultValueAttribute) }({ (key.KeyDefaultValue == null ? "null" : $"@\"{ EscapeQuotes(key.KeyDefaultValue) }\"" ) })]",
$"[{ nameof(EncodedDefinitionAttribute) }(\"{ MetadataEncoder.Encode(key) }\")]",
$"public const string { key.KeyName } = \"{ key.KeyName }\";"
};
var code = string.Join(Environment.NewLine, codeLines);
return(code);
}
internal static void RegisterSettingsKey(UFile name, object defaultValue, SettingsKey settingsKey)
{
SettingsKeys.Add(name, settingsKey);
var entry = SettingsEntry.CreateFromValue(DefaultProfile, name, defaultValue);
DefaultProfile.RegisterEntry(entry);
// Ensure that the value is converted to the key type in each loaded profile.
foreach (var profile in Profiles.Where(x => x != DefaultProfile))
{
if (profile.Settings.TryGetValue(name, out entry))
{
var convertedValue = settingsKey.ConvertValue(entry.Value);
entry = SettingsEntry.CreateFromValue(profile, name, convertedValue);
profile.Settings[name] = entry;
}
}
}
public abstract string ToXMLString(SettingsKey key);
public override string ToXMLString(SettingsKey key)
{
string result = StartXML(key);
result += mChild.NestedXML(1);
result += EndXML();
return result;
}
public string StartXML(SettingsKey key)
{
string result = null;
string assemblyName = mParentType.Assembly.FullName;
if (!string.IsNullOrEmpty(assemblyName))
{
assemblyName = assemblyName.Split(',')[0];
}
result += " <XML>";
result += Common.NewLine + " <FullClassName>" + mParentType.FullName + "," + assemblyName + "</FullClassName>";
result += Common.NewLine + " <FieldName>" + mFieldName + "</FieldName>";
if (key != null)
{
result += key.ToXMLString();
}
return result;
}
public Dictionary<string, string> GetSettingsValues(string user, string instanceKey)
{
IDictionary<string, string> settings;
var key = new SettingsKey(user, instanceKey);
return _settings.TryGetValue(key, out settings) ? settings.ToDictionary(x => x.Key, x => x.Value) : GetEmptySettingsDictionary();
}
public string GetSettingsAsString(SettingsKey Key)
{
return(GetSettingsAsString_FromString(Key.ToString()));
}
static string GetSettingsAsString(SettingsKey Key)
{
XmlNodeList SettingsList = Settings.DocumentElement.SelectSingleNode("SETTINGS").ChildNodes;
string returnValue = string.Empty;
foreach (XmlNode Setting in SettingsList)
{
if (Setting.Attributes["NAME"].Value != Key.ToString()) continue;
returnValue = Setting.Attributes["VALUE"].Value;
break;
}
return returnValue;
}
static bool GetSettingsAsBool(SettingsKey Key)
{
return GetSettingsAsString(Key) == "1";
}
static void ChangeSettings(SettingsKey Key, bool Value)
{
ChangeSettings(Key, (Value) ? "1" : "0");
}
static void ChangeSettings(SettingsKey Key, string Value)
{
XmlNode SettingsNode = Settings.DocumentElement.SelectSingleNode("SETTINGS");
foreach (XmlNode Setting in SettingsNode.ChildNodes)
{
if (Setting.Attributes["NAME"].Value != Key.ToString()) continue;
Setting.Attributes["VALUE"].Value = Value;
return;
}
XmlNode NewSetting = Settings.CreateElement("KEY");
XmlAttribute Attrib = Settings.CreateAttribute("NAME");
Attrib.Value = Key.ToString();
NewSetting.Attributes.Append(Attrib);
Attrib = Settings.CreateAttribute("NAME");
Attrib.Value = Value;
NewSetting.Attributes.Append(Attrib);
SettingsNode.AppendChild(NewSetting);
}
public void RemoveSettingsValues(string user, string instanceKey)
{
var key = new SettingsKey(user, instanceKey);
_settings.Remove(key);
}
public void SetSettingAsString(SettingsKey Key, string Data)
{
SetSettingAsString_FromString(Key.ToString(), Data);
}
public void PutSettingsValues(string user, string instanceKey, IDictionary<string, string> dirtyValues)
{
IDictionary<string, string> settings;
var key = new SettingsKey(user, instanceKey);
if (_settings.TryGetValue(key, out settings))
{
foreach (var x in dirtyValues)
settings[x.Key] = x.Value;
}
else _settings.Add(key, new Dictionary<string, string>(dirtyValues));
}
public void SetValue(SettingsKey key, object value)
{
TunableStore store = GetParentStore(new ValueStore(mField, value));
store.Apply(key);
Retuner.SeasonSettings.AddTunable(store, true);
}
public void Apply(SettingsKey key)
{
try
{
if (Retuner.StoreDefault(key, Clone().SetToDefault(null)))
{
PrivateApply(null);
}
}
catch (Exception e)
{
Common.Exception(ToString(), e);
}
}
public static void Load(SettingsKey Key)
{
BeginUpdate();
try
{
InsertedColor = Color.FromArgb(Key.GetInt("InsertedColor", s_DefaultInsertedColor.ToArgb()));
DeletedColor = Color.FromArgb(Key.GetInt("DeletedColor", s_DefaultDeletedColor.ToArgb()));
ChangedColor = Color.FromArgb(Key.GetInt("ChangedColor", s_DefaultChangedColor.ToArgb()));
SpacesPerTab = Key.GetInt("SpacesPerTab", s_iDefaultSpacesPerTab);
}
finally
{
EndUpdate();
}
}
public void SetValue <T>(SettingsKey <T> key, T value)
{
key.SetValue(value, profile);
}
public T GetValue <T>(SettingsKey <T> key)
{
return(key.GetValue(profile, true));
}
public static void Save(SettingsKey Key)
{
Key.SetInt("InsertedColor", InsertedColor.ToArgb());
Key.SetInt("DeletedColor", DeletedColor.ToArgb());
Key.SetInt("ChangedColor", ChangedColor.ToArgb());
Key.SetInt("SpacesPerTab", SpacesPerTab);
}
public static T Get <T>(SettingsProfile profile, SettingsKey <T> key)
{
return(key.GetValue(profile, true));
}
public override string ToXMLString(SettingsKey key)
{
string result = StartXML(key);
result += Common.NewLine + " <Value>" + mValue + "</Value>";
result += EndXML();
return result;
}
