Ejemplo n.º 1
0
        static void ToggleInspectorDebug()
        {
            EditorWindow targetInspector = EditorWindow.mouseOverWindow; // "EditorWindow.focusedWindow" can be used instead

            if (targetInspector != null && targetInspector.GetType().Name == "InspectorWindow")
            {
                //Get the type of the inspector window to find out the variable/method from
                Type type = Assembly.GetAssembly(typeof(UnityEditor.Editor)).GetType("UnityEditor.InspectorWindow");
                //get the field we want to read, for the type (not our instance)
                FieldInfo field = type.GetField("m_InspectorMode", BindingFlags.NonPublic | BindingFlags.Instance);

                //read the value for our target inspector
                InspectorMode mode = (InspectorMode)field.GetValue(targetInspector);
                //toggle the value
                mode = (mode == InspectorMode.Normal ? InspectorMode.Debug : InspectorMode.Normal);
                //Debug.Log("New Inspector Mode: " + mode.ToString());

                //Find the method to change the mode for the type
                MethodInfo method = type.GetMethod("SetMode", BindingFlags.NonPublic | BindingFlags.Instance);
                //Call the function on our targetInspector, with the new mode as an object[]
                method.Invoke(targetInspector, new object[] { mode });

                //refresh inspector
                targetInspector.Repaint();
            }
        }
Ejemplo n.º 2
0
        public void SetMode(InspectorMode mode)
        {
            if (this.inspectorMode == mode)
            {
                return;
            }
            SkillEditor.DoDirtyFsmPrefab();
            EditorPrefs.SetInt(EditorPrefStrings.get_InspectorMode(), (int)mode);
            Keyboard.ResetFocus();
            this.inspectorMode = mode;
            this.ResetView();
            InspectorMode inspectorMode = this.inspectorMode;

            if (inspectorMode != InspectorMode.FsmInspector)
            {
                if (inspectorMode == InspectorMode.Watermarks)
                {
                    WatermarkSelector.Init();
                }
            }
            else
            {
                FsmInspector.Init();
            }
            SkillEditor.Repaint(true);
        }
Ejemplo n.º 3
0
 public Inspector(ref T t, InspectorMode mode = InspectorMode.All)
 {
     _mode     = mode;
     Metadata  = new MetadataInfo(ref t);
     Addresses = new AddressInfo(ref t);
     Sizes     = new SizeInfo();
 }
Ejemplo n.º 4
0
        /// <summary>
        /// Scripted importer editor UI callback
        /// </summary>
        public override void OnInspectorGUI()
        {
            var onnxModelImporter = target as ONNXModelImporter;

            if (onnxModelImporter == null)
            {
                return;
            }

            InspectorMode inspectorMode = InspectorMode.Normal;

            if (s_InspectorModeInfo != null)
            {
                inspectorMode = (InspectorMode)s_InspectorModeInfo.GetValue(assetSerializedObject);
            }

            serializedObject.Update();

            bool debugView = inspectorMode != InspectorMode.Normal;
            SerializedProperty iterator = serializedObject.GetIterator();

            for (bool enterChildren = true; iterator.NextVisible(enterChildren); enterChildren = false)
            {
                if (iterator.propertyPath != "m_Script")
                {
                    EditorGUILayout.PropertyField(iterator, true);
                }
            }

            // Additional options exposed from ImportMode
            SerializedProperty importModeProperty = serializedObject.FindProperty(nameof(onnxModelImporter.importMode));
            bool skipMetadataImport = ((ImportMode)importModeProperty.intValue).HasFlag(ImportMode.SkipMetadataImport);

            if (EditorGUILayout.Toggle("Skip Metadata Import", skipMetadataImport) != skipMetadataImport)
            {
                importModeProperty.intValue ^= (int)ImportMode.SkipMetadataImport;
            }

            if (debugView)
            {
                importModeProperty.intValue = (int)(ImportMode)EditorGUILayout.EnumFlagsField("Import Mode", (ImportMode)importModeProperty.intValue);
            }
            else
            {
                if (onnxModelImporter.optimizeModel)
                {
                    EditorGUILayout.HelpBox("Model optimizations are on\nRemove and re-import model if you observe incorrect behavior", MessageType.Info);
                }

                if (onnxModelImporter.importMode == ImportMode.Legacy)
                {
                    EditorGUILayout.HelpBox("Legacy importer is in use", MessageType.Warning);
                }
            }

            serializedObject.ApplyModifiedProperties();

            ApplyRevertGUI();
        }
        /// <summary>
        /// Sets the mode.
        /// </summary>
        /// <param name="inspector">Inspector.</param>
        /// <param name="mode">Mode.</param>
        public static void SetMode(EditorWindow inspector, InspectorMode mode)
        {
            CheckInspector(inspector);
            if (null == _modeMethod)
            {
                throw new MissingMethodException("UnityEditor.InspectorWindow", "SetMode");
            }

            _modeMethod.Invoke(inspector, new object[] { mode });
        }
