public SignalChooser(INodeWrapper nodeItem, NodeSignalIn initialSignalIn, double maxWidth, TextAlignment textAlignment)
{
NodeItem = nodeItem;
SignalIn = initialSignalIn;
MaxWidth = maxWidth;
TextAlignment = textAlignment;
}
public static NodeAnalogOutput BuildWith(FieldIdentifier Code, FieldString Address, FieldSignalName OutputName)
{
//build fields
Dictionary <FieldIdentifier, FieldBase> mutableFields =
new Dictionary <FieldIdentifier, FieldBase>();
mutableFields.Add(new FieldIdentifier(m_CodeName), Code);
mutableFields.Add(new FieldIdentifier(m_AddressName), Address);
mutableFields.Add(new FieldIdentifier(m_ForcedName), new FieldBool(false));
mutableFields.Add(new FieldIdentifier(m_ForcedValueName), new FieldConstant(FieldDataType.DataTypeEnum.NUMBER, FieldDataType.DefaultValue(FieldDataType.DataTypeEnum.NUMBER)));
mutableFields.Add(new FieldIdentifier(m_OutputNameName), OutputName);
//Add Fields here: mutableFields.Add(new FieldIdentifier(m_CodeName), Code);
//build children
KeyedNodeCollection <NodeBase> mutableChildren =
new KeyedNodeCollection <NodeBase>();
mutableChildren.Add(NodeSignalIn.BuildWith(
new FieldDataType(FieldDataType.DataTypeEnum.NUMBER),
new FieldConstant(FieldDataType.DataTypeEnum.NUMBER, FieldDataType.DefaultValue(FieldDataType.DataTypeEnum.NUMBER))));
//Add Children here: mutableChildren.Add(SomeChild);
//build node
NodeAnalogOutput Builder = new NodeAnalogOutput(
new ReadOnlyDictionary <FieldIdentifier, FieldBase>(mutableFields),
new ReadOnlyCollection <NodeBase>(mutableChildren));
return(Builder);
}
public SignalInItem(ISolutionItem parent, NodeSignalIn signalIn)
: base(parent, string.Empty)
{
ContextMenu = extensionService.Sort(contextMenu);
SignalIn = signalIn;
runtimeService.SignalChanged += new SignalChangedHandler(runtimeService_SignalChanged);
}
public NodeAnalogOutput SetSignalIn(NodeSignalIn NewSignalIn)
{
if (NewSignalIn == null)
{
throw new ArgumentNullException(m_SignalInName);
}
return(m_SignalIn.Set(NewSignalIn));
}
public NodeInstruction SetSignalInToSignalId(int index, FieldGuid signalId)
{
var oldSignalIn = this.NodeSignalInChildren[index];
var newSignalIn = NodeSignalIn.BuildWith(oldSignalIn.DataType, signalId);
var newInstruction = this.NodeSignalInChildren.Replace(oldSignalIn, newSignalIn);
return(newInstruction);
}
public SignalDescriptionDisplay(IInstructionItem instructionNode, NodeSignalIn signalIn, double maxWidth, double maxHeight, TextAlignment textAlignment)
: base(string.Empty, maxWidth, maxHeight, textAlignment, false)
{
if (instructionNode == null)
{
throw new ArgumentNullException("instructionNode");
}
m_instructionNode = instructionNode;
SignalIn = signalIn;
if (runtimeService != null)
{
runtimeService.SignalChanged += new SignalChangedHandler(runtimeService_SignalChanged);
}
}
public static NodeSignalIn BuildWith(FieldDataType DataType, FieldDataType CompatibleTypes, FieldConstant Literal)
{
//build fields
Dictionary <FieldIdentifier, FieldBase> mutableFields =
new Dictionary <FieldIdentifier, FieldBase>();
mutableFields.Add(new FieldIdentifier(m_DataTypeName), DataType);
mutableFields.Add(new FieldIdentifier(m_CompatibleTypesName), CompatibleTypes);
mutableFields.Add(new FieldIdentifier(m_LiteralName), Literal);
//Add Fields here: mutableFields.Add(new FieldIdentifier(m_CodeName), Code);
//build children
KeyedNodeCollection <NodeBase> mutableChildren =
new KeyedNodeCollection <NodeBase>();
//Add Children here: mutableChildren.Add(SomeChild);
//build node
NodeSignalIn Builder = new NodeSignalIn(
new ReadOnlyDictionary <FieldIdentifier, FieldBase>(mutableFields),
new ReadOnlyCollection <NodeBase>(mutableChildren));
return(Builder);
}
/// <summary>
/// Displays the Dialog as modal
/// </summary>
/// <returns>Signal ID</returns>
public NodeSignalIn ShowDialog(INodeWrapper requester, NodeSignalIn originalSignalIn)
{
m_dataTypefilter = originalSignalIn.CompatibleTypes.DataType;
OriginalSignalIn = originalSignalIn;
setDefaultValues();
NodeItem = requester;
Window dlg = new SignalChooserDialogView();
dlg.Owner = mainWindowExport.Value;
dlg.DataContext = this;
dlg.ShowDialog();
if (SignalSelected)
{
return NodeSignalIn.BuildWith(OriginalSignalIn.DataType, OriginalSignalIn.CompatibleTypes, SignalId);
}
else
{
return NodeSignalIn.BuildWith(OriginalSignalIn.DataType, OriginalSignalIn.CompatibleTypes, Literal);
}
}
public static void SetControlFillColorBySignalIn(DependencyObject target, NodeSignalIn value)
{
target.SetValue(SignalValueBehavior.ControlFillColorBySignalInProperty, value);
}
public Int16 GetBooleanSignalAddress(NodeSignalIn signalIn)
{
if (signalIn == null) throw new ArgumentNullException("signalIn");
Int16 result;
if (!this.TryGetBooleanAddressBySignal(signalIn, out result))
{
throw new Exception("Signal not found.");
}
return result;
}
public NodeSignalIn SignalDialog(INodeWrapper requester, NodeSignalIn defaultSignalIn)
{
if (DisconnectDialog(requester))
{
return signalChooserDialog.ShowDialog(requester, defaultSignalIn);
}
else
{
return defaultSignalIn;
}
}
public bool TryGetNumericAddressBySignal(NodeSignalIn signalIn, out Byte? numericAddress)
{
var signalId = Guid.Parse(signalIn.SignalId.ToString());
if (this.m_numericAddressBySignal.ContainsKey(signalId))
{
numericAddress = this.m_numericAddressBySignal[signalId];
return true;
}
numericAddress = null;
return false;
}
public bool TryGetBooleanAddressBySignal(NodeSignalIn signalIn, out Int16 booleanAddress)
{
if (signalIn == null) throw new ArgumentNullException("signalIn");
if (signalIn.SignalId == null) throw new ArgumentNullException("signalIn.SignalId");
var signalId = Guid.Parse(signalIn.SignalId.ToString());
if (this.m_booleanAddressBySignal.ContainsKey(signalId))
{
booleanAddress = this.m_booleanAddressBySignal[signalId];
return true;
}
booleanAddress = -1;
return false;
}
public byte GetNumericSignalAddress(NodeSignalIn signalIn)
{
if (signalIn == null) throw new ArgumentNullException("signalIn");
Byte? result;
if (!this.TryGetNumericAddressBySignal(signalIn, out result))
{
throw new Exception("Signal not found.");
}
return result.Value;
}
public static NodeSignalIn BuildWith(FieldDataType DataType, FieldDataType CompatibleTypes, FieldConstant Literal)
{
//build fields
Dictionary<FieldIdentifier, FieldBase> mutableFields =
new Dictionary<FieldIdentifier, FieldBase>();
mutableFields.Add(new FieldIdentifier(m_DataTypeName), DataType);
mutableFields.Add(new FieldIdentifier(m_CompatibleTypesName), CompatibleTypes);
mutableFields.Add(new FieldIdentifier(m_LiteralName), Literal);
//Add Fields here: mutableFields.Add(new FieldIdentifier(m_CodeName), Code);
//build children
KeyedNodeCollection<NodeBase> mutableChildren =
new KeyedNodeCollection<NodeBase>();
//Add Children here: mutableChildren.Add(SomeChild);
//build node
NodeSignalIn Builder = new NodeSignalIn(
new ReadOnlyDictionary<FieldIdentifier, FieldBase>(mutableFields),
new ReadOnlyCollection<NodeBase>(mutableChildren));
return Builder;
}
private void readTextBox()
{
var tb = textBox;
var selectedText = tb.SelectedText;
string unselectedText;
if (selectedText.Length > 0)
{
unselectedText = tb.Text.Replace(selectedText, string.Empty);
}
else
{
unselectedText = tb.Text;
}
if (unselectedText.Length > 0)
{
// check to see if the value entered is a valid literal
object parseResult;
if (SignalIn.CompatibleTypes.TryParse(unselectedText, out parseResult))
{
tb.Text = parseResult.ToString();
m_editedSignalIn = NodeSignalIn.BuildWith(
SignalIn.DataType, SignalIn.CompatibleTypes,
new FieldConstant(SignalIn.CompatibleTypes.DataType, parseResult));
}
else
{
Tuple<string, NodeSignal> closestSignal = findClosestMatchingSignal(unselectedText);
if (closestSignal != null)
{
var signalName = closestSignal.Item1;
var nSignal = closestSignal.Item2;
tb.Text = signalName;
tb.SelectionStart = tb.Text.ToLower().IndexOf(unselectedText.ToLower()) + unselectedText.Length;
tb.SelectionLength = tb.Text.Length - unselectedText.Length;
m_editedSignalIn = NodeSignalIn.BuildWith(
SignalIn.DataType, SignalIn.CompatibleTypes,
closestSignal.Item2.SignalId);
}
else
{
m_editedSignalIn = SignalIn;
}
}
}
else
{
m_editedSignalIn = SignalIn;
}
}
public NodeAnalogOutput SetSignalIn(NodeSignalIn NewSignalIn)
{
if (NewSignalIn == null)
{
throw new ArgumentNullException(m_SignalInName);
}
return m_SignalIn.Set(NewSignalIn);
}
