- Remove NodeCreator

- Derive Port so that we can use our own IEdgeConnectorListener
- Handle element removal event from GraphView

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/GraphEditorView.cs

         AbstractMaterialGraph m_Graph;
         PreviewManager m_PreviewManager;
         SearchWindowProvider m_SearchWindowProvider;
+        EdgeConnectorListener m_EdgeConnectorListener;
 
         public Action onUpdateAssetClick
         {
         public GraphEditorView(EditorWindow editorWindow, AbstractMaterialGraph graph, string assetName)
         {
             m_Graph = graph;
-            m_SearchWindowProvider = ScriptableObject.CreateInstance<SearchWindowProvider>();
             AddStyleSheetPath("Styles/MaterialGraph");
 
             previewManager = new PreviewManager(graph);
                 m_GraphView.graphViewChanged = GraphViewChanged;
             }
 
+            m_SearchWindowProvider = ScriptableObject.CreateInstance<SearchWindowProvider>();
-            //m_GraphView.AddManipulator(new NodeCreator(m_SearchWindowProvider));
+
+            m_EdgeConnectorListener = new EdgeConnectorListener(m_Graph);
 
             foreach (var node in graph.GetNodes<INode>())
                 AddNode(node);
                 }
             }
 
+            if (graphViewChange.elementsToRemove != null)
+            {
+                m_Graph.owner.RegisterCompleteObjectUndo("Remove Elements");
+                m_Graph.RemoveElements(graphViewChange.elementsToRemove.OfType<MaterialNodeView>().Select(v => (INode) v.node),
+                    graphViewChange.elementsToRemove.OfType<Edge>().Select(e => (IEdge) e.userData));
+            }
+
             return graphViewChange;
         }
 
         {
             var nodeView = new MaterialNodeView { userData = node };
             m_GraphView.AddElement(nodeView);
-            nodeView.Initialize(node as AbstractMaterialNode, m_PreviewManager);
+            nodeView.Initialize(node as AbstractMaterialNode, m_PreviewManager, m_EdgeConnectorListener);
             node.onModified += OnNodeChanged;
         }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/MaterialGraphView.cs

         public override void BuildContextualMenu(ContextualMenuPopulateEvent evt)
         {
             base.BuildContextualMenu(evt);
-            evt.menu.AppendSeparator();
             evt.menu.AppendAction("Convert To Sub-graph", ConvertToSubgraph, ConvertToSubgraphStatus);
             evt.menu.AppendAction("Convert To Inline Node", ConvertToInlineNode, ConvertToInlineNodeStatus);
             evt.menu.AppendAction("Convert To Property", ConvertToProperty, ConvertToPropertyStatus);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/MaterialNodeView.cs

         VisualElement m_PreviewContainer;
         List<Attacher> m_Attachers;
         VisualElement m_ControlsDivider;
+        IEdgeConnectorListener m_ConnectorListener;
-        public void Initialize(AbstractMaterialNode inNode, PreviewManager previewManager)
+        public void Initialize(AbstractMaterialNode inNode, PreviewManager previewManager, IEdgeConnectorListener connectorListener)
         {
             AddToClassList("MaterialNode");
 
+            m_ConnectorListener = connectorListener;
             node = inNode;
             persistenceKey = node.guid.ToString();
             UpdateTitle();
                 if (slot.hidden)
                     continue;
 
-                var port = InstantiatePort(Orientation.Horizontal, slot.isInputSlot ? Direction.Input : Direction.Output, null);
+                var port = ShaderPort.Create(Orientation.Horizontal, slot.isInputSlot ? Direction.Input : Direction.Output, null, m_ConnectorListener);
                 port.portName = slot.displayName;
                 port.userData = slot;
                 port.visualClass = slot.concreteValueType.ToClassName();

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Resources/Styles/MaterialGraph.uss

     padding-bottom: 0;
 }
 
+
+
+/* TEMP STUFF THAT SHOULD ACTUALLY STAY IN GRAPHVIEW */
+
 FloatField {
 	min-height: 15;
 	margin-left: 4;
 FloatField:focus {
 	background-image: resource("Builtin Skins/DarkSkin/Images/TextField focused.png");
 }
+
+ShaderPort {
+    height: 24;
+    align-items: center;
+    padding-left: 4;
+    padding-right: 4;
+    port-color: rgb(200, 200, 200);
+    disabled-port-color: rgb(70, 70, 70);
+}
+
+ShaderPort.input {
+    flex-direction: row;
+}
+
+ShaderPort.output {
+    flex-direction: row-reverse;
+}
+
+ShaderPort > #connector {
+    border-color: rgb(70, 70, 70);
+    background-color: #212121;
+    width: 8;
+    height: 8;
+    border-radius: 8;
+    align-items: center;
+    justify-content: center;
+
+    margin-left: 4;
+    margin-right: 4;
+    border-left-width:1;
+    border-top-width:1;
+    border-right-width:1;
+    border-bottom-width:1;
+}
+
+ShaderPort > #connector:hover {
+    border-color:  #f0f0f0
+}
+
+ShaderPort > #connector > #cap
+{
+    background-color: #212121;
+    width: 4;
+    height: 4;
+    border-radius: 4;
+}
+
+ShaderPort > #connector > #cap:hover
+{
+    background-color: #f0f0f0;
+}
+
+ShaderPort > #connector.portHighlight {
+    border-color: #f0f0f0;
+}
+
+ShaderPort > #type {
+    text-color: #c1c1c1;
+    font-size:11;
+    height:16;
+    padding-left: 0;
+    padding-right: 0;
+    margin-left: 4;
+    margin-right: 4;
+}
+
+ShaderPort.input > #type {
+    text-alignment: middle-left;
+}
+
+ShaderPort.output > #type {
+    text-alignment:middle-right;
+}
+
+/*******************************/
+/* ShaderPorts colors by types */
+/*******************************/
+
+ShaderPort.typeTexture {
+    port-color:#FF8B8B;
+}
+
+ShaderPort.typeTexture2D {
+    /* Same as typeTexture */
+    port-color:#FF8B8B;
+}
+
+ShaderPort.typeGraphScript {
+    /* Todo: there is no such type in Unity atm */
+    port-color:#E681BA;
+}
+
+ShaderPort.typeFloat4 {
+    port-color:#FBCBF4;
+}
+
+ShaderPort.typeVector4 {
+    /* Same as typeFloat4 */
+    port-color:#FBCBF4;
+}
+
+ShaderPort.typeQuaternion {
+    /* Same as typeFloat4 */
+    port-color:#FBCBF4;
+}
+
+ShaderPort.typeColor {
+    /* Same as typeFloat4 */
+    port-color:#FBCBF4;
+}
+
+ShaderPort.typeInt {
+    port-color:#9481E6;
+}
+
+ShaderPort.typeInt32 {
+    /* Same as typeInt */
+    port-color:#9481E6;
+}
+
+ShaderPort.typeInt64 {
+    /* Same as typeInt */
+    /* todo we might want to differentiate that from int32 */
+    port-color:#9481E6;
+}
+
+ShaderPort.typeBool {
+    port-color:#9481E6;
+}
+
+ShaderPort.typeMatrix {
+    port-color:#8FC1DF;
+}
+
+ShaderPort.typeMatrix4x4 {
+    /* Same as typeMatrix */
+    port-color:#8FC1DF;
+}
+
+ShaderPort.typeGameObject {
+    port-color:#8FC1DF;
+}
+
+ShaderPort.typeFloat {
+    port-color:#84E4E7;
+}
+
+ShaderPort.typeFloat1 {
+    /* Same as typeFloat */
+    port-color:#84E4E7;
+}
+
+ShaderPort.typeSingle {
+    /* Same as typeFloat */
+    port-color:#84E4E7;
+}
+
+ShaderPort.typeDouble {
+    /* Same as typeFloat */
+    /* todo we might want to differentiate that from float */
+    port-color:#84E4E7;
+}
+
+ShaderPort.typeFloat2 {
+    port-color:#9AEF92;
+}
+
+ShaderPort.typeVector2 {
+    /* Same as typeFloat2 */
+    port-color:#9AEF92;
+}
+
+ShaderPort.typeComponent {
+    port-color:#C9F774;
+}
+
+ShaderPort.typeFloat3 {
+    port-color:#F6FF9A;
+}
+
+ShaderPort.typeVector3 {
+    /* Same as typeFloat3 */
+    port-color:#F6FF9A;
+}
+
+ShaderPort.typeString {
+    port-color:#FCD76E;
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/EdgeConnectorListener.cs

+using UnityEditor.Experimental.UIElements.GraphView;
+using UnityEditor.Graphing;
+using UnityEngine;
+using Edge = UnityEditor.Experimental.UIElements.GraphView.Edge;
+
+namespace UnityEditor.ShaderGraph.Drawing
+{
+    public class EdgeConnectorListener : IEdgeConnectorListener
+    {
+        readonly AbstractMaterialGraph m_Graph;
+
+        public EdgeConnectorListener(AbstractMaterialGraph graph)
+        {
+            m_Graph = graph;
+        }
+
+        public void OnDropOutsidePort(Edge edge, Vector2 position)
+        {
+        }
+
+        public void OnDrop(GraphView graphView, Edge edge)
+        {
+            var leftSlot = edge.output.userData as ISlot;
+            var rightSlot = edge.input.userData as ISlot;
+            if (leftSlot != null && rightSlot != null)
+            {
+                m_Graph.Connect(leftSlot.slotReference, rightSlot.slotReference);
+            }
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/EdgeConnectorListener.cs.meta

+fileFormatVersion: 2
+guid: 36c61698900b42c9a6b5e28c3651249a
+timeCreated: 1512740035

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/ShaderPort.cs

+using System;
+using UnityEditor.Experimental.UIElements.GraphView;
+using UnityEngine.Experimental.UIElements;
+
+namespace UnityEditor.ShaderGraph.Drawing
+{
+    sealed class ShaderPort : Port
+    {
+        ShaderPort(Orientation portOrientation, Direction portDirection, Type type)
+            : base(portOrientation, portDirection, type) { }
+
+        public static Port Create(Orientation orientation, Direction direction, Type type, IEdgeConnectorListener connectorListener)
+        {
+            var port = new ShaderPort(orientation, direction, type)
+            {
+                m_EdgeConnector = new EdgeConnector<Edge>(connectorListener),
+            };
+            port.AddManipulator(port.m_EdgeConnector);
+            return port;
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/ShaderPort.cs.meta

+fileFormatVersion: 2
+guid: 96f5a3d0303d4d9395a450dcce906110
+timeCreated: 1512739794

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Manipulators/NodeCreator.cs.meta

-fileFormatVersion: 2
-guid: 48d2349cc7ed41d9bf77231b69efbc05
-timeCreated: 1508752297

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Manipulators/NodeCreator.cs

-using System;
-using System.Linq;
-using System.Reflection;
-using UnityEditor.Experimental.UIElements.GraphView;
-using UnityEngine;
-using UnityEngine.Experimental.UIElements;
-using UnityEditor.ShaderGraph;
-
-namespace UnityEditor.ShaderGraph.Drawing
-{
-    public class NodeCreator : MouseManipulator
-    {
-        SearchWindowProvider m_SearchWindowProvider;
-
-        public NodeCreator(SearchWindowProvider searchWindowProvider)
-        {
-            m_SearchWindowProvider = searchWindowProvider;
-            activators.Add(new ManipulatorActivationFilter { button = MouseButton.RightMouse });
-        }
-
-        protected override void RegisterCallbacksOnTarget()
-        {
-            target.RegisterCallback<MouseUpEvent>(OnMouseUp);
-        }
-
-        void OnMouseUp(MouseUpEvent evt)
-        {
-            if (CanStartManipulation(evt))
-            {
-                SearchWindow.Open(new SearchWindowContext(GUIUtility.GUIToScreenPoint(evt.mousePosition)), m_SearchWindowProvider);
-                evt.StopPropagation();
-            }
-        }
-
-        protected override void UnregisterCallbacksFromTarget()
-        {
-            target.UnregisterCallback<MouseUpEvent>(OnMouseUp);
-        }
-    }
-}