Ejemplo n.º 6
0
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        InspectorMode inspectorMode = ActiveEditorTracker.sharedTracker.inspectorMode;

        if (inspectorMode == InspectorMode.Debug || inspectorMode == InspectorMode.DebugInternal)
        {
            base.OnGUI(position, property, label);
        }
        else
        {
        }
    }
Ejemplo n.º 7
0
        internal static Mode GetModeFromInspectorMode(InspectorMode mode)
        {
            switch (mode)
            {
            case InspectorMode.Debug:
                return(Mode.Debug);

            case InspectorMode.DebugInternal:
                return(Mode.DebugInternal);

            default:
                return(Mode.Normal);
            }
        }
Ejemplo n.º 8
0
        private void DoBottomToolbar()
        {
            GUILayout.BeginHorizontal(EditorStyles.get_toolbar(), new GUILayoutOption[0]);
            bool flag = GUILayout.Toggle(FsmEditorSettings.ShowHints, Strings.get_Command_Toggle_Hints(), EditorStyles.get_toolbarButton(), new GUILayoutOption[]
            {
                GUILayout.MaxWidth(100f)
            });

            if (flag != FsmEditorSettings.ShowHints)
            {
                FsmEditorSettings.ShowHints = flag;
                FsmEditorSettings.SaveSettings();
                SkillEditor.RepaintAll();
            }
            if (GUILayout.Button(Strings.get_Command_Preferences(), EditorStyles.get_toolbarButton(), new GUILayoutOption[]
            {
                GUILayout.MinWidth(150f)
            }))
            {
                this.inspectorMode = InspectorMode.Preferences;
            }
            GUILayout.EndHorizontal();
        }
Ejemplo n.º 9
0
        public static void SetInspectorModel(InspectorMode mode)
        {
            System.Reflection.Assembly assembly = typeof(UnityEditor.EditorWindow).Assembly;
            Type         type   = assembly.GetType("UnityEditor.InspectorWindow");
            EditorWindow window = EditorWindow.GetWindow(type);
            MethodInfo   info   = null;

            if (mode == InspectorMode.Normal)
            {
                info = type.GetMethod("SetNormal", BindingFlags.Instance | BindingFlags.NonPublic);
            }
            else if (mode == InspectorMode.Debug)
            {
                info = type.GetMethod("SetDebug", BindingFlags.Instance | BindingFlags.NonPublic);
            }
            else if (mode == InspectorMode.DebugInternal)
            {
                info = type.GetMethod("SetDebugInternal", BindingFlags.Instance | BindingFlags.NonPublic);
            }
            if (info != null)
            {
                info.Invoke(window, null);
            }
        }
Ejemplo n.º 10
0
		private void SetMode(InspectorMode mode)
		{
			if (mode == InspectorMode.Normal)
			{
				base.title = "UnityEditor.InspectorWindow";
			}
			else
			{
				base.title = "UnityEditor.DebugInspectorWindow";
			}
			this.m_InspectorMode = mode;
			this.CreateTracker();
			this.m_Tracker.inspectorMode = mode;
			this.m_ResetKeyboardControl = true;
		}
Ejemplo n.º 11
0
 static extern void Internal_SetInspectorMode(ActiveEditorTracker self, InspectorMode value);
Ejemplo n.º 12
0
 public static void SetInspectorMode(SerializedObject serializedObject, InspectorMode inspectorMode)
 {
     s_InspectorMode.SetValue(serializedObject, (int)inspectorMode);
 }
