/// <summary>
/// Checks if a node may be processed without running into circular references. The node is not added to the list.
/// </summary>
/// <param name="node">The node we want to process.</param>
/// <returns>Returns true when the node may be processed, if not the calling function has to stop.</returns>
public bool MayProcessCheckOnly(Node node)
{
ReferencedBehaviorNode refnode = node as ReferencedBehaviorNode;
if (refnode != null)
{
return(!_processedBehaviors.Contains(refnode));
}
return(true);
}
/// <summary>
/// Creates a new referenced behaviour node.
/// </summary>
/// <param name="rootBehavior">The behaviour we are adding the reference to.</param>
/// <param name="referencedBehavior">The behaviour we are referencing.</param>
/// <returns>Returns the created referenced behaviour node.</returns>
public static ReferencedBehaviorNode CreateReferencedBehaviorNode(BehaviorNode rootBehavior, BehaviorNode referencedBehavior)
{
ReferencedBehaviorNode node = (ReferencedBehaviorNode)Plugin.ReferencedBehaviorNodeType.InvokeMember(string.Empty, BindingFlags.CreateInstance, null, null, new object[] { rootBehavior, referencedBehavior });
if (node == null)
{
throw new Exception(Resources.ExceptionMissingNodeConstructor);
}
return(node);
}
/// <summary>
/// Branches the list for a node.
/// </summary>
/// <param name="node">The node we are branching for.</param>
/// <returns>A new list which contains the previously processed behaviours for referenced behaviours. For other nodes it returns the same list.</returns>
public ProcessedBehaviors Branch(Node node)
{
ReferencedBehaviorNode refnode = node as ReferencedBehaviorNode;
if (refnode != null)
{
return(new ProcessedBehaviors(this));
}
return(this);
}
/// <summary>
/// Returns the first NodeViewData which is associated with the given node. Notice that there might be other NodeViewDatas which are ignored.
/// </summary>
/// <param name="node">The node you want to get the NodeViewData for.</param>
/// <returns>Returns the first NodeViewData found.</returns>
public override NodeViewData FindNodeViewData(Node node)
{
if (node is ReferencedBehaviorNode)
{
ReferencedBehaviorNode refnode = (ReferencedBehaviorNode)_node;
ReferencedBehaviorNode refnode2 = (ReferencedBehaviorNode)node;
if (refnode.Reference == refnode2.Reference)
{
return(this);
}
}
return(base.FindNodeViewData(node));
}
/// <summary>
/// Checks if a node may be processed without running into circular references and adds it to the list.
/// </summary>
/// <param name="node">The node we want to process.</param>
/// <returns>Returns true when the node may be processed, if not the calling function has to stop.</returns>
public bool MayProcess(Node node)
{
ReferencedBehaviorNode refnode = node as ReferencedBehaviorNode;
if (refnode != null)
{
if (_processedBehaviors.Contains(refnode))
{
return(false);
}
_processedBehaviors.Add(refnode);
}
return(true);
}
/// <summary>
/// This function adapts the children of the view that they represent the children of the node this view is for.
/// Children are added and removed.
/// </summary>
/// <param name="processedBehaviors">A list of previously processed behaviours to deal with circular references.</param>
public override void SynchronizeWithNode(IList <BehaviorNode> processedBehaviors)
{
// if we have a circular reference, we must skip it
ReferencedBehaviorNode rb = (ReferencedBehaviorNode)_node;
if (rb.Reference == null || processedBehaviors.Contains(rb.Reference))
{
_children.Clear();
return;
}
List <BehaviorNode> newProcessedBehaviors = new List <BehaviorNode>(processedBehaviors);
newProcessedBehaviors.Add(rb.Reference);
base.SynchronizeWithNode(newProcessedBehaviors.AsReadOnly());
}
protected void CollectRequiredModules(List <Object> requiredModules, Node node)
{
foreach (Node child in node.Children)
{
if (!requiredModules.Contains(child.GetType()))
{
requiredModules.Add(child.GetType());
}
// for referenced behaviours we add the behaviours as a reference
ReferencedBehaviorNode refbn = child as ReferencedBehaviorNode;
if (refbn != null && !requiredModules.Contains(refbn.Reference))
{
requiredModules.Add(refbn.Reference);
}
CollectRequiredModules(requiredModules, child);
}
}
/// <summary>
/// Returns if any of the node's parents is a given behaviour.
/// </summary>
/// <param name="behavior">The behavior we want to check if it is an ancestor of this node.</param>
/// <returns>Returns true if this node is a descendant of the given behavior.</returns>
public override bool HasParentBehavior(BehaviorNode behavior)
{
if (behavior == null)
{
return(false);
}
ReferencedBehaviorNode refb = (ReferencedBehaviorNode)_node;
Debug.Check(refb.Reference != null);
if (refb.Reference == behavior)
{
return(true);
}
if (_parent == null)
{
return(false);
}
return(_parent.HasParentBehavior(behavior));
}
/// <summary>
/// Handles when a referenced behaviour is modified.
/// </summary>
/// <param name="node">The referenced behaviour node whose referenced behaviour is modified.</param>
void refnode_ReferencedBehaviorWasModified(ReferencedBehaviorNode node) {
LayoutChanged();
}
/// <summary>
/// Loads a node from a given XML node.
/// </summary>
/// <param name="getBehaviorNode">The callback used to return the behavior.</param>
/// <param name="xml">The XML node we want to create the node from.</param>
/// <param name="parent">The parent this node will be added to.</param>
/// <param name="connector">The connector used to add this node to the parent.</param>
/// <returns>Returns the created node.</returns>
protected Node CreateNodeAndAdd(List <Nodes.Node.ErrorCheck> result, GetBehaviorNode getBehaviorNode, XmlNode xml, Node parent, Node.Connector connector)
{
try {
// get the type of the node and create it
string clss = GetAttribute(xml, "Class");
Type t = Plugin.GetType(clss);
if (t == null)
{
string msg = string.Format(Resources.ExceptionUnknownNodeType, clss);
string msgError = string.Format("{0}:\n{1}", this.Filename, msg);
//throw new Exception(msg);
MessageBox.Show(msgError, Resources.LoadError, MessageBoxButtons.OK);
parent.Behavior.TriggerWasModified(parent);
return(null);
}
Node node = Nodes.Node.Create(t);
if (parent == null)
{
//if this._version == 0, it means there is no Version attribute in the file
node.Behavior.Version = this._version;
}
// update the loaded behaviour member
if (node is BehaviorNode)
{
((BehaviorNode)node).FileManager = this;
}
// add the node to the parent
if (parent != null)
{
if (connector != null)
{
parent.AddChildNotModified(connector, node);
}
else
{
parent.AddFSMNode(node);
}
}
int version = 0;
if (node.Behavior != null)
{
version = node.Behavior.Version;
}
else
{
Debug.Check(true);
}
SetEnterExitSlot(result, xml, node, version);
// initialise the properties
IList <DesignerPropertyInfo> properties = node.GetDesignerProperties();
foreach (DesignerPropertyInfo property in properties)
{
if (!property.Attribute.HasFlags(DesignerProperty.DesignerFlags.NoSave))
{
InitProperty(result, xml, node, property);
}
}
// return the created behaviour node
if (node is BehaviorNode)
{
getBehaviorNode((BehaviorNode)node);
}
// maintain compatibility with version 1
if (node is ReferencedBehaviorNode)
{
ReferencedBehaviorNode refbehavior = (ReferencedBehaviorNode)node;
if (refbehavior.ReferenceFilename == null)
{
refbehavior.ReferenceFilename = GetAttribute(xml, "Reference");
}
}
// update node with properties
node.OnPropertyValueChanged(false);
// load child objects
foreach (XmlNode xnode in xml.ChildNodes)
{
if (xnode.NodeType == XmlNodeType.Element)
{
switch (xnode.Name)
{
// load parameters
case ("Parameters"):
if (node is Behavior || node is ReferencedBehavior)
{
LoadParameters(result, xnode, node, node.LocalVars);
node.Behavior.PostLoadPars();
}
break;
case ("DescriptorRefs"):
#if QUERY_EANBLED
LoadDescriptorRefs(result, xnode, node.Behavior as Behavior);
#endif//#if QUERY_EANBLED
break;
// maintain compatibility with version 1
case ("Node"):
CreateNodeAndAdd(result, getBehaviorNode, xnode, node, node.GetConnector(BaseNode.Connector.kGeneric));
break;
// maintain compatibility with version 2.1
case ("Event"):
case ("Attachment"): {
Attachments.Attachment a = CreateAttachment(result, node, xnode);
if (a != null)
{
node.AddAttachment(a);
a.PostCreate(result, version, node, xnode);
}
}
break;
case ("Comment"):
// create a comment object
node.CommentText = "temp";
// initialise the attributes
properties = node.CommentObject.GetDesignerProperties();
foreach (DesignerPropertyInfo property in properties)
{
if (property.Attribute.HasFlags(DesignerProperty.DesignerFlags.NoSave))
{
continue;
}
string value;
if (GetAttribute(xnode, property.Property.Name, out value))
{
property.SetValueFromString(result, node.CommentObject, value);
}
}
break;
case ("Connector"):
string identifier = GetAttribute(xnode, "Identifier");
Nodes.Node.Connector conn = node.GetConnector(identifier);
foreach (XmlNode connected in xnode.ChildNodes)
{
if (connected.NodeType == XmlNodeType.Element && connected.Name == "Node")
{
CreateNodeAndAdd(result, getBehaviorNode, connected, node, conn);
}
}
break;
case ("FSMNodes"):
string locationX = GetAttribute(xnode, "ScreenLocationX");
string locationY = GetAttribute(xnode, "ScreenLocationY");
if (!string.IsNullOrEmpty(locationX) && !string.IsNullOrEmpty(locationY))
{
try {
float x = float.Parse(locationX);
float y = float.Parse(locationY);
node.ScreenLocation = new System.Drawing.PointF(x, y);
} catch {
}
}
foreach (XmlNode fsmNode in xnode.ChildNodes)
{
if (fsmNode.NodeType == XmlNodeType.Element && fsmNode.Name == "Node")
{
CreateNodeAndAdd(result, getBehaviorNode, fsmNode, node, null);
}
}
break;
}
}
}
// update attachments with attributes
foreach (Attachments.Attachment attach in node.Attachments)
{
attach.OnPropertyValueChanged(false);
}
// set the properties from its prefab
bool isPrefabInstance = !string.IsNullOrEmpty(node.PrefabName) && !node.HasOwnPrefabData;
if (isPrefabInstance)
{
Node prefabNode = Plugin.GetPrefabNode(node);
if (prefabNode != null)
{
node.ResetByPrefab(node.PrefabName, prefabNode);
Behavior b = node.Behavior as Behavior;
b.AgentType.AddPars(b.LocalVars);
}
}
node.PostCreate(result, version, xml);
return(node);
} catch (Exception e) {
string idNode = xml.Attributes["Id"].Value;
string msgError = string.Format("{0}:\r\nNode Id:{1}\r\n{2}", this.Filename, idNode, e.Message);
//throw new Exception(msg);
MessageBox.Show(msgError, Resources.LoadError, MessageBoxButtons.OK);
}
return(null);
}
/// <summary>
/// Loads a node from a given XML node.
/// </summary>
/// <param name="getBehaviorNode">The callback used to return the behavior.</param>
/// <param name="xml">The XML node we want to create the node from.</param>
/// <param name="parent">The parent this node will be added to.</param>
/// <param name="connector">The connector used to add this node to the parent.</param>
/// <returns>Returns the created node.</returns>
protected Node CreateNodeAndAdd(GetBehaviorNode getBehaviorNode, XmlNode xml, Node parent, Node.Connector connector)
{
// get the type of the node and create it
string clss = GetAttribute(xml, "Class");
Type t = Plugin.GetType(clss);
if (t == null)
{
throw new Exception(string.Format(Resources.ExceptionUnknownNodeType, clss));
}
Node node = Nodes.Node.Create(t);
// update the loaded behaviour member
if (node is BehaviorNode)
{
((BehaviorNode)node).FileManager = this;
}
// add the node to the parent
if (parent != null)
{
Debug.Check(connector != null);
parent.AddChildNotModified(connector, node);
}
// initialise the properties
IList <DesignerPropertyInfo> properties = node.GetDesignerProperties();
foreach (DesignerPropertyInfo property in properties)
{
if (property.Attribute.HasFlags(DesignerProperty.DesignerFlags.NoSave))
{
continue;
}
InitProperty(xml, node, property);
node.PostPropertyInit(property);
}
// return the created behaviour node
if (node is BehaviorNode)
{
getBehaviorNode((BehaviorNode)node);
}
// maintain compatibility with version 1
if (node is ReferencedBehaviorNode)
{
ReferencedBehaviorNode refbehavior = (ReferencedBehaviorNode)node;
if (refbehavior.ReferenceFilename == null)
{
refbehavior.ReferenceFilename = GetAttribute(xml, "Reference");
}
}
// update node with properties
node.OnPropertyValueChanged(false);
// load child objects
foreach (XmlNode xnode in xml.ChildNodes)
{
if (xnode.NodeType == XmlNodeType.Element)
{
switch (xnode.Name.ToLowerInvariant())
{
// maintain compatibility with version 1
case ("node"):
CreateNodeAndAdd(getBehaviorNode, xnode, node, node.GetConnector("GenericChildren"));
break;
// maintain compatibility with version 2.1
case ("event"):
case ("attachment"):
node.AddAttachment(CreateAttachment(node, xnode));
break;
case ("comment"):
// create a comment object
node.CommentText = "temp";
// initialise the attributes
properties = node.CommentObject.GetDesignerProperties();
foreach (DesignerPropertyInfo property in properties)
{
if (property.Attribute.HasFlags(DesignerProperty.DesignerFlags.NoSave))
{
continue;
}
string value;
if (GetAttribute(xnode, property.Property.Name, out value))
{
property.SetValueFromString(node.CommentObject, value);
}
}
break;
case ("connector"):
string identifier = GetAttribute(xnode, "Identifier");
Nodes.Node.Connector conn = node.GetConnector(identifier);
foreach (XmlNode connected in xnode.ChildNodes)
{
if (connected.NodeType == XmlNodeType.Element &&
connected.Name.ToLowerInvariant() == "node")
{
CreateNodeAndAdd(getBehaviorNode, connected, node, conn);
}
}
break;
}
}
}
// update attachments with attributes
foreach (Attachments.Attachment attach in node.Attachments)
{
attach.OnPropertyValueChanged(false);
}
return(node);
}
/// <summary>
/// Loads a node from a given XML node.
/// </summary>
/// <param name="xml">The XML node we want to create the node from.</param>
/// <returns>Returns the created node.</returns>
protected Node CreateNode(XmlNode xml)
{
// get the type of the node and create it
string clss = GetAttribute(xml, "Class");
Type t = Plugin.GetType(clss);
if (t == null)
{
throw new Exception(string.Format(Resources.ExceptionUnknownNodeType, clss));
}
Node node = Nodes.Node.Create(t);
// update the loaded behaviour member
if (node is BehaviorNode && _loadedBehavior == null)
{
_loadedBehavior = (BehaviorNode)node;
}
// initialise the properties
IList <DesignerPropertyInfo> properties = node.GetDesignerProperties();
foreach (DesignerPropertyInfo property in properties)
{
if (property.Attribute.HasFlags(DesignerProperty.DesignerFlags.NoSave))
{
continue;
}
InitProperty(xml, node, property);
node.PostPropertyInit(property);
}
// maintain compatibility with version 1
if (node is ReferencedBehaviorNode)
{
ReferencedBehaviorNode refbehavior = (ReferencedBehaviorNode)node;
if (refbehavior.ReferenceFilename == null)
{
refbehavior.ReferenceFilename = GetAttribute(xml, "Reference");
}
}
// update node with properties
node.OnPropertyValueChanged(false);
// load child objects
foreach (XmlNode xnode in xml.ChildNodes)
{
if (xnode.NodeType == XmlNodeType.Element)
{
switch (xnode.Name.ToLowerInvariant())
{
// maintain compatibility with version 1
case ("node"):
node.AddChild(node.DefaultConnector, CreateNode(xnode));
break;
case ("event"):
node.AddSubItem(new Node.SubItemEvent(CreateEvent(node, xnode)));
break;
case ("comment"):
// create a comment object
node.CommentText = "temp";
// initialise the attributes
properties = node.CommentObject.GetDesignerProperties();
foreach (DesignerPropertyInfo property in properties)
{
if (property.Attribute.HasFlags(DesignerProperty.DesignerFlags.NoSave))
{
continue;
}
string value;
if (GetAttribute(xnode, property.Property.Name, out value))
{
property.SetValueFromString(node.CommentObject, value);
}
}
break;
case ("connector"):
string identifier = GetAttribute(xnode, "Identifier");
Nodes.Node.Connector connector = node.GetConnector(identifier);
foreach (XmlNode connected in xnode.ChildNodes)
{
if (connected.NodeType == XmlNodeType.Element &&
connected.Name.ToLowerInvariant() == "node")
{
node.AddChildNotModified(connector, CreateNode(connected));
}
}
break;
}
}
}
// update events with attributes
if (node.SubItems.Count > 0)
{
foreach (Nodes.Node.SubItem sub in node.SubItems)
{
node.SelectedSubItem = sub;
node.OnSubItemPropertyValueChanged(false);
}
node.SelectedSubItem = null;
}
return(node);
}
public NodeViewDataReferencedMethod(NodeViewData parent, BehaviorNode rootBehavior, ReferencedBehaviorNode node, Pen borderPen, SolidColorBrush backgroundBrush, string label, string description) :
base(parent, rootBehavior, (Node)node, borderPen, backgroundBrush, label, description)
{
}
/// <summary>
/// Loads a node from a given XML node.
/// </summary>
/// <param name="getBehaviorNode">The callback used to return the behavior.</param>
/// <param name="xml">The XML node we want to create the node from.</param>
/// <param name="parent">The parent this node will be added to.</param>
/// <param name="connector">The connector used to add this node to the parent.</param>
/// <returns>Returns the created node.</returns>
protected Node CreateNodeAndAdd(GetBehaviorNode getBehaviorNode, XmlNode xml, Node parent, Node.Connector connector)
{
try
{
// get the type of the node and create it
string clss = GetAttribute(xml, "Class");
Type t = Plugin.GetType(clss);
if (t == null)
{
string msg = string.Format(Resources.ExceptionUnknownNodeType, clss);
string msgError = string.Format("{0}:\n{1}", this.Filename, msg);
//throw new Exception(msg);
MessageBox.Show(msgError, Resources.LoadError, MessageBoxButtons.OK);
parent.Behavior.IsModified = true;
return(null);
}
Node node = Nodes.Node.Create(t);
// update the loaded behaviour member
if (node is BehaviorNode)
{
((BehaviorNode)node).FileManager = this;
}
// add the node to the parent
if (parent != null)
{
Debug.Check(connector != null);
parent.AddChildNotModified(connector, node);
}
// initialise the properties
IList <DesignerPropertyInfo> properties = node.GetDesignerProperties();
foreach (DesignerPropertyInfo property in properties)
{
if (!property.Attribute.HasFlags(DesignerProperty.DesignerFlags.NoSave))
{
InitProperty(xml, node, property);
node.PostPropertyInit(property);
}
}
// return the created behaviour node
if (node is BehaviorNode)
{
getBehaviorNode((BehaviorNode)node);
}
// maintain compatibility with version 1
if (node is ReferencedBehaviorNode)
{
ReferencedBehaviorNode refbehavior = (ReferencedBehaviorNode)node;
if (refbehavior.ReferenceFilename == null)
{
refbehavior.ReferenceFilename = GetAttribute(xml, "Reference");
}
}
// update node with properties
node.OnPropertyValueChanged(false);
// load child objects
foreach (XmlNode xnode in xml.ChildNodes)
{
if (xnode.NodeType == XmlNodeType.Element)
{
switch (xnode.Name.ToLowerInvariant())
{
// load parameters
case ("parameters"):
LoadParameters(xnode, node, node.Pars);
break;
case ("descriptorrefs"):
#if QUERY_EANBLED
LoadDescriptorRefs(xnode, node.Behavior as Behavior);
#endif//#if QUERY_EANBLED
break;
// maintain compatibility with version 1
case ("node"):
CreateNodeAndAdd(getBehaviorNode, xnode, node, node.GetConnector("GenericChildren"));
break;
// maintain compatibility with version 2.1
case ("event"):
case ("attachment"):
{
Attachments.Attachment a = CreateAttachment(node, xnode);
if (a != null)
{
node.AddAttachment(a);
}
}
break;
case ("comment"):
// create a comment object
node.CommentText = "temp";
// initialise the attributes
properties = node.CommentObject.GetDesignerProperties();
foreach (DesignerPropertyInfo property in properties)
{
if (property.Attribute.HasFlags(DesignerProperty.DesignerFlags.NoSave))
{
continue;
}
string value;
if (GetAttribute(xnode, property.Property.Name, out value))
{
property.SetValueFromString(node.CommentObject, value);
}
}
break;
case ("connector"):
string identifier = GetAttribute(xnode, "Identifier");
Nodes.Node.Connector conn = node.GetConnector(identifier);
foreach (XmlNode connected in xnode.ChildNodes)
{
if (connected.NodeType == XmlNodeType.Element &&
connected.Name.ToLowerInvariant() == "node")
{
CreateNodeAndAdd(getBehaviorNode, connected, node, conn);
}
}
break;
}
}
}
// update attachments with attributes
foreach (Attachments.Attachment attach in node.Attachments)
{
attach.OnPropertyValueChanged(false);
}
// set the properties from its prefab
bool isPrefabInstance = !string.IsNullOrEmpty(node.PrefabName) && !node.HasOwnPrefabData;
if (isPrefabInstance)
{
Node prefabNode = Plugin.GetPrefabNode(node);
if (prefabNode != null)
{
node.ResetByPrefab(node.PrefabName, prefabNode);
}
}
return(node);
}
catch (Exception e)
{
string idNode = xml.Attributes["Id"].Value;
string msgError = string.Format("{0}:\r\nNode Id:{1}\r\n{2}", this.Filename, idNode, e.Message);
//throw new Exception(msg);
MessageBox.Show(msgError, Resources.LoadError, MessageBoxButtons.OK);
}
return(null);
}
