public static Region GetConnectionRegion(NodeConnection connection) { var pt1 = ConnectorInterfacePoint(connection.From); var pt2 = ConnectorInterfacePoint(connection.To); Region region; float centerX; float centerY; using (var linePath = GetArrowLinePath(pt1.X, pt1.Y, pt2.X, pt2.Y, out centerX, out centerY, true, 5.0f)) { region = new Region(linePath); } return(region); }
public bool Disconnect(NodeConnection connection) { if (connection == null) { return(false); } if (ConnectionRemoving != null) { var eventArgs = new AcceptNodeConnectionEventArgs(connection); ConnectionRemoving(this, eventArgs); if (eventArgs.Cancel) { return(false); } } // if (HasFocus(connection)) // FocusElement = null; var from = connection.From; var to = connection.To; if (from != null && from.Node != null) { from.Node.RemoveConnection(connection); } if (to != null && to.Node != null) { to.Node.RemoveConnection(connection); } // Just in case somebody stored it somewhere .. connection.From = null; connection.To = null; if (ConnectionRemoved != null) { ConnectionRemoved(this, new NodeConnectionEventArgs(from, to, connection)); } UpdateRevisionIndex(); if (InvalidateViews != null) { InvalidateViews(this, EventArgs.Empty); } return(true); }
public static Region GetConnectionRegion(NodeConnection connection) { var to = connection.To; var from = connection.From; RectangleF toBounds; RectangleF fromBounds; if (to.Node.Collapsed) { toBounds = to.Node.inputBounds; } else { toBounds = to.bounds; } if (from.Node.Collapsed) { fromBounds = from.Node.outputBounds; } else { fromBounds = from.bounds; } var pt1 = ConnectorInterfacePoint(fromBounds, ConnectorType.Output); var pt2 = ConnectorInterfacePoint(toBounds, ConnectorType.Input); Region region; float centerX; float centerY; using (var linePath = GetArrowLinePath(pt1.X, pt1.Y, pt2.X, pt2.Y, out centerX, out centerY, true, 5.0f)) { region = new Region(linePath); } return(region); }
public static Region GetConnectionRegion(NodeConnection connection) { var pt1 = ConnectorInterfacePoint(connection.From); var pt2 = ConnectorInterfacePoint(connection.To); Region region; float centerX; float centerY; using (var linePath = GetArrowLinePath(pt1.X, pt1.Y, pt2.X, pt2.Y, out centerX, out centerY, true, 5.0f)) { region = new Region(linePath); } return region; }
public bool Disconnect(NodeConnection connection) { if (connection == null) return false; if (ConnectionRemoving != null) { var eventArgs = new AcceptNodeConnectionEventArgs(connection); ConnectionRemoving(this, eventArgs); if (eventArgs.Cancel) return false; } if (HasFocus(connection)) FocusElement = null; var from = connection.From; var to = connection.To; if (from != null && from.Node != null) { from.Node.connections.Remove(connection); } if (to != null && to.Node != null) { to.Node.connections.Remove(connection); } // Just in case somebody stored it somewhere .. connection.From = null; connection.To = null; if (ConnectionRemoved != null) ConnectionRemoved(this, new NodeConnectionEventArgs(from, to, connection)); this.Invalidate(); return true; }
public NodeConnection Connect(NodeConnector from, NodeConnector to, string name) { if (from != null) { foreach (var other in from.Node.Connections) { if (other.From == from && other.To == to) return null; } } if (to != null) { foreach (var other in to.Node.Connections) { if (other.From == from && other.To == to) return null; } } var connection = new NodeConnection(); connection.From = from; connection.To = to; connection.Name = name; if (from != null) from.Node.AddConnection(connection); if (to != null) to.Node.AddConnection(connection); if (ConnectionAdded != null) { var eventArgs = new AcceptNodeConnectionEventArgs(connection); ConnectionAdded(this, eventArgs); if (eventArgs.Cancel) { Disconnect(connection); return null; } } UpdateRevisionIndex(); if (InvalidateViews != null) InvalidateViews(this, EventArgs.Empty); return connection; }
public void RemoveConnection(NodeConnection connection) { connections.Remove(connection); }
public static Region GetConnectionRegion(NodeConnection connection) { var to = connection.To; var from = connection.From; RectangleF toBounds; RectangleF fromBounds; if (to.Node.Collapsed) toBounds = to.Node.inputBounds; else toBounds = to.bounds; if (from.Node.Collapsed) fromBounds = from.Node.outputBounds; else fromBounds = from.bounds; var pt1 = ConnectorInterfacePoint(fromBounds, ConnectorType.Output); var pt2 = ConnectorInterfacePoint(toBounds, ConnectorType.Input); Region region; float centerX; float centerY; using (var linePath = GetArrowLinePath(pt1.X, pt1.Y, pt2.X, pt2.Y, out centerX, out centerY, true, 5.0f)) { region = new Region(linePath); } return region; }
void OnConnectorDoubleClick(object sender, HyperGraph.GraphControl.NodeConnectorEventArgs e) { var dialog = new HyperGraph.TextEditForm(); dialog.InputText = "1.0f"; // look for an existing simple connection attached to this connector foreach(var i in e.Node.Connections) { if (i.To == e.Connector && i.From == null) dialog.InputText = i.Name; } var result = dialog.ShowDialog(); if (result == DialogResult.OK) { bool foundExisting = false; foreach (var i in e.Node.Connections) if (i.To == e.Connector && i.From == null) { i.Name = dialog.InputText; foundExisting = true; } if (!foundExisting) { var connection = new NodeConnection(); connection.To = e.Connector; connection.Name = dialog.InputText; e.Node.AddConnection(connection); } ShaderFragmentNodeUtil.InvalidateAttachedConstants(graphControl); } }
public NodeConnectionEventArgs(NodeConnection connection) { Connection = connection; From = connection.From; To = connection.To; }
public AcceptNodeConnectionEventArgs(NodeConnection connection) { Connection = connection; }
public NodeConnectionEventArgs(NodeConnector from, NodeConnector to, NodeConnection connection) { Connection = connection; From = from; To = to; }
public AcceptNodeConnectionEventArgs(NodeConnection connection, bool cancel) : base(cancel) { Connection = connection; }
public static void AddToHyperGraph(ShaderPatcherLayer.NodeGraph nodeGraph, HyperGraph.GraphControl graphControl, ShaderDiagram.Document doc) { // // Convert from the "ShaderPatcherLayer" representation back to // our graph control nodes. // // This is required for robust serialisation. We can't easily // serialise in and out the graph control objects directly, because // it risks problems if the rendering code or shader fragment objects // change. That is, it's not very version-robust. // // It's better to serialise a slightly higher level representation // that just contains the node names and connections. That way, we // can adapt to changes in the tool and data. // { // --------< Basic Nodes >-------- var newNodes = new Dictionary<int, Node>(); var nodeIdToControlNode = new Dictionary<UInt64, Node>(); foreach (var n in nodeGraph.Nodes) { if (!newNodes.ContainsKey(n.VisualNodeId)) { if (n.NodeType == ShaderPatcherLayer.Node.Type.Procedure) { var fn = ShaderFragmentArchive.Archive.GetFunction(n.FragmentArchiveName); if (fn != null) { var visualNode = nodeGraph.VisualNodes[n.VisualNodeId]; var newNode = ShaderFragmentNodeCreator.CreateNode(fn, n.FragmentArchiveName, graphControl, doc); newNode.Location = visualNode.Location; newNode.Collapsed = visualNode.State == ShaderPatcherLayer.VisualNode.StateType.Collapsed; newNodes[n.VisualNodeId] = newNode; nodeIdToControlNode[n.NodeId] = newNode; } } else { var ps = ShaderFragmentArchive.Archive.GetParameterStruct(n.FragmentArchiveName); if (ps != null) { var visualNode = nodeGraph.VisualNodes[n.VisualNodeId]; var newNode = ShaderFragmentNodeCreator.CreateParameterNode(ps, n.FragmentArchiveName, AsSourceType(n.NodeType)); newNode.Location = visualNode.Location; newNode.Collapsed = visualNode.State == ShaderPatcherLayer.VisualNode.StateType.Collapsed; newNodes[n.VisualNodeId] = newNode; nodeIdToControlNode[n.NodeId] = newNode; } } } } graphControl.AddNodes(newNodes.Values); // --------< Node Connections >-------- foreach (var c in nodeGraph.NodeConnections) { if (nodeIdToControlNode.ContainsKey(c.InputNodeID) && nodeIdToControlNode.ContainsKey(c.OutputNodeID)) { var inputItem = FindOrCreateNodeItem(nodeIdToControlNode[c.InputNodeID], (item) => (item.Output != null && item.Output.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.InputParameterName)), () => new ShaderFragmentNodeItem("return", c.InputType, null, false, true)); var outputItem = FindOrCreateNodeItem(nodeIdToControlNode[c.OutputNodeID], (item) => (item.Input != null && item.Input.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.OutputParameterName)), () => new ShaderFragmentNodeItem(c.OutputParameterName, c.OutputType, null, true, false)); graphControl.Connect(inputItem.Output, outputItem.Input); } } // --------< Node Constant Connections >-------- foreach (var c in nodeGraph.NodeConstantConnections) { if (nodeIdToControlNode.ContainsKey(c.OutputNodeID)) { var node = nodeIdToControlNode[c.OutputNodeID]; var outputItem = FindOrCreateNodeItem(node, (item) => (item.Input != null && item.Input.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.OutputParameterName)), () => new ShaderFragmentNodeItem(c.OutputParameterName, "float", null, true, false)); var connection = new NodeConnection(); connection.To = outputItem.Input; connection.Name = c.Value; node.AddConnection(connection); } } } }
public void AddConnection(NodeConnection newConnection) { connections.Add(newConnection); }
public void AddToHyperGraph(ShaderPatcherLayer.NodeGraph nodeGraph, HyperGraph.IGraphModel graph) { // // Convert from the "ShaderPatcherLayer" representation back to // our graph control nodes. // // This is required for robust serialisation. We can't easily // serialise in and out the graph control objects directly, because // it risks problems if the rendering code or shader fragment objects // change. That is, it's not very version-robust. // // It's better to serialise a slightly higher level representation // that just contains the node names and connections. That way, we // can adapt to changes in the tool and data. // { // --------< Basic Nodes >-------- var newNodes = new Dictionary<int, Node>(); var nodeIdToControlNode = new Dictionary<UInt64, Node>(); foreach (var n in nodeGraph.Nodes) { if (!newNodes.ContainsKey(n.VisualNodeId)) { var visualNode = nodeGraph.VisualNodes[n.VisualNodeId]; // also look for preview settings... var previewSettings = nodeGraph.PreviewSettingsObjects.Where(x => x.VisualNodeId == n.VisualNodeId).FirstOrDefault(); Node newNode = null; if (n.NodeType == ShaderPatcherLayer.Node.Type.Procedure) { var fn = _shaderFragments.GetFunction(n.FragmentArchiveName); newNode = _nodeCreator.CreateNode(fn, n.FragmentArchiveName, previewSettings); } else { var ps = _shaderFragments.GetParameterStruct(n.FragmentArchiveName); newNode = _nodeCreator.CreateParameterNode(ps, n.FragmentArchiveName, AsSourceType(n.NodeType)); } if (newNode != null) { MatchVisualNode(newNode, visualNode); newNodes[n.VisualNodeId] = newNode; nodeIdToControlNode[n.NodeId] = newNode; } } } graph.AddNodes(newNodes.Values); // --------< Node Connections >-------- foreach (var c in nodeGraph.NodeConnections) { if (nodeIdToControlNode.ContainsKey(c.InputNodeID) && nodeIdToControlNode.ContainsKey(c.OutputNodeID)) { var inputItem = FindOrCreateNodeItem(nodeIdToControlNode[c.InputNodeID], (item) => (item.Output != null && item.Output.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.InputParameterName)), () => new ShaderFragmentNodeItem(c.InputParameterName, c.InputType, null, false, true)); var outputItem = FindOrCreateNodeItem(nodeIdToControlNode[c.OutputNodeID], (item) => (item.Input != null && item.Input.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.OutputParameterName)), () => new ShaderFragmentNodeItem(c.OutputParameterName, c.OutputType, null, true, false)); graph.Connect(inputItem.Output, outputItem.Input); } } // --------< Constant Connections >-------- foreach (var c in nodeGraph.ConstantConnections) { if (nodeIdToControlNode.ContainsKey(c.OutputNodeID)) { var node = nodeIdToControlNode[c.OutputNodeID]; var outputItem = FindOrCreateNodeItem(node, (item) => (item.Input != null && item.Input.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.OutputParameterName)), () => new ShaderFragmentNodeItem(c.OutputParameterName, "float", null, true, false)); var connection = new NodeConnection(); connection.To = outputItem.Input; connection.Name = c.Value; node.AddConnection(connection); } } // --------< Input Parameter Connections >-------- foreach (var c in nodeGraph.InputParameterConnections) { if (!nodeIdToControlNode.ContainsKey(c.OutputNodeID)) continue; var dstItem = FindOrCreateNodeItem( nodeIdToControlNode[c.OutputNodeID], (item) => (item.Input != null && item.Input.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.OutputParameterName)), () => new ShaderFragmentNodeItem(c.OutputParameterName, c.Type, null, true, false)); Node srcNode; if (!newNodes.ContainsKey(c.VisualNodeId)) { srcNode = _nodeCreator.CreateInterfaceNode("Inputs", InterfaceDirection.In); MatchVisualNode(srcNode, nodeGraph.VisualNodes[c.VisualNodeId]); newNodes[c.VisualNodeId] = srcNode; graph.AddNode(srcNode); } else srcNode = newNodes[c.VisualNodeId]; var srcItem = FindOrCreateNodeItem( srcNode, (item) => { var i = item as ShaderFragmentInterfaceParameterItem; if (i==null) return false; return i.Name.Equals(c.Name) && i.Type.Equals(c.Type) && i.Semantic.Equals(c.Semantic); }, () => new ShaderFragmentInterfaceParameterItem(c.Name, c.Type, InterfaceDirection.In) { Semantic = c.Semantic, Default = c.Default }); graph.Connect(srcItem.Output, dstItem.Input); } // --------< Output Parameter Connections >-------- foreach (var c in nodeGraph.OutputParameterConnections) { if (!nodeIdToControlNode.ContainsKey(c.InputNodeID)) continue; var srcItem = FindOrCreateNodeItem( nodeIdToControlNode[c.InputNodeID], (item) => (item.Output != null && item.Output.Enabled && item is ShaderFragmentNodeItem && ((ShaderFragmentNodeItem)item).Name.Equals(c.InputParameterName)), () => new ShaderFragmentNodeItem(c.InputParameterName, c.Type, null, false, true)); Node dstNode; if (!newNodes.ContainsKey(c.VisualNodeId)) { dstNode = _nodeCreator.CreateInterfaceNode("Outputs", InterfaceDirection.Out); MatchVisualNode(dstNode, nodeGraph.VisualNodes[c.VisualNodeId]); newNodes[c.VisualNodeId] = dstNode; graph.AddNode(dstNode); } else dstNode = newNodes[c.VisualNodeId]; var dstItem = FindOrCreateNodeItem( dstNode, (item) => { var i = item as ShaderFragmentInterfaceParameterItem; if (i == null) return false; return i.Name.Equals(c.Name) && i.Type.Equals(c.Type) && i.Semantic.Equals(c.Semantic); }, () => new ShaderFragmentInterfaceParameterItem(c.Name, c.Type, InterfaceDirection.Out) { Semantic = c.Semantic }); graph.Connect(srcItem.Output, dstItem.Input); } } }
static void RenderLabel(Graphics graphics, NodeConnection connection, string text, PointF center, RenderState state) { using (var path = new GraphicsPath(FillMode.Winding)) { int cornerSize = (int)GraphConstants.CornerSize * 2; var stringFormat = GraphConstants.RightTextStringFormat; // CenterTextStringFormat; var size = graphics.MeasureString(text, SystemFonts.StatusFont, center, stringFormat); RectangleF position = connection.textBounds = new RectangleF(new PointF(center.X - size.Width, center.Y - size.Height/2), size); path.AddArc(position.Left, position.Top, cornerSize, cornerSize, 180, 90); path.AddArc(position.Right - cornerSize, position.Top, cornerSize, cornerSize, 270, 90); path.AddArc(position.Right - cornerSize, position.Bottom - cornerSize, cornerSize, cornerSize, 0, 90); path.AddArc(position.Left, position.Bottom - cornerSize, cornerSize, cornerSize, 90, 90); path.CloseFigure(); using (var brush = new SolidBrush(GetArrowLineColor(state))) { graphics.FillPath(brush, path); } graphics.DrawString(text, SystemFonts.StatusFont, Brushes.Black, position, GraphConstants.CenterTextStringFormat); if (state == RenderState.None) graphics.DrawPath(Pens.Black, path); //graphics.DrawRectangle(Pens.Black, connection.textBounds.Left, connection.textBounds.Top, connection.textBounds.Width, connection.textBounds.Height); } }
/// <summary> /// Checks whether the connection between two connectors is allowed. /// This is achieved through event propagation. /// </summary> /// <returns></returns> private bool ConnectionIsAllowed(NodeConnector from, NodeConnector to) { if (HighlightCompatible && null != CompatibilityStrategy) { if (CompatibilityStrategy.CanConnect(from, to) == ConnectionType.Incompatible) return false; } // If someone has subscribed to the ConnectionAdding event, // give them a chance to interrupt this connection attempt. if (null != ConnectionAdding) { // Populate a temporary NodeConnection instance. var connection = new NodeConnection(); connection.From = from; connection.To = to; // Fire the event and see if someone cancels it. var eventArgs = new AcceptNodeConnectionEventArgs(connection); ConnectionAdding(this, eventArgs); if (eventArgs.Cancel) return false; } return true; }
public NodeConnection Connect(NodeConnector from, NodeConnector to) { if (from == null || to == null || from.Node == null || to.Node == null || !from.Enabled || !to.Enabled) return null; foreach (var other in from.Node.connections) { if (other.From == from && other.To == to) return null; } foreach (var other in to.Node.connections) { if (other.From == from && other.To == to) return null; } var connection = new NodeConnection(); connection.From = from; connection.To = to; from.Node.connections.Add(connection); to.Node.connections.Add(connection); if (ConnectionAdded != null) { var eventArgs = new AcceptNodeConnectionEventArgs(connection); ConnectionAdded(this, eventArgs); if (eventArgs.Cancel) { Disconnect(connection); return null; } } return connection; }
public bool MoveToFront(NodeConnection connection) { if (connections[0] == connection) return false; connections.Remove(connection); connections.Insert(0, connection); return true; }