Ejemplo n.º 13
0
        private void DoModeSelector()
        {
            InspectorMode inspectorMode = (InspectorMode)GUILayout.Toolbar((int)this.inspectorMode, InspectorPanel.InspectorModeLabels, SkillEditorStyles.ToolbarTab, new GUILayoutOption[0]);

            if (inspectorMode != this.inspectorMode)
            {
                this.SetMode(inspectorMode);
            }
            if (FsmErrorChecker.StateHasActionErrors(SkillEditor.SelectedState))
            {
                GUI.Box(this.errorBox, SkillEditorStyles.StateErrorIcon, SkillEditorStyles.InlineErrorIcon);
            }
            else
            {
                GUI.Box(this.errorBox, GUIContent.none, GUIStyle.get_none());
            }
            if (DragAndDropManager.mode == DragAndDropManager.DragMode.None && Event.get_current().get_type() == 9)
            {
                Vector2 mousePosition = Event.get_current().get_mousePosition();
                if (mousePosition.x > 0f && mousePosition.y > 0f && mousePosition.y < EditorStyles.get_toolbar().get_fixedHeight())
                {
                    int num = Mathf.FloorToInt(4f * mousePosition.x / 350f);
                    if (this.mouseOverTab != num)
                    {
                        this.mouseOverStartTime = EditorApplication.get_timeSinceStartup();
                        this.mouseOverTab       = num;
                    }
                    if (EditorApplication.get_timeSinceStartup() - this.mouseOverStartTime > 0.5)
                    {
                        this.mouseOverStartTime = EditorApplication.get_timeSinceStartup();
                        switch (num)
                        {
                        case 0:
                            this.SetMode(InspectorMode.FsmInspector);
                            GUIUtility.ExitGUI();
                            return;

                        case 1:
                            this.SetMode(InspectorMode.StateInspector);
                            GUIUtility.ExitGUI();
                            return;

                        case 2:
                            this.SetMode(InspectorMode.EventManager);
                            GUIUtility.ExitGUI();
                            return;

                        case 3:
                            this.SetMode(InspectorMode.VariableManager);
                            GUIUtility.ExitGUI();
                            return;

                        default:
                            return;
                        }
                    }
                }
                else
                {
                    this.mouseOverTab = -1;
                }
            }
        }
