public override void LoadFromXML(XmlElement xmlElement, LTSCanvas canvas)
{
if (canvas is PNCanvas)
{
PNCanvas myCanvas = canvas as PNCanvas;
string startingState = xmlElement.GetAttribute("From");
this.From = myCanvas.FindState(startingState);
string endState = xmlElement.GetAttribute("To");
this.To = myCanvas.FindState(endState);
if (From is PNTransition)
{
(From as PNTransition).OutputPlaces.Add(To as PNPlace);
}
else
{
(To as PNTransition).InputPlaces.Add(From as PNPlace);
}
this.Weight = int.Parse(xmlElement.GetAttribute("Weight"));
for (int i = 0; i < xmlElement.ChildNodes.Count - 1; i++)
{
NailItem nail = new NailItem(this);
nail.LoadFromXml(xmlElement.ChildNodes[i] as XmlElement);
this.Nails.Add(nail);
}
this.Label.LoadFromXml(xmlElement.ChildNodes[xmlElement.ChildNodes.Count - 1] as XmlElement);
}
}
public SNModel()
{
Network = new LTSCanvas();
this.Sensors = new Dictionary <string, NodeData>();
LinkList = new List <string>();
Assertion = "";
}
public SNModel(LTSCanvas declare, string assertion, Dictionary <string, NodeData> sensors, string system)
{
this.Network = declare;
this.Assertion = assertion;
this.Sensors = sensors;
this.SystemName = system;
}
public override void LoadFromXML(XmlElement xmlElement, LTSCanvas canvas)
{
base.LoadFromXML(xmlElement, canvas);
_channelType = ChannelType.Unicast;
try
{
_channelType = (ChannelType)int.Parse(xmlElement.GetAttribute(TAG_PRO_CHANNEL_TYPE));
}
catch { }
_channelMode = ChannelMode.Normal;
try
{
_channelMode = (ChannelMode)int.Parse(xmlElement.GetAttribute(TAG_PRO_CHANNEL_MODE));
}
catch { }
_id = xmlElement.GetAttribute(TAG_PRO_CHANNEL_ID);
if (_id != null && _id.Length == 0)
{
_id = null;
}
//Hashtable _pros = TransitionCondition;
//WSNUtil.LoadPNTranProperties(xmlElement, ref _pros);
}
public ILAProcessEditingForm(LTSCanvas canves)
{
InitializeComponent();
Canves = canves;
TextBox_Name.Text = Canves.Node.Text;
this.TextBox_Paramater.Text = Canves.Parameters;
}
public virtual void HandleMouseHoverOut(LTSCanvas canvas)
{
if (this.CurrentState == ItemState.Hover)
{
this.CurrentState = ItemState.Free;
}
}
public void HandleMouseHoverIn(LTSCanvas canvas)
{
if (this.CurrentState != ItemState.Selected)
{
this.CurrentState = ItemState.Hover;
}
}
public override void LoadFromXML(XmlElement xmlElement, LTSCanvas canvas)
{
base.LoadFromXML(xmlElement, canvas);
try
{
Kind = (ChannelKind)Enum.Parse(typeof(ChannelKind), xmlElement.GetAttribute(XmlTag.ATTR_CHANNEL_KIND), true);
Type = (ChannelType)int.Parse(xmlElement.GetAttribute(XmlTag.ATTR_LINK_TYPE));
SendingRate = int.Parse(xmlElement.GetAttribute(XmlTag.ATTR_MAX_SENDING_RATE));
string cgnLevel = xmlElement.GetAttribute(XmlTag.ATTR_CONGESTION_LEVEL);
CongestionLevel = (CGNLevel)Enum.Parse(typeof(CGNLevel), cgnLevel);
// Add probability of choosing path leading to congestion
ProbabilityPathCongestion = double.Parse(xmlElement.GetAttribute(XmlTag.ATTR_PROB_PATH_CONGESTION));
ID = xmlElement.GetAttribute(XmlTag.ATTR_ID);
if (ID != null && ID.Length == 0)
{
ID = null;
}
}
catch (Exception ex)
{
DevLog.d(TAG, ex.ToString());
}
}
public static LTSModel LoadLTSFromXML(string text)
{
LTSModel lts = new LTSModel();
XmlDataDocument doc = new XmlDataDocument();
doc.LoadXml(text);
XmlNodeList sitesNodes = doc.GetElementsByTagName(Parsing.DECLARATION_NODE_NAME);
foreach (XmlElement component in sitesNodes)
{
lts.Declaration = component.InnerText;
}
sitesNodes = doc.GetElementsByTagName(Parsing.PROCESSES_NODE_NAME);
if (sitesNodes.Count > 0)
{
foreach (XmlElement component in sitesNodes[0].ChildNodes)
{
LTSCanvas canvas = new LTSCanvas();
canvas.LoadFromXml(component);
lts.Processes.Add(canvas);
}
}
return(lts);
}
public override void HandleMouseHoverOut(LTSCanvas canvas)
{
try
{
PNArc route = this.FindSelectedRouteBasedOnTransition(canvas);
route.HandleMouseHoverOut(canvas);
}
catch { }
}
public WSNConfigForm(IConfigurationForm configListener, LTSCanvas canvas, WSNExtendInfo extendInfo)
{
this.mCanvas = canvas;
this.configListener = configListener;
InitializeComponent();
// init value
InitDefaultValue(extendInfo);
LoadSensorListInfo();
LoadChannelListInfo();
}
public StateMachineForm(string sensorName, LTSCanvas canvas)
{
SensorName = sensorName;
Canvas = canvas;
//Canvas.Visible = true;
//Canvas.Size = this.Size;
//Canvas.AutoArrange();
//this.Visible = true;
this.Controls.Add(Canvas);
InitializeComponent();
this.Text = "State Machine of " + SensorName;
}
public virtual void LoadFromXML(XmlElement xmlElement, LTSCanvas canvas)
{
//string startingState = xmlElement.ChildNodes[0].InnerText;
//this.from = canvas.FindState(startingState);
//string endState = xmlElement.ChildNodes[1].InnerText;
//this.to = canvas.FindState(endState);
//this.Transition.Select = xmlElement.ChildNodes[2].InnerText;
//this.Transition.Event = xmlElement.ChildNodes[3].InnerText;
//this.Transition.ClockGuard = xmlElement.ChildNodes[4].InnerText;
//this.Transition.Guard = xmlElement.ChildNodes[5].InnerText;
//this.Transition.Program = xmlElement.ChildNodes[6].InnerText;
//this.Transition.ClockReset = xmlElement.ChildNodes[7].InnerText;
//this.Transition.Width = this.Transition.GetWidthOfLabel();
//for (int i = 8; i < xmlElement.ChildNodes.Count - 1; i++)
//{
// NailItem nail = new NailItem(this);
// nail.LoadFromXml(xmlElement.ChildNodes[i] as XmlElement);
// this.nails.Add(nail);
//}
//this.transition.LoadFromXml(xmlElement.ChildNodes[xmlElement.ChildNodes.Count - 1] as XmlElement);
string startingState = xmlElement.SelectSingleNode("./" + FROM_NODE_NAME).InnerText;
this.from = canvas.FindState(startingState);
string endState = xmlElement.SelectSingleNode("./" + TO_NODE_NAME).InnerText;
this.to = canvas.FindState(endState);
this.Transition.Select = xmlElement.SelectSingleNode("./" + SELECT_NODE_NAME).InnerText;
this.Transition.Event = xmlElement.SelectSingleNode("./" + EVENT_NODE_NAME).InnerText;
this.Transition.ClockGuard = xmlElement.SelectSingleNode("./" + CLOCK_GUARD_NODE_NAME).InnerText;
this.Transition.Guard = xmlElement.SelectSingleNode("./" + GUARD_NODE_NAME).InnerText;
this.Transition.Program = xmlElement.SelectSingleNode("./" + PROGRAM_NODE_NAME).InnerText;
this.Transition.ClockReset = xmlElement.SelectSingleNode("./" + CLOCK_RESET_NODE_NAME).InnerText;
this.Transition.Width = this.Transition.GetWidthOfLabel();
XmlNodeList nails = xmlElement.SelectNodes("./" + NAIL_NODE_NAME);
if (nails != null)
{
foreach (XmlElement xmlNail in nails)
{
NailItem nail = new NailItem(this);
nail.LoadFromXml(xmlNail);
this.nails.Add(nail);
}
}
this.transition.LoadFromXml((XmlElement)xmlElement.SelectSingleNode("./" + LABEL_NODE_NAME));
}
public virtual void RemovedFromCanvas(LTSCanvas canvas)
{
//Remove nail
foreach (NailItem nailItem in this.Nails)
canvas.RemoveSingleCanvasItem(nailItem);
this.Nails.Clear();
//Remove transition
canvas.RemoveSingleCanvasItem(this.transition);
canvas.RemoveSingleRoute(this);
}
/// <summary>
/// Throw exception when route not found
/// </summary>
public PNArc FindSelectedRouteBasedOnTransition(LTSCanvas canvas)
{
foreach (Route route in canvas.diagramRouter.routes)
{
if (route is PNArc && (route as PNArc).Label.Equals(this))
{
return(route as PNArc);
}
}
throw new Exception("Route not found");
}
public override void RemovedFromCanvas(LTSCanvas canvas)
{
//Remove nail
foreach (NailItem nailItem in this.Nails)
{
canvas.RemoveSingleCanvasItem(nailItem);
}
this.Nails.Clear();
//Remove transition
canvas.RemoveSingleCanvasItem(Label);
canvas.RemoveSingleRoute(this);
}
public ChannelEditForm(Route route, LTSCanvas canvas, NetMode mode)
{
do
{
InitializeComponent();
mChannel = (WSNChannel)route;
mMode = mode;
mCanvas = canvas;
List <LTSCanvas.CanvasItemData> canvasItems = canvas.itemsList;
foreach (LTSCanvas.CanvasItemData itemData in canvasItems)
{
if (itemData.Item is StateItem)
{
this.cmbSource.Items.Add(itemData.Item);
this.cmbDest.Items.Add(itemData.Item);
if (itemData.Item.Equals(route.From))
{
this.cmbSource.SelectedItem = itemData.Item;
}
if (itemData.Item.Equals(route.To))
{
this.cmbDest.SelectedItem = itemData.Item;
}
}
}
if (!mMode.Equals(NetMode.MULTICAST))
{
txtSensorsConn.Visible = false;
lblSensorsConn.Visible = false;
break;
}
StringBuilder subConn = new StringBuilder();
subConn.Append(((WSNSensor)mChannel.To).ID.ToString());
foreach (int item in mChannel.SubIdList)
{
subConn.Append("," + item);
}
txtSensorsConn.Text = subConn.ToString();
} while (false);
}
/// <summary>
/// Load model from XML string
/// </summary>
/// <param name="xml"></param>
/// <param name="PNDocRes"></param>
/// <returns></returns>
public static WSNModel LoadModelFromXML(string xml, XmlDocument PNDocRes)
{
WSNModel model = new WSNModel();
do
{
XmlDocument doc = new XmlDocument();
try
{
doc.LoadXml(xml);
}
catch { }
XmlNodeList nodes = null;
do
{
nodes = doc.GetElementsByTagName(Data.TAG_DECLARATION);
if (nodes == null || nodes.Count != 1)
{
break;
}
model.Declaration = nodes.Item(0).InnerText;
} while (false);
do
{
nodes = doc.GetElementsByTagName(Data.TAG_NETWORK);
if (nodes == null)
{
break;
}
LTSCanvas canvas = null;
foreach (XmlElement node in nodes[0].ChildNodes)
{
canvas = new WSNCanvas(PNDocRes);
canvas.LoadFromXml(node);
model.Processes.Add(canvas);
}
} while (false);
} while (false);
return(model);
}
public virtual void AddToCanvas(LTSCanvas canvas)
{
canvas.AddSingleLink(this);
for (int i = 1; i < canvas.temporaryNails.Count; i++)
{
PointF p = canvas.temporaryNails[i];
NailItem nailItem = new NailItem(this);
nailItem.X = p.X;
nailItem.Y = p.Y;
canvas.AddSingleCanvasItem(nailItem);
this.AddNail(nailItem, this.Nails.Count);
}
canvas.temporaryNails.Clear();
this.FindLabelLocation();
canvas.AddSingleCanvasItem(this.transition);
}
public string NetworkToString(LTSCanvas network)
{
StringBuilder sb = new StringBuilder();
StateItem.StateCounterSpec = 0;
sb.AppendLine("<Network Deployment>");
sb.AppendLine("<Base Nodes>");
foreach (LTSCanvas.CanvasItemData item in network.itemsList)
{//append base station nodes
if (item.Item is StateItem)
{
if ((item.Item as StateItem).IsInitialState)
{
sb.AppendLine((item.Item as StateItem).GetName());
}
}
}
sb.AppendLine("</Base Nodes>");
sb.AppendLine("<Normal Nodes>");
foreach (LTSCanvas.CanvasItemData item in network.itemsList)
{//append client nodes
if (item.Item is StateItem)
{
if (!(item.Item as StateItem).IsInitialState)
{
sb.AppendLine((item.Item as StateItem).GetName());
}
}
}
sb.AppendLine("</Normal Nodes>");
sb.AppendLine("<Links>");
foreach (Route route in network.diagramRouter.Routes)
{
sb.AppendLine("\"" + (route.From as StateItem).GetName()
+ "\"-->\""
+ (route.To as StateItem).GetName() + "\"");
}
sb.AppendLine("</Links>");
sb.AppendLine("</Network Deployment>");
return(sb.ToString());
}
public PNModelHelper(string fileName, LTSCanvas canvas)
{
_fileName = fileName;
// get the sensors list
_sensors = new List <WSNSensorItem>();
foreach (LTSCanvas.CanvasItemData item in canvas.itemsList)
{
if ((item.Item is WSNSensorItem) == false)
{
continue;
}
WSNSensorItem add = (WSNSensorItem)item.Item;
add.locateX = item.Item.X / 120; //kkk
add.locateY = item.Item.Y / 120;
if (minX == 0 || add.locateX < minX)
{
minX = add.locateX;
}
if (minY == 0 || add.locateY < minY)
{
minY = add.locateY;
}
_sensors.Add(add);//
}
// get the channels list
_channels = new List <WSNSensorChannel>();
foreach (Route route in canvas.diagramRouter.routes)
{
if ((route is WSNSensorChannel) == false)
{
continue;
}
_channels.Add((WSNSensorChannel)route);
}
initXML();
}
public static SNModel LoadSensorNetworkFromXML(string text)
{
SNModel snModel = new SNModel();
XmlDataDocument doc = new XmlDataDocument();
doc.LoadXml(text);
XmlNodeList sitesNodes = doc.GetElementsByTagName(Parsing.SYSTEM_NODE_NAME);
snModel.SystemName = sitesNodes[0].ChildNodes[0].InnerText;
sitesNodes = doc.GetElementsByTagName(Parsing.NETWORK_NODE_NAME);
foreach (XmlElement component in sitesNodes)
{
LTSCanvas canvas = new LTSCanvas();
canvas.LoadFromXml(component.ChildNodes[0] as XmlElement);
snModel.Network = canvas;
}
sitesNodes = doc.GetElementsByTagName(Parsing.LINK_NODE_NAME);
if (sitesNodes.Count > 0)
{
foreach (XmlElement node in sitesNodes[0].ChildNodes)
{
snModel.AddLink(node.InnerText);
}
}
sitesNodes = doc.GetElementsByTagName(Parsing.ASSERTION_NODE_NAME);
if (sitesNodes[0].ChildNodes[0] != null)
{
snModel.Assertion = sitesNodes[0].ChildNodes[0].InnerText;
}
sitesNodes = doc.GetElementsByTagName(Parsing.SENSORS_NODE_NAME);
if (sitesNodes.Count > 0)
{
foreach (XmlElement component in sitesNodes[0].ChildNodes)
{
//ID
//Application
XmlNodeList sensorID = component.GetElementsByTagName("ID");
XmlNodeList tosId = component.GetElementsByTagName("TOSID");
string tosid = "";
if (tosId == null || tosId.Count < 1)
{
tosid = "0";
}
else
{
tosid = tosId[0].InnerText;
}
XmlNodeList sensorApp = component.GetElementsByTagName("App");
string app = "";
if (sensorApp == null || sensorApp.Count < 1)
{
app = "app";
}
else
{
app = sensorApp[0].InnerText;
}
XmlNodeList sensorRange = component.GetElementsByTagName("Range");
string range = "";
if (sensorRange == null || sensorRange.Count < 1)
{
range = "//enter the sensor settings here...";
}
else
{
range = sensorRange[0].InnerText;
}
string predefVars = "";
if (component.HasAttribute("Predefined"))
{
XmlNodeList sensorPredefVars = component.GetElementsByTagName("Predefined");
if (sensorRange.Count < 1)
{
predefVars = "//enter predefined variables here...";
}
else
{
predefVars = sensorPredefVars[0].InnerText;
}
}
else
{
predefVars = "//enter predefined variables here...";
}
snModel.Sensors.Add(sensorID[0].InnerText, new NodeData(sensorID[0].InnerText, app, range, tosid, predefVars));
}
}
return(snModel);
}
/// <summary>
/// Load model from XML string
/// </summary>
/// <param name="xml"></param>
/// <param name="PNDocRes"></param>
/// <returns></returns>
public static WSNModel LoadModelFromXML(string xml, XmlDocument PNDocRes)
{
WSNModel model = new WSNModel();
do
{
XmlDocument doc = new XmlDocument();
try
{
doc.LoadXml(xml);
}
catch { }
XmlNodeList nodes = null;
do
{
nodes = doc.GetElementsByTagName(XmlTag.TAG_DECLARATION);
if (nodes == null || nodes.Count != 1)
{
break;
}
model.Declaration = nodes.Item(0).InnerText;
} while (false);
do
{
nodes = doc.GetElementsByTagName(XmlTag.TAG_NETWORK);
if (nodes == null)
{
break;
}
// mlqvu -- load attributes for network tag
XmlNode firstNetworkNode = nodes[0];
if (firstNetworkNode == null)
{
break;
}
if (model.mExtendInfo == null)
{
model.mExtendInfo = new WSNExtendInfo();
}
try
{
String noID = firstNetworkNode.Attributes[XmlTag.ATTR_mID].Value;
model.mExtendInfo.mID = long.Parse(noID);
String noPacket = firstNetworkNode.Attributes[XmlTag.ATTR_NUMOFPACKETS].Value;
model.mExtendInfo.mNumberPacket = Int32.Parse(noPacket);
String noSensor = firstNetworkNode.Attributes[XmlTag.ATTR_NUMOFSENSORS].Value;
model.mExtendInfo.mNumberSensor = Int32.Parse(noSensor);
String maxSensorBufferSize = firstNetworkNode.Attributes[XmlTag.ATTR_SENSOR_MAX_BUFFER_SIZE].Value;
model.mExtendInfo.mSensorMaxBufferSize = Int32.Parse(maxSensorBufferSize);
String maxSensorQueueSize = firstNetworkNode.Attributes[XmlTag.ATTR_SENSOR_MAX_QUEUE_SIZE].Value;
model.mExtendInfo.mSensorMaxQueueSize = Int32.Parse(maxSensorQueueSize);
String maxChannelBufferSize = firstNetworkNode.Attributes[XmlTag.ATTR_CHANNEL_MAX_BUFFER_SIZE].Value;
model.mExtendInfo.mChannelMaxBufferSize = Int32.Parse(maxChannelBufferSize);
}
catch (Exception e) { }
LTSCanvas canvas = null;
foreach (XmlElement node in nodes[0].ChildNodes)
{
canvas = new WSNCanvas(node.GetAttribute(XmlTag.ATTR_NAME));
canvas.LoadFromXml(node);
model.Processes.Add(canvas);
}
} while (false);
} while (false);
return(model);
}
public override void AddToCanvas(LTSCanvas canvas)
{
canvas.AddSingleCanvasItem(this);
}
public override void RemovedFromCanvas(LTSCanvas canvas)
{
PNArc route = this.FindSelectedRouteBasedOnTransition(canvas);
route.RemovedFromCanvas(canvas);
}
public override void HandleSelected(LTSCanvas canvas)
{
PNArc route = this.FindSelectedRouteBasedOnTransition(canvas);
route.CurrentState = ItemState.Selected;
}