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;
}
