public SettingButton(float x, float y, float height, SettingsEnum settingOption, SettingsPanel settingsPanel) : base(x, y, height, string.Empty)
{
OriginalY = y;
Text = SetSettingTitle(settingOption);
SettingName = settingOption;
_settingsPanel = settingsPanel;
}
public static bool IsSettingSet(SettingsEnum setting, dynamic repositorySettings = null, dynamic topicSettings = null)
{
// Topic-specific settings overrule everything else
if (IsDynamicSettingSet(setting, topicSettings))
{
return(true);
}
// Settings for the whole repository still overrule app-global settings
if (IsDynamicSettingSet(setting, repositorySettings))
{
return(true);
}
// We haven't found anything yet, so we take a look at the global app settings
if (GlobalConfiguration != null)
{
var dynamicGlobalConfiguraiton = (dynamic)GlobalConfiguration;
var value = dynamicGlobalConfiguraiton[GetSettingNameFromSetting(setting)];
if (value != null)
{
return(true);
}
}
return(false);
}
private static T GetDictionarySetting <T>(SettingsEnum setting, IDictionary <string, object> dictionary)
{
if (dictionary == null)
{
return(default(T));
}
var settingName = GetSettingNameFromSetting(setting);
var settingKey = dictionary.Keys.FirstOrDefault(k => IsMatch(k, settingName));
if (!string.IsNullOrEmpty(settingKey))
{
return((T)dictionary[settingKey]);
}
var alternateSettingNames = GetAllternateSettingNamesFromSetting(setting);
foreach (var alternateSettingName in alternateSettingNames)
{
settingKey = dictionary.Keys.FirstOrDefault(k => IsMatch(k, alternateSettingName));
if (!string.IsNullOrEmpty(settingKey))
{
return((T)dictionary[settingKey]);
}
}
return(default(T));
}
private void UpdateSetting(SettingsEnum settings, object value)
{
using (var context = new TestContext(ContextUtil.GetOptions()))
{
context.Truncate <Setting>();
}
using (var context = new TestContext(ContextUtil.GetOptions()))
{
context.Settings.Add(new Setting()
{
Settings = SettingsEnum.Sett1, Value = "Val1"
});
context.SaveChanges();
}
using (var context = new TestContext(ContextUtil.GetOptions()))
{
// can work with explicit value: .Where(x => x.Settings == SettingsEnum.Sett1) or if named Parameter used then it has to be named (settings) same as Property (Settings) - Case not relevant, it is CaseInsensitive
context.Settings.Where(x => x.Settings == settings).BatchUpdate(x => new Setting {
Value = value.ToString()
});
}
using (var context = new TestContext(ContextUtil.GetOptions()))
{
context.Truncate <Setting>();
}
}
private async Task UpdateSettingAsync(SettingsEnum settings, object value)
{
using (var context = new TestContext(ContextUtil.GetOptions()))
{
await context.TruncateAsync <Setting>();
}
using (var context = new TestContext(ContextUtil.GetOptions()))
{
await context.Settings.AddAsync(new Setting()
{
Settings = SettingsEnum.Sett1, Value = "Val1"
}).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
}
using (var context = new TestContext(ContextUtil.GetOptions()))
{
// can work with explicit value: .Where(x => x.Settings == SettingsEnum.Sett1) or if named Parameter used then it has to be named (settings) same as Property (Settings) - Case not relevant, it is CaseInsensitive
await context.Settings.Where(x => x.Settings == settings).BatchUpdateAsync(x => new Setting {
Value = value.ToString()
}).ConfigureAwait(false);
}
using (var context = new TestContext(ContextUtil.GetOptions()))
{
await context.TruncateAsync <Setting>();
}
}
public List <SheepParameter> GetSheepParameterValue(SettingsEnum settingsEnum)
{
string sql = "SELECT \"Value\",\"Range\",\"IsRemaindful\" from \"T_SheepParameter\" p join \"T_Settings\" s on s.\"Id\"=p.\"SettingsId\" where \"Type\"=:type";
IDbParameters pms = AdoTemplate.CreateDbParameters();
pms.AddWithValue("type", (int)settingsEnum);
return(GetData <SheepParameter>(sql, pms));
}
public AVProLiveCameraSettingBase GetVideoSettingByType(SettingsEnum type)
{
AVProLiveCameraSettingBase result = null;
if (!_settingsByType.TryGetValue((int)type, out result))
{
result = null;
}
return(result);
}
public void SetSettings(SettingsEnum settings, bool value)
{
if (settings == SettingsEnum.Penalties)
{
PenaltiesAllowed(value);
}
else if (settings == SettingsEnum.NegativeScores)
{
NegativeScoresAllowed(value);
}
}
private static bool IsDynamicSettingSet(SettingsEnum setting, dynamic settingsObject)
{
if (settingsObject == null)
{
return(false);
}
var settingName = GetSettingNameFromSetting(setting);
var settingsDictionary = settingsObject as IDictionary <string, JToken>;
if (settingsDictionary != null)
{
if (settingsDictionary.Keys.Any(k => IsMatch(k, settingName)))
{
return(true);
}
}
var settingsDictionary2 = settingsObject as IDictionary <string, object>;
if (settingsDictionary2 != null)
{
if (settingsDictionary2.Keys.Any(k => IsMatch(k, settingName)))
{
return(true);
}
}
var alternateSettingNames = GetAllternateSettingNamesFromSetting(setting);
foreach (var alternateSettingName in alternateSettingNames)
{
var settingsDictionary3 = settingsObject as IDictionary <string, JToken>;
if (settingsDictionary3 != null)
{
if (settingsDictionary3.Keys.Any(k => IsMatch(k, alternateSettingName)))
{
return(true);
}
}
var settingsDictionary4 = settingsObject as IDictionary <string, object>;
if (settingsDictionary4 != null)
{
if (settingsDictionary4.Keys.Any(k => IsMatch(k, alternateSettingName)))
{
return(true);
}
}
}
return(false);
}
public void OverrideSetting <T>(SettingsEnum setting, T value)
{
if (_cachedSettings.ContainsKey(setting))
{
_cachedSettings[setting] = value;
}
else
{
_cachedSettings.Add(setting, value);
}
}
/// <summary>
/// 設定値を保存する
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
/// <returns></returns>
public IAttemptResult SaveSetting <T>(T data) where T : Enum
{
SettingsEnum setting = this.GetSettingType <T>();
this.localSettingHandler.SaveSetting(Convert.ToInt32(data), setting);
return(new AttemptResult()
{
IsSucceeded = true
});
}
private T GetSetting <T>(SettingsEnum enumName)
{
try
{
var value = GetSetting(enumName);
return((T)Convert.ChangeType(value, typeof(T)));
}
catch (Exception ex)
{
log.Error(string.Format("Exception when reading setting {0} of type {1}", enumName, typeof(T)), ex);
return(default(T));
}
}
private T GetSetting <T>(SettingsEnum enumName)
{
try
{
var value = GetSetting(enumName);
return((T)Convert.ChangeType(value, typeof(T)));
}
catch (Exception ex)
{
log.Error(ex, $"Exception when reading setting {enumName} of type {typeof(T)}");
return(default(T));
}
}
/// <summary>
/// 設定を取得する
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="settingName"></param>
/// <returns></returns>
public T GetSetting <T>() where T : Enum
{
SettingsEnum setting = this.GetSettingType <T>();
var value = this.localSettingHandler.GetIntSetting(setting);
if (value == -1)
{
value = 0;
}
return((T)Enum.ToObject(typeof(T), value));
}
public void SetSettings(SettingsEnum settings, float value)
{
if (settings == SettingsEnum.Music)
{
MusicVolume(value);
}
else if (settings == SettingsEnum.Sound)
{
SFXVolume(value);
}
else if (settings == SettingsEnum.CardDelay)
{
CardDelay(value);
}
}
private string SetSettingTitle(SettingsEnum settingName)
{
switch (settingName)
{
case SettingsEnum.GetLife:
return("Get Life");
break;
case SettingsEnum.Language:
return("Language");
break;
case SettingsEnum.Sound:
return("Sound");
break;
case SettingsEnum.Support:
return("Support");
break;
case SettingsEnum.RateUs:
return("Rate Us !");
break;
case SettingsEnum.ConnectWithFriends:
return("Connect with Friends");
break;
case SettingsEnum.OtherGames:
return("Other Games");
break;
case SettingsEnum.ResetAccount:
return("Reset");
break;
default:
return(string.Empty);
}
}
public Task Expand(SettingsEnum settingEnum)
{
if (!IsShrinking)
{
IsActive = true;
this.AbortAnimation("Shrink");
IsExpanding = true;
this.Animate("Expand", p => Height = (float)p, Height, _clipHeight, 8, (uint)_animationMs,
Easing.CubicInOut, (a, b) => IsExpanding = false);
_currentOptionsDisplayer = _listOfOptionsDisplayers.FirstOrDefault(p => p.SettingName == settingEnum);
_currentOptionsDisplayer?.Display();
//return ExpandDialogBox();
}
return(Task.Delay(_animationMs));
}
public static void Set(SettingsEnum setting, object value)
{
switch (setting)
{
case SettingsEnum.DefaultTimeout:
DefaultTimeout = (int)value;
break;
case SettingsEnum.WaitStrategy:
WaitStrategy = (WaitStrategy)value;
break;
default:
throw new ArgumentOutOfRangeException(nameof(setting), setting, null);
}
}
public static T GetSetting <T>(SettingsEnum setting, dynamic repositorySettings = null, dynamic topicSettings = null, dynamic requestRootSettings = null)
{
// Topic-specific settings overrule everything else
if (IsDynamicSettingSet(setting, topicSettings))
{
return(GetDynamicSetting <T>(setting, topicSettings));
}
// Settings for the whole repository still overrule app-global settings
if (IsDynamicSettingSet(setting, repositorySettings))
{
return(GetDynamicSetting <T>(setting, repositorySettings));
}
// If we have request-specific root settings, we consider that
if (IsDynamicSettingSet(setting, requestRootSettings))
{
return(GetDynamicSetting <T>(setting, requestRootSettings));
}
// We haven't found anything yet, so we take a look at the global app settings
if (GlobalConfiguration != null)
{
var dynamicGlobalConfiguraiton = (dynamic)GlobalConfiguration;
var value = dynamicGlobalConfiguraiton[GetSettingNameFromSetting(setting)];
if (value != null)
{
return(value);
}
}
// We still haven't found anything, so we check if the setting enum defines a default value for the current setting
var type = typeof(SettingsEnum);
var memInfo = type.GetMember(setting.ToString());
if (memInfo.Length > 0)
{
var attributes = memInfo[0].GetCustomAttributes(typeof(DefaultValueAttribute), false);
if (attributes.Length > 0)
{
return((T)((DefaultValueAttribute)attributes[0]).Value);
}
}
return(default(T));
}
public T GetSetting <T>(SettingsEnum setting)
{
if (_cachedSettings.ContainsKey(setting))
{
return((T)_cachedSettings[setting]);
}
var value = SettingsHelper.GetSetting <T>(setting, TocSettings, CurrentTopicSettings, CurrentRequestRootSettings);
if (CurrentTopicSettings != null)
{
// We can only cache if we already have current topic settings, otherwise, those may just not have been loaded yet, and may thus still be loaded and needed later.
_cachedSettings.Add(setting, value);
}
return(value);
}
public static List <string> GetAllternateSettingNamesFromSetting(SettingsEnum setting)
{
var names = new List <string>();
var type = typeof(SettingsEnum);
var memInfo = type.GetMembers().FirstOrDefault(m => SettingsHelper.IsMatch(setting.ToString(), m.Name));
if (memInfo != null)
{
var attributes = memInfo.GetCustomAttributes(typeof(AlternateNameAttribute), false);
foreach (var attribute in attributes.OfType <AlternateNameAttribute>())
{
names.Add(attribute.Name);
}
}
return(names);
}
/// <summary>
/// 文字列の設定を取得する
/// </summary>
/// <param name="setting"></param>
/// <returns></returns>
public string?GetStringSetting(SettingsEnum setting)
{
var settingname = this.GetSettingName(setting);
if (settingname is null)
{
return(null);
}
if (this.settingHandler.Exists(settingname, SettingType.stringSetting))
{
return(this.settingHandler.GetStringSetting(settingname).Data);
}
else
{
return(null);
}
}
/// <summary>
/// 真偽値の設定を取得する
/// </summary>
/// <param name="setting"></param>
/// <returns></returns>
public bool GetBoolSetting(SettingsEnum setting)
{
var settingname = this.GetSettingName(setting);
if (settingname is null)
{
return(false);
}
if (this.settingHandler.Exists(settingname, SettingType.boolSetting))
{
return(this.settingHandler.GetBoolSetting(settingname).Data);
}
else
{
return(false);
}
}
/// <summary>
/// 整数値の設定を取得する
/// </summary>
/// <param name="setting"></param>
/// <returns></returns>
public int GetIntSetting(SettingsEnum setting)
{
var settingname = this.GetSettingName(setting);
if (settingname is null)
{
return(-1);
}
if (this.settingHandler.Exists(settingname, SettingType.intSetting))
{
return(this.settingHandler.GetIntSetting(settingname).Data);
}
else
{
return(-1);
}
}
/// <summary>
/// 設定を保存する
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="fiels"></param>
/// <param name="data"></param>
/// <param name="settingname"></param>
/// <param name="propertyname"></param>
protected void SaveSetting <T>(T data, SettingsEnum setting, [CallerMemberName] string?propertyname = null)
{
if (data is bool boolData)
{
WS::SettingPage.SettingHandler.SaveSetting(boolData, setting);
}
else if (data is string stringData)
{
WS::SettingPage.SettingHandler.SaveSetting(stringData, setting);
}
else if (data is int intData)
{
WS::SettingPage.SettingHandler.SaveSetting(intData, setting);
}
else
{
return;
}
}
public int UpdateSetting(string value, SettingsEnum settingName, string email, string serviceCode)
{
var setting = GetSetting(settingName, email, serviceCode);
if (setting == null)
{
setting = new Settings
{
Name = settingName.ToString(),
Email = email,
Value = value,
ServiceCode = serviceCode
};
return(base.Insert <Settings>(base.MainDbPath, setting));
}
else
{
setting.Value = value;
return(base.Update <Settings>(base.MainDbPath, setting));
}
}
/// <summary>
/// 設定を保存する
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="fiels"></param>
/// <param name="data"></param>
/// <param name="settingname"></param>
/// <param name="propertyname"></param>
protected void Savesetting <T>(ref T fiels, T data, SettingsEnum setting, [CallerMemberName] string?propertyname = null)
{
if (data is bool boolData)
{
WS::SettingPage.SettingHandler.SaveSetting(boolData, setting);
}
else if (data is string stringData)
{
WS::SettingPage.SettingHandler.SaveSetting(stringData, setting);
}
else if (data is int intData)
{
WS::SettingPage.SettingHandler.SaveSetting(intData, setting);
}
else
{
return;
}
fiels = data;
this.OnPropertyChanged(propertyname);
}
/// <summary>
/// 設定を保存する
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
/// <param name="setting"></param>
public void SaveSetting <T>(T data, SettingsEnum setting)
{
var settingname = this.GetSettingName(setting);
if (settingname is null)
{
return;
}
if (data is bool boolData)
{
this.settingHandler.SaveBoolSetting(settingname, boolData);
}
else if (data is string stringData)
{
this.settingHandler.SaveStringSetting(settingname, stringData);
}
else if (data is int intData)
{
this.settingHandler.SaveIntSetting(settingname, intData);
}
}
private static T GetDynamicSetting <T>(SettingsEnum setting, dynamic settingsObject)
{
if (settingsObject == null)
{
return(default(T));
}
var settingsDictionary = settingsObject as IDictionary <string, JToken>;
if (settingsDictionary != null)
{
return(GetDictionarySetting <T>(setting, settingsDictionary));
}
var settingsDictionary2 = settingsObject as IDictionary <string, object>;
if (settingsDictionary2 != null)
{
return(GetDictionarySetting <T>(setting, settingsDictionary2));
}
return(default(T));
}
public AVProLiveCameraSettingBase GetVideoSettingByType(SettingsEnum type)
{
AVProLiveCameraSettingBase result = null;
if (!_settingsByType.TryGetValue((int)type, out result))
{
result = null;
}
return result;
}
public static string GetSettingNameFromSetting(SettingsEnum setting) => setting.ToString().Trim().ToLowerInvariant();
