private static void ProcessCapability( string uuid, Capability capability )
{
List<Signal> signals = SignalManager.ExtractSignalsFromExtension(capability.SignalDescription);
if (signals != null)
{
foreach (Signal signal in signals)
{
//SignalItemsChoiceType signalType = signal.
//signal.Items;
}
}
}
private void lvCapabilities_DragDrop(object sender, DragEventArgs de)
{
if (de.Data.GetDataPresent(DataFormats.Text))
{
TSFType tsf = TSFType.Deserialize((string) de.Data.GetData(DataFormats.Text));
var capability = new Capability();
capability.name = tsf.name;
object item = tsf.model.Item;
if (item is Signal)
{
var signal = (Signal) item;
XmlElement elm = XmlUtils.Object2XmlElement(item);
capability.SignalDescription = new Extension();
if (capability.SignalDescription.Any == null)
capability.SignalDescription.Any = new List<XmlElement>();
capability.SignalDescription.Any.Add(elm);
capability.Interface = new Interface();
if (signal.In != null)
{
String[] ins = signal.In.Split(' ');
foreach (String i in ins)
{
var p = new Port();
p.name = i;
p.direction = PortDirection.Input;
p.directionSpecified = true;
capability.Interface.Ports.Add(p);
}
}
if (signal.Out != null)
{
String[] outs = signal.Out.Split(' ');
foreach (String o in outs)
{
var p = new Port();
p.name = o;
p.direction = PortDirection.Output;
p.directionSpecified = true;
if (capability.Interface.Ports == null)
capability.Interface.Ports = new List<Port>();
capability.Interface.Ports.Add(p);
}
}
var form = new CapabilityForm(_instrumentDescription);
form.Capability = capability;
if (DialogResult.OK == form.ShowDialog())
{
String reference = EMPTYCHAR;
String uuid = EMPTYCHAR;
capability = form.Capability;
_capabilityItems.Add(capability);
var lvi = new ListViewItem(reference);
lvi.SubItems.Add(capability.name);
lvi.SubItems.Add(uuid);
lvi.Tag = capability;
Items.Add(lvi);
}
}
}
}
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 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);
}
}
private void ControlsToData()
{
_capability = capabilityControl.Capability;
}
public static bool LoadFromFile(string fileName, out Capability obj)
{
Exception exception;
return LoadFromFile(fileName, out obj, out exception);
}
/// <summary>
/// Deserializes xml markup from file into an Capability object
/// </summary>
/// <param name="fileName">string xml file to load and deserialize</param>
/// <param name="obj">Output Capability 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 Capability obj, out Exception exception)
{
exception = null;
obj = default(Capability);
try
{
obj = LoadFromFile(fileName);
return true;
}
catch (Exception ex)
{
exception = ex;
return false;
}
}
public static bool Deserialize(string input, out Capability obj)
{
Exception exception;
return Deserialize(input, out obj, out exception);
}
/// <summary>
/// Deserializes workflow markup into an Capability object
/// </summary>
/// <param name="input">string workflow markup to deserialize</param>
/// <param name="obj">Output Capability 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 Capability obj, out Exception exception)
{
exception = null;
obj = default(Capability);
try
{
obj = Deserialize(input);
return true;
}
catch (Exception ex)
{
exception = ex;
return false;
}
}