Ejemplo n.º 14
0
        void OnGUI()
        {
            // Flexible width for the label based on overall width
            EditorGUIUtility.labelWidth = Mathf.Round(EditorGUIUtility.currentViewWidth * 0.4f);
            // Use inline controls if there is enough horizontal room
            EditorGUIUtility.wideMode = EditorGUIUtility.currentViewWidth > 400;

            // Frame rate tracking
            if (Event.current.type == EventType.Repaint)
            {
                AnimationHelper.UpdateTime();
            }

            current = this;

            CleanStacks();

            DrawToolbar();

            Type[]       inspectedTypes       = null;
            object[]     inspectedContexts    = null;
            ECSContext[] inspectedECSContexts = null;

            GUILayout.Space(9);

            string buttonPrefix = "";

#if ECS_EXISTS
            int selectionWrapWidth = 465;
#else
            int selectionWrapWidth = 400;
#endif
            if (EditorGUIUtility.currentViewWidth > selectionWrapWidth)
            {
                EditorGUILayout.BeginHorizontal();
                GUILayout.Label("Selection Helpers");
            }
            else
            {
                buttonPrefix = "Select ";
            }

            var popupRect = GUILayoutUtility.GetLastRect();
            popupRect.width = EditorGUIUtility.currentViewWidth;

            if (GUILayout.Button(new GUIContent(buttonPrefix + "Type From Assembly"), EditorStyles.miniButton))
            {
                TypeSelectDropdown dropdown = new TypeSelectDropdown(new AdvancedDropdownState(), SetSelection);
                dropdown.Show(popupRect);
            }

            if (GUILayout.Button(new GUIContent(buttonPrefix + "Loaded Unity Object"), EditorStyles.miniButton))
            {
                UnityObjectSelectDropdown dropdown = new UnityObjectSelectDropdown(new AdvancedDropdownState(), SetSelection);
                dropdown.Show(popupRect);
            }

#if ECS_EXISTS
            if (GUILayout.Button(new GUIContent(buttonPrefix + "ECS System"), EditorStyles.miniButton))
            {
                ECSSystemSelectDropdown dropdown = new ECSSystemSelectDropdown(new AdvancedDropdownState(), SetSelection);
                dropdown.Show(popupRect);
            }
#endif

            if (EditorGUIUtility.currentViewWidth > selectionWrapWidth)
            {
                EditorGUILayout.EndHorizontal();
            }

            if (activeSelection.IsEmpty)
            {
                GUILayout.FlexibleSpace();
                GUIStyle style = new GUIStyle(EditorStyles.wordWrappedLabel)
                {
                    alignment = TextAnchor.MiddleCenter
                };
                GUILayout.Label("No object selected.\n\nSelect something in Unity or use one of the selection helper buttons.", style);
                GUILayout.FlexibleSpace();
                return;
            }

            if (activeSelection.Object != null)
            {
                if (activeSelection.Object is GameObject selectedGameObject)
                {
                    List <object> components = selectedGameObject.GetComponents <Component>().Cast <object>().ToList();
                    components.RemoveAll(item => item == null);
                    components.Insert(0, selectedGameObject);
                    inspectedContexts = components.ToArray();
                }
#if ECS_EXISTS
                else if (activeSelection.Object is EntitySelectionProxy entitySelectionProxy)
                {
                    EntityManager currentEntityManager = entitySelectionProxy.World.EntityManager;
                    string        name = currentEntityManager.GetName(entitySelectionProxy.Entity);

                    if (string.IsNullOrEmpty(name))
                    {
                        name = "Entity " + entitySelectionProxy.Entity.Index;
                    }

                    inspectedContexts       = new object [1 + currentEntityManager.GetComponentCount(entitySelectionProxy.Entity)];
                    inspectedContexts[0]    = activeSelection.Object;
                    inspectedECSContexts    = new ECSContext[1 + currentEntityManager.GetComponentCount(entitySelectionProxy.Entity)];
                    inspectedECSContexts[0] = new ECSContext {
                        EntityManager = currentEntityManager, Entity = entitySelectionProxy.Entity
                    };

                    NativeArray <ComponentType> types = currentEntityManager.GetComponentTypes(entitySelectionProxy.Entity);
                    for (var index = 0; index < types.Length; index++)
                    {
                        object componentData = ECSAccess.GetComponentData(currentEntityManager, entitySelectionProxy.Entity, types[index]);

                        inspectedContexts[1 + index]    = componentData;
                        inspectedECSContexts[1 + index] = new ECSContext {
                            EntityManager = currentEntityManager, Entity = entitySelectionProxy.Entity, ComponentType = types[index]
                        };
                    }

                    types.Dispose();
                }
#endif
                else
                {
                    inspectedContexts = new[] { activeSelection.Object };
                }

                inspectedTypes = inspectedContexts.Select(x => x.GetType()).ToArray();
            }
            else
            {
                inspectedTypes = new[] { activeSelection.Type };

                inspectedContexts = new Type[] { null };
            }

            if (inspectedECSContexts == null)
            {
                inspectedECSContexts = new ECSContext[inspectedContexts.Length];
            }

            GUILayout.Space(5);
            searchTerm = searchField.OnToolbarGUI(searchTerm);

            SidekickEditorGUI.BeginLabelHighlight(searchTerm);

            mode = SidekickUtility.EnumToolbar(mode);

            GUILayout.Space(5);
            scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);

            for (int i = 0; i < inspectedTypes.Length; i++)
            {
                Type type = inspectedTypes[i];

                var inspectedContext    = inspectedContexts[i];
                var inspectedECSContext = inspectedECSContexts[i];

                bool?activeOrEnabled = inspectedContext switch
                {
                    GameObject gameObject => gameObject.activeSelf,
                    Behaviour behaviour => behaviour.enabled,
                    _ => null
                };

                if (typesHidden.All(row => row.Key != type))
                {
                    typesHidden.Add(new KeyValuePair <Type, bool>(type, false));
                }

                int index = typesHidden.FindIndex(row => row.Key == type);

                string name;
                if (inspectedContexts[0] != null)
                {
                    if (activeOrEnabled.HasValue)
                    {
                        name = "              " + type.Name;
                    }
                    else
                    {
                        name = "       " + type.Name;
                    }

                    if (i == 0 && inspectedContexts[i] is Object unityObject)
                    {
                        name += $" ({unityObject.name})";
                    }
                }
                else
                {
                    name = type.Name + " (Class)";
                }

                GUIContent content = new GUIContent(name, $"{type.FullName}, {type.Assembly.FullName}");

                Rect foldoutRect = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.foldoutHeader);

                Rect toggleRect = foldoutRect;
                toggleRect.xMin += 36;
                toggleRect.width = 20;

                Rect iconRect = foldoutRect;
                iconRect.xMin  += 16;
                iconRect.yMin  += 1;
                iconRect.height = iconRect.width = 16;

                // Have to do this before BeginFoldoutHeaderGroup otherwise it'll consume the mouse down event
                if (activeOrEnabled.HasValue && SidekickEditorGUI.DetectClickInRect(toggleRect))
                {
                    switch (inspectedContexts[i])
                    {
                    case GameObject gameObject:
                        gameObject.SetActive(!gameObject.activeSelf);
                        break;

                    case Behaviour behaviour:
                        behaviour.enabled = !behaviour.enabled;
                        break;
                    }
                }

                bool foldout = EditorGUI.BeginFoldoutHeaderGroup(foldoutRect, !typesHidden[index].Value, content, EditorStyles.foldoutHeader, rect => ClassUtilities.GetMenu(inspectedContext, inspectedECSContext).DropDown(rect));

                Texture icon = SidekickEditorGUI.GetIcon(inspectedContexts[i], type);
                if (icon != null)
                {
                    GUI.DrawTexture(iconRect, icon);
                }

                // Right click context menu
                if (SidekickEditorGUI.DetectClickInRect(foldoutRect, 1))
                {
                    ClassUtilities.GetMenu(inspectedContext, inspectedECSContext).DropDown(new Rect(Event.current.mousePosition, Vector2.zero));
                }

                if (activeOrEnabled.HasValue)
                {
                    EditorGUI.Toggle(toggleRect, activeOrEnabled.Value);
                }

                EditorGUILayout.EndFoldoutHeaderGroup();

                typesHidden[index] = new KeyValuePair <Type, bool>(type, !foldout);

                if (!typesHidden[index].Value)
                {
                    SidekickEditorGUI.DrawSplitter(0.5f);

                    EditorGUI.indentLevel++;

                    BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly;

                    if (inspectedContext != null) // Is this an object instance?
                    {
                        bindingFlags |= BindingFlags.Instance;
                    }

                    var typeScope = type;

                    while (typeScope != null)
                    {
                        if (InspectionExclusions.GetExcludedTypes().Contains(typeScope))
                        {
                            break;
                        }

                        if (typeScope != type)
                        {
                            SidekickEditorGUI.DrawTypeChainHeader(new GUIContent(": " + typeScope.Name));
                        }

                        FieldInfo[]    fields     = typeScope.GetFields(bindingFlags);
                        PropertyInfo[] properties = typeScope.GetProperties(bindingFlags);
                        MethodInfo[]   methods    = typeScope.GetMethods(bindingFlags);

                        // Hide methods and backing fields that have been generated for properties
                        if (SidekickSettings.HideAutoGenerated)
                        {
                            List <MethodInfo> methodList = new List <MethodInfo>(methods.Length);

                            foreach (MethodInfo method in methods)
                            {
                                if (!TypeUtility.IsPropertyMethod(method, typeScope))
                                {
                                    methodList.Add(method);
                                }
                            }

                            methods = methodList.ToArray();

                            List <FieldInfo> fieldList = new List <FieldInfo>(fields.Length);

                            for (int j = 0; j < fields.Length; j++)
                            {
                                if (!TypeUtility.IsBackingField(fields[j], typeScope))
                                {
                                    fieldList.Add(fields[j]);
                                }
                            }

                            fields = fieldList.ToArray();
                        }


                        FieldInfo[] events = typeScope.GetFields(bindingFlags);

                        if (mode == InspectorMode.Fields)
                        {
                            fieldPane.DrawFields(inspectedTypes[i], inspectedContexts[i], inspectedECSContext, searchTerm, fields);
                        }
                        else if (mode == InspectorMode.Properties)
                        {
                            propertyPane.DrawProperties(inspectedTypes[i], inspectedContexts[i], searchTerm, properties);
                        }
                        else if (mode == InspectorMode.Methods)
                        {
                            methodPane.DrawMethods(inspectedTypes[i], inspectedContexts[i], searchTerm, methods);
                        }
                        else if (mode == InspectorMode.Events)
                        {
                            eventPane.DrawEvents(inspectedTypes[i], inspectedContexts[i], searchTerm, events);
                        }

                        typeScope = typeScope.BaseType;
                    }


                    EditorGUI.indentLevel--;
                }

                SidekickEditorGUI.DrawSplitter();
            }

            EditorGUILayout.Space();
            EditorGUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();

            if (inspectedTypes[0] == typeof(GameObject)
#if ECS_EXISTS
                || inspectedTypes[0] == typeof(EntitySelectionProxy)
#endif
                )
            {
                bool pressed    = GUILayout.Button("Add Component", GUILayout.Width(230), GUILayout.Height(24));
                var  popupRect2 = GUILayoutUtility.GetLastRect();
                popupRect2.width = EditorGUIUtility.currentViewWidth;
                if (pressed)
                {
                    if (inspectedTypes[0] == typeof(GameObject))
                    {
                        TypeSelectDropdown dropdown = new TypeSelectDropdown(new AdvancedDropdownState(), type =>
                        {
                            ((GameObject)inspectedContexts[0]).AddComponent(type);
                        }, new[] { typeof(Component) });
                        dropdown.Show(popupRect2);
                    }
#if ECS_EXISTS
                    else if (inspectedTypes[0] == typeof(EntitySelectionProxy))
                    {
                        TypeSelectDropdown dropdown = new TypeSelectDropdown(new AdvancedDropdownState(), type =>
                        {
                            inspectedECSContexts[0].EntityManager.AddComponent(inspectedECSContexts[0].Entity, ComponentType.ReadWrite(type));
                        }, null, new [] { typeof(IComponentData) });
                        dropdown.Show(popupRect2);
                    }
#endif
                }
            }

            GUILayout.FlexibleSpace();
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.EndScrollView();

            if (mode == InspectorMode.Methods)
            {
                methodPane.PostDraw();
            }


            //if(AnimationHelper.AnimationActive)
            {
                // Cause repaint on next frame
                Repaint();
                if (Event.current.type == EventType.Repaint)
                {
                    //AnimationHelper.ClearAnimationActive();
                }
            }

            SidekickEditorGUI.EndLabelHighlight();
        }
