/// <summary>
/// Adds a node to the collection</summary>
/// <remarks>Can't contain duplicates!</remarks>
/// <param name="item">The Node to add</param>
public void Add(Node item)
{
if (IsReadOnly)
{
throw new InvalidOperationException("collection is read only");
}
if (Contains(item))
{
return;
}
if (m_owner != null)
{
item.Parent = m_owner;
}
var ea = new CancelNodeEventArgs(item);
bool cancelled = NodeAdding.RaiseCancellable(this, ea);
if (cancelled)
{
return;
}
m_nodes.Add(item);
NodeAdded.Raise(this, new NodeEventArgs(item));
}
public NodeList()
{
_nodes = new HashSet <T>();
NodeAddedEvent = new NodeAdded <T>();
NodeRemovedEvent = new NodeRemoved <T>();
_pending = new List <KeyValuePair <T, PendingChange> >();
}
public async Task <bool> AddAsync(string enode, bool updateFile = true)
{
NetworkNode node = new NetworkNode(enode);
if (!_nodes.TryAdd(node.NodeId, node))
{
if (_logger.IsInfo)
{
_logger.Info($"Static node was already added: {enode}");
}
return(false);
}
if (_logger.IsInfo)
{
_logger.Info($"Static node added: {enode}");
}
NodeAdded?.Invoke(this, new NetworkNodeEventArgs(node));
if (updateFile)
{
await SaveFileAsync();
}
return(true);
}
public async Task SearchTree(string domain)
{
IByteBuffer buffer = PooledByteBufferAllocator.Default.Buffer();
try
{
await foreach (string nodeRecordText in _crawler.SearchTree(domain))
{
try
{
NodeRecord nodeRecord = _parser.ParseRecord(nodeRecordText, buffer);
Node? node = CreateNode(nodeRecord);
if (node is not null)
{
// here could add network info to the node
NodeAdded?.Invoke(this, new NodeEventArgs(node));
}
}
catch (Exception e)
{
if (_logger.IsDebug)
{
_logger.Error($"failed to parse enr record {nodeRecordText}", e);
}
}
}
}
finally
{
buffer.Release();
}
}
public NodeEditorNodes(EditorWindow _editorWindow,
NodeConfig _nodeConfig,
ConstellationScript _constellationScript,
IUndoable _undoable,
NodeEditorSelection _nodeEditorSelection,
ILinkEditor _linkEditor,
IGUI _gui,
IVisibleObject _visibleObject,
NodeAdded _nodeAdded,
NodeRemoved _nodeRemoved,
HelpClicked _helpClicked)
{
linkEditor = _linkEditor;
editorWindow = _editorWindow;
Nodes = new List <NodeView> ();
nodeConfig = _nodeConfig;
constellationScript = _constellationScript;
isInstance = constellationScript.IsInstance;
nodesFactory = new NodesFactory();
undoable = _undoable;
nodeEditorSelection = _nodeEditorSelection;
GUI = _gui;
visibleObject = _visibleObject;
OnNodeAdded += _nodeAdded;
OnNodeRemoved += _nodeRemoved;
OnHelpClicked += _helpClicked;
SetNodes();
}
public NodeEditorPanel(IGUI _gui,
EditorWindow _editorWindow,
ConstellationScript _script,
IUndoable _undoable,
ClipBoard _editorClipBoard,
float positionX,
float positionY,
LinkAdded linkAdded,
NodeAdded nodeAdded,
NodeRemoved nodeRemoved)
{
nodesFactory = new NodesFactory();
constellationScript = _script;
undoable = _undoable;
Nodes = new List <NodeView> ();
GUI = _gui;
EditorWindow = _editorWindow;
editorScrollSize = new Vector2(500, 500);
Background = AssetDatabase.LoadAssetAtPath(editorPath + "background.png", typeof(Texture2D)) as Texture2D;
var allNodes = NodesFactory.GetAllNodes();
nodes = new string[allNodes.Length];
editorScrollPos = new Vector2(positionX, positionY);
for (var i = 0; i < allNodes.Length; i++)
{
nodes[i] = allNodes[i];
}
OnLinkAdded += linkAdded;
OnNodeAdded += nodeAdded;
OnNodeRemoved += nodeRemoved;
nodeEditorSelection = new NodeEditorSelection(GUI, _editorClipBoard);
}
public void Draw(float _width, float _height, NodeAdded OnNodeAdded, bool _allowTypesNodes)
{
GUILayout.BeginVertical();
DrawSearchField();
const int SearchFieldSize = 55; //Has to be fixed but for now it's the only way to keep the margins right
nodeSelectorScrollPos = EditorGUILayout.BeginScrollView(nodeSelectorScrollPos, GUILayout.Width(_width), GUILayout.Height(_height - SearchFieldSize));
foreach (NodeNamespacesData nodeNamespace in NodeNamespaceData)
{
if (!_allowTypesNodes && nodeNamespace.namespaceName == Constellation.ConstellationTypes.NameSpace.NAME)
{
continue;
}
var displayedNamespace = nodeNamespace.namespaceName.Replace(GetStaticNodeNameSpace(), "");
GUILayout.Label(displayedNamespace, GUI.skin.GetStyle("OL Title"), GUILayout.Width(_width - 20));
var selGridInt = GUILayout.SelectionGrid(-1, nodeNamespace.GetNiceNames(), 1 + (int)Mathf.Floor(_width / 255));
if (selGridInt >= 0)
{
OnNodeAdded(nodeNamespace.GetNames()[selGridInt], nodeNamespace.namespaceName);
}
}
//GUILayout.Space(20);
EditorGUILayout.EndScrollView();
GUILayout.EndVertical();
}
public Constellation(ConstellationScriptData constellationScriptData,
NodesFactory nodesFactory,
NodeAdded onNodeAdded = null)
{
NodesFactory = nodesFactory;
SetNodes(constellationScriptData.GetNodes(), onNodeAdded);
SetLinks(constellationScriptData.GetLinks());
}
private void M_nodes_Inserted(ConversationNode <INodeGui> node)
{
NodeAdded.Execute(node);
foreach (Output connection in node.Data.Connectors)
{
UIInfo(connection, false);
}
}
private void ReloadNodesAndEdges()
{
CloseNodesAndEdges();
if (Graph == null)
{
return;
}
var entityMatrix = Entity.PositionComp.WorldMatrix;
for (var i = 0; i < Nodes.Length; i++)
{
MyObjectBuilder_BendyComponent.NodePose data;
if (_movableNodeData.TryGetValue((uint)i, out data))
{
Nodes[i] = Graph.GetOrCreateNode(Vector3D.Transform((Vector3)data.Position, ref entityMatrix),
Vector3D.Transform((Vector3)data.Up, ref entityMatrix));
}
else
{
Assert.False(Definition.Nodes[i].Movable,
$"Creating movable bendy node {i} for entity {Entity}, component def {Definition.Id} without movable data");
var nodeMatrix = Definition.Nodes[i].Position * entityMatrix;
Nodes[i] = Graph.GetOrCreateNode(nodeMatrix.Translation, nodeMatrix.Up, !Definition.Nodes[i].Movable);
if (!Definition.Nodes[i].Movable)
{
Nodes[i].Pin(nodeMatrix);
}
}
if (Nodes[i] != null)
{
NodeAdded?.Invoke(this, Nodes[i]);
}
}
for (var i = 0; i < Edges.Length; i++)
{
var def = Definition.Edges[i];
var from = Nodes[def.From];
var to = Nodes[def.To];
Edges[i] = Graph.GetEdge(from, to) ?? Graph.CreateEdge(this, from, to, def.Mode, def.Control0, def.Control1);
if (Edges[i] != null)
{
EdgeAdded?.Invoke(this, Edges[i]);
Edges[i].CurveUpdated += OnCurveUpdated;
}
}
EdgeSetupChanged?.Invoke(this);
if (_skeletonComponent != null)
{
OnBonesReloaded(_skeletonComponent);
}
}
public void AddNode(Node parent, bool byUser)
{
var node = new Node(parent);
if (parent == null)
{
root = node;
}
NodeAdded?.Invoke(node, byUser);
}
void SetNodes(NodeData[] nodes, NodeAdded onNodeAdded)
{
foreach (NodeData node in nodes)
{
var newNode = NodesFactory.GetNode(node);
AddNode(newNode, node.Guid, node);
if (onNodeAdded != null)
{
onNodeAdded(newNode, node);
}
}
}
public void AddNodes(params NodeModel[] nodes)
{
_nodes.AddRange(nodes);
// Is this okay?
foreach (var node in nodes)
{
NodeAdded?.Invoke(node);
}
Changed?.Invoke();
}
private Node GetExistingNodeOrCreateNew(TilePos position)
{
if (Nodes.ContainsKey(position))
{
return(Nodes[position]);
}
var newNode = new Node(position);
Nodes.Add(position, newNode);
NodeAdded.CallEvent(newNode);
return(newNode);
}
public NodeSelectorPanel(NodeAdded _onNodeAdded)
{
OnNodeAdded = null;
OnNodeAdded += _onNodeAdded;
var nodes = NodesFactory.GetAllNodes();
namespaces = NodesFactory.GetAllNamespaces(nodes);
NodeNamespaceData = new List <NodeNamespacesData> ();
foreach (var _namespace in namespaces)
{
var nodeNamespace = new NodeNamespacesData(_namespace, nodes);
NodeNamespaceData.Add(nodeNamespace);
}
}
void RegisterNode(Node node)
{
NodeEditor.Assertions.IsFalse(Nodes.Contains(node), "Node already exists in this graph.");
if (!Nodes.Contains(node))
{
NodeEditor.Logger.Log <NodeGraph>("Registered node.");
node.Destroyed += RemoveNode;
node.Changed += Node_Changed;
node.PinRemoved += Node_PinRemoved;
Nodes.Add(node);
NodeAdded.InvokeSafe(node);
Edited.InvokeSafe(this);
}
}
private void MapImage_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
Canvas fe = Parent as Canvas;
fe.Children.Remove(this);
AddNodeEventArgs eventArgs = new AddNodeEventArgs();
eventArgs.NodeTypeName = "CompendiumMapNode";
Point location = e.GetPosition(null);
eventArgs.XPosition = location.X - (this.ActualWidth / 2);
eventArgs.YPosition = location.Y - (this.ActualHeight / 2); // -64; (toolbar row)
if (NodeAdded != null)
{
NodeAdded.Invoke(this, eventArgs);
}
}
public Node AddNode(NodeInfo info, bool select = false)
{
Node node = new Node(info);
this.Children.Add(node);
if (select)
{
node.Select();
}
var removeOpt = new MenuItem();
removeOpt.Header = "Remove Node";
removeOpt.Click += (s, e) => { this.RemoveNode(node); };
node.ContextMenu.Items.Add(removeOpt);
NodeAdded?.Invoke(this, new NodeAddedEventArgs(node));
return(node);
}
public void Draw(float _width, float _height, NodeAdded OnNodeAdded)
{
GUILayout.BeginVertical();
DrawSearchField();
const int SearchFieldSize = 55; //Has to be fixed but for now it's the only way to keep the margins right
nodeSelectorScrollPos = EditorGUILayout.BeginScrollView(nodeSelectorScrollPos, GUILayout.Width(_width), GUILayout.Height(_height - SearchFieldSize));
foreach (NodeNamespacesData nodeNamespace in NodeNamespaceData)
{
GUILayout.Label(nodeNamespace.namespaceName, GUI.skin.GetStyle("OL Title"), GUILayout.Width(_width - 20));
var selGridInt = GUILayout.SelectionGrid(-1, nodeNamespace.GetNiceNames(), 1 + (int)Mathf.Floor(_width / 255));
if (selGridInt >= 0)
{
OnNodeAdded(nodeNamespace.GetNames()[selGridInt], nodeNamespace.namespaceName);
}
}
//GUILayout.Space(20);
EditorGUILayout.EndScrollView();
GUILayout.EndVertical();
}
public NodeSelectorPanel(NodeAdded _onNodeAdded, NodeNamespacesData[] customNodes)
{
OnNodeAdded = null;
OnNodeAdded += _onNodeAdded;
var nodes = new List <string> (NodesFactory.GetAllNodes());
namespaces = NodesFactory.GetAllNamespaces(nodes.ToArray());
NodeNamespaceData = new List <NodeNamespacesData> ();
foreach (var _namespace in namespaces)
{
var nodeNamespace = new NodeNamespacesData(_namespace, nodes.ToArray());
NodeNamespaceData.Add(nodeNamespace);
}
foreach (var node in customNodes)
{
NodeNamespaceData.Add(node);
}
}
/// <summary>
/// Adds the given node to the patch
/// </summary>
/// <param name="node">node reference</param>
/// <param name="cancellationToken">cancellation token</param>
/// <param name="configuration">optional configuration</param>
/// <returns></returns>
private async Task InternalAddNode(INode node, CancellationToken cancellationToken, string configuration = null)
{
// Double check for node id collisions
if (_nodes.ToArray().Any(n => n.Id == node.Id))
{
throw new ArgumentException("node with this id already exists", nameof(node.Id));
}
_nodes.Add(node);
NodeAdded?.Invoke(node);
// Try to setup
if (!string.IsNullOrEmpty(configuration))
{
await node.Initialize(configuration, cancellationToken);
}
else
{
await node.Initialize(cancellationToken);
}
}
public Constellation(ConstellationScriptData constellationScriptData,
NodesFactory nodesFactory,
NodeAdded onNodeAdded = null)
{
isConstellationInitialized = false;
NodesFactory = nodesFactory;
var newAssembly = new List <ConstellationScriptData>();
if (nodesFactory.GetStaticScripts() == null)
{
foreach (var node in constellationScriptData.Nodes)
{
if (node.Namespace == ConstellationNodes.NameSpace.NAME)
{
newAssembly.Add(UnityEngine.JsonUtility.FromJson <ConstellationScriptData>(node.DiscreteParametersData[1].Value.GetString()));
}
}
nodesFactory.UpdateConstellationScripts(newAssembly.ToArray());
}
SetNodes(constellationScriptData.GetNodes(), onNodeAdded);
SetLinks(constellationScriptData.GetLinks());
isConstellationInitialized = true;
}
protected virtual void OnNodeAdded(MNode e) => NodeAdded?.Invoke(this, e);
private static async Task LoadRoot()
{
Root Result = null;
foreach (MeteringNode Node in await Database.Find <MeteringNode>(new FilterFieldEqualTo("ParentId", Guid.Empty)))
{
if (Node is Root)
{
if (Result is null)
{
Result = (Root)Node;
}
else
{
await Database.Delete(Node);
}
}
}
if (Result is null)
{
Result = new Root()
{
NodeId = await(await Translator.GetDefaultLanguageAsync()).GetStringAsync(typeof(MeteringTopology), 14, "Root")
};
await Database.Insert(Result);
Language Language = await Translator.GetDefaultLanguageAsync();
await MeteringTopology.NewEvent(new NodeAdded()
{
Parameters = await Result.GetDisplayableParameterAraryAsync(Language, RequestOrigin.Empty),
NodeType = Result.GetType().FullName,
Sniffable = Result is ISniffable,
DisplayName = await Result.GetTypeNameAsync(Language),
HasChildren = Result.HasChildren,
ChildrenOrdered = Result.ChildrenOrdered,
IsReadable = Result.IsReadable,
IsControllable = Result.IsControllable,
HasCommands = Result.HasCommands,
ParentId = string.Empty,
ParentPartition = string.Empty,
Updated = Result.Updated,
State = Result.State,
NodeId = Result.NodeId,
Partition = Result.Partition,
LogId = NodeAdded.EmptyIfSame(Result.LogId, Result.NodeId),
LocalId = NodeAdded.EmptyIfSame(Result.LocalId, Result.NodeId),
SourceId = Result.SourceId,
Timestamp = DateTime.Now
});
}
lock (nodes)
{
nodes[Result.NodeId] = Result;
}
root = Result;
}
/// <summary>
/// Called when a <see cref="T:Microsoft.Msagl.Drawing.Node"/> is added.
/// </summary>
/// <param name="args">Event arguments.</param>
protected virtual void OnNodeAdded([NotNull] MsaglVertexEventArgs <TVertex> args)
{
Debug.Assert(args != null);
NodeAdded?.Invoke(this, args);
}
public void AddNode(NodeModel node)
{
_nodes.Add(node);
NodeAdded?.Invoke(node);
Changed?.Invoke();
}
/// <summary>
/// Start slcan stream sending a nodestatus packet every second
/// </summary>
/// <param name="stream"></param>
public void StartSLCAN(Stream stream)
{
//cleanup
stream.Write(new byte[] { (byte)'\r' }, 0, 1);
// close
stream.Write(new byte[] { (byte)'C', (byte)'\r' }, 0, 2);
// speed
stream.Write(new byte[] { (byte)'S', (byte)'8', (byte)'\r' }, 0, 3);
//hwid
stream.Write(new byte[] { (byte)'N', (byte)'\r' }, 0, 2);
// open
stream.Write(new byte[] { (byte)'O', (byte)'\r' }, 0, 2);
// clear status
stream.Write(new byte[] { (byte)'F', (byte)'\r' }, 0, 2);
sr = stream;
// read everything
Task.Run(() =>
{
while (sr.CanRead)
{
try
{
var line = ReadLine(stream);
ReadMessage(line);
}
catch
{
}
}
});
// 1 second nodestatus send
Task.Run(() =>
{
while (stream.CanWrite)
{
try
{
if (NodeStatus)
{
var slcan = PackageMessage(SourceNode, 20, transferID++,
new uavcan.uavcan_protocol_NodeStatus()
{
health = (byte)uavcan.UAVCAN_PROTOCOL_NODESTATUS_HEALTH_OK, mode = (byte)uavcan.UAVCAN_PROTOCOL_NODESTATUS_MODE_OPERATIONAL, sub_mode = 0, uptime_sec = (uint)(DateTime.Now - uptime).TotalSeconds, vendor_specific_status_code = 0
});
lock (sr_lock)
WriteToStream(slcan);
}
}
catch
{
}
Thread.Sleep(1000);
}
});
// build nodelist
MessageReceived += (frame, msg, transferID) =>
{
if (frame.IsServiceMsg && frame.SvcDestinationNode != SourceNode)
{
return;
}
if (msg.GetType() == typeof(uavcan.uavcan_protocol_NodeStatus))
{
if (!nodeList.ContainsKey(frame.SourceNode))
{
nodeList.Add(frame.SourceNode, msg as uavcan.uavcan_protocol_NodeStatus);
NodeAdded?.Invoke(frame.SourceNode, msg as uavcan.uavcan_protocol_NodeStatus);
}
}
else if (msg.GetType() == typeof(uavcan.uavcan_protocol_GetNodeInfo_req))
{
var gnires = new uavcan.uavcan_protocol_GetNodeInfo_res();
gnires.software_version.major = (byte)Assembly.GetExecutingAssembly().GetName().Version.Major;
gnires.software_version.minor = (byte)Assembly.GetExecutingAssembly().GetName().Version.Minor;
gnires.hardware_version.major = 0;
gnires.hardware_version.unique_id = ASCIIEncoding.ASCII.GetBytes("MissionPlanner\x0\x0\x0\x0\x0\x0");
gnires.name = ASCIIEncoding.ASCII.GetBytes("org.missionplanner");
gnires.name_len = (byte)gnires.name.Length;
gnires.status = new uavcan.uavcan_protocol_NodeStatus()
{
health = (byte)uavcan.UAVCAN_PROTOCOL_NODESTATUS_HEALTH_OK, mode = (byte)uavcan.UAVCAN_PROTOCOL_NODESTATUS_MODE_OPERATIONAL, sub_mode = 0, uptime_sec = (uint)(DateTime.Now - uptime).TotalSeconds, vendor_specific_status_code = 0
};
var slcan = PackageMessage(frame.SourceNode, frame.Priority, transferID, gnires);
lock (sr_lock)
WriteToStream(slcan);
}
};
}
public void Serialize(bool save)
{
var jsonPath = FilePath;
string jsonText;
if (save)
{
jsonText = JsonConvert.SerializeObject(root,
new JsonSerializerSettings
{
PreserveReferencesHandling = PreserveReferencesHandling.All,
Formatting = Formatting.Indented
});
using (StreamWriter sw = new StreamWriter(jsonPath, false))
{
sw.WriteLine(jsonText);
}
}
else
{
if (File.Exists(jsonPath))
{
using (StreamReader sr = new StreamReader(jsonPath))
{
jsonText = sr.ReadToEnd();
_deserializing = true;
try
{
ITraceWriter traceWriter = new MemoryTraceWriter();
root = JsonConvert.DeserializeObject <Node>(jsonText,
new JsonSerializerSettings
{
PreserveReferencesHandling = PreserveReferencesHandling.All
//,TraceWriter = traceWriter
}
);
Debug.WriteLine(traceWriter);
root.ParentTree = this;
}
finally
{
_deserializing = false;
}
}
}
NodeAdded?.Invoke(root, false);
foreach (var node in root.Childs.SelectRecursive(c => c.Childs).ToArray())
{
//Debug.Print(node.label);
NodeAdded?.Invoke(node, false);
}
//var query =
// from node in root.SelectRecursive(c => c.childs);
//where node.Name.Contains("5")
//select node.Name;
}
}
private void OnNodeAdded(NodeBase node)
{
NodeAdded?.Invoke(this, new NodeEventArgs(node));
}
public void AddNode(TimeNode node)
{
Nodes.Add(node);
NodeAdded?.Invoke(this, new TimeProfileNodeAddedEvent(node));
}
