Applied pull request suggestions

Grizmu · Grizmu · commit 9d646b7efc82 · 2023-06-14T19:39:33.000+02:00
diff --git a/Assets/Editor Toolbox/Editor/SceneView/ToolboxEditorSceneViewObjectSelector.cs b/Assets/Editor Toolbox/Editor/SceneView/ToolboxEditorSceneViewObjectSelector.cs
@@ -19,40 +19,21 @@ public class ToolboxEditorSceneViewObjectSelector : EditorWindow
         private Vector2 size;
         private Vector2 buttonSize;
         private GUIStyle buttonStyle;
-        private Color selectionColor = new Color(0.50f, 0.70f, 1.00f);
+        private static readonly Color selectionColor = new Color(0.50f, 0.70f, 1.00f);
 
-        private int shiftMinSelectionID = -1;
-        private int shiftMaxSelectionID = -1;
-        private int shiftLastID = -1;
-
-        private GameObject HighlightedObject
-        {
-            set
-            {
-                if (highlightedObject == value)
-                {
-                    return;
-                }
-
-                highlightedObject = value;
-                UnityEditor.SceneView.RepaintAll();
-
-                if (highlightedObject != null)
-                {
-                    EditorGUIUtility.PingObject(highlightedObject);
-                }
-            }
-        }
+        private int shiftMinSelectionId = -1;
+        private int shiftMaxSelectionId = -1;
+        private int shiftLastId = -1;
 
         public static void Show(List<GameObject> gameObjects, Vector2 position)
         {
-            Rect rect = new Rect(position, Vector2.one);
+            var rect = new Rect(position, Vector2.one);
 
-            ToolboxEditorSceneViewObjectSelector window = CreateInstance<ToolboxEditorSceneViewObjectSelector>();
+            var window = CreateInstance<ToolboxEditorSceneViewObjectSelector>();
             window.wantsMouseMove = true;
             window.wantsMouseEnterLeaveWindow = true;
             window.gameObjects = gameObjects;
-            window.InitializeGameobjectPaths();
+            window.InitializeGameObjectPaths();
             window.CalculateSize();
             window.ShowAsDropDown(rect, window.size);
         }
@@ -72,7 +53,7 @@ private Vector2 CalculateSize()
 
             size = Vector2.zero;
 
-            foreach (GameObject go in gameObjects)
+            foreach (var go in gameObjects)
             {
                 GUIContent content = EditorGUIUtility.ObjectContent(go, typeof(GameObject));
                 Vector2 currentSize = buttonStyle.CalcSize(content);
@@ -94,21 +75,21 @@ private Vector2 CalculateSize()
             return size;
         }
 
-        private void InitializeGameobjectPaths()
+        private void InitializeGameObjectPaths()
         {
             gameObjectPaths = new List<string>();
-            Stack<string> pathStack = new Stack<string>();
+            var pathStack = new Stack<string>();
 
             for (int i = 0; i < gameObjects.Count; i++)
             {
                 pathStack.Clear();
-                Transform transf = gameObjects[i].transform;
-                pathStack.Push(transf.gameObject.name);
+                Transform transform = gameObjects[i].transform;
+                pathStack.Push(transform.gameObject.name);
 
-                while (transf.parent != null)
+                while (transform.parent != null)
                 {
-                    transf = transf.parent;
-                    pathStack.Push(transf.gameObject.name);
+                    transform = transform.parent;
+                    pathStack.Push(transform.gameObject.name);
                 }
 
                 string path = string.Join("/", pathStack.ToArray());
@@ -128,37 +109,41 @@ private void OnGUI()
                 return;
             }
 
-            //Debug.Log($"Event : {Event.current.type}");
-
-            if (Event.current.type == EventType.MouseMove)
+            switch (Event.current.type)
             {
-                OnGUI_MouseMove();
-            }
-            else if (Event.current.type == EventType.MouseLeaveWindow)
-            {
-                OnGUI_MouseLeave();
-            }
-            else
-            {
-                OnGUI_Normal();
+                case EventType.MouseMove:
+                {
+                    OnGUIMouseMove();
+                    break;
+                }
+                case EventType.MouseLeaveWindow: 
+                {
+                    OnGUIMouseLeave();
+                    break;
+                }
+                default:
+                {
+                    OnGUINormal();
+                    break;
+                }
             }
         }
 