Ejemplo n.º 15
0
        void OnGUI()
        {
            // Frame rate tracking
            if (Event.current.type == EventType.Repaint)
            {
                AnimationHelper.UpdateTime();
            }

            current = this;
            // Make sure we have a valid set of assemblies
            if (assemblies == null || assemblies.Count == 0)
            {
                ConstructAssembliesAndTypes();
            }

            Rect windowRect = position;

            Type[]   inspectedTypes    = null;
            object[] inspectedContexts = null;

            GUILayout.Space(9);

            inspectedType = SidekickUtility.EnumToolbar(inspectedType, "LargeButton");//, GUILayout.Width(windowRect.width - 60));

            if (inspectedType == InspectedType.Selection)
            {
                object selectedObject = ActiveSelection;

                if (selectedObject == null)
                {
                    GUILayout.Space(windowRect.height / 2 - 40);
                    GUIStyle style = new GUIStyle(GUI.skin.label);
                    style.alignment = TextAnchor.MiddleCenter;
                    GUILayout.Label("No object selected", style);
                    return;
                }

                if (selectedObject is GameObject)
                {
                    List <object> components = ((GameObject)selectedObject).GetComponents <Component>().Cast <object>().ToList();
                    components.RemoveAll(item => item == null);
                    components.Insert(0, selectedObject);
                    inspectedContexts = components.ToArray();
                }
                else
                {
                    inspectedContexts = new object[] { selectedObject };
                }
                inspectedTypes = inspectedContexts.Select(x => x.GetType()).ToArray();
            }
            else if (inspectedType == InspectedType.AssemblyClass)
            {
                int newSelectedAssemblyIndex = EditorGUILayout.Popup(selectedAssemblyIndex, assemblyNames);
                if (newSelectedAssemblyIndex != selectedAssemblyIndex)
                {
                    selectedTypeIndex     = 0;
                    selectedAssemblyIndex = newSelectedAssemblyIndex;
                }

                Assembly    activeAssembly = assemblies[selectedAssemblyIndex];
                List <Type> types          = assemblyTypes[activeAssembly];
                string[]    typeNames      = new string[types.Count];
                for (int i = 0; i < types.Count; i++)
                {
                    typeNames[i] = types[i].FullName;
                }
                selectedTypeIndex = EditorGUILayout.Popup(selectedTypeIndex, typeNames);

                inspectedTypes    = new Type[] { assemblyTypes[activeAssembly][selectedTypeIndex] };
                inspectedContexts = new Type[] { null };
            }
            else if (inspectedType == InspectedType.Remote)
            {
            }
            else
            {
                throw new NotImplementedException("Unhandled InspectedType");
            }

            GUILayout.Space(5);
            EditorGUILayout.BeginHorizontal();
            GUIStyle searchStyle   = GUI.skin.FindStyle("ToolbarSeachTextField");
            GUIStyle cancelStyle   = GUI.skin.FindStyle("ToolbarSeachCancelButton");
            GUIStyle noCancelStyle = GUI.skin.FindStyle("ToolbarSeachCancelButtonEmpty");

            GUILayout.Space(10);
            settings.SearchTerm = EditorGUILayout.TextField(settings.SearchTerm, searchStyle);
            if (!string.IsNullOrEmpty(settings.SearchTerm))
            {
                if (GUILayout.Button("", cancelStyle))
                {
                    settings.SearchTerm               = "";
                    GUIUtility.hotControl             = 0;
                    EditorGUIUtility.editingTextField = false;
                }
            }
            else
            {
                GUILayout.Button("", noCancelStyle);
            }
            GUILayout.Space(10);
            EditorGUILayout.EndHorizontal();
            GUILayout.Space(5);
            mode = SidekickUtility.EnumToolbar(mode);
            //			mode = SabreGUILayout.DrawEnumGrid(mode);

            GUILayout.Space(5);
            scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);

            for (int i = 0; i < inspectedTypes.Length; i++)
            {
                Type type = inspectedTypes[i];
                if (!typesHidden.Any(row => row.Key == type))// ContainsKey(component))
                {
                    typesHidden.Add(new KeyValuePair <Type, bool>(type, false));
                }


                int index = typesHidden.FindIndex(row => row.Key == type);

                GUIStyle style = new GUIStyle(EditorStyles.foldout);
                style.fontStyle = FontStyle.Bold;
                //				Texture2D icon = AssetPreview.GetMiniTypeThumbnail(type);
                GUIContent objectContent = EditorGUIUtility.ObjectContent(inspectedContexts[i] as UnityEngine.Object, type);
                Texture2D  icon          = objectContent.image as Texture2D;
                GUIContent content       = new GUIContent(type.Name, icon);

                bool newValue = !EditorGUILayout.Foldout(!typesHidden[index].Value, content, style);

                if (newValue != typesHidden[index].Value)
                {
                    typesHidden[index] = new KeyValuePair <Type, bool>(type, newValue);
                }
                if (!typesHidden[index].Value)
                {
                    EditorGUI.indentLevel = 1;

                    BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
                    if (!settings.IncludeInherited)
                    {
                        bindingFlags |= BindingFlags.DeclaredOnly;
                    }

                    FieldInfo[]    fields     = type.GetFields(bindingFlags);
                    PropertyInfo[] properties = type.GetProperties(bindingFlags);
                    MethodInfo[]   methods    = type.GetMethods(bindingFlags);

                    // Hide methods and backing fields that have been generated for properties
                    if (settings.HideAutoGenerated)
                    {
                        List <MethodInfo> methodList = new List <MethodInfo>(methods.Length);

                        for (int j = 0; j < methods.Length; j++)
                        {
                            if (!TypeUtility.IsPropertyMethod(methods[j], type))
                            {
                                methodList.Add(methods[j]);
                            }
                        }
                        methods = methodList.ToArray();

                        List <FieldInfo> fieldList = new List <FieldInfo>(fields.Length);

                        for (int j = 0; j < fields.Length; j++)
                        {
                            if (!TypeUtility.IsBackingField(fields[j], type))
                            {
                                fieldList.Add(fields[j]);
                            }
                        }
                        fields = fieldList.ToArray();
                    }


                    FieldInfo[] events = type.GetFields(bindingFlags);

                    if (mode == InspectorMode.Fields)
                    {
                        fieldPane.DrawFields(inspectedTypes[i], inspectedContexts[i], fields);
                    }
                    else if (mode == InspectorMode.Props)
                    {
                        propertyPane.DrawProperties(inspectedTypes[i], inspectedContexts[i], properties);
                    }
                    else if (mode == InspectorMode.Methods)
                    {
                        methodPane.DrawMethods(inspectedTypes[i], inspectedContexts[i], methods);
                    }
                    else if (mode == InspectorMode.Events)
                    {
                        eventPane.DrawEvents(inspectedTypes[i], inspectedContexts[i], events);
                    }
                    else if (mode == InspectorMode.Misc)
                    {
                        utilityPane.Draw(inspectedTypes[i], inspectedContexts[i]);
                    }

                    EditorGUI.indentLevel = 0;
                }

                Rect rect = GUILayoutUtility.GetRect(new GUIContent(), GUI.skin.label, GUILayout.ExpandWidth(true), GUILayout.Height(1));
                rect.xMin -= 10;
                rect.xMax += 10;
                GUI.color  = new Color(0.5f, 0.5f, 0.5f);
                GUI.DrawTexture(rect, EditorGUIUtility.whiteTexture);
                GUI.color = Color.white;
            }

            EditorGUILayout.EndScrollView();

            if (mode == InspectorMode.Methods)
            {
                methodPane.PostDraw();
            }

            settings.RotationsAsEuler  = EditorGUILayout.Toggle("Rotations as euler", settings.RotationsAsEuler);
            settings.IncludeInherited  = EditorGUILayout.Toggle("Include inherited", settings.IncludeInherited);
            settings.HideAutoGenerated = EditorGUILayout.Toggle("Hide auto-generated", settings.HideAutoGenerated);
            settings.TreatEnumsAsInts  = EditorGUILayout.Toggle("Enums as ints", settings.TreatEnumsAsInts);

            EditorGUILayout.BeginHorizontal();
            GUI.enabled = (backStack.Count > 0);
            if (GUILayout.Button("<-") ||
                (Event.current.type == EventType.MouseDown && Event.current.button == 3) ||
                (Event.current.type == EventType.KeyDown && SidekickUtility.EventsMatch(Event.current, Event.KeyboardEvent("Backspace"), false, true)))
            {
                object backStackLast = backStack.Last();
                backStack.RemoveAt(backStack.Count - 1);
                forwardStack.Add(ActiveSelection);
                SetSelection(backStackLast, false);
            }
            GUI.enabled = (forwardStack.Count > 0);
            if (GUILayout.Button("->") ||
                (Event.current.type == EventType.MouseDown && Event.current.button == 4) ||
                (Event.current.type == EventType.KeyDown && SidekickUtility.EventsMatch(Event.current, Event.KeyboardEvent("#Backspace"), false, true)))
            {
                object forwardStackLast = forwardStack.Last();
                forwardStack.RemoveAt(forwardStack.Count - 1);
                backStack.Add(ActiveSelection);
                SetSelection(forwardStackLast, false);
            }
            GUI.enabled = true;

            if (GUILayout.Button("Pin"))
            {
                selectionOverride = ActiveSelection;
            }

            EditorGUILayout.EndHorizontal();
            //			test += currentFrameDelta;
            //			Color color = Color.Lerp(Color.white, Color.red, Mathf.PingPong(test, 1f));
            //			GUI.backgroundColor = color;
            //			GUILayout.Button(Mathf.PingPong(test, 1f).ToString());//test.ToString());

            //			if(AnimationHelper.AnimationActive)
            {
                // Cause repaint on next frame
                Repaint();
                if (Event.current.type == EventType.Repaint)
                {
                    //					AnimationHelper.ClearAnimationActive();
                }
            }
        }
Ejemplo n.º 16
0
 private void SetMode(InspectorMode mode)
 {
   this.m_InspectorMode = mode;
   this.RefreshTitle();
   this.CreateTracker();
   this.m_Tracker.inspectorMode = mode;
   this.m_ResetKeyboardControl = true;
 }
Ejemplo n.º 17
0
 public static void SetInspectorMode(EditorWindow inspector, InspectorMode mode)
 {
     inspectorModeProperty.SetValue(inspector, (int)mode);
 }
Ejemplo n.º 18
0
 public ReferenceInspector(ref T t, InspectorMode mode = InspectorMode.All) : base(ref t, mode)
 {
     Metadata  = new ReferenceMetadataInfo(ref t);
     Sizes     = new ReferenceSizeInfo(ref t);
     Addresses = new ReferenceAddressInfo(ref t);
 }