public void Handle(NodeRemoved notification)
{
lock (lockObj)
{
backupServers.Remove(notification.Id);
}
}
public NodeList()
{
_nodes = new HashSet <T>();
NodeAddedEvent = new NodeAdded <T>();
NodeRemovedEvent = new NodeRemoved <T>();
_pending = new List <KeyValuePair <T, PendingChange> >();
}
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 async Task <bool> RemoveAsync(string enode, bool updateFile = true)
{
var node = new NetworkNode(enode);
var removed = _nodes.TryRemove(node.NodeId, out _);
if (!removed && _logger.IsDebug)
{
_logger.Debug($"Static node already was not found: {enode}");
}
else
{
if (_logger.IsInfo)
{
_logger.Info($"Static node was removed: {enode}");
}
if (updateFile)
{
await SaveFileAsync();
}
}
var args = new RemoveNetworkNodeEventArgs(node, removed);
NodeRemoved?.Invoke(this, args);
return(args.Removed);
}
public async Task <bool> RemoveAsync(string enode, bool updateFile = true)
{
NetworkNode node = new NetworkNode(enode);
if (!_nodes.TryRemove(node.NodeId, out _))
{
if (_logger.IsInfo)
{
_logger.Info($"Static node was not found: {enode}");
}
return(false);
}
if (_logger.IsInfo)
{
_logger.Info($"Static node was removed: {enode}");
}
NodeRemoved?.Invoke(this, new NetworkNodeEventArgs(node));
if (updateFile)
{
await SaveFileAsync();
}
return(true);
}
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();
}
protected void ReportDelete(TKey key, TValue value)
{
Interlocked.CompareExchange(ref _deletes, 0, int.MaxValue);
Interlocked.Increment(ref _deletes);
NodeRemoved?.Invoke(key, value);
NodeRemovedByPaging?.Invoke(key, value);
}
private void RemoveOneWayConnection(Node node1, Node node2)
{
node1.Connections.Remove(node2);
if (node1.Connections.Count == 0)
{
Nodes.Remove(node1.Position);
NodeRemoved.CallEvent(node1);
}
}
private void OnNodeRemoved(NodeRemoved msg)
{
if (!_index.TryGet(msg.NodeId, out var itemViewModel))
{
return;
}
Items.Remove(itemViewModel);
_index.Remove(msg.NodeId);
}
private void M_nodes_Removing(ConversationNode <INodeGui> node)
{
foreach (var parameter in node.Data.Parameters.OfType <IDynamicEnumParameter>())
{
//Give it a junk source so it's value stops counting towards the real source
parameter.MergeInto(new DynamicEnumParameter.Source());
}
NodeRemoved.Execute(node);
foreach (Output connection in node.Data.Connectors)
{
m_cachedNodeUI.Remove(connection);
}
}
public bool TryRemove(TKey key, out TValue value)
{
lock (_padlock)
{
if (ValueStorage.TryGetValue(key, out var nValue))
{
ValueStorage.Remove(key);
OnNodeRemove(nValue);
value = nValue.Value;
NodeRemoved?.Invoke(key, value);
return(true);
}
}
value = default(TValue);
return(false);
}
private void M_nodes_Clearing()
{
foreach (var parameter in m_nodes.SelectMany(n => n.Data.Parameters).OfType <IDynamicEnumParameter>())
{
//Give it a junk source so it's value stops counting towards the real source
parameter.MergeInto(new DynamicEnumParameter.Source());
}
foreach (var node in m_nodes)
{
NodeRemoved.Execute(node);
foreach (Output connection in node.Data.Connectors)
{
m_cachedNodeUI.Remove(connection);
}
}
}
public void RemoveNode(NodeModel node, bool triggerEvent = true)
{
if (_nodes.Remove(node))
{
// In case its selected
_selectedModels.Remove(node);
foreach (var link in node.AllLinks.ToList()) // Since we're removing from the list
{
RemoveLink(link, false);
}
NodeRemoved?.Invoke(node);
if (triggerEvent)
{
Changed?.Invoke();
}
}
}
/// <summary>
/// Removes the given node from the system
/// - Stops and disposes it
/// - Removes all wires
/// - removes it
/// </summary>
/// <param name="node"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
private async Task InternalRemoveNode(INode node, CancellationToken cancellationToken)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
if (!_nodes.ToArray().Contains(node))
{
throw new ArgumentException("node does not exist", nameof(node));
}
// Shut down and dispose it
await node.Deinitialize(cancellationToken);
// TODO: Remove Wires
// TODO: Remove attached nodes
_nodes.Remove(node);
NodeRemoved?.Invoke(node);
}
public void RemoveNode(Node node)
{
NodeEditor.Assertions.IsTrue(Nodes.Contains(node), "Node Graph does not contain node.");
if (Nodes.Contains(node))
{
NodeEditor.Logger.Log <NodeGraph>("Removing node.");
Selection = null;
node.Dispose();
Nodes.Remove(node);
NodeRemoved.InvokeSafe(node);
// TODO: Gracefully handle disconnections...
var connections = Connections
.Where(x => x.SourcePin.Node.ID == node.ID || x.TargetPin.Node.ID == node.ID)
.ToList();
connections.ForEach(x => Disconnect(x));
Edited.InvokeSafe(this);
}
}
private void CloseNodesAndEdges()
{
CacheMovableData();
if (Edges != null)
{
for (var i = 0; i < Edges.Length; i++)
{
if (Edges[i] != null)
{
Edges[i].CurveUpdated -= OnCurveUpdated;
EdgeRemoved?.Invoke(this, Edges[i]);
Edges[i].Close();
}
Edges[i] = null;
}
}
// ReSharper disable once InvertIf
if (Nodes != null)
{
for (var i = 0; i < Nodes.Length; i++)
{
if (Nodes[i] != null)
{
NodeRemoved?.Invoke(this, Nodes[i]);
if (!Definition.Nodes[i].Movable)
{
Nodes[i].UnpinTangent();
}
}
Nodes[i] = null;
}
}
EdgeSetupChanged?.Invoke(this);
}
private void OnNodeRemoved(NodeBase node)
{
NodeRemoved?.Invoke(this, new NodeEventArgs(node));
}
protected virtual void OnNodeRemoved(MNode e) => NodeRemoved?.Invoke(this, e);
internal void RaiseNodeRemoved()
{
NodeRemoved?.Invoke(this, EventArgs.Empty);
}
private void NodeSourceOnNodeRemoved(object?sender, NodeEventArgs e)
{
NodeRemoved?.Invoke(sender, e);
}
internal void RaiseNodeRemoved(Node n)
{
NodeRemoved?.Invoke(n);
}
private void OnUiObjectInfoRemoved(UiObjectInfoRemovedMessage message)
{
NodeRemoved?.Invoke(this, message.UiObjectInfo.Node);
}
private void OnNodeRemoved(NodeRemoved msg)
{
_items[msg.NodeId].Dispose();
_items.Remove(msg.NodeId);
}
public void OnRemoved(TreeNodeData node) => NodeRemoved?.Invoke(this, new TreeViewNodeRemovedEventArgs(node, true));
/// <summary>
/// <inheritdoc />
/// </summary>
public void OnNodeRemoved(Guid instanceGuid)
{
NodeRemoved?.Invoke(instanceGuid);
}
void Graph_NodeRemoved(Node node)
{
NodeRemoved.InvokeSafe(node);
}
