Minor refactor changes

Author: arimger

Assets/Editor Toolbox/Editor/SceneView/ToolboxEditorSceneViewObjectSelector.cs

@@ -6,19 +6,20 @@ namespace Toolbox.Editor.SceneView
 {
     public class ToolboxEditorSceneViewObjectSelector : EditorWindow
     {
-        private List<GameObject> gameObjects;
-        private List<string> gameObjectPaths;
+        private static readonly Color selectionColor = new Color(0.50f, 0.70f, 1.00f);
 
         private const float sizeXPadding = 2f;
         private const float sizeYPadding = 2f;
         private const float buttonYSpacing = 0.0f;
         private const float buttonYSize = 20f;
         private const float sizeXOffset = -30f;
 
+        private List<GameObject> gameObjects;
+        private List<string> gameObjectPaths;
+
         private GameObject highlightedObject;
         private Vector2 size;
         private Vector2 buttonSize;
-        private static readonly Color selectionColor = new Color(0.50f, 0.70f, 1.00f);
 
         private int shiftMinSelectionId = -1;
         private int shiftMaxSelectionId = -1;
@@ -37,54 +38,6 @@ public static void Show(List<GameObject> gameObjects, Vector2 position)
             window.ShowAsDropDown(rect, window.size);
         }
 
-        private Vector2 CalculateSize()
-        {
-            size = Vector2.zero;
-
-            foreach (var go in gameObjects)
-            {
-                GUIContent content = EditorGUIUtility.ObjectContent(go, typeof(GameObject));
-                Vector2 currentSize = Style.buttonStyle.CalcSize(content);
-                if (currentSize.x > size.x)
-                {
-                    size.x = currentSize.x;
-                }
-            }
-
-            //This is needed because CalcSize calculates content drawing with icon at full size.
-            size.x += sizeXOffset;
-
-            buttonSize.x = size.x;
-            buttonSize.y = buttonYSize;
-
-            size.y = gameObjects.Count * buttonYSize + sizeYPadding * 2.0f + buttonYSpacing * gameObjects.Count - 1;
-            size.x += sizeXPadding * 2.0f;
-
-            return size;
-        }
-
-        private void InitializeGameObjectPaths()
-        {
-            gameObjectPaths = new List<string>();
-            var pathStack = new Stack<string>();
-
-            for (int i = 0; i < gameObjects.Count; i++)
-            {
-                pathStack.Clear();
-                Transform transform = gameObjects[i].transform;
-                pathStack.Push(transform.gameObject.name);
-
-                while (transform.parent != null)
-                {
-                    transform = transform.parent;
-                    pathStack.Push(transform.gameObject.name);
-                }
-
-                string path = string.Join("/", pathStack.ToArray());
-                gameObjectPaths.Add(path);
-            }
-        }
-
         private void OnGUI()
         {
             if (Event.current.type == EventType.Layout)
@@ -95,41 +48,59 @@ private void OnGUI()
             switch (Event.current.type)
             {
                 case EventType.MouseMove:
-                {
-                    OnGUIMouseMove();
+                    OnGuiMouseMove();
                     break;
-                }
-                case EventType.MouseLeaveWindow: 
-                {
-                    OnGUIMouseLeave();
+                case EventType.MouseLeaveWindow:
+                    OnGuiMouseLeave();
                     break;
-                }
                 default:
-                {
-                    OnGUINormal();
+                    OnGuiNormal();
                     break;
-                }
             }
         }
 
-        private void OnGUINormal()
+        private void OnGuiMouseLeave()
         {
-            Rect rect = new Rect(sizeXPadding, sizeYPadding, buttonSize.x, buttonSize.y);
+            HighlightedObject = null;
+        }
 
-            for (int i = 0; i < gameObjects.Count; i++)
+        private void OnGuiMouseMove()
+        {
+            var rect = new Rect(sizeXPadding, sizeYPadding, buttonSize.x, buttonSize.y);
+            for (var i = 0; i < gameObjects.Count; i++)
             {
                 var gameObject = gameObjects[i];
-
-                if(gameObject == null)
+                if (gameObject == null)
                 {
                     //Can happen when something removes the gameobject during the window display.
                     continue;
                 }
 
                 var content = EditorGUIUtility.ObjectContent(gameObject, typeof(GameObject));
+                GUI.Button(rect, content, Style.buttonStyle);
+                if (rect.Contains(Event.current.mousePosition))
+                {
+                    HighlightedObject = gameObject;
+                }
 
-                bool objectSelected = Selection.Contains(gameObject);
+                rect.y += buttonYSize + buttonYSpacing;
+            }
+        }
 
+        private void OnGuiNormal()
+        {
+            var rect = new Rect(sizeXPadding, sizeYPadding, buttonSize.x, buttonSize.y);
+            for (var i = 0; i < gameObjects.Count; i++)
+            {
+                var gameObject = gameObjects[i];
+                if (gameObject == null)
+                {
+                    //Can happen when something removes the gameobject during the window display.
+                    continue;
+                }
+
+                var content = EditorGUIUtility.ObjectContent(gameObject, typeof(GameObject));
+                var objectSelected = Selection.Contains(gameObject);
                 if (objectSelected)
                 {
                     GUI.backgroundColor = selectionColor;
@@ -141,42 +112,61 @@ private void OnGUINormal()
                 }
 
                 GUI.backgroundColor = Color.white;
-
                 rect.y += buttonYSize + buttonYSpacing;
             }
         }
 
-        private void OnGUIMouseMove()
+        private Vector2 CalculateSize()
         {
-            var rect = new Rect(sizeXPadding, sizeYPadding, buttonSize.x, buttonSize.y);
+            size = Vector2.zero;
 
-            for (int i = 0; i < gameObjects.Count; i++)
+            foreach (var go in gameObjects)
             {
-                var gameObject = gameObjects[i];
-
-                if (gameObject == null)
+                var content = EditorGUIUtility.ObjectContent(go, typeof(GameObject));
+                var currentSize = Style.buttonStyle.CalcSize(content);
+                if (currentSize.x > size.x)
                 {
-                    //Can happen when something removes the gameobject during the window display.
-                    continue;
+                    size.x = currentSize.x;
                 }
+            }
 
-                var content = EditorGUIUtility.ObjectContent(gameObject, typeof(GameObject));
+            //This is needed because CalcSize calculates content drawing with icon at full size.
+            size.x += sizeXOffset;
 
-                GUI.Button(rect, content, Style.buttonStyle);
+            buttonSize.x = size.x;
+            buttonSize.y = buttonYSize;
 
-                if (rect.Contains(Event.current.mousePosition))
+            size.y = gameObjects.Count * buttonYSize + sizeYPadding * 2.0f + buttonYSpacing * gameObjects.Count - 1;
+            size.x += sizeXPadding * 2.0f;
+
+            return size;
+        }
+
+        private void InitializeGameObjectPaths()
+        {
+            gameObjectPaths = new List<string>();
+            var pathStack = new Stack<string>();
+
+            for (var i = 0; i < gameObjects.Count; i++)
+            {
+                pathStack.Clear();
+                var transform = gameObjects[i].transform;
+                pathStack.Push(transform.gameObject.name);
+
+                while (transform.parent != null)
                 {
-                    HighlightedObject = gameObject;
+                    transform = transform.parent;
+                    pathStack.Push(transform.gameObject.name);
                 }
 
-                rect.y += buttonYSize + buttonYSpacing;
+                var path = string.Join("/", pathStack.ToArray());
+                gameObjectPaths.Add(path);
             }
         }
 
         private void GameObjectButtonPress(int id)
         {
             SelectObject(id, Event.current.control, Event.current.shift);
-
             if (Event.current.control || Event.current.shift)
             {
                 return;
@@ -187,12 +177,12 @@ private void GameObjectButtonPress(int id)
 
         private void UpdateShiftSelectionIDs(int id)
         {
-            if(shiftLastId == -1)
+            if (shiftLastId == -1)
             {
                 shiftLastId = id;
             }
 
-            if(shiftMinSelectionId == -1)
+            if (shiftMinSelectionId == -1)
             {
                 shiftMinSelectionId = id;
             }
@@ -202,18 +192,18 @@ private void UpdateShiftSelectionIDs(int id)
                 shiftMaxSelectionId = id;
             }
 
-            if(id < shiftMinSelectionId)
+            if (id < shiftMinSelectionId)
             {
                 shiftMinSelectionId = id;
             }
-            else if(id >= shiftMaxSelectionId)
+            else if (id >= shiftMaxSelectionId)
             {
                 shiftMaxSelectionId = id;
             }
-            else if(id > shiftMinSelectionId)
+            else if (id > shiftMinSelectionId)
             {
                 //ID is between min and max.
-                if(shiftLastId < id)
+                if (shiftLastId < id)
                 {
                     shiftMaxSelectionId = id;
                 }
@@ -238,16 +228,13 @@ private void SelectObject(int id, bool control, bool shift)
             else if (control)
             {
                 UpdateShiftSelectionIDs(id);
-
                 if (Selection.Contains(gameObject))
                 {
-                    //Deselect
-                    RemoveObjectFromSelection(gameObject);
+                    RemoveSelectedObject(gameObject);
                 }
                 else
                 {
-                    //Select
-                    AddObjectToSelection(gameObject);
+                    AppendSelectedObject(gameObject);
                 }
             }
             else
@@ -256,14 +243,14 @@ private void SelectObject(int id, bool control, bool shift)
             }
         }
 
-        private void SelectObjects(int minID, int maxID)
+        private void SelectObjects(int minId, int maxId)
         {
-            var size = maxID - minID + 1;
+            var size = maxId - minId + 1;
             var newSelection = new Object[size];
 
-            int index = 0;
+            var index = 0;
 
-            for (int i = minID; i <= maxID; i++)
+            for (var i = minId; i <= maxId; i++)
             {
                 newSelection[index] = gameObjects[i];
                 index++;
@@ -272,7 +259,7 @@ private void SelectObjects(int minID, int maxID)
             Selection.objects = newSelection;
         }
 
-        private void AddObjectToSelection(GameObject gameObject)
+        private void AppendSelectedObject(GameObject gameObject)
         {
             var currentSelection = Selection.objects;
             var newSelection = new Object[currentSelection.Length + 1];
@@ -283,14 +270,14 @@ private void AddObjectToSelection(GameObject gameObject)
             Selection.objects = newSelection;
         }
 
-        private void RemoveObjectFromSelection(GameObject gameObject)
+        private void RemoveSelectedObject(GameObject gameObject)
         {
             var currentSelection = Selection.objects;
             var newSelection = new Object[currentSelection.Length - 1];
 
             var index = 0;
 
-            for (int i = 0; i < currentSelection.Length; i++)
+            for (var i = 0; i < currentSelection.Length; i++)
             {
                 if (currentSelection[i] == gameObject)
                 {
@@ -304,11 +291,6 @@ private void RemoveObjectFromSelection(GameObject gameObject)
             Selection.objects = newSelection;
         }
 
-        private void OnGUIMouseLeave()
-        {
-            HighlightedObject = null;
-        }
-
         private GameObject HighlightedObject
         {
             set
@@ -334,8 +316,10 @@ private static class Style
 
             static Style()
             {
-                buttonStyle = new GUIStyle(GUI.skin.button);
-                buttonStyle.alignment = TextAnchor.MiddleLeft;
+                buttonStyle = new GUIStyle(GUI.skin.button)
+                {
+                    alignment = TextAnchor.MiddleLeft
+                };
             }
         }
     }

Assets/Editor Toolbox/Editor/ToolboxEditorSceneView.cs

@@ -16,15 +16,16 @@ static ToolboxEditorSceneView()
 
         private static List<GameObject> GetObjectsUnderCursor()
         {
-            List<GameObject> hitObjects = new List<GameObject>();
-            GameObject[] hitObjectsArray;
+            const int maxIterations = 50;
 
-            int maxIterations = 50;
-            for (int i = 0; i < maxIterations; i++)
+            var mousePosition = Event.current.mousePosition;
+            var hitObjects = new List<GameObject>();
+            GameObject[] hitObjectsArray;
+            for (var i = 0; i < maxIterations; i++)
             {
                 hitObjectsArray = hitObjects.ToArray();
 
-                GameObject go = HandleUtility.PickGameObject(Event.current.mousePosition, true, hitObjectsArray);
+                var go = HandleUtility.PickGameObject(mousePosition, true, hitObjectsArray);
                 if (go == null)
                 {
                     break;
@@ -48,13 +49,13 @@ private static void UpdateEventCallback()
 
         private static void SceneViewDuringSceneGUI(UnityEditor.SceneView sceneView)
         {
-            if (Event.current.type != EventType.KeyDown
-                || Event.current.keyCode != SelectorKey)
+            if (Event.current.type != EventType.KeyDown ||
+                Event.current.keyCode != SelectorKey)
             {
                 return;
             }
 
-            List<GameObject> objectsUnderCursor = GetObjectsUnderCursor();
+            var objectsUnderCursor = GetObjectsUnderCursor();
             if (objectsUnderCursor.Count > 0)
             {
                 ToolboxEditorSceneViewObjectSelector.Show(objectsUnderCursor, Event.current.mousePosition + sceneView.position.position);