public SignalControl()
{
_signal = new Signal();
InitializeComponent();
signalInputList.SignalINs = new List<SignalIN>();
SetOtherAttributesColumnWidths();
SetInterfaceAttributesColumnWidths();
Clear();
XmlDocument tree = SignalManager.Instance.TSFSignalTree;
awbDropListTree.TreeModel = tree;
}
private static void ProcessExtensionAsSignal(Capability capability, Extension ext)
{
if (ext != null)
{
List<XmlElement> any = ext.Any;
if (any.Count > 0)
{
String attIn = null;
String attOut = null;
String name = null;
if (SIGNAL.Equals(any[0].LocalName))
{
if (any[0].HasAttribute(IN))
attIn = any[0].GetAttribute(IN);
if (any[0].HasAttribute(OUT))
attIn = any[0].GetAttribute(OUT);
if (any[0].HasAttribute(NAME))
attIn = any[0].GetAttribute(NAME);
//Console.WriteLine(any[0].OuterXml.Trim());
var signal = new Signal();
try
{
signal = MarshallSignal(any, signal);
}
catch (Exception ee)
{
LogManager.Error(ee,
"An error has occured atttempting to extract the signal from Capability \"",
capability.name,
"\"\r\n\r\n",
ee.Message);
}
}
}
}
}
private static Signal MarshallSignal(List<XmlElement> any, Signal signal)
{
signal = Signal.Deserialize(any[0].OuterXml.Trim());
foreach (object item in signal.Items)
{
String sigName = item.GetType().Name;
if (XMLELEMENT.Equals(sigName))
{
//MessageBox.Show(String.Format("A class was not found for signal \"{0}\" for the namespace \"{1}\"",
// ((XmlElement)item).Name, ((XmlElement)item).NamespaceURI));
//Console.Write(((XmlElement) item).LocalName);
//Console.Write(TAB);
//Console.Write(EMPTYCHAR);
//Console.Write(TAB);
//Console.WriteLine(((XmlElement) item).Value);
}
else
{
foreach (PropertyInfo prop in item.GetType().GetProperties())
{
//Console.Write(prop.Name);
//Console.Write(TAB);
//Console.Write(prop.PropertyType);
//Console.Write(TAB);
//Console.WriteLine(prop.GetValue(item, null));
}
}
}
return signal;
}
private void DataToControls()
{
//------------------------------------------------------------//
//--- Create a new Capability if we don't already have one ---//
//------------------------------------------------------------//
if (_capability == null)
_capability = new Capability();
//----------------------------------------//
//--- Now lets start grabbing the data ---//
//----------------------------------------//
edtName.Value = _capability.name;
edtDescription.Value = _capability.Description;
interfaceListControl.Interface = _capability.Interface;
Extension ext = _capability.SignalDescription;
//------------------------------------------------------------//
//--- Process the SignalDescription as a Extension element ---//
//------------------------------------------------------------//
if (ext != null)
{
List<XmlElement> any = ext.Any;
if (any.Count > 0)
{
//-------------------------------------------------//
//--- Make sure we're dealing with a Signal tag ---//
//-------------------------------------------------//
if ("Signal".Equals(any[0].LocalName))
{
_signal = new Signal();
_signal = Signal.Deserialize(any[0].OuterXml.Trim());
signalControl.Signal = _signal;
//-------------------------------------//
//--- Time to walk the Signal Items ---//
//-------------------------------------//
foreach (object item in _signal.Items)
{
String sigName = item.GetType().Name;
foreach (PropertyInfo prop in item.GetType().GetProperties())
{
try
{
//Console.Write(prop.Name);
//Console.Write("\t");
//Console.Write(prop.PropertyType);
//Console.Write("\t");
//Console.WriteLine(prop.GetValue(item, null));
}
catch (Exception eee)
{
}
}
}
}
}
}
}
private void ControlsToData()
{
if (_capability == null)
_capability = new Capability();
_capability.name = edtName.GetValue<string>();
_capability.Description = edtDescription.GetValue<string>();
_capability.Interface = interfaceListControl.Interface;
_signal = signalControl.Signal;
SignalFunctionType sft = signalControl.SignalFunctionType;
try
{
XmlElement elm = XmlUtils.Object2XmlElement(_signal);
if (elm != null)
{
if (_capability.SignalDescription == null)
_capability.SignalDescription = new Extension();
if (_capability.SignalDescription.Any == null)
_capability.SignalDescription.Any = new List<XmlElement>();
_capability.SignalDescription.Any.Clear();
_capability.SignalDescription.Any.Add(elm);
}
}
catch (Exception e)
{
LogManager.Error(e);
}
}
public SignalModel( TSFType tsf,
string nameSpace,
string defaultNameSpace,
string interfaceSchema,
string modelXml,
XmlDocument xml)
{
_tsf = tsf;
_interfaceSchema = interfaceSchema;
_name = tsf.name;
Process( xml );
_signalNameSpace = nameSpace;
if (string.IsNullOrEmpty( _baseSignalNameSpace ))
_baseSignalNameSpace = defaultNameSpace;
_signal = Signal.Deserialize( modelXml );
//SaveSignalModel();
}
private void ControlsToData()
{
_signal = signalControl.Signal;
}
public SignalForm()
{
InitializeComponent();
Signal = new Signal();
}
public static bool LoadFromFile(string fileName, out Signal obj)
{
System.Exception exception;
return LoadFromFile(fileName, out obj, out exception);
}
/// <summary>
/// Deserializes xml markup from file into an Signal object
/// </summary>
/// <param name="fileName">string xml file to load and deserialize</param>
/// <param name="obj">Output Signal object</param>
/// <param name="exception">output Exception value if deserialize failed</param>
/// <returns>true if this Serializer can deserialize the object; otherwise, false</returns>
public static bool LoadFromFile(string fileName, out Signal obj, out System.Exception exception)
{
exception = null;
obj = default(Signal);
try
{
obj = LoadFromFile(fileName);
return true;
}
catch (System.Exception ex)
{
exception = ex;
return false;
}
}
public static bool Deserialize(string input, out Signal obj)
{
System.Exception exception;
return Deserialize(input, out obj, out exception);
}
/// <summary>
/// Deserializes workflow markup into an Signal object
/// </summary>
/// <param name="input">string workflow markup to deserialize</param>
/// <param name="obj">Output Signal object</param>
/// <param name="exception">output Exception value if deserialize failed</param>
/// <returns>true if this Serializer can deserialize the object; otherwise, false</returns>
public static bool Deserialize(string input, out Signal obj, out System.Exception exception)
{
exception = null;
obj = default(Signal);
try
{
obj = Deserialize(input);
return true;
}
catch (System.Exception ex)
{
exception = ex;
return false;
}
}
private bool LoadSignalModel(SignalModel sm, XmlDocument tsfDocument )
{
bool loaded = false;
if (sm != null)
{
string tsfNameSpace = sm.SignalNameSpace;
string tsfName = sm.TSF.name;
string tsfUuid = sm.TSF.uuid;
_currentSignalModel = sm;
Signal modelSignal = new Signal();
modelSignal.name = tsfName;
XmlElement el = tsfDocument.CreateElement("tsf", tsfName, tsfNameSpace);
foreach (SignalAttribute attr in sm.Attributes)
el.Attributes.Append( tsfDocument.CreateAttribute( attr.Name ) );
modelSignal.Items = new[] { el };
Signal = modelSignal;
var items = new List<object>();
items.AddRange(modelSignal.Items);
signalPartsListControl.SignalItems = items;
/*
var modelSignal = sm.TSF.model.Item as Signal;
var modelStandard = sm.TSF.model.Item as TSFTypeModelStandard;
if (modelSignal != null)
{
modelSignal.type = tsfName;
var la = new List<XmlAttribute>( modelSignal.AnyAttr );
if (tsfDocument != null)
{
XmlAttribute xAttribute1 = tsfDocument.CreateAttribute("tsf-xmlns");
XmlAttribute xAttribute2 = tsfDocument.CreateAttribute("tsf-uuid");
XmlAttribute xAttribute3 = tsfDocument.CreateAttribute("tsf-name");
xAttribute1.Value = tsfNameSpace;
xAttribute2.Value = tsfUuid;
xAttribute3.Value = tsfName;
la.Add(xAttribute1);
la.Add(xAttribute2);
la.Add(xAttribute3);
}
modelSignal.AnyAttr = la.ToArray();
Signal = modelSignal;
var items = new List<object>();
items.AddRange(modelSignal.Items);
signalPartsListControl.SignalItems = items;
signalInterfaceListControl.Load( sm );
//dg.Rows.Clear();
//string uuid = sm.TSF.uuid;
//foreach (SignalAttribute attribute in sm.Attributes)
// dgInterfaceAttributes.Rows.Add(new object[] { attribute.Name, "" });
}
else if (modelStandard != null) //TODO: Figure out TSFTypeModelStandard
{
}
* */
loaded = true;
}
return loaded;
}