-        private void OnGUI_Normal()
+        private void OnGUINormal()
         {
             Rect rect = new Rect(sizeXPadding, sizeYPadding, buttonSize.x, buttonSize.y);
 
             for (int i = 0; i < gameObjects.Count; i++)
             {
-                GameObject gameObject = gameObjects[i];
+                var gameObject = gameObjects[i];
 
                 if(gameObject == null)
                 {
                     //Can happen when something removes the gameobject during the window display.
                     continue;
                 }
 
-                GUIContent content = EditorGUIUtility.ObjectContent(gameObject, typeof(GameObject));
+                var content = EditorGUIUtility.ObjectContent(gameObject, typeof(GameObject));
 
                 bool objectSelected = Selection.Contains(gameObject);
 
@@ -178,21 +163,21 @@ private void OnGUI_Normal()
             }
         }
 
-        private void OnGUI_MouseMove()
+        private void OnGUIMouseMove()
         {
-            Rect rect = new Rect(sizeXPadding, sizeYPadding, buttonSize.x, buttonSize.y);
+            var rect = new Rect(sizeXPadding, sizeYPadding, buttonSize.x, buttonSize.y);
 
             for (int i = 0; i < gameObjects.Count; i++)
             {
-                GameObject gameObject = gameObjects[i];
+                var gameObject = gameObjects[i];
 
                 if (gameObject == null)
                 {
                     //Can happen when something removes the gameobject during the window display.
                     continue;
                 }
 
-                GUIContent content = EditorGUIUtility.ObjectContent(gameObject, typeof(GameObject));
+                var content = EditorGUIUtility.ObjectContent(gameObject, typeof(GameObject));
 
                 GUI.Button(rect, content, buttonStyle);
 
@@ -219,53 +204,53 @@ private void GameObjectButtonPress(int id)
 
         private void UpdateShiftSelectionIDs(int id)
         {
-            if(shiftLastID == -1)
+            if(shiftLastId == -1)
             {
-                shiftLastID = id;
+                shiftLastId = id;
             }
 
-            if(shiftMinSelectionID == -1)
+            if(shiftMinSelectionId == -1)
             {
-                shiftMinSelectionID = id;
+                shiftMinSelectionId = id;
             }
 
-            if (shiftMaxSelectionID == -1)
+            if (shiftMaxSelectionId == -1)
             {
-                shiftMaxSelectionID = id;
+                shiftMaxSelectionId = id;
             }
 
-            if(id < shiftMinSelectionID)
+            if(id < shiftMinSelectionId)
             {
-                shiftMinSelectionID = id;
+                shiftMinSelectionId = id;
             }
-            else if(id >= shiftMaxSelectionID)
+            else if(id >= shiftMaxSelectionId)
             {
-                shiftMaxSelectionID = id;
+                shiftMaxSelectionId = id;
             }
-            else if(id > shiftMinSelectionID)
+            else if(id > shiftMinSelectionId)
             {
                 //ID is between min and max.
-                if(shiftLastID < id)
+                if(shiftLastId < id)
                 {
-                    shiftMaxSelectionID = id;
+                    shiftMaxSelectionId = id;
                 }
                 else
                 {
-                    shiftMinSelectionID = id;
+                    shiftMinSelectionId = id;
                 }
             }
 
-            shiftLastID = id;
+            shiftLastId = id;
         }
 
         private void SelectObject(int id, bool control, bool shift)
         {
-            GameObject gameObject = gameObjects[id];
+            var gameObject = gameObjects[id];
 
             if (shift)
             {
                 UpdateShiftSelectionIDs(id);
-                SelectObjects(shiftMinSelectionID, shiftMaxSelectionID);
+                SelectObjects(shiftMinSelectionId, shiftMaxSelectionId);
             }
             else if (control)
             {
@@ -290,8 +275,8 @@ private void SelectObject(int id, bool control, bool shift)
 
         private void SelectObjects(int minID, int maxID)
         {
-            int size = maxID - minID + 1;
-            Object[] newSelection = new Object[size];
+            var size = maxID - minID + 1;
+            var newSelection = new Object[size];
 
             int index = 0;
 
@@ -306,8 +291,8 @@ private void SelectObjects(int minID, int maxID)
 
         private void AddObjectToSelection(GameObject gameObject)
         {
-            Object[] currentSelection = Selection.objects;
-            Object[] newSelection = new Object[currentSelection.Length + 1];
+            var currentSelection = Selection.objects;
+            var newSelection = new Object[currentSelection.Length + 1];
 
             currentSelection.CopyTo(newSelection, 0);
             newSelection[newSelection.Length - 1] = gameObject;
@@ -317,10 +302,10 @@ private void AddObjectToSelection(GameObject gameObject)
 
         private void RemoveObjectFromSelection(GameObject gameObject)
         {
-            Object[] currentSelection = Selection.objects;
-            Object[] newSelection = new Object[currentSelection.Length - 1];
+            var currentSelection = Selection.objects;
+            var newSelection = new Object[currentSelection.Length - 1];
 
-            int index = 0;
+            var index = 0;
 
             for (int i = 0; i < currentSelection.Length; i++)
             {
@@ -336,9 +321,29 @@ private void RemoveObjectFromSelection(GameObject gameObject)
             Selection.objects = newSelection;
         }
 
-        private void OnGUI_MouseLeave()
+        private void OnGUIMouseLeave()
         {
             HighlightedObject = null;
         }
+
+        private GameObject HighlightedObject
+        {
+            set
+            {
+                if (highlightedObject == value)
+                {
+                    return;
+                }
+
+                highlightedObject = value;
+                UnityEditor.SceneView.RepaintAll();
+
+                if (highlightedObject != null)
+                {
+                    EditorGUIUtility.PingObject(highlightedObject);
+                }
+            }
+        }
+
     }
 }
diff --git a/Assets/Editor Toolbox/Editor/ToolboxEditorSceneView.cs b/Assets/Editor Toolbox/Editor/ToolboxEditorSceneView.cs
@@ -38,28 +38,26 @@ private static List<GameObject> GetObjectsUnderCursor()
 
         private static void UpdateEventCallback()
         {
-            if (UseToolboxSceneView && !IsEventAttached)
-            {
-                UnityEditor.SceneView.duringSceneGui += SceneView_DuringSceneGUI;
-                IsEventAttached = true;
-            }
-            else if (!UseToolboxSceneView && IsEventAttached)
+            UnityEditor.SceneView.duringSceneGui -= SceneViewDuringSceneGUI;
+
+            if (UseToolboxSceneView)
             {
-                UnityEditor.SceneView.duringSceneGui -= SceneView_DuringSceneGUI;
-                IsEventAttached = false;
+                UnityEditor.SceneView.duringSceneGui += SceneViewDuringSceneGUI;
             }
         }
 
-        private static void SceneView_DuringSceneGUI(UnityEditor.SceneView sceneView)
+        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)
             {
-                List<GameObject> objectsUnderCursor = GetObjectsUnderCursor();
-                if (objectsUnderCursor.Count > 0)
-                {
-                    ToolboxEditorSceneViewObjectSelector.Show(objectsUnderCursor, Event.current.mousePosition + sceneView.position.position);
-                }
+                return;
+            }
+
+            List<GameObject> objectsUnderCursor = GetObjectsUnderCursor();
+            if (objectsUnderCursor.Count > 0)
+            {
+                ToolboxEditorSceneViewObjectSelector.Show(objectsUnderCursor, Event.current.mousePosition + sceneView.position.position);
             }
         }
 
@@ -79,8 +77,6 @@ internal static void UpdateSettings(IToolboxSceneViewSettings settings)
             UpdateEventCallback();
         }
 
-        private static bool IsEventAttached { get; set; } = false;
-
         /// <summary>
         /// Should the scene view be used.
         /// </summary>
@@ -90,6 +86,5 @@ internal static void UpdateSettings(IToolboxSceneViewSettings settings)
         /// Which key should activate the scene view.
         /// </summary>
         private static KeyCode SelectorKey { get; set; } = KeyCode.LeftControl;
-
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -19,40 +19,21 @@ public class ToolboxEditorSceneViewObjectSelector : EditorWindow`
`19`	`19`	`private Vector2 size;`
`20`	`20`	`private Vector2 buttonSize;`
`21`	`21`	`private GUIStyle buttonStyle;`
`22`		`- private Color selectionColor = new Color(0.50f, 0.70f, 1.00f);`
	`22`	`+ private static readonly Color selectionColor = new Color(0.50f, 0.70f, 1.00f);`
`23`	`23`
`24`		`- private int shiftMinSelectionID = -1;`
`25`		`- private int shiftMaxSelectionID = -1;`
`26`		`- private int shiftLastID = -1;`
`27`		`-`
`28`		`- private GameObject HighlightedObject`
`29`		`- {`
`30`		`- set`
`31`		`- {`
`32`		`- if (highlightedObject == value)`
`33`		`- {`
`34`		`- return;`
`35`		`- }`
`36`		`-`
`37`		`- highlightedObject = value;`
`38`		`- UnityEditor.SceneView.RepaintAll();`
`39`		`-`
`40`		`- if (highlightedObject != null)`
`41`		`- {`
`42`		`- EditorGUIUtility.PingObject(highlightedObject);`
`43`		`- }`
`44`		`- }`
`45`		`- }`
	`24`	`+ private int shiftMinSelectionId = -1;`
	`25`	`+ private int shiftMaxSelectionId = -1;`
	`26`	`+ private int shiftLastId = -1;`
`46`	`27`
`47`	`28`	`public static void Show(List<GameObject> gameObjects, Vector2 position)`
`48`	`29`	`{`
`49`		`- Rect rect = new Rect(position, Vector2.one);`
	`30`	`+ var rect = new Rect(position, Vector2.one);`
`50`	`31`
`51`		`- ToolboxEditorSceneViewObjectSelector window = CreateInstance<ToolboxEditorSceneViewObjectSelector>();`
	`32`	`+ var window = CreateInstance<ToolboxEditorSceneViewObjectSelector>();`
`52`	`33`	`window.wantsMouseMove = true;`
`53`	`34`	`window.wantsMouseEnterLeaveWindow = true;`
`54`	`35`	`window.gameObjects = gameObjects;`
`55`		`- window.InitializeGameobjectPaths();`
	`36`	`+ window.InitializeGameObjectPaths();`
`56`	`37`	`window.CalculateSize();`
`57`	`38`	`window.ShowAsDropDown(rect, window.size);`
`58`	`39`	`}`
`@@ -72,7 +53,7 @@ private Vector2 CalculateSize()`
`72`	`53`
`73`	`54`	`size = Vector2.zero;`
`74`	`55`
`75`		`- foreach (GameObject go in gameObjects)`
	`56`	`+ foreach (var go in gameObjects)`
`76`	`57`	`{`
`77`	`58`	`GUIContent content = EditorGUIUtility.ObjectContent(go, typeof(GameObject));`
`78`	`59`	`Vector2 currentSize = buttonStyle.CalcSize(content);`
`@@ -94,21 +75,21 @@ private Vector2 CalculateSize()`
`94`	`75`	`return size;`
`95`	`76`	`}`
`96`	`77`
`97`		`- private void InitializeGameobjectPaths()`
	`78`	`+ private void InitializeGameObjectPaths()`
`98`	`79`	`{`
`99`	`80`	`gameObjectPaths = new List<string>();`
`100`		`- Stack<string> pathStack = new Stack<string>();`
	`81`	`+ var pathStack = new Stack<string>();`
`101`	`82`
`102`	`83`	`for (int i = 0; i < gameObjects.Count; i++)`
`103`	`84`	`{`
`104`	`85`	`pathStack.Clear();`
`105`		`- Transform transf = gameObjects[i].transform;`
`106`		`- pathStack.Push(transf.gameObject.name);`
	`86`	`+ Transform transform = gameObjects[i].transform;`
	`87`	`+ pathStack.Push(transform.gameObject.name);`
`107`	`88`
`108`		`- while (transf.parent != null)`
	`89`	`+ while (transform.parent != null)`
`109`	`90`	`{`
`110`		`- transf = transf.parent;`
`111`		`- pathStack.Push(transf.gameObject.name);`
	`91`	`+ transform = transform.parent;`
	`92`	`+ pathStack.Push(transform.gameObject.name);`
`112`	`93`	`}`
`113`	`94`
`114`	`95`	`string path = string.Join("/", pathStack.ToArray());`
`@@ -128,37 +109,41 @@ private void OnGUI()`
`128`	`109`	`return;`
`129`	`110`	`}`
`130`	`111`
`131`		`- //Debug.Log($"Event : {Event.current.type}");`
`132`		`-`
`133`		`- if (Event.current.type == EventType.MouseMove)`
	`112`	`+ switch (Event.current.type)`
`134`	`113`	`{`
`135`		`- OnGUI_MouseMove();`
`136`		`- }`
`137`		`- else if (Event.current.type == EventType.MouseLeaveWindow)`
`138`		`- {`
`139`		`- OnGUI_MouseLeave();`
`140`		`- }`
`141`		`- else`
`142`		`- {`
`143`		`- OnGUI_Normal();`
	`114`	`+ case EventType.MouseMove:`
	`115`	`+ {`
	`116`	`+ OnGUIMouseMove();`
	`117`	`+ break;`
	`118`	`+ }`
	`119`	`+ case EventType.MouseLeaveWindow:`
	`120`	`+ {`
	`121`	`+ OnGUIMouseLeave();`
	`122`	`+ break;`
	`123`	`+ }`
	`124`	`+ default:`
	`125`	`+ {`
	`126`	`+ OnGUINormal();`
	`127`	`+ break;`
	`128`	`+ }`
`144`	`129`	`}`
`145`	`130`	`}`
`146`	`131`
`147`		`- private void OnGUI_Normal()`
	`132`	`+ private void OnGUINormal()`
`148`	`133`	`{`
`149`	`134`	`Rect rect = new Rect(sizeXPadding, sizeYPadding, buttonSize.x, buttonSize.y);`
`150`	`135`
`151`	`136`	`for (int i = 0; i < gameObjects.Count; i++)`
`152`	`137`	`{`
`153`		`- GameObject gameObject = gameObjects[i];`
	`138`	`+ var gameObject = gameObjects[i];`
`154`	`139`
`155`	`140`	`if(gameObject == null)`
`156`	`141`	`{`
`157`	`142`	`//Can happen when something removes the gameobject during the window display.`
`158`	`143`	`continue;`
`159`	`144`	`}`
`160`	`145`
`161`		`- GUIContent content = EditorGUIUtility.ObjectContent(gameObject, typeof(GameObject));`
	`146`	`+ var content = EditorGUIUtility.ObjectContent(gameObject, typeof(GameObject));`
`162`	`147`
`163`	`148`	`bool objectSelected = Selection.Contains(gameObject);`
`164`	`149`
`@@ -178,21 +163,21 @@ private void OnGUI_Normal()`
`178`	`163`	`}`
`179`	`164`	`}`
`180`	`165`
`181`		`- private void OnGUI_MouseMove()`
	`166`	`+ private void OnGUIMouseMove()`
`182`	`167`	`{`
`183`		`- Rect rect = new Rect(sizeXPadding, sizeYPadding, buttonSize.x, buttonSize.y);`
	`168`	`+ var rect = new Rect(sizeXPadding, sizeYPadding, buttonSize.x, buttonSize.y);`
`184`	`169`
`185`	`170`	`for (int i = 0; i < gameObjects.Count; i++)`
`186`	`171`	`{`
`187`		`- GameObject gameObject = gameObjects[i];`
	`172`	`+ var gameObject = gameObjects[i];`
`188`	`173`
`189`	`174`	`if (gameObject == null)`
`190`	`175`	`{`
`191`	`176`	`//Can happen when something removes the gameobject during the window display.`
`192`	`177`	`continue;`
`193`	`178`	`}`
`194`	`179`
`195`		`- GUIContent content = EditorGUIUtility.ObjectContent(gameObject, typeof(GameObject));`
	`180`	`+ var content = EditorGUIUtility.ObjectContent(gameObject, typeof(GameObject));`
`196`	`181`
`197`	`182`	`GUI.Button(rect, content, buttonStyle);`
`198`	`183`
`@@ -219,53 +204,53 @@ private void GameObjectButtonPress(int id)`
`219`	`204`
`220`	`205`	`private void UpdateShiftSelectionIDs(int id)`
`221`	`206`	`{`
`222`		`- if(shiftLastID == -1)`
	`207`	`+ if(shiftLastId == -1)`
`223`	`208`	`{`
`224`		`- shiftLastID = id;`
	`209`	`+ shiftLastId = id;`
`225`	`210`	`}`
`226`	`211`
`227`		`- if(shiftMinSelectionID == -1)`
	`212`	`+ if(shiftMinSelectionId == -1)`
`228`	`213`	`{`
`229`		`- shiftMinSelectionID = id;`
	`214`	`+ shiftMinSelectionId = id;`
`230`	`215`	`}`
`231`	`216`
`232`		`- if (shiftMaxSelectionID == -1)`
	`217`	`+ if (shiftMaxSelectionId == -1)`
`233`	`218`	`{`
`234`		`- shiftMaxSelectionID = id;`
	`219`	`+ shiftMaxSelectionId = id;`
`235`	`220`	`}`
`236`	`221`
`237`		`- if(id < shiftMinSelectionID)`
	`222`	`+ if(id < shiftMinSelectionId)`
`238`	`223`	`{`
`239`		`- shiftMinSelectionID = id;`
	`224`	`+ shiftMinSelectionId = id;`
`240`	`225`	`}`
`241`		`- else if(id >= shiftMaxSelectionID)`
	`226`	`+ else if(id >= shiftMaxSelectionId)`
`242`	`227`	`{`
`243`		`- shiftMaxSelectionID = id;`
	`228`	`+ shiftMaxSelectionId = id;`
`244`	`229`	`}`
`245`		`- else if(id > shiftMinSelectionID)`
	`230`	`+ else if(id > shiftMinSelectionId)`
`246`	`231`	`{`
`247`	`232`	`//ID is between min and max.`
`248`		`- if(shiftLastID < id)`
	`233`	`+ if(shiftLastId < id)`
`249`	`234`	`{`
`250`		`- shiftMaxSelectionID = id;`
	`235`	`+ shiftMaxSelectionId = id;`
`251`	`236`	`}`
`252`	`237`	`else`
`253`	`238`	`{`
`254`		`- shiftMinSelectionID = id;`
	`239`	`+ shiftMinSelectionId = id;`
`255`	`240`	`}`
`256`	`241`	`}`
`257`	`242`
`258`		`- shiftLastID = id;`
	`243`	`+ shiftLastId = id;`
`259`	`244`	`}`
`260`	`245`
`261`	`246`	`private void SelectObject(int id, bool control, bool shift)`
`262`	`247`	`{`
`263`		`- GameObject gameObject = gameObjects[id];`
	`248`	`+ var gameObject = gameObjects[id];`
`264`	`249`
`265`	`250`	`if (shift)`
`266`	`251`	`{`
`267`	`252`	`UpdateShiftSelectionIDs(id);`
`268`		`- SelectObjects(shiftMinSelectionID, shiftMaxSelectionID);`
	`253`	`+ SelectObjects(shiftMinSelectionId, shiftMaxSelectionId);`
`269`	`254`	`}`
`270`	`255`	`else if (control)`
`271`	`256`	`{`
`@@ -290,8 +275,8 @@ private void SelectObject(int id, bool control, bool shift)`
`290`	`275`
`291`	`276`	`private void SelectObjects(int minID, int maxID)`
`292`	`277`	`{`
`293`		`- int size = maxID - minID + 1;`
`294`		`- Object[] newSelection = new Object[size];`
	`278`	`+ var size = maxID - minID + 1;`
	`279`	`+ var newSelection = new Object[size];`
`295`	`280`
`296`	`281`	`int index = 0;`
`297`	`282`
`@@ -306,8 +291,8 @@ private void SelectObjects(int minID, int maxID)`
`306`	`291`
`307`	`292`	`private void AddObjectToSelection(GameObject gameObject)`
`308`	`293`	`{`
`309`		`- Object[] currentSelection = Selection.objects;`
`310`		`- Object[] newSelection = new Object[currentSelection.Length + 1];`
	`294`	`+ var currentSelection = Selection.objects;`
	`295`	`+ var newSelection = new Object[currentSelection.Length + 1];`
`311`	`296`
`312`	`297`	`currentSelection.CopyTo(newSelection, 0);`
`313`	`298`	`newSelection[newSelection.Length - 1] = gameObject;`
`@@ -317,10 +302,10 @@ private void AddObjectToSelection(GameObject gameObject)`
`317`	`302`
`318`	`303`	`private void RemoveObjectFromSelection(GameObject gameObject)`
`319`	`304`	`{`
`320`		`- Object[] currentSelection = Selection.objects;`
`321`		`- Object[] newSelection = new Object[currentSelection.Length - 1];`
	`305`	`+ var currentSelection = Selection.objects;`
	`306`	`+ var newSelection = new Object[currentSelection.Length - 1];`
`322`	`307`
`323`		`- int index = 0;`
	`308`	`+ var index = 0;`
`324`	`309`
`325`	`310`	`for (int i = 0; i < currentSelection.Length; i++)`
`326`	`311`	`{`
`@@ -336,9 +321,29 @@ private void RemoveObjectFromSelection(GameObject gameObject)`
`336`	`321`	`Selection.objects = newSelection;`
`337`	`322`	`}`
`338`	`323`
`339`		`- private void OnGUI_MouseLeave()`
	`324`	`+ private void OnGUIMouseLeave()`
`340`	`325`	`{`
`341`	`326`	`HighlightedObject = null;`
`342`	`327`	`}`
	`328`	`+`
	`329`	`+ private GameObject HighlightedObject`
	`330`	`+ {`
	`331`	`+ set`
	`332`	`+ {`
	`333`	`+ if (highlightedObject == value)`
	`334`	`+ {`
	`335`	`+ return;`
	`336`	`+ }`
	`337`	`+`
	`338`	`+ highlightedObject = value;`
	`339`	`+ UnityEditor.SceneView.RepaintAll();`
	`340`	`+`
	`341`	`+ if (highlightedObject != null)`
	`342`	`+ {`
	`343`	`+ EditorGUIUtility.PingObject(highlightedObject);`
	`344`	`+ }`
	`345`	`+ }`
	`346`	`+ }`
	`347`	`+`
`343`	`348`	`}`
`344`	`349`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,28 +38,26 @@ private static List<GameObject> GetObjectsUnderCursor()`
`38`	`38`
`39`	`39`	`private static void UpdateEventCallback()`
`40`	`40`	`{`
`41`		`- if (UseToolboxSceneView && !IsEventAttached)`
`42`		`- {`
`43`		`- UnityEditor.SceneView.duringSceneGui += SceneView_DuringSceneGUI;`
`44`		`- IsEventAttached = true;`
`45`		`- }`
`46`		`- else if (!UseToolboxSceneView && IsEventAttached)`
	`41`	`+ UnityEditor.SceneView.duringSceneGui -= SceneViewDuringSceneGUI;`
	`42`	`+`
	`43`	`+ if (UseToolboxSceneView)`
`47`	`44`	`{`
`48`		`- UnityEditor.SceneView.duringSceneGui -= SceneView_DuringSceneGUI;`
`49`		`- IsEventAttached = false;`
	`45`	`+ UnityEditor.SceneView.duringSceneGui += SceneViewDuringSceneGUI;`
`50`	`46`	`}`
`51`	`47`	`}`
`52`	`48`
`53`		`- private static void SceneView_DuringSceneGUI(UnityEditor.SceneView sceneView)`
	`49`	`+ private static void SceneViewDuringSceneGUI(UnityEditor.SceneView sceneView)`
`54`	`50`	`{`
`55`		`- if (Event.current.type == EventType.KeyDown`
`56`		`- && Event.current.keyCode == SelectorKey)`
	`51`	`+ if (Event.current.type != EventType.KeyDown`
	`52`	`+ \|\| Event.current.keyCode != SelectorKey)`
`57`	`53`	`{`
`58`		`- List<GameObject> objectsUnderCursor = GetObjectsUnderCursor();`
`59`		`- if (objectsUnderCursor.Count > 0)`
`60`		`- {`
`61`		`- ToolboxEditorSceneViewObjectSelector.Show(objectsUnderCursor, Event.current.mousePosition + sceneView.position.position);`
`62`		`- }`
	`54`	`+ return;`
	`55`	`+ }`
	`56`	`+`
	`57`	`+ List<GameObject> objectsUnderCursor = GetObjectsUnderCursor();`
	`58`	`+ if (objectsUnderCursor.Count > 0)`
	`59`	`+ {`
	`60`	`+ ToolboxEditorSceneViewObjectSelector.Show(objectsUnderCursor, Event.current.mousePosition + sceneView.position.position);`
`63`	`61`	`}`
`64`	`62`	`}`
`65`	`63`
`@@ -79,8 +77,6 @@ internal static void UpdateSettings(IToolboxSceneViewSettings settings)`
`79`	`77`	`UpdateEventCallback();`
`80`	`78`	`}`
`81`	`79`
`82`		`- private static bool IsEventAttached { get; set; } = false;`
`83`		`-`
`84`	`80`	`/// <summary>`
`85`	`81`	`/// Should the scene view be used.`
`86`	`82`	`/// </summary>`
`@@ -90,6 +86,5 @@ internal static void UpdateSettings(IToolboxSceneViewSettings settings)`
`90`	`86`	`/// Which key should activate the scene view.`
`91`	`87`	`/// </summary>`
`92`	`88`	`private static KeyCode SelectorKey { get; set; } = KeyCode.LeftControl;`
`93`		`-`
`94`	`89`	`}`
`95`	`90`	`}`