// XXX this is gross... we churn HeliosTriggerEventArgs and HeliosActionEventArgs objects for no reason. let's have one EventArgs object that represents a value change
// XXX and then we can reuse it through the action/trigger/action/trigger stack frames and even use it for tracing
protected void OnFireTrigger(BindingValue value)
{
HeliosTriggerEventArgs args = new HeliosTriggerEventArgs(value);
HeliosTriggerHandler handler = TriggerFired;
handler?.Invoke(this, args);
}
protected void OnFireTrigger(BindingValue value)
{
HeliosTriggerEventArgs args = new HeliosTriggerEventArgs(value);
HeliosTriggerHandler handler = TriggerFired;
if (handler != null)
{
handler.Invoke(this, args);
}
}
/// <summary>
/// Contains information to allow AutoBinding in the onProfileChanged method.
/// </summary>
/// <param name="childName">Name of the device which has the action</param>
/// <param name="interfaceTriggerName">The name of the trigger when that trigger is from an interface</param>
/// <param name="deviceActionName">The name of the action to be performed</param>
/// <param name="deviceTriggerName">The name of the trigger if it is from a visual component</param>
/// <param name="deviceTriggerBindingValue">Static trigger value which only used with deviceTriggerValue</param>
public DefaultInputBinding(string childName, string interfaceTriggerName, string deviceActionName, string deviceTriggerName, BindingValue deviceTriggerBindingValue)
{
ChildName = childName;
InterfaceTriggerName = "";
DeviceTriggerName = deviceTriggerName;
DeviceActionName = deviceActionName;
DeviceTriggerBindingValue = deviceTriggerBindingValue;
Logger.Info("Default Input Binding: Trigger " + deviceTriggerName + " to action " + deviceActionName + " for child " + childName);
}
public void FireTrigger(BindingValue value)
{
HeliosTriggerEventArgs args = new HeliosTriggerEventArgs(value);
HeliosTriggerHandler handler = TriggerFired;
if (handler != null)
{
handler.Invoke(this, args);
}
}
/// <summary>
/// Executes this action.
/// </summary>
/// <param name="value">Value to be processed by this action.</param>
/// <param name="bypassCascadingTriggers">If true this action will not fire additional triggers.</param>
public void ExecuteAction(BindingValue value, bool bypassCascadingTriggers)
{
HeliosActionEventArgs args = new HeliosActionEventArgs(value, bypassCascadingTriggers);
HeliosActionHandler handler = Execute;
if (handler != null)
{
handler.Invoke(this, args);
}
}
public BindingValue ConvertUnit(BindingValue value, BindingValueUnit from, BindingValueUnit to)
{
BindingValueUnitConverter converter = GetUnitConverter(from, to);
if (converter != null)
{
return(converter.Convert(value, from, to));
}
return(BindingValue.Empty);
}
public HeliosValue(HeliosObject owner, BindingValue initialValue, string device, string name, string description, string valueDescription, BindingValueUnit unit)
{
_device = device;
_name = name;
_description = description;
_valueDescription = valueDescription;
_owner = new WeakReference(owner);
_value = initialValue;
_unit = unit;
UpdateId();
}
public HeliosValue(HeliosObject owner, BindingValue initialValue, string device, string name, string description, string valueDescription, BindingValueUnit unit)
{
_device = device;
_name = name;
_description = description;
_valueDescription = valueDescription;
_owner = new WeakReference(owner);
_value = initialValue;
_unit = unit;
UpdateId();
}
/// <summary>
/// Sets a new value for this helios value object
/// </summary>
/// <param name="value">Value to be sent to bindings.</param>
/// <param name="bypassCascadingTriggers">True if bindings should not trigger further triggers.</param>
public void SetValue(BindingValue value, bool bypassCascadingTriggers)
{
if ((_value == null && value != null) ||
(_value != null && !_value.Equals(value)))
{
_value = value;
if (!bypassCascadingTriggers)
{
OnFireTrigger(value);
}
}
}
/// <summary>
/// WARNING: This function returns true if the object being compared can provide an equal value, even if the types differ.
/// Use IsIdenticalTo to check for complete equality (same type and value)
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
object compareObject = obj;
if (obj == this)
{
return(true);
}
else if (obj == Empty || this == Empty)
{
return(false);
}
if (obj is BindingValue)
{
BindingValue bvObj = (BindingValue)obj;
switch (bvObj._nativeValueType)
{
case BindingValueType.Boolean:
compareObject = bvObj.BoolValue;
break;
case BindingValueType.String:
compareObject = bvObj.StringValue;
break;
case BindingValueType.Double:
compareObject = bvObj.DoubleValue;
break;
}
}
// XXX rewrite. this is insanely inefficient to use a type check here to check what branch we took above
if (compareObject is string)
{
return(StringValue.Equals(compareObject));
}
else if (compareObject is double)
{
return(DoubleValue.Equals(compareObject));
}
else if (compareObject is bool)
{
return(BoolValue.Equals(compareObject));
}
return(false);
}
public override bool Equals(object obj)
{
object compareObject = obj;
if (obj == this)
{
return(true);
}
else if (obj == Empty || this == Empty)
{
return(false);
}
if (obj is BindingValue)
{
BindingValue bvObj = (BindingValue)obj;
switch (bvObj._nativeValueType)
{
case BindingValueType.Boolean:
compareObject = bvObj.BoolValue;
break;
case BindingValueType.String:
compareObject = bvObj.StringValue;
break;
case BindingValueType.Double:
compareObject = bvObj.DoubleValue;
break;
}
}
if (compareObject is string)
{
return(StringValue.Equals(compareObject));
}
else if (compareObject is double)
{
return(DoubleValue.Equals(compareObject));
}
else if (compareObject is bool)
{
return(BoolValue.Equals(compareObject));
}
return(false);
}
public int NonConvertingCompare(BindingValue right)
{
if (ReferenceEquals(right, this))
{
return(0);
}
bool thisIsEmpty = (ReferenceEquals(this, Empty));
if (ReferenceEquals(right, Empty))
{
// empty is less than all values
return(thisIsEmpty ? 0 : 1);
}
int typeDifference = _nativeValueType - right._nativeValueType;
if (typeDifference != 0)
{
// different types sort by type
return(typeDifference);
}
switch (_nativeValueType)
{
case BindingValueType.Boolean:
return(BoolValue.CompareTo(right.BoolValue));
case BindingValueType.String:
return(string.Compare(StringValue, right.StringValue, StringComparison.InvariantCulture));
case BindingValueType.Double:
return(DoubleValue.CompareTo(right.DoubleValue));
default:
throw new ArgumentOutOfRangeException();
}
}
private void Execute(BindingValue value, bool bypass)
{
Action.ExecuteAction(value, bypass);
}
public HeliosActionEventArgs(BindingValue value, bool bypassCascadingTriggers)
{
_value = value;
_bypass = bypassCascadingTriggers;
}
private void Execute(BindingValue value, bool bypass)
{
Action.ExecuteAction(value, bypass);
}
public void OnTriggerFired(object trigger, HeliosTriggerEventArgs e)
{
if (IsActive)
{
if (_executing)
{
ConfigManager.LogManager.LogWarning("Binding loop condition detected, binding aborted. (Binding=\"" + Description + "\")");
}
else
{
if (ConfigManager.LogManager.LogLevel >= LogLevel.Info)
{
ConfigManager.LogManager.LogInfo("Binding triggered. (Binding=\"" + Description + "\", Value=\"" + e.Value.StringValue + "\")");
}
try
{
_executing = true;
BindingValue value = BindingValue.Empty;
//LuaInterpreter["TriggerValue"] = e.Value.NaitiveValue;
switch (e.Value.NaitiveType)
{
case BindingValueType.Boolean:
LuaInterpreter["TriggerValue"] = e.Value.BoolValue;
break;
case BindingValueType.String:
LuaInterpreter["TriggerValue"] = e.Value.StringValue;
break;
case BindingValueType.Double:
LuaInterpreter["TriggerValue"] = e.Value.DoubleValue;
break;
}
if (HasCondition)
{
try
{
object[] conditionReturnValues = LuaInterpreter.DoString(_condition);
if (conditionReturnValues.Length >= 1)
{
BindingValue returnValue = CreateBindingValue(conditionReturnValues[0]);
if (returnValue.BoolValue == false)
{
if (ConfigManager.LogManager.LogLevel >= LogLevel.Debug)
{
ConfigManager.LogManager.LogDebug("Binding condition evaluated to false, binding aborted. (Binding=\"" + Description + "\")");
}
return;
}
}
}
catch (LuaScriptException luaException)
{
ConfigManager.LogManager.LogWarning("Binding condition lua error. (Error=\"" + luaException.Message + "\", Condition Script=\"" + Condition + "\", Binding=\"" + Description + "\")");
}
catch (Exception conditionException)
{
ConfigManager.LogManager.LogError("Binding condition has thown an unhandled exception. (Binding=\"" + Description + "\", Condition=\"" + Condition + "\")", conditionException);
return;
}
}
switch (ValueSource)
{
case BindingValueSources.StaticValue:
value = _value;
break;
case BindingValueSources.TriggerValue:
if (_needsConversion && _converter != null)
{
value = _converter.Convert(e.Value, Trigger.Unit, Action.Unit);
if (ConfigManager.LogManager.LogLevel >= LogLevel.Debug)
{
ConfigManager.LogManager.LogDebug("Binding converted value. (Binding=\"" + Description + "\", Original Value=\"" + e.Value.StringValue + "\", New Value=\"" + value.StringValue + "\")");
}
}
else
{
value = e.Value;
}
break;
case BindingValueSources.LuaScript:
try
{
object[] returnValues = LuaInterpreter.DoString(Value);
if (returnValues.Length >= 1)
{
value = CreateBindingValue(returnValues[0]);
if (ConfigManager.LogManager.LogLevel >= LogLevel.Debug)
{
ConfigManager.LogManager.LogDebug("Binding value lua script evaluated (Binding=\"" + Description + "\", Expression=\"" + Value + "\", TriggerValue=\"" + LuaInterpreter["TriggerValue"] + "\", ReturnValue=\"" + returnValues[0] + "\")");
}
}
else
{
ConfigManager.LogManager.LogWarning("Binding value lua script did not return a value. (Binding=\"" + Description + "\", Expression=\"" + Value + "\", TriggerValue=\"" + LuaInterpreter["TriggerValue"] + "\")");
}
}
catch (LuaScriptException luaException)
{
ConfigManager.LogManager.LogWarning("Binding value lua error. (Error=\"" + luaException.Message + "\", Value Script=\"" + Value + "\", Binding=\"" + Description + "\")");
}
catch (Exception valueException)
{
ConfigManager.LogManager.LogError("Binding value lua script has thown an unhandled exception. (Binding=\"" + Description + "\", Value Script=\"" + Value + "\")", valueException);
}
break;
}
if (Action.Target.Dispatcher == null)
{
// if we don't have a dispatcher, likely because this is a composite device, we use the dispatcher object from the owner of the trigger
// this seems to work and was the best I could come up with, but it is very much a kludge because I could not work out the proper way
// to have a dispatcher created for Actions
Action.Target.Dispatcher = Trigger.Owner.Dispatcher;
}
Action.Target.Dispatcher.Invoke(new Action <BindingValue, bool>(Execute), value, BypassCascadingTriggers);
}
catch (Exception ex)
{
ConfigManager.LogManager.LogError("Binding threw unhandled exception. (Binding=\"" + Description + "\")", ex);
}
_executing = false;
}
}
}
public HeliosTriggerEventArgs(BindingValue value)
{
_value = value;
}
public HeliosActionEventArgs(BindingValue value, bool bypassCascadingTriggers)
{
_value = value;
_bypass = bypassCascadingTriggers;
}
public BindingValue ConvertUnit(BindingValue value, BindingValueUnit from, BindingValueUnit to)
{
BindingValueUnitConverter converter = GetUnitConverter(from, to);
if (converter != null)
{
return converter.Convert(value, from, to);
}
return BindingValue.Empty;
}
/// <summary>
/// Sets a new value for this helios value object
/// </summary>
/// <param name="value">Value to be sent to bindings.</param>
/// <param name="bypassCascadingTriggers">True if bindings should not trigger further triggers.</param>
public void SetValue(BindingValue value, bool bypassCascadingTriggers)
{
if ((_value == null && value != null)
|| (_value != null && !_value.Equals(value)))
{
_value = value;
if (!bypassCascadingTriggers)
{
OnFireTrigger(value);
}
}
}
public bool IsIdenticalTo(BindingValue other)
{
return(0 == NonConvertingCompare(other));
}
public HeliosTriggerEventArgs(BindingValue value)
{
_value = value;
}
private HeliosBinding CreateNewBinding(IBindingTrigger trigger, IBindingAction action, BindingValue bindingValue)
{
HeliosBinding binding = new HeliosBinding(trigger, action);
binding.BypassCascadingTriggers = true;
if (action.ActionRequiresValue && (ConfigManager.ModuleManager.CanConvertUnit(trigger.Unit, action.Unit)))
{
binding.ValueSource = BindingValueSources.TriggerValue;
}
else
{
binding.ValueSource = BindingValueSources.StaticValue;
if (bindingValue is null)
{
}
else
{
if (action.Unit.ShortName == "Boolean")
{
binding.Value = bindingValue.BoolValue ? "True" : "False";
}
else
{
binding.Value = bindingValue.StringValue;
}
}
}
return(binding);
}
/// <summary>
/// Executes this action.
/// </summary>
/// <param name="value">Value to be processed by this action.</param>
/// <param name="bypassCascadingTriggers">If true this action will not fire additional triggers.</param>
public void ExecuteAction(BindingValue value, bool bypassCascadingTriggers)
{
HeliosActionEventArgs args = new HeliosActionEventArgs(value, bypassCascadingTriggers);
HeliosActionHandler handler = Execute;
if (handler != null)
{
handler.Invoke(this, args);
}
}