public void LoadPorts(XmlNode node)
{
object v;
XmlNodeList nds = node.SelectNodes(XmlSerialization.XML_PORT);
List <LinkLineNodeOutPort> outports = new List <LinkLineNodeOutPort>();
if (nds != null)
{
IXmlCodeReader r = GetReader();
foreach (XmlNode nd in nds)
{
v = XmlSerialization.ReadFromXmlNode(r, nd, this);
if (v != null)
{
if (v is LinkLineNodeInPort)
{
InPort = (LinkLineNodeInPort)v;
}
else if (v is LinkLineNodeOutPort)
{
outports.Add((LinkLineNodeOutPort)v);
}
}
}
}
LinkLineNodeOutPort[] o = new LinkLineNodeOutPort[outports.Count];
outports.CopyTo(o);
OutPorts = o;
}
protected void Init()
{
LinkLineNodeOutPort[] _outports = new LinkLineNodeOutPort[] { new LinkLineNodeOutPort(this) };
this.Variable.OutPorts = _outports;
this.Variable.MathExpression.SetFont(new Font("Times New Roman", 12));
_color = System.Drawing.Color.Blue;
_outports[0].PositionType = enumPositionType.Circle;
this.Variable.VariableName = this.Name;
this.Variable.VariableType = this.DataType;
((DrawingVariable)(_outports[0].Label)).SetVariable(this.Variable);
((DrawingVariable)(_outports[0].Label)).SetOwner(_outports[0]);
}
public void AddOutPort(LinkLineNodeOutPort port)
{
int n = _outports.Length;
LinkLineNodeOutPort[] o = new LinkLineNodeOutPort[n + 1];
for (int i = 0; i < n; i++)
{
o[i] = _outports[i];
}
_outports = o;
_outports[n] = port;
}
public void AddOutPort(LinkLineNodeOutPort port)
{
EventPortOut po = port as EventPortOut;
if (po == null)
{
throw new DesignerException("Cannot add non-EventPortOut to EventIcon");
}
if (_outPortList == null)
{
_outPortList = new List <EventPortOut>();
}
_outPortList.Add(po);
}
public override object CloneExp(MathNode parent)
{
MathNodeVariable node = (MathNodeVariable)base.CloneExp(parent);
node.VariableName = _value;
node.SubscriptName = _subscript;
node._id = ID;
node.IsLocal = IsLocal;
node.IsParam = IsParam;
node.IsReturn = IsReturn;
node._passin = _passin;
if (_subscriptFont != null)
{
node._subscriptFont = (Font)_subscriptFont.Clone();
}
node.IsSuperscript = IsSuperscript;
node.Position = new Point(Position.X, Position.Y);
if (VariableType == null)
{
throw new MathException("VariableType is null when clone it. {0}", _value);
}
else
{
node.VariableType = (RaisDataType)VariableType.Clone();
}
if (ClonePorts)
{
if (_outports != null)
{
LinkLineNodeOutPort[] ports = new LinkLineNodeOutPort[_outports.Length];
for (int i = 0; i < ports.Length; i++)
{
_outports[i].ConstructorParameters = new object[] { node };
ports[i] = (LinkLineNodeOutPort)_outports[i].Clone();
}
node.OutPorts = ports;
}
if (_inport != null)
{
_inport.ConstructorParameters = new object[] { node };
node.InPort = (LinkLineNodeInPort)_inport.Clone();
}
}
return(node);
}
public override void LinkJumpBranches()
{
if (_jumpToId != 0)
{
if (_jumpToActionBranch == null)
{
throw new DesignerException("Cannot set portlink from {0} to {1}. Linked actions not set", this.BranchId, _jumpToId);
}
ActionPortOut po = this.OutPortList[0];
ActionPortIn pi = _jumpToActionBranch.GetInPort(po.LinkedPortID, po.LinkedPortInstanceID); //.InPortList[po.LinkedPortIndex];
if (pi == null)
{
throw new DesignerException("out-port {0} is linked to [{1},{2}] of the jump-to-branch {3}, but in-port [{1},{2}] is not among the in-port list of the branch",
po.PortID, po.LinkedPortID, po.LinkedPortInstanceID, _jumpToActionBranch.BranchId);
}
LinkLineNode start = po.End;
LinkLineNode end;
LinkLineNodeOutPort pipo = pi.Start as LinkLineNodeOutPort;
if (pipo != null)
{
if (pipo.LinkedPortID != pi.PortID || pipo.LinkedPortInstanceID != pi.PortInstanceID)
{
throw new DesignerException("Input [{0},{1}] is already linked to [{2},{3}], cannot link it to [{4},{5}]",
pi.PortID, pi.PortInstanceID, pipo.PortID, pipo.PortInstanceID, po.PortID, po.PortInstanceID);
}
}
else
{
end = pi.Start;
if (end != start)
{
start.SetNext(end);
end.SetPrevious(start);
po.LinkedPortID = pi.PortID;
pi.LinkedPortID = po.PortID;
}
else
{
//it is not an error, it is already linked
}
}
}
base.LinkJumpBranches();
}
public bool IsOnTheLine(LinkLineNode lineNode)
{
LinkLineNodeOutPort start = lineNode.Start as LinkLineNodeOutPort;
if (start != null)
{
if (start.PortID == _startNode.PortID && start.PortInstanceID == _startNode.PortInstanceID)
{
LinkLineNodeInPort end = lineNode.End as LinkLineNodeInPort;
if (end != null)
{
if (end.PortID == _endNode.PortID && end.PortInstanceID == _endNode.PortInstanceID)
{
return(true);
}
}
}
}
return(false);
}
public void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
_owner = (ObjectRef)XmlSerialization.ReadFromChildXmlNode(serializer, node, XML_Owner);
XmlNodeList nodes = node.SelectNodes(XmlSerialization.FormatString("{0}/{1}",
XML_Inports, XmlSerialization.XML_PORT));
_inports = new ProgramInPort[nodes.Count];
for (int i = 0; i < nodes.Count; i++)
{
_inports[i] = (ProgramInPort)XmlSerialization.ReadFromXmlNode(serializer, nodes[i], this);
}
nodes = node.SelectNodes(XmlSerialization.FormatString("{0}/{1}",
XML_Outports, XmlSerialization.XML_PORT));
_outports = new ProgramOutPort[nodes.Count];
for (int i = 0; i < nodes.Count; i++)
{
_outports[i] = (ProgramOutPort)XmlSerialization.ReadFromXmlNode(serializer, nodes[i], this);
}
_newInport = (LinkLineNodeInPort)XmlSerialization.ReadFromChildXmlNode(serializer, node, XML_NewInport, this);
_newOutport = (LinkLineNodeOutPort)XmlSerialization.ReadFromChildXmlNode(serializer, node, XML_NewOutport, this);
}
public virtual PortCollection GetAllPorts()
{
PortCollection ports = new PortCollection();
if (_newInport == null)
{
_newInport = new ProgramNewInPort(this);
}
if (_newOutport == null)
{
_newOutport = new ProgramNewOutPort(this);
}
ports.Add(_newInport);
ports.Add(_newOutport);
if (_inports != null)
{
ports.AddRange(_inports);
}
if (_outports != null)
{
ports.AddRange(_outports);
}
return(ports);
}
protected override void OnMouseDown(MouseEventArgs e)
{
LinkLineNode nodeTest = HitTest(e.X, e.Y);
if (nodeTest != null)
{
if (AllowLineSelection)
{
nodeTest.SelectLine(true);
if (nodeTest.Start != null && nodeTest.End != null)
{
LinkLineNodeOutPort startNode = nodeTest.Start as LinkLineNodeOutPort;
LinkLineNodeInPort endNode = nodeTest.End as LinkLineNodeInPort;
if (startNode != null && endNode != null)
{
bool bChanged = true;
if (_selectedLine != null)
{
if (_selectedLine.StartNode.PortID == startNode.PortID &&
_selectedLine.StartNode.PortInstanceID == startNode.PortInstanceID &&
_selectedLine.EndNode.PortID == endNode.PortID &&
_selectedLine.EndNode.PortInstanceID == endNode.PortInstanceID)
{
bChanged = false;
}
}
if (bChanged)
{
_selectedLine = new LinkLineEnds(startNode, endNode);
OnLineSelectionChanged();
}
}
}
}
}
if (e.Button == MouseButtons.Right)
{
ContextMenu mnu = new ContextMenu();
Point pt = new Point(e.X, e.Y);
if (nodeTest != null)
{
//nodeTest is the line holder
nodeTest.SelectLine(true);
MenuItemWithBitmap mi = new MenuItemWithBitmap("Add line join", Resource1.newLineBreak);
mi.Click += new EventHandler(miAddLineNode_Click);
mi.Tag = new NodeData(nodeTest, pt);
mnu.MenuItems.Add(mi);
//
if (AllowLineDisconnect)
{
if (nodeTest.LinkedInPort != null && nodeTest.LinkedOutPort != null)
{
mi = new MenuItemWithBitmap("Disconnect", Resource1.disconnect);
mi.Click += new EventHandler(miDisconnectNodes_Click);
mi.Tag = new NodeData(nodeTest, pt);
mnu.MenuItems.Add(mi);
}
}
OnCreateContextMenuForLinkLine(nodeTest, mnu, pt);
}
else
{
OnCreateContextMenu(mnu, pt);
}
if (mnu.MenuItems.Count > 0)
{
_menuPoint = pt;
mnu.Show(this, pt);
}
}
}
public LinkLineEnds(LinkLineNodeOutPort startNode, LinkLineNodeInPort endNode)
{
_startNode = startNode;
_endNode = endNode;
}
public void AddOutPort(LinkLineNodeOutPort port)
{
throw new DesignerException("Cannot call AddOutPort for {0}", this.GetType().Name);
}
public void AddOutPort(LinkLineNodeOutPort port)
{
AddOutport((ProgramOutPort)port);
}
