private static HeliosVisual GetVisualByPath(HeliosVisual visual, Queue <string> nameQueue)
{
HeliosVisual returnValue = null;
string name = nameQueue.Dequeue();
if (visual.Name.Equals(name))
{
if (nameQueue.Count == 0)
{
returnValue = visual;
}
else
{
string childName = nameQueue.Peek();
foreach (HeliosVisual child in visual.Children)
{
if (childName.Equals(child.Name))
{
returnValue = GetVisualByPath(child, nameQueue);
if (returnValue != null)
{
break;
}
}
}
}
}
return(returnValue);
}
public NonClickableZone(Rect nonClickableZone, ToggleSwitchPosition position, HeliosVisual childVisual, ToggleSwitchPosition guardedChildPosition)
{
_pastToChildZone = nonClickableZone;
PositionWhenApplicable = position;
ChildVisual = childVisual;
GuardedChildPosition = guardedChildPosition;
}
private object DispCreateNewObject(string type, string typeId)
{
switch (type)
{
case "Monitor":
return(new Monitor());
case "Visual":
HeliosVisual visual = ConfigManager.ModuleManager.CreateControl(typeId);
visual.Dispatcher = _dispatcher;
return(visual);
case "Interface":
HeliosInterfaceDescriptor descriptor = ConfigManager.ModuleManager.InterfaceDescriptors[typeId];
HeliosInterface heliosInterface = descriptor != null?descriptor.CreateInstance() : null;
if (heliosInterface != null)
{
heliosInterface.Dispatcher = _dispatcher;
}
return(heliosInterface);
case "Binding":
return(new HeliosBinding());
}
return(null);
}
public static string GetReferenceName(HeliosObject refObject)
{
StringBuilder sb = new StringBuilder("");
HeliosInterface refInterface = refObject as HeliosInterface;
if (refInterface != null)
{
sb.Append("Interface;;");
}
HeliosVisual refControl = refObject as HeliosVisual;
if (refControl != null)
{
sb.Append("Visual;");
sb.Append(GetVisualPath(refControl));
sb.Append(";");
}
sb.Append(refObject.TypeIdentifier);
sb.Append(";");
sb.Append(refObject.Name);
sb.Append("");
return(sb.ToString());
}
public void SerializeBindings(HeliosVisual visual, XmlWriter xmlWriter)
{
SerializeBindings(visual.OutputBindings, xmlWriter);
foreach (HeliosVisual control in visual.Children)
{
SerializeBindings(control, xmlWriter);
}
}
protected object CreateNewObject(string type, string typeId, ComponentUnsupportedSeverity ifUnsupported = ComponentUnsupportedSeverity.Error)
{
switch (type)
{
case "Monitor":
return(new Monitor());
case "Visual":
HeliosVisual visual = ConfigManager.ModuleManager.CreateControl(typeId);
if (visual == null)
{
Logger.Error("Ignoring control not supported by this version of Helios: " + typeId);
return(null);
}
return(visual);
case "Interface":
HeliosInterfaceDescriptor descriptor = ConfigManager.ModuleManager.InterfaceDescriptors[typeId];
if (descriptor == null)
{
switch (ifUnsupported)
{
case ComponentUnsupportedSeverity.Error:
Logger.Error("Ignoring interface not supported by this version of Helios: {TypeId}; bindings to this interface will fail", typeId);
return(null);
case ComponentUnsupportedSeverity.Warning:
Logger.Warn("Ignoring interface not supported by this version of Helios: {TypeId}; bindings to this interface will fail", typeId);
return(null);
case ComponentUnsupportedSeverity.Ignore:
Logger.Info("Ignoring interface not supported by this version of Helios: {TypeId}; bindings to this interface will be silently ignored", typeId);
// create a dummy interface that preserves the XML and ignores but allows writing of all bindings
UnsupportedInterface dummy = new UnsupportedInterface();
dummy.RepresentedTypeIdentifier = typeId;
// record interface type alias, but don't install it yet because we may read more instances of this interface
// alias will allow resolution of the unsupported class to our dummy for use in places where we try to instantiate the editor
HeliosInterfaceDescriptor dummyDescriptor = ConfigManager.ModuleManager.InterfaceDescriptors[UnsupportedInterface.TYPE_IDENTIFIER];
if (DiscoveredAliases != null)
{
DiscoveredAliases[typeId] = dummyDescriptor;
}
return(dummy);
default:
throw new ArgumentOutOfRangeException(nameof(ifUnsupported), ifUnsupported, null);
}
}
return(descriptor.CreateInstance());
case "Binding":
return(new HeliosBinding());
}
return(null);
}
public HeliosVisual CreateControl(string typeIdentifier)
{
HeliosVisual control = null;
HeliosDescriptor descriptor = _controlDescriptors[typeIdentifier];
if (descriptor != null)
{
control = (HeliosVisual)Activator.CreateInstance(descriptor.ControlType);
}
return(control);
}
public static string GetVisualPath(HeliosVisual visual)
{
List <string> names = new List <string>();
HeliosVisual pathItem = visual;
while (pathItem != null)
{
names.Add(pathItem.Name);
pathItem = pathItem.Parent;
}
names.Reverse();
return(string.Join(".", names));
}
private static HeliosVisual GetVisualByPath(HeliosProfile profile, string path)
{
HeliosVisual visual = null;
foreach (HeliosVisual monitor in profile.Monitors)
{
visual = GetVisualByPath(monitor, path);
if (visual != null)
{
break;
}
}
return(visual);
}
private static HeliosVisual GetVisualByPath(List <HeliosVisual> visuals, string path)
{
HeliosVisual returnVisual = null;
foreach (HeliosVisual child in visuals)
{
returnVisual = GetVisualByPath(child, path);
if (returnVisual != null)
{
break;
}
}
return(returnVisual);
}
public HeliosTemplate(HeliosVisual control)
{
_user = true;
_typeIdentifier = control.TypeIdentifier;
_name = control.Name;
StringWriter templateWriter = new StringWriter();
XmlWriter xmlWriter = new XmlTextWriter(templateWriter);
xmlWriter.WriteStartElement("TemplateValues");
control.WriteXml(xmlWriter);
xmlWriter.WriteEndElement();
xmlWriter.Close();
templateWriter.Close();
_templateControl = templateWriter.ToString();
}
private static HeliosObject ResolveReferenceName(HeliosProfile profile, HeliosVisual root, string copyRoot, List <HeliosVisual> localObjects, string reference)
{
string[] components;
if (reference.StartsWith("{"))
{
components = reference.Substring(1, reference.Length - 2).Split(';');
}
else
{
components = reference.Split(';');
}
string refType = components[0];
string path = components[1];
string typeId = components[2];
string name = components[3];
switch (refType)
{
case "Visual":
HeliosVisual visual = null;
if (!string.IsNullOrWhiteSpace(copyRoot) && !path.Equals(copyRoot, StringComparison.InvariantCultureIgnoreCase) && path.StartsWith(copyRoot, StringComparison.InvariantCultureIgnoreCase))
{
visual = GetVisualByPath(localObjects, path.Substring(copyRoot.Length + 1));
}
if (visual == null)
{
if (root == null)
{
visual = GetVisualByPath(profile, path);
}
else
{
visual = GetVisualByPath(root, path);
}
}
return(visual);
case "Interface":
if (profile.Interfaces.ContainsKey(name))
{
return(profile.Interfaces[name]);
}
break;
}
return(null);
}
public HeliosTemplate(HeliosVisual control)
{
_user = true;
_typeIdentifier = control.TypeIdentifier;
_name = control.Name;
StringWriter templateWriter = new StringWriter();
XmlWriter xmlWriter = new XmlTextWriter(templateWriter);
xmlWriter.WriteStartElement("TemplateValues");
control.WriteXml(xmlWriter);
xmlWriter.WriteEndElement();
xmlWriter.Close();
templateWriter.Close();
_templateControl = templateWriter.ToString();
}
public HeliosVisualRenderer CreaterRenderer(HeliosVisual visual)
{
HeliosVisualRenderer renderer = null;
Type visualType = visual.GetType();
HeliosDescriptor descriptor = _controlDescriptors[visualType];
if (descriptor != null)
{
renderer = (HeliosVisualRenderer)Activator.CreateInstance(descriptor.Renderer);
renderer.Visual = visual;
}
return(renderer);
}
public IEnumerable <string> DeserializeControl(HeliosVisualCollection controls, XmlReader xmlReader)
{
TypeConverter boolConverter = TypeDescriptor.GetConverter(typeof(bool));
HeliosVisual control = (HeliosVisual)CreateNewObject("Visual", xmlReader.GetAttribute("TypeIdentifier"));
if (control != null)
{
string name = xmlReader.GetAttribute("Name");
if (xmlReader.GetAttribute("SnapTarget") != null)
{
control.IsSnapTarget = (bool)boolConverter.ConvertFromInvariantString(xmlReader.GetAttribute("SnapTarget"));
}
if (xmlReader.GetAttribute("Locked") != null)
{
control.IsLocked = (bool)boolConverter.ConvertFromInvariantString(xmlReader.GetAttribute("Locked"));
}
if (xmlReader.IsEmptyElement)
{
xmlReader.Read();
}
else
{
xmlReader.ReadStartElement("Control");
control.ReadXml(xmlReader);
foreach (string progress in DeserializeControls(control.Children, xmlReader))
{
yield return(progress);
}
;
xmlReader.ReadEndElement();
}
control.Name = name;
controls.Add(control);
yield return($"loaded {control.TypeIdentifier}");
}
else
{
xmlReader.Skip();
yield return("failed to load a control");
}
}
public void DeserializeControls(HeliosVisualCollection controls, XmlReader xmlReader)
{
if (!xmlReader.IsEmptyElement)
{
xmlReader.ReadStartElement("Children");
while (xmlReader.NodeType != XmlNodeType.EndElement)
{
HeliosVisual control = DeserializeControl(xmlReader);
if (control != null)
{
controls.Add(control);
}
}
xmlReader.ReadEndElement();
}
else
{
xmlReader.Read();
}
}
public void SerializeControl(HeliosVisual control, XmlWriter xmlWriter)
{
TypeConverter boolConverter = TypeDescriptor.GetConverter(typeof(bool));
xmlWriter.WriteStartElement("Control");
xmlWriter.WriteAttributeString("TypeIdentifier", control.TypeIdentifier);
xmlWriter.WriteAttributeString("Name", control.Name);
xmlWriter.WriteAttributeString("SnapTarget", boolConverter.ConvertToInvariantString(control.IsSnapTarget));
xmlWriter.WriteAttributeString("Locked", boolConverter.ConvertToInvariantString(control.IsLocked));
control.WriteXml(xmlWriter);
if (control.PersistChildren)
{
SerializeControls(control.Children, xmlWriter);
}
else
{
xmlWriter.WriteStartElement("Children");
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
public HeliosVisual DeserializeControl(XmlReader xmlReader)
{
TypeConverter boolConverter = TypeDescriptor.GetConverter(typeof(bool));
HeliosVisual control = (HeliosVisual)CreateNewObject("Visual", xmlReader.GetAttribute("TypeIdentifier"));
if (control != null)
{
string name = xmlReader.GetAttribute("Name");
if (xmlReader.GetAttribute("SnapTarget") != null)
{
control.IsSnapTarget = (bool)boolConverter.ConvertFromInvariantString(xmlReader.GetAttribute("SnapTarget"));
}
if (xmlReader.GetAttribute("Locked") != null)
{
control.IsLocked = (bool)boolConverter.ConvertFromInvariantString(xmlReader.GetAttribute("Locked"));
}
if (xmlReader.IsEmptyElement)
{
xmlReader.Read();
}
else
{
xmlReader.ReadStartElement("Control");
control.ReadXml(xmlReader);
DeserializeControls(control.Children, xmlReader);
xmlReader.ReadEndElement();
}
control.Name = name;
}
else
{
xmlReader.Skip();
}
return(control);
}
private object DispCreateNewObject(string type, string typeId)
{
switch (type)
{
case "Monitor":
return(new Monitor());
case "Visual":
HeliosVisual visual = ConfigManager.ModuleManager.CreateControl(typeId);
if (visual == null)
{
ConfigManager.LogManager.LogError("Ignoring control not supported by this version of Helios: " + typeId);
return(null);
}
visual.Dispatcher = _dispatcher;
return(visual);
case "Interface":
HeliosInterfaceDescriptor descriptor = ConfigManager.ModuleManager.InterfaceDescriptors[typeId];
if (descriptor == null)
{
ConfigManager.LogManager.LogError("Ignoring interface not supported by this version of Helios: " + typeId);
return(null);
}
HeliosInterface heliosInterface = descriptor != null?descriptor.CreateInstance() : null;
if (heliosInterface != null)
{
heliosInterface.Dispatcher = _dispatcher;
}
return(heliosInterface);
case "Binding":
return(new HeliosBinding());
}
return(null);
}
public HeliosVisual CreateInstance()
{
HeliosVisual control = ConfigManager.ModuleManager.CreateControl(_typeIdentifier);
if (control != null)
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreComments = true;
settings.IgnoreWhitespace = true;
settings.CloseInput = true;
StringReader templateReader = new StringReader(_templateControl);
XmlReader xmlReader = XmlReader.Create(templateReader, settings);
xmlReader.ReadStartElement("TemplateValues");
control.ReadXml(xmlReader);
xmlReader.ReadEndElement();
xmlReader.Close();
templateReader.Close();
control.Name = Name;
}
return(control);
}
private HeliosBindingCollection DeserializeBindings(HeliosProfile profile, HeliosVisual root, string copyRoot, List <HeliosVisual> localObjects, XmlReader xmlReader)
{
HeliosBindingCollection bindings = new HeliosBindingCollection();
if (!xmlReader.IsEmptyElement)
{
xmlReader.ReadStartElement("Bindings");
while (xmlReader.NodeType != XmlNodeType.EndElement)
{
HeliosBinding binding = DeserializeBinding(profile, root, copyRoot, localObjects, xmlReader);
if (binding != null && binding.Action != null && binding.Trigger != null)
{
bindings.Add(binding);
}
}
xmlReader.ReadEndElement();
}
else
{
xmlReader.Read();
}
return(bindings);
}
public IEnumerable <HeliosBinding> DeserializeBindings(HeliosVisual root, string copyRoot, List <HeliosVisual> localObjects, XmlReader xmlReader)
{
return(DeserializeBindings(root.Profile, root, copyRoot, localObjects, xmlReader));
}
private IEnumerable <HeliosBinding> DeserializeBindings(HeliosProfile profile, HeliosVisual root, string copyRoot, List <HeliosVisual> localObjects, XmlReader xmlReader)
{
if (!xmlReader.IsEmptyElement)
{
xmlReader.ReadStartElement("Bindings");
while (xmlReader.NodeType != XmlNodeType.EndElement)
{
HeliosBinding binding = DeserializeBinding(profile, root, copyRoot, localObjects, xmlReader);
if (binding?.Action != null && binding.Trigger != null)
{
yield return(binding);
}
}
xmlReader.ReadEndElement();
}
else
{
xmlReader.Read();
}
}
public static string GetVisualPath(HeliosVisual visual)
{
List<string> names = new List<string>();
HeliosVisual pathItem = visual;
while (pathItem != null)
{
names.Add(pathItem.Name);
pathItem = pathItem.Parent;
}
names.Reverse();
return string.Join(".", names);
}
public SnapTarget(HeliosVisual visual)
{
_rectangle = visual.DisplayRectangle;
_tag = visual;
}
private static HeliosVisual GetVisualByPath(HeliosVisual visual, string path)
{
return(GetVisualByPath(visual, new Queue <string>(path.Split('.'))));
}
private static HeliosObject ResolveReferenceName(HeliosProfile profile, HeliosVisual root, string copyRoot, List<HeliosVisual> localObjects, string reference)
{
string[] components;
if (reference.StartsWith("{"))
{
components = reference.Substring(1, reference.Length - 2).Split(';');
}
else
{
components = reference.Split(';');
}
string refType = components[0];
string path = components[1];
string typeId = components[2];
string name = components[3];
switch (refType)
{
case "Visual":
HeliosVisual visual = null;
if (!string.IsNullOrWhiteSpace(copyRoot) && !path.Equals(copyRoot, StringComparison.InvariantCultureIgnoreCase) && path.StartsWith(copyRoot, StringComparison.InvariantCultureIgnoreCase))
{
visual = GetVisualByPath(localObjects, path.Substring(copyRoot.Length + 1));
}
if (visual == null)
{
if (root == null)
{
visual = GetVisualByPath(profile, path);
}
else
{
visual = GetVisualByPath(root, path);
}
}
return visual;
case "Interface":
if (profile.Interfaces.ContainsKey(name))
{
return profile.Interfaces[name];
}
break;
}
return null;
}
private static HeliosVisual GetVisualByPath(HeliosVisual visual, string path)
{
return GetVisualByPath(visual, new Queue<string>(path.Split('.')));
}
private static HeliosVisual GetVisualByPath(HeliosVisual visual, Queue<string> nameQueue)
{
HeliosVisual returnValue = null;
string name = nameQueue.Dequeue();
if (visual.Name.Equals(name))
{
if (nameQueue.Count == 0)
{
returnValue = visual;
}
else
{
string childName = nameQueue.Peek();
foreach (HeliosVisual child in visual.Children)
{
if (childName.Equals(child.Name))
{
returnValue = GetVisualByPath(child, nameQueue);
if (returnValue != null)
{
break;
}
}
}
}
}
return returnValue;
}
public HeliosVisualRenderer CreaterRenderer(HeliosVisual visual)
{
HeliosVisualRenderer renderer = null;
Type visualType = visual.GetType();
HeliosDescriptor descriptor = _controlDescriptors[visualType];
if (descriptor != null)
{
renderer = (HeliosVisualRenderer)Activator.CreateInstance(descriptor.Renderer);
renderer.Visual = visual;
}
return renderer;
}
public IEnumerable <HeliosCapabilityEditorDescriptor> GetCapabilityEditors(HeliosVisual visual)
{
// NOTE: we could check for each interface and keep a list of editors for that interface, but that
// complexity is not reasonable, considering it will typically be 1:1
return(_capabilityEditors.Where(editor => editor.InterfaceType.IsInstanceOfType(visual)));
}
public static HeliosObject ResolveReferenceName(HeliosVisual root, string copyRoot, string reference)
{
return(ResolveReferenceName(root.Profile, root, copyRoot, EMPTYLOCALS, reference));
}
void Child_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
HeliosVisual control = sender as HeliosVisual;
OnPropertyChanged("Controls." + control.Name, (PropertyNotificationEventArgs)e);
}
private HeliosBinding DeserializeBinding(HeliosProfile profile, HeliosVisual root, string copyRoot, List<HeliosVisual> localObjects, XmlReader xmlReader)
{
TypeConverter boolConverter = TypeDescriptor.GetConverter(typeof(bool));
HeliosBinding binding = (HeliosBinding)CreateNewObject("Binding", "");
binding.BypassCascadingTriggers = (bool)boolConverter.ConvertFromString(null, System.Globalization.CultureInfo.InvariantCulture, xmlReader.GetAttribute("BypassCascadingTriggers"));
xmlReader.ReadStartElement("Binding");
HeliosObject source = ResolveReferenceName(profile, root, copyRoot, localObjects, xmlReader.GetAttribute("Source"));
if (source != null)
{
string trigger = xmlReader.GetAttribute("Name");
if (source.Triggers.ContainsKey(trigger))
{
binding.Trigger = source.Triggers[trigger];
}
else if (source is HeliosVisual)
{
HeliosVisual parent = ((HeliosVisual)source).Parent;
if (parent.Triggers.ContainsKey(trigger))
{
source = parent;
binding.Trigger = source.Triggers[trigger];
}
}
}
xmlReader.Read();
HeliosObject target = ResolveReferenceName(profile, root, copyRoot, localObjects, xmlReader.GetAttribute("Target"));
if (target != null)
{
string action = xmlReader.GetAttribute("Name");
if (target.Actions.ContainsKey(action))
{
binding.Action = target.Actions[action];
}
else if (target is HeliosVisual)
{
HeliosVisual parent = ((HeliosVisual)target).Parent;
if (parent.Actions.ContainsKey(action))
{
target = parent;
binding.Action = target.Actions[action];
}
}
}
xmlReader.Read();
switch (xmlReader.Name)
{
case "StaticValue":
binding.ValueSource = BindingValueSources.StaticValue;
binding.Value = xmlReader.ReadElementString("StaticValue");
break;
case "TriggerValue":
binding.ValueSource = BindingValueSources.TriggerValue;
xmlReader.Read();
break;
case "LuaScript":
binding.ValueSource = BindingValueSources.LuaScript;
binding.Value = xmlReader.ReadElementString("LuaScript");
break;
}
if (xmlReader.Name.Equals("Condition"))
{
binding.Condition = xmlReader.ReadElementString("Condition");
}
xmlReader.ReadEndElement();
return binding;
}
public static HeliosObject ResolveReferenceName(HeliosVisual root, string copyRoot, string reference)
{
return ResolveReferenceName(root.Profile, root, copyRoot, EMPTYLOCALS, reference);
}
public void SerializeBindings(HeliosVisual visual, XmlWriter xmlWriter)
{
SerializeBindings(visual.OutputBindings, xmlWriter);
foreach (HeliosVisual control in visual.Children)
{
SerializeBindings(control, xmlWriter);
}
}
public HeliosBindingCollection DeserializeBindings(HeliosVisual root, string copyRoot, List<HeliosVisual> localObjects, XmlReader xmlReader)
{
return DeserializeBindings(root.Profile, root, copyRoot, localObjects, xmlReader);
}
public NonClickableZone(Rect nonClickableZone, bool allPosition, HeliosVisual childVisual)
{
_pastToChildZone = nonClickableZone;
AllPositions = allPosition;
ChildVisual = childVisual;
}
private HeliosBindingCollection DeserializeBindings(HeliosProfile profile, HeliosVisual root, string copyRoot, List<HeliosVisual> localObjects, XmlReader xmlReader)
{
HeliosBindingCollection bindings = new HeliosBindingCollection();
if (!xmlReader.IsEmptyElement)
{
xmlReader.ReadStartElement("Bindings");
while (xmlReader.NodeType != XmlNodeType.EndElement)
{
HeliosBinding binding = DeserializeBinding(profile, root, copyRoot, localObjects, xmlReader);
if (binding != null && binding.Action != null && binding.Trigger != null)
{
bindings.Add(binding);
}
}
xmlReader.ReadEndElement();
}
else
{
xmlReader.Read();
}
return bindings;
}
protected override void OnProfileChanged(HeliosProfile oldProfile)
{
base.OnProfileChanged(oldProfile);
if (!DesignMode)
{
return;
}
/// grab the default interface, if it exists
if (_defaultInterfaceName == "")
{
return;
}
if (!Profile.Interfaces.ContainsKey(_defaultInterfaceName))
{
ConfigManager.LogManager.LogError("Cannot find default interface " + _defaultInterfaceName);
return;
}
_defaultInterface = Profile.Interfaces[_defaultInterfaceName];
/// looping for all default input bindings to assign the value
foreach (DefaultInputBinding defaultBinding in _defaultInputBindings)
{
if (!Children.ContainsKey(defaultBinding.ChildName))
{
ConfigManager.LogManager.LogError("Cannot find child " + defaultBinding.ChildName);
continue;
}
ConfigManager.LogManager.LogDebug("Auto binding child " + defaultBinding.ChildName);
HeliosVisual child = Children[defaultBinding.ChildName];
if (!child.Actions.ContainsKey(defaultBinding.DeviceActionName))
{
ConfigManager.LogManager.LogError("Cannot find action " + defaultBinding.DeviceActionName);
continue;
}
if (!_defaultInterface.Triggers.ContainsKey(defaultBinding.InterfaceTriggerName))
{
ConfigManager.LogManager.LogError("Cannot find interface trigger " + defaultBinding.InterfaceTriggerName);
continue;
}
ConfigManager.LogManager.LogDebug("Auto binding trigger " + defaultBinding.InterfaceTriggerName + " to " + defaultBinding.DeviceActionName);
child.OutputBindings.Add(CreateNewBinding(_defaultInterface.Triggers[defaultBinding.InterfaceTriggerName],
child.Actions[defaultBinding.DeviceActionName]));
//child.OutputBindings.Add(
// new HeliosBinding(_defaultInterface.Triggers[defaultBinding.InterfaceTriggerName],
// child.Actions[defaultBinding.DeviceActionName]));
}
/// now looping for all default output bindings to assign the value
foreach (DefaultOutputBinding defaultBinding in _defaultOutputBindings)
{
if (!Children.ContainsKey(defaultBinding.ChildName))
{
ConfigManager.LogManager.LogError("Cannot find child " + defaultBinding.ChildName);
continue;
}
HeliosVisual child = Children[defaultBinding.ChildName];
if (!child.Triggers.ContainsKey(defaultBinding.DeviceTriggerName))
{
ConfigManager.LogManager.LogError("Cannot find trigger " + defaultBinding.DeviceTriggerName);
continue;
}
if (!_defaultInterface.Actions.ContainsKey(defaultBinding.InterfaceActionName))
{
ConfigManager.LogManager.LogError("Cannot find action " + defaultBinding.InterfaceActionName);
continue;
}
ConfigManager.LogManager.LogDebug("Child Output binding trigger " + defaultBinding.DeviceTriggerName + " to " + defaultBinding.InterfaceActionName);
child.OutputBindings.Add(CreateNewBinding(child.Triggers[defaultBinding.DeviceTriggerName],
_defaultInterface.Actions[defaultBinding.InterfaceActionName]));
// child.OutputBindings.Add(
//new HeliosBinding(child.Triggers[defaultBinding.DeviceTriggerName],
// _defaultInterface.Actions[defaultBinding.InterfaceActionName]));
}
}
private HeliosBinding DeserializeBinding(HeliosProfile profile, HeliosVisual root, string copyRoot, List <HeliosVisual> localObjects, XmlReader xmlReader)
{
TypeConverter boolConverter = TypeDescriptor.GetConverter(typeof(bool));
HeliosBinding binding = (HeliosBinding)CreateNewObject("Binding", "");
binding.BypassCascadingTriggers = (bool)boolConverter.ConvertFromString(null, CultureInfo.InvariantCulture, xmlReader.GetAttribute("BypassCascadingTriggers"));
xmlReader.ReadStartElement("Binding");
HeliosObject source = ResolveReferenceName(profile, root, copyRoot, localObjects, xmlReader.GetAttribute("Source"));
if (source != null)
{
string trigger = xmlReader.GetAttribute("Name");
if (source is IDynamicBindings dynamic)
{
binding.Trigger = dynamic.ResolveTrigger(trigger);
}
else if (source.Triggers.ContainsKey(trigger))
{
binding.Trigger = source.Triggers[trigger];
}
else if (source is HeliosVisual)
{
HeliosVisual parent = ((HeliosVisual)source).Parent;
if (parent.Triggers.ContainsKey(trigger))
{
source = parent;
binding.Trigger = source.Triggers[trigger];
}
}
}
else
{
Logger.Error("Binding Source Reference Unresolved: " + xmlReader.GetAttribute("Source"));
}
xmlReader.Read();
HeliosObject target = ResolveReferenceName(profile, root, copyRoot, localObjects, xmlReader.GetAttribute("Target"));
if (target != null)
{
string action = xmlReader.GetAttribute("Name");
if (target is IDynamicBindings dynamic)
{
binding.Action = dynamic.ResolveAction(action);
}
else if (target.Actions.ContainsKey(action))
{
binding.Action = target.Actions[action];
}
else if (target is HeliosVisual)
{
HeliosVisual parent = ((HeliosVisual)target).Parent;
if (parent.Actions.ContainsKey(action))
{
target = parent;
binding.Action = target.Actions[action];
}
}
}
else
{
Logger.Error("Binding Target Reference Unresolved: " + xmlReader.GetAttribute("Target"));
}
xmlReader.Read();
switch (xmlReader.Name)
{
case "StaticValue":
binding.ValueSource = BindingValueSources.StaticValue;
binding.Value = xmlReader.ReadElementString("StaticValue");
break;
case "TriggerValue":
binding.ValueSource = BindingValueSources.TriggerValue;
xmlReader.Read();
break;
case "LuaScript":
binding.ValueSource = BindingValueSources.LuaScript;
binding.Value = xmlReader.ReadElementString("LuaScript");
break;
}
if (xmlReader.Name.Equals("Condition"))
{
binding.Condition = xmlReader.ReadElementString("Condition");
}
xmlReader.ReadEndElement();
return(binding);
}
protected override void OnProfileChanged(HeliosProfile oldProfile)
{
base.OnProfileChanged(oldProfile);
if (!DesignMode)
{
return;
}
// grab the default interface, if it exists
foreach (Type supportedInterface in SupportedInterfaces)
{
_defaultInterface = Profile.Interfaces.FirstOrDefault(i => supportedInterface.IsInstanceOfType(i));
if (_defaultInterface != null)
{
Logger.Info($"{Name} auto binding to interface '{_defaultInterface.Name}'");
break;
}
}
if (_defaultInterface == null)
{
Logger.Info($"{Name} could not locate any supported interface for auto binding");
return;
}
// looping for all default input bindings to assign the value
foreach (DefaultInputBinding defaultBinding in _defaultInputBindings)
{
if (!Children.ContainsKey(defaultBinding.ChildName))
{
Logger.Error("Cannot find child " + defaultBinding.ChildName);
continue;
}
Logger.Debug("Auto binding child " + defaultBinding.ChildName);
HeliosVisual child = Children[defaultBinding.ChildName];
if (!child.Actions.ContainsKey(defaultBinding.DeviceActionName))
{
Logger.Error("Cannot find action " + defaultBinding.DeviceActionName);
continue;
}
if (defaultBinding.InterfaceTriggerName != "")
{
if (!_defaultInterface.Triggers.ContainsKey(defaultBinding.InterfaceTriggerName))
{
Logger.Error("Cannot find interface trigger " + defaultBinding.InterfaceTriggerName);
continue;
}
Logger.Debug("Auto binding trigger " + defaultBinding.InterfaceTriggerName + " to " + defaultBinding.ChildName + defaultBinding.DeviceActionName);
child.OutputBindings.Add(CreateNewBinding(_defaultInterface.Triggers[defaultBinding.InterfaceTriggerName],
child.Actions[defaultBinding.DeviceActionName]));
}
else
{
if (!Triggers.ContainsKey(defaultBinding.DeviceTriggerName))
{
Logger.Error("Cannot find interface trigger " + defaultBinding.DeviceTriggerName);
continue;
}
Logger.Debug("Auto binding trigger " + defaultBinding.DeviceTriggerName + " to " + defaultBinding.ChildName + defaultBinding.DeviceActionName);
child.OutputBindings.Add(CreateNewBinding(Triggers[defaultBinding.DeviceTriggerName],
child.Actions[defaultBinding.DeviceActionName], defaultBinding.DeviceTriggerBindingValue));
}
//child.OutputBindings.Add(
// new HeliosBinding(_defaultInterface.Triggers[defaultBinding.InterfaceTriggerName],
// child.Actions[defaultBinding.DeviceActionName]));
}
// now looping for all default output bindings to assign the value
foreach (DefaultOutputBinding defaultBinding in _defaultOutputBindings)
{
if (!Children.ContainsKey(defaultBinding.ChildName))
{
Logger.Error("Cannot find child " + defaultBinding.ChildName);
continue;
}
HeliosVisual child = Children[defaultBinding.ChildName];
if (!child.Triggers.ContainsKey(defaultBinding.DeviceTriggerName))
{
Logger.Error("Cannot find trigger " + defaultBinding.DeviceTriggerName);
continue;
}
if (!_defaultInterface.Actions.ContainsKey(defaultBinding.InterfaceActionName))
{
Logger.Error("Cannot find action " + defaultBinding.InterfaceActionName);
continue;
}
Logger.Debug("Child Output binding trigger " + defaultBinding.DeviceTriggerName + " to " + defaultBinding.InterfaceActionName);
child.OutputBindings.Add(CreateNewBinding(child.Triggers[defaultBinding.DeviceTriggerName],
_defaultInterface.Actions[defaultBinding.InterfaceActionName]));
// child.OutputBindings.Add(
//new HeliosBinding(child.Triggers[defaultBinding.DeviceTriggerName],
// _defaultInterface.Actions[defaultBinding.InterfaceActionName]));
}
}
public void SerializeControl(HeliosVisual control, XmlWriter xmlWriter)
{
TypeConverter boolConverter = TypeDescriptor.GetConverter(typeof(bool));
xmlWriter.WriteStartElement("Control");
xmlWriter.WriteAttributeString("TypeIdentifier", control.TypeIdentifier);
xmlWriter.WriteAttributeString("Name", control.Name);
xmlWriter.WriteAttributeString("SnapTarget", boolConverter.ConvertToInvariantString(control.IsSnapTarget));
xmlWriter.WriteAttributeString("Locked", boolConverter.ConvertToInvariantString(control.IsLocked));
control.WriteXml(xmlWriter);
if (control.PersistChildren)
{
SerializeControls(control.Children, xmlWriter);
}
else
{
xmlWriter.WriteStartElement("Children");
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
