Added support for reordering properties in blackboard

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/AbstractMaterialGraph.cs

             get { return m_RemovedProperties; }
         }
 
+        [NonSerialized]
+        List<IShaderProperty> m_MovedProperties = new List<IShaderProperty>();
+
+        public IEnumerable<IShaderProperty> movedProperties
+        {
+            get { return m_MovedProperties; }
+        }
+
         [SerializeField]
         SerializableGuid m_GUID = new SerializableGuid();
 
             m_RemovedEdges.Clear();
             m_AddedProperties.Clear();
             m_RemovedProperties.Clear();
+            m_MovedProperties.Clear();
         }
 
         public virtual void AddNode(INode node)
             ValidateGraph();
         }
 
+        public void MoveShaderProperty(IShaderProperty property, int newIndex)
+        {
+            if (newIndex > m_Properties.Count || newIndex < 0)
+                throw new ArgumentException("New index is not within properties list.");
+            var currentIndex = m_Properties.IndexOf(property);
+            if (currentIndex == -1)
+                throw new ArgumentException("Property is not in graph.");
+            if (newIndex == currentIndex)
+                return;
+            m_Properties.RemoveAt(currentIndex);
+            if (newIndex > currentIndex)
+                newIndex--;
+            var isLast = newIndex == m_Properties.Count;
+            if (isLast)
+                m_Properties.Add(property);
+            else
+                m_Properties.Insert(newIndex, property);
+            if (!m_MovedProperties.Contains(property))
+                m_MovedProperties.Add(property);
+        }
+
+        public int GetShaderPropertyIndex(IShaderProperty property)
+        {
+            return m_Properties.IndexOf(property);
+        }
+
+            {
+                m_AddedProperties.RemoveAll(x => x.guid == guid);
+                m_MovedProperties.RemoveAll(x => x.guid == guid);
+            }
         }
 
         static List<IEdge> s_TempEdges = new List<IEdge>();

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Blackboard/BlackboardField.cs

 using UnityEditor.Experimental.UIElements.GraphView;
 using UnityEngine;
 using UnityEngine.Experimental.UIElements;
-using Debug = System.Diagnostics.Debug;
 
 namespace UnityEditor.ShaderGraph.Drawing
 {
 
         void Handler(IMGUIEvent evt, List<ISelectable> selection, IDropTarget dropTarget)
         {
+            if (dropTarget == null)
+                return;
+
+            var propagation = EventPropagation.Continue;
+            if (evt.imguiEvent.type == EventType.DragUpdated)
+                propagation = dropTarget.DragUpdated(evt, selection, dropTarget);
+            else if (evt.imguiEvent.type == EventType.DragPerform)
+                propagation = dropTarget.DragPerform(evt, selection, dropTarget);
+            else if (evt.imguiEvent.type == EventType.DragExited)
+                propagation = dropTarget.DragExited();
+
+            if (propagation == EventPropagation.Stop)
+                evt.StopPropagation();
         }
 
         private void OnTextFieldKeyPressed(KeyDownEvent e)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Blackboard/BlackboardProvider.cs

 using System;
 using System.Collections.Generic;
+using System.Linq;
 using UnityEditor.Graphing;
 using UnityEngine;
 using UnityEngine.Experimental.UIElements;
             blackboard.Add(m_Section);
         }
 
-        void MoveItemRequested(Blackboard blackboard, int i, VisualElement visualElement)
+        void MoveItemRequested(Blackboard blackboard, int newIndex, VisualElement visualElement)
-            Debug.Log(i);
+            var property = visualElement.userData as IShaderProperty;
+            if (property == null)
+                return;
+            m_Graph.MoveShaderProperty(property, newIndex);
         }
 
         void AddItemRequested(Blackboard blackboard)
             }
 
             foreach (var property in m_Graph.addedProperties)
-                AddProperty(property);
+                AddProperty(property, index: m_Graph.GetShaderPropertyIndex(property));
+
+            if (m_Graph.movedProperties.Any())
+            {
+                foreach (var row in m_PropertyRows.Values)
+                    row.RemoveFromHierarchy();
+
+                foreach (var property in m_Graph.properties)
+                    m_Section.Add(m_PropertyRows[property.guid]);
+            }
-        void AddProperty(IShaderProperty property, bool create = false)
+        void AddProperty(IShaderProperty property, bool create = false, int index = -1)
-                throw new ArgumentException("Property already exists");
+                return;
-            m_Section.Add(row);
+            row.userData = property;
+            if (index < 0)
+                index = m_PropertyRows.Count;
+            if (index == m_PropertyRows.Count)
+                m_Section.Add(row);
+            else
+                m_Section.Insert(index, row);
             m_PropertyRows[property.guid] = row;
 
             if (create)
+                m_Graph.AddShaderProperty(property);
             }
         }