/// <summary>
/// When overridden in the derived class, converts the <paramref name="value"/> to a string, separating
/// each element with the given <paramref name="separator"/>.
/// </summary>
/// <param name="value">The value to convert to a string.</param>
/// <param name="separator">The string to use to separate the values.</param>
/// <returns>The <paramref name="value"/> as a string.</returns>
protected override string ConvertToString(IVariableValue <T> value, string separator)
{
var minStr = ConvertToString(value.Min);
var maxStr = ConvertToString(value.Max);
return(string.Format("{1}{0}{2}", separator, minStr, maxStr));
}
static void ReadWriteTest <T>(IVariableValue <T> value, Action <IValueWriter, string, IVariableValue <T> > write,
Func <IValueReader, string, IVariableValue <T> > read, bool testRead)
{
foreach (var createCreator in IValueReaderWriterTestHelper.CreateCreators)
{
using (var creator = createCreator())
{
using (var w = creator.GetWriter())
{
for (var i = 0; i < 3; i++)
{
write(w, GetValueKey(i), value);
}
}
if (testRead)
{
var r = creator.GetReader();
{
for (var i = 0; i < 3; i++)
{
var readValue = read(r, GetValueKey(i));
Assert.AreEqual(value.Min, readValue.Min);
Assert.AreEqual(value.Max, readValue.Max);
}
}
}
}
}
}
public BoundVariable(XmlLayoutElement element, T instance, IVariableValue <P> value, ValueSetterDelegate <T, P> setter)
{
this.element = element;
this.instance = instance;
this.value = value;
this.setter = setter;
value.OnValueChanged += ApplyChanged;
}
public static void ReplactVarialbe(IVariableValue oldvar, IVariableValue newvar)
{
var node = VariableCollection.Find(oldvar);
if (node != null)
{
VariableCollection.AddAfter(node, newvar);
VariableChanged.Invoke(new VariableChangedEventArgs(ValueChangedType.Add, newvar));
VariableCollection.Remove(node);
VariableChanged.Invoke(new VariableChangedEventArgs(ValueChangedType.Remove, node.Value));
}
}
/// <summary>
/// Helps write a variable value.
/// </summary>
/// <typeparam name="T">The internal type of the variable value.</typeparam>
/// <param name="writer">The writer.</param>
/// <param name="name">The name.</param>
/// <param name="value">The value.</param>
/// <param name="writeValue">Delegate used to write type <typeparamref name="T"/>.</param>
static void WriteVariableValue <T>(IValueWriter writer, string name, IVariableValue <T> value, Action <string, T> writeValue)
{
if (writer.SupportsNodes && writer.SupportsNameLookup)
{
writer.WriteStartNode(name);
writeValue("Min", value.Min);
writeValue("Max", value.Max);
writer.WriteEndNode(name);
}
else
{
writeValue("Min", value.Min);
writeValue("Max", value.Max);
}
}
static void WriteTest <T>(IVariableValue <T> value, Action <IValueWriter, string, IVariableValue <T> > write,
Func <IValueReader, string, IVariableValue <T> > read)
{
ReadWriteTest(value, write, read, false);
}
public VariableChangedEventArgs(ValueChangedType type, IVariableValue variable)
{
ChangedType = type;
Variable = variable;
}
public static void RemoveVariable(IVariableValue variable)
{
VariableCollection.Remove(variable);
VariableChanged.Invoke(new VariableChangedEventArgs(ValueChangedType.Remove, variable));
}
public static void AddVariable(IVariableValue variable)
{
VariableCollection.AddLast(variable);
VariableChanged.Invoke(new VariableChangedEventArgs(ValueChangedType.Add, variable));
}
