public ModuleObject(string displayName, UserControl contentControl, IValueHelper<bool> canSaveHelper) { DisplayName = displayName; ContentControl = contentControl; IsAvailableHelper = new ValueHelper<bool>() { Value = true/*Starts available by default*/ }; CanSaveHelper = canSaveHelper; }
private static T GetGCD <T>(IValueHelper <T> valueHelper, T d1, params T[] denominators) where T : struct, IComparable, IFormattable, IConvertible, IComparable <T>, IEquatable <T> { if (denominators == null || denominators.Length == 0) { return(d1); } T gcd = valueHelper.Abs(d1); foreach (T d in denominators) { T b; if (d.CompareTo(gcd) > 0) { b = gcd; gcd = valueHelper.Abs(d); } else { b = valueHelper.Abs(d); } while (b.CompareTo(valueHelper.Zero) > 0) { T rem = valueHelper.Modulus(gcd, b); gcd = b; b = rem; } } return(gcd); }
private static T GetSimplifiedRational <T>(IValueHelper <T> valueHelper, T n, T d, out T denominator) where T : struct, IComparable, IFormattable, IConvertible, IComparable <T>, IEquatable <T> { if (d.Equals(valueHelper.Zero)) { throw new DivideByZeroException(); } if (n.Equals(valueHelper.Zero)) { denominator = valueHelper.PositiveOne; return(valueHelper.Zero); } if (n.Equals(d)) { denominator = valueHelper.PositiveOne; return(valueHelper.PositiveOne); } if (d.CompareTo(valueHelper.Zero) < 0) { d = valueHelper.Multiply(d, valueHelper.NegativeOne); n = valueHelper.Multiply(n, valueHelper.NegativeOne); } T gcd = GetGCD <T>(valueHelper, n, d); denominator = valueHelper.Divide(d, gcd); return(valueHelper.Divide(n, gcd)); }
private static T GetNormalizedRational <T>(IValueHelper <T> valueHelper, T w, T n, T d, out T numerator, out T denominator) where T : struct, IComparable, IFormattable, IConvertible, IComparable <T>, IEquatable <T> { n = GetSimplifiedRational <T>(valueHelper, n, d, out denominator); if (n.Equals(valueHelper.Zero)) { numerator = n; return(w); } if (denominator.Equals(valueHelper.PositiveOne)) { numerator = valueHelper.Zero; return(valueHelper.Add(w, n)); } if (n.CompareTo(denominator) > 0) { numerator = valueHelper.Modulus(n, denominator); if (w.CompareTo(valueHelper.Zero) < 0) { w = valueHelper.Subtract(w, valueHelper.Divide(valueHelper.Subtract(n, numerator), denominator)); } else { w = valueHelper.Add(w, valueHelper.Divide(valueHelper.Subtract(n, numerator), denominator)); } numerator = GetSimplifiedRational <T>(valueHelper, numerator, denominator, out denominator); } else { numerator = n; } if (w.Equals(valueHelper.Zero)) { return(w); } if (numerator.CompareTo(valueHelper.Zero) < 0) { if (w.CompareTo(valueHelper.Zero) < 0) { w = valueHelper.Add(w, valueHelper.PositiveOne); } else { w = valueHelper.Subtract(w, valueHelper.PositiveOne); } numerator = valueHelper.Add(numerator, denominator); } return(w); }
private static T Parse <T>(IValueHelper <T> valueHelper, string s, out T n, out T d) where T : struct, IComparable, IFormattable, IConvertible, IComparable <T>, IEquatable <T> { if (s == null) { throw new ArgumentNullException("s"); } if (s.Length == 0) { throw new FormatException("Input string was empty."); } Match m = FractionParseRegex.Match(s); if (!m.Success) { throw new FormatException("Input string was not in a correct format."); } T w; if (m.Groups["w"].Success) { if (!valueHelper.TryParse(m.Groups["w"].Value, out w)) { throw new FormatException("Whole number in input string was not in a correct format."); } } else { w = valueHelper.Zero; } if (m.Groups["n"].Success) { if (!valueHelper.TryParse(m.Groups["n"].Value, out n)) { throw new FormatException("Numerator in input string was not in a correct format."); } if (!valueHelper.TryParse(m.Groups["d"].Value, out d)) { throw new FormatException("Denominator in input string was not in a correct format."); } } else { n = valueHelper.Zero; d = valueHelper.PositiveOne; } return(w); }
private static string ToString <T>(IValueHelper <T> valueHelper, T w, T n, T d) where T : struct, IComparable, IFormattable, IConvertible, IComparable <T>, IEquatable <T> { if (n.Equals(valueHelper.Zero)) { return(w.ToString()); } if (w.Equals(valueHelper.Zero)) { return(n.ToString() + "/" + d.ToString()); } return(w.ToString() + " " + n.ToString() + "/" + d.ToString()); }
public ConnectionStringHelper(IValueHelper <string> valueHelper) { ValueHelper = valueHelper; ServerHelper = new ValueHelper <string>(); DatabaseHelper = new ValueHelper <string>(); UserHelper = new ValueHelper <string>(); PasswordHelper = new ValueHelper <string>(); ValueHelper.ValueChanged += ParseConnectionString; ParseConnectionString(); ServerHelper.ValueChanged += () => { SetValue(KeysServer, ServerHelper.Value); }; DatabaseHelper.ValueChanged += () => { SetValue(KeysDatabase, DatabaseHelper.Value); }; UserHelper.ValueChanged += () => { SetValue(KeysUser, UserHelper.Value); }; PasswordHelper.ValueChanged += () => { SetValue(KeysPassword, PasswordHelper.Value); }; }
public ConnectionStringHelper(IValueHelper<string> valueHelper) { ValueHelper = valueHelper; ServerHelper = new ValueHelper<string>(); DatabaseHelper = new ValueHelper<string>(); UserHelper = new ValueHelper<string>(); PasswordHelper = new ValueHelper<string>(); ValueHelper.ValueChanged += ParseConnectionString; ParseConnectionString(); ServerHelper.ValueChanged += ()=> { SetValue( KeysServer, ServerHelper.Value ); }; DatabaseHelper.ValueChanged += ()=> { SetValue( KeysDatabase, DatabaseHelper.Value ); }; UserHelper.ValueChanged += ()=> { SetValue( KeysUser, UserHelper.Value ); }; PasswordHelper.ValueChanged += ()=> { SetValue( KeysPassword, PasswordHelper.Value ); }; }
private static bool TryParse <T>(IValueHelper <T> valueHelper, string s, out T w, out T n, out T d) where T : struct, IComparable, IFormattable, IConvertible, IComparable <T>, IEquatable <T> { Match m; if (String.IsNullOrEmpty(s) || !(m = FractionParseRegex.Match(s)).Success) { w = valueHelper.Zero; n = valueHelper.Zero; d = valueHelper.PositiveOne; return(false); } if (m.Groups["w"].Success) { if (!valueHelper.TryParse(m.Groups["w"].Value, out w)) { n = valueHelper.Zero; d = valueHelper.PositiveOne; return(false); } } else { w = valueHelper.Zero; } if (m.Groups["n"].Success) { if (!valueHelper.TryParse(m.Groups["n"].Value, out n)) { d = valueHelper.PositiveOne; return(false); } if (!valueHelper.TryParse(m.Groups["d"].Value, out d)) { return(false); } } else { n = valueHelper.Zero; d = valueHelper.PositiveOne; } return(true); }
private static void ToCommonDenominator <T>(IValueHelper <T> valueHelper, ref T n1, ref T d1, ref T n2, ref T d2) where T : struct, IComparable, IFormattable, IConvertible, IComparable <T>, IEquatable <T> { if (d1.Equals(valueHelper.Zero) || d2.Equals(valueHelper.Zero)) { throw new DivideByZeroException(); } if (n1.Equals(valueHelper.Zero)) { d1 = d2; } else if (n2.Equals(valueHelper.Zero)) { d2 = d1; } else if (!d1.Equals(d2)) { n1 = GetSimplifiedRational <T>(valueHelper, n1, d1, out d1); n2 = GetSimplifiedRational <T>(valueHelper, n2, d2, out d2); if (d1.Equals(valueHelper.PositiveOne)) { n1 = valueHelper.Multiply(n1, d2); } else if (d2.Equals(valueHelper.PositiveOne)) { n2 = valueHelper.Multiply(n2, d1); } else if (!d1.Equals(d2)) { T m2; T m1 = GetLCM <T>(valueHelper, d1, d2, out m2); n1 = valueHelper.Multiply(n1, m1); d1 = valueHelper.Multiply(d1, m1); n2 = valueHelper.Multiply(n2, m1); d2 = valueHelper.Multiply(d2, m1); } } }
private static T GetInvertedRational <T>(IValueHelper <T> valueHelper, T w, T n, T d, out T numerator, out T denominator) where T : struct, IComparable, IFormattable, IConvertible, IComparable <T>, IEquatable <T> { w = GetNormalizedRational <T>(valueHelper, w, n, d, out numerator, out denominator); if (n.Equals(valueHelper.Zero)) { if (w.Equals(valueHelper.Zero)) { numerator = n; return(w); } return(GetNormalizedRational <T>(valueHelper, valueHelper.Zero, valueHelper.PositiveOne, w, out numerator, out denominator)); } if (w.Equals(valueHelper.Zero)) { return(GetNormalizedRational <T>(valueHelper, valueHelper.Zero, d, n, out numerator, out denominator)); } return(GetNormalizedRational <T>(valueHelper, valueHelper.Zero, d, valueHelper.Add(n, valueHelper.Multiply(d, w)), out numerator, out denominator)); }
private static T GetLCM <T>(IValueHelper <T> valueHelper, T d1, T d2, out T secondMultiplier) where T : struct, IComparable, IFormattable, IConvertible, IComparable <T>, IEquatable <T> { T zero = default(T); if (d1.CompareTo(zero) < 0) { return(GetLCM <T>(valueHelper, valueHelper.Abs(d1), d2, out secondMultiplier)); } if (d2.CompareTo(zero) < 0) { return(GetLCM <T>(valueHelper, d1, valueHelper.Abs(d2), out secondMultiplier)); } if (d1.Equals(d2)) { secondMultiplier = valueHelper.PositiveOne; return(secondMultiplier); } if (d1.CompareTo(d2) < 0) { secondMultiplier = GetLCM <T>(valueHelper, d2, d1, out d1); return(d1); } secondMultiplier = d1; while (!valueHelper.Modulus(secondMultiplier, d2).Equals(zero)) { secondMultiplier = valueHelper.Add(secondMultiplier, d1); } return(GetSimplifiedRational <T>(valueHelper, valueHelper.Divide(secondMultiplier, d1), secondMultiplier, out secondMultiplier)); }
public void Init(ActionsManager actionsManager, string creator, IValueHelper<string> connectionStringValueHelper) { System.Diagnostics.Debug.Assert( Creator == null, "Init() should be called only once!" ); Creator = creator; ActionsManager = actionsManager; IsConnectionOkHelper = new ValueHelper<bool>{ Value = false }; ConnectionString_ValueChangedActionDelayer = new ActionHelper(); bool hadInitialConnectionString; if( string.IsNullOrEmpty(connectionStringValueHelper.Value) ) { // Fill control with initial values connectionStringValueHelper.Value = ConnectionStringHelper.SampleConnectionString; hadInitialConnectionString = false; } else { hadInitialConnectionString = true; } ConnectionStringHelper = new Utils.Event.ConnectionStringHelper( connectionStringValueHelper ); // Link Show Password CheckBox cbShowPassword.Checked += ES.Routed( cbShowPassword_Changed ); cbShowPassword.Unchecked += ES.Routed( cbShowPassword_Changed ); cbShowPassword_Changed(); // Link TextBoxes to ConnectionStringHelper txtServer.Text = Server; ConnectionStringHelper.ServerHelper.ValueChanged += ()=>{ txtServer.Text = Server; }; txtServer.TextChanged += ES.TextChanged( ()=>{ Server = txtServer.Text; } ); txtDatabase.Text = Database; ConnectionStringHelper.DatabaseHelper.ValueChanged += ()=>{ txtDatabase.Text = Database; }; txtDatabase.TextChanged += ES.TextChanged( ()=>{ Database = txtDatabase.Text; } ); txtUser.Text = User; ConnectionStringHelper.UserHelper.ValueChanged += ()=>{ txtUser.Text = User; }; txtUser.TextChanged += ES.TextChanged( ()=>{ User = txtUser.Text; } ); txtPasswordClear.Text = txtPasswordHidden.Password = txtPasswordConfirm.Password = Password; ConnectionStringHelper.PasswordHelper.ValueChanged += ()=> { var password = Password; txtPasswordClear.Text = password; if( txtPasswordHidden.Password != password ) txtPasswordHidden.Password = password; if( txtPasswordConfirm.Password != password ) txtPasswordConfirm.Password = password; }; txtPasswordClear.TextChanged += (sender,e)=>{ Password = txtPasswordClear.Text; }; txtPasswordHidden.PasswordChanged += ES.Routed( txtPasswordHiddenConfirm_PasswordChanged ); txtPasswordConfirm.PasswordChanged += ES.Routed( txtPasswordHiddenConfirm_PasswordChanged ); // Monitor ConnectionString changes txtConnectionString.Text = ConnectionStringHelper.GetConnectionStringWithoutPassword( PasswordHideString ); ConnectionString_ValueChangedActionDelayer.Action = ConnectionString_ValueChangedDelayed; ConnectionStringHelper.ValueHelper.ValueChanged += ConnectionString_ValueChanged; if( hadInitialConnectionString ) // Try connection right now if a ConnectionString is already available ConnectionString_ValueChangedActionDelayer.Trigger(); // Set delay on the ConnectionString's ActionHelper ConnectionString_ValueChangedActionDelayer.DelaySeconds = 1; }