protected override void OnHeaderGUI()
        {
            if (GameObjectInspector.s_Styles == null)
            {
                GameObjectInspector.s_Styles = new GameObjectInspector.Styles();
            }
            bool enabled = GUI.enabled;

            GUI.enabled = true;
            EditorGUILayout.BeginVertical(GameObjectInspector.s_Styles.header, new GUILayoutOption[0]);
            GUI.enabled = enabled;
            this.DrawInspector();
            EditorGUILayout.EndVertical();
        }
Esempio n. 2
0
        internal bool DrawInspector(Rect contentRect)
        {
            if (GameObjectInspector.s_styles == null)
            {
                GameObjectInspector.s_styles = new GameObjectInspector.Styles();
            }
            base.serializedObject.Update();
            GameObject gameObject = this.target as GameObject;

            EditorGUIUtility.labelWidth = 52f;
            bool enabled = GUI.enabled;

            GUI.enabled = true;
            GUI.Label(new Rect(contentRect.x, contentRect.y, contentRect.width, contentRect.height + 3f), GUIContent.none, EditorStyles.inspectorBig);
            GUI.enabled = enabled;
            float      width      = contentRect.width;
            float      y          = contentRect.y;
            GUIContent gUIContent = null;
            PrefabType prefabType = PrefabType.None;

            if (this.m_AllOfSamePrefabType)
            {
                prefabType = PrefabUtility.GetPrefabType(gameObject);
                switch (prefabType)
                {
                case PrefabType.None:
                    gUIContent = GameObjectInspector.s_styles.goIcon;
                    break;

                case PrefabType.Prefab:
                case PrefabType.PrefabInstance:
                case PrefabType.DisconnectedPrefabInstance:
                    gUIContent = GameObjectInspector.s_styles.prefabIcon;
                    break;

                case PrefabType.ModelPrefab:
                case PrefabType.ModelPrefabInstance:
                case PrefabType.DisconnectedModelPrefabInstance:
                    gUIContent = GameObjectInspector.s_styles.modelIcon;
                    break;

                case PrefabType.MissingPrefabInstance:
                    gUIContent = GameObjectInspector.s_styles.prefabIcon;
                    break;
                }
            }
            else
            {
                gUIContent = GameObjectInspector.s_styles.typelessIcon;
            }
            EditorGUI.ObjectIconDropDown(new Rect(3f, 4f + y, 24f, 24f), base.targets, true, gUIContent.image as Texture2D, this.m_Icon);
            using (new EditorGUI.DisabledScope(prefabType == PrefabType.ModelPrefab))
            {
                EditorGUI.PropertyField(new Rect(34f, 4f + y, 14f, 14f), this.m_IsActive, GUIContent.none);
                float num    = GameObjectInspector.s_styles.staticFieldToggleWidth + 15f;
                float width2 = width - 52f - num - 5f;
                EditorGUI.DelayedTextField(new Rect(52f, 4f + y + 1f, width2, 16f), this.m_Name, GUIContent.none);
                Rect rect = new Rect(width - num, 4f + y, GameObjectInspector.s_styles.staticFieldToggleWidth, 16f);
                EditorGUI.BeginProperty(rect, GUIContent.none, this.m_StaticEditorFlags);
                EditorGUI.BeginChangeCheck();
                Rect position = rect;
                EditorGUI.showMixedValue |= GameObjectInspector.ShowMixedStaticEditorFlags((StaticEditorFlags)this.m_StaticEditorFlags.intValue);
                Event     current = Event.current;
                EventType type    = current.type;
                bool      flag    = current.type == EventType.MouseDown && current.button != 0;
                if (flag)
                {
                    current.type = EventType.Ignore;
                }
                bool flagValue = EditorGUI.ToggleLeft(position, "Static", gameObject.isStatic);
                if (flag)
                {
                    current.type = type;
                }
                EditorGUI.showMixedValue = false;
                if (EditorGUI.EndChangeCheck())
                {
                    SceneModeUtility.SetStaticFlags(base.targets, -1, flagValue);
                    base.serializedObject.SetIsDifferentCacheDirty();
                }
                EditorGUI.EndProperty();
                EditorGUI.BeginChangeCheck();
                EditorGUI.showMixedValue = this.m_StaticEditorFlags.hasMultipleDifferentValues;
                int  changedFlags;
                bool flagValue2;
                EditorGUI.EnumMaskField(new Rect(rect.x + GameObjectInspector.s_styles.staticFieldToggleWidth, rect.y, 10f, 14f), GameObjectUtility.GetStaticEditorFlags(gameObject), GameObjectInspector.s_styles.staticDropdown, out changedFlags, out flagValue2);
                EditorGUI.showMixedValue = false;
                if (EditorGUI.EndChangeCheck())
                {
                    SceneModeUtility.SetStaticFlags(base.targets, changedFlags, flagValue2);
                    base.serializedObject.SetIsDifferentCacheDirty();
                }
                float num2 = 4f;
                float num3 = 4f;
                EditorGUIUtility.fieldWidth = (width - num2 - 52f - GameObjectInspector.s_styles.layerFieldWidth - num3) / 2f;
                string tag = null;
                try
                {
                    tag = gameObject.tag;
                }
                catch (Exception)
                {
                    tag = "Undefined";
                }
                EditorGUIUtility.labelWidth = GameObjectInspector.s_styles.tagFieldWidth;
                Rect rect2 = new Rect(52f - EditorGUIUtility.labelWidth, 24f + y, EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth, 16f);
                EditorGUI.BeginProperty(rect2, GUIContent.none, this.m_Tag);
                EditorGUI.BeginChangeCheck();
                string text = EditorGUI.TagField(rect2, EditorGUIUtility.TempContent("Tag"), tag);
                if (EditorGUI.EndChangeCheck())
                {
                    this.m_Tag.stringValue = text;
                    Undo.RecordObjects(base.targets, "Change Tag of " + this.targetTitle);
                    UnityEngine.Object[] targets = base.targets;
                    for (int i = 0; i < targets.Length; i++)
                    {
                        UnityEngine.Object @object = targets[i];
                        (@object as GameObject).tag = text;
                    }
                }
                EditorGUI.EndProperty();
                EditorGUIUtility.labelWidth = GameObjectInspector.s_styles.layerFieldWidth;
                rect2 = new Rect(52f + EditorGUIUtility.fieldWidth + num2, 24f + y, EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth, 16f);
                EditorGUI.BeginProperty(rect2, GUIContent.none, this.m_Layer);
                EditorGUI.BeginChangeCheck();
                int num4 = EditorGUI.LayerField(rect2, EditorGUIUtility.TempContent("Layer"), gameObject.layer);
                if (EditorGUI.EndChangeCheck())
                {
                    GameObjectUtility.ShouldIncludeChildren shouldIncludeChildren = GameObjectUtility.DisplayUpdateChildrenDialogIfNeeded(base.targets.OfType <GameObject>(), "Change Layer", "Do you want to set layer to " + InternalEditorUtility.GetLayerName(num4) + " for all child objects as well?");
                    if (shouldIncludeChildren != GameObjectUtility.ShouldIncludeChildren.Cancel)
                    {
                        this.m_Layer.intValue = num4;
                        this.SetLayer(num4, shouldIncludeChildren == GameObjectUtility.ShouldIncludeChildren.IncludeChildren);
                    }
                }
                EditorGUI.EndProperty();
                if (this.m_HasInstance)
                {
                    using (new EditorGUI.DisabledScope(EditorApplication.isPlayingOrWillChangePlaymode))
                    {
                        float      num5        = (width - 52f - 5f) / 3f;
                        Rect       position2   = new Rect(52f + num5 * 0f, 44f + y, num5, 15f);
                        Rect       position3   = new Rect(52f + num5 * 1f, 44f + y, num5, 15f);
                        Rect       position4   = new Rect(52f + num5 * 2f, 44f + y, num5, 15f);
                        Rect       position5   = new Rect(52f, 44f + y, num5 * 3f, 15f);
                        GUIContent gUIContent2 = (base.targets.Length <= 1) ? GameObjectInspector.s_styles.goTypeLabel[(int)prefabType] : GameObjectInspector.s_styles.goTypeLabelMultiple;
                        if (gUIContent2 != null)
                        {
                            float x = GUI.skin.label.CalcSize(gUIContent2).x;
                            if (prefabType == PrefabType.DisconnectedModelPrefabInstance || prefabType == PrefabType.MissingPrefabInstance || prefabType == PrefabType.DisconnectedPrefabInstance)
                            {
                                GUI.contentColor = GUI.skin.GetStyle("CN StatusWarn").normal.textColor;
                                if (prefabType == PrefabType.MissingPrefabInstance)
                                {
                                    GUI.Label(new Rect(52f, 44f + y, width - 52f - 5f, 18f), gUIContent2, EditorStyles.whiteLabel);
                                }
                                else
                                {
                                    GUI.Label(new Rect(52f - x - 5f, 44f + y, width - 52f - 5f, 18f), gUIContent2, EditorStyles.whiteLabel);
                                }
                                GUI.contentColor = Color.white;
                            }
                            else
                            {
                                Rect position6 = new Rect(52f - x - 5f, 44f + y, x, 18f);
                                GUI.Label(position6, gUIContent2);
                            }
                        }
                        if (base.targets.Length > 1)
                        {
                            GUI.Label(position5, "Instance Management Disabled", GameObjectInspector.s_styles.instanceManagementInfo);
                        }
                        else
                        {
                            if (prefabType != PrefabType.MissingPrefabInstance && GUI.Button(position2, "Select", "MiniButtonLeft"))
                            {
                                Selection.activeObject = PrefabUtility.GetPrefabParent(this.target);
                                EditorGUIUtility.PingObject(Selection.activeObject);
                            }
                            if ((prefabType == PrefabType.DisconnectedModelPrefabInstance || prefabType == PrefabType.DisconnectedPrefabInstance) && GUI.Button(position3, "Revert", "MiniButtonMid"))
                            {
                                Undo.RegisterFullObjectHierarchyUndo(gameObject, "Revert to prefab");
                                PrefabUtility.ReconnectToLastPrefab(gameObject);
                                PrefabUtility.RevertPrefabInstance(gameObject);
                                this.CalculatePrefabStatus();
                                Undo.RegisterCreatedObjectUndo(gameObject, "Reconnect prefab");
                                GUIUtility.ExitGUI();
                            }
                            using (new EditorGUI.DisabledScope(AnimationMode.InAnimationMode()))
                            {
                                if ((prefabType == PrefabType.ModelPrefabInstance || prefabType == PrefabType.PrefabInstance) && GUI.Button(position3, "Revert", "MiniButtonMid"))
                                {
                                    Undo.RegisterFullObjectHierarchyUndo(gameObject, "Revert Prefab Instance");
                                    PrefabUtility.RevertPrefabInstance(gameObject);
                                    this.CalculatePrefabStatus();
                                    Undo.RegisterCreatedObjectUndo(gameObject, "Revert prefab");
                                    GUIUtility.ExitGUI();
                                }
                                if (prefabType == PrefabType.PrefabInstance || prefabType == PrefabType.DisconnectedPrefabInstance)
                                {
                                    GameObject gameObject2 = PrefabUtility.FindValidUploadPrefabInstanceRoot(gameObject);
                                    GUI.enabled = (gameObject2 != null && !AnimationMode.InAnimationMode());
                                    if (GUI.Button(position4, "Apply", "MiniButtonRight"))
                                    {
                                        UnityEngine.Object prefabParent = PrefabUtility.GetPrefabParent(gameObject2);
                                        string             assetPath    = AssetDatabase.GetAssetPath(prefabParent);
                                        bool flag2 = Provider.PromptAndCheckoutIfNeeded(new string[]
                                        {
                                            assetPath
                                        }, "The version control requires you to check out the prefab before applying changes.");
                                        if (flag2)
                                        {
                                            PrefabUtility.ReplacePrefab(gameObject2, prefabParent, ReplacePrefabOptions.ConnectToPrefab);
                                            this.CalculatePrefabStatus();
                                            EditorSceneManager.MarkSceneDirty(gameObject2.scene);
                                            GUIUtility.ExitGUI();
                                        }
                                    }
                                }
                            }
                            if ((prefabType == PrefabType.DisconnectedModelPrefabInstance || prefabType == PrefabType.ModelPrefabInstance) && GUI.Button(position4, "Open", "MiniButtonRight"))
                            {
                                AssetDatabase.OpenAsset(PrefabUtility.GetPrefabParent(this.target));
                                GUIUtility.ExitGUI();
                            }
                        }
                    }
                }
            }
            base.serializedObject.ApplyModifiedProperties();
            return(true);
        }
        internal bool DrawInspector(Rect contentRect)
        {
            if (GameObjectInspector.s_styles == null)
            {
                GameObjectInspector.s_styles = new GameObjectInspector.Styles();
            }
            this.serializedObject.Update();
            GameObject target1 = this.target as GameObject;

            EditorGUIUtility.labelWidth = 52f;
            bool enabled1 = GUI.enabled;

            GUI.enabled = true;
            GUI.Label(new Rect(contentRect.x, contentRect.y, contentRect.width, contentRect.height + 3f), GUIContent.none, EditorStyles.inspectorBig);
            GUI.enabled = enabled1;
            float      width1     = contentRect.width;
            float      y          = contentRect.y;
            GUIContent guiContent = (GUIContent)null;
            PrefabType prefabType = PrefabType.None;

            if (this.m_AllOfSamePrefabType)
            {
                prefabType = PrefabUtility.GetPrefabType((UnityEngine.Object)target1);
                switch (prefabType)
                {
                case PrefabType.None:
                    guiContent = GameObjectInspector.s_styles.goIcon;
                    break;

                case PrefabType.Prefab:
                case PrefabType.PrefabInstance:
                case PrefabType.DisconnectedPrefabInstance:
                    guiContent = GameObjectInspector.s_styles.prefabIcon;
                    break;

                case PrefabType.ModelPrefab:
                case PrefabType.ModelPrefabInstance:
                case PrefabType.DisconnectedModelPrefabInstance:
                    guiContent = GameObjectInspector.s_styles.modelIcon;
                    break;

                case PrefabType.MissingPrefabInstance:
                    guiContent = GameObjectInspector.s_styles.prefabIcon;
                    break;
                }
            }
            else
            {
                guiContent = GameObjectInspector.s_styles.typelessIcon;
            }
            EditorGUI.ObjectIconDropDown(new Rect(3f, 4f + y, 24f, 24f), this.targets, true, guiContent.image as Texture2D, this.m_Icon);
            EditorGUI.BeginDisabledGroup(prefabType == PrefabType.ModelPrefab);
            EditorGUI.PropertyField(new Rect(34f, 4f + y, 14f, 14f), this.m_IsActive, GUIContent.none);
            float num1   = GameObjectInspector.s_styles.staticFieldToggleWidth + 15f;
            float width2 = (float)((double)width1 - 52.0 - (double)num1 - 5.0);

            EditorGUI.DelayedTextField(new Rect(52f, (float)(4.0 + (double)y + 1.0), width2, 16f), this.m_Name, GUIContent.none);
            Rect totalPosition = new Rect(width1 - num1, 4f + y, GameObjectInspector.s_styles.staticFieldToggleWidth, 16f);

            EditorGUI.BeginProperty(totalPosition, GUIContent.none, this.m_StaticEditorFlags);
            EditorGUI.BeginChangeCheck();
            Rect position1 = totalPosition;

            EditorGUI.showMixedValue |= GameObjectInspector.ShowMixedStaticEditorFlags((StaticEditorFlags)this.m_StaticEditorFlags.intValue);
            Event     current = Event.current;
            EventType type    = current.type;
            bool      flag    = current.type == EventType.MouseDown && current.button != 0;

            if (flag)
            {
                current.type = EventType.Ignore;
            }
            bool flagValue = EditorGUI.ToggleLeft(position1, "Static", target1.isStatic);

            if (flag)
            {
                current.type = type;
            }
            EditorGUI.showMixedValue = false;
            if (EditorGUI.EndChangeCheck())
            {
                SceneModeUtility.SetStaticFlags(this.targets, -1, flagValue);
                this.serializedObject.SetIsDifferentCacheDirty();
            }
            EditorGUI.EndProperty();
            EditorGUI.BeginChangeCheck();
            EditorGUI.showMixedValue = this.m_StaticEditorFlags.hasMultipleDifferentValues;
            int  changedFlags;
            bool changedToValue;

            EditorGUI.EnumMaskField(new Rect(totalPosition.x + GameObjectInspector.s_styles.staticFieldToggleWidth, totalPosition.y, 10f, 14f), (Enum)GameObjectUtility.GetStaticEditorFlags(target1), GameObjectInspector.s_styles.staticDropdown, out changedFlags, out changedToValue);
            EditorGUI.showMixedValue = false;
            if (EditorGUI.EndChangeCheck())
            {
                SceneModeUtility.SetStaticFlags(this.targets, changedFlags, changedToValue);
                this.serializedObject.SetIsDifferentCacheDirty();
            }
            float num2 = 4f;
            float num3 = 4f;

            EditorGUIUtility.fieldWidth = (float)(((double)width1 - (double)num2 - 52.0 - (double)GameObjectInspector.s_styles.layerFieldWidth - (double)num3) / 2.0);
            string tag;

            try
            {
                tag = target1.tag;
            }
            catch (Exception ex)
            {
                tag = "Undefined";
            }
            EditorGUIUtility.labelWidth = GameObjectInspector.s_styles.tagFieldWidth;
            Rect rect = new Rect(52f - EditorGUIUtility.labelWidth, 24f + y, EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth, 16f);

            EditorGUI.BeginProperty(rect, GUIContent.none, this.m_Tag);
            EditorGUI.BeginChangeCheck();
            string str = EditorGUI.TagField(rect, EditorGUIUtility.TempContent("Tag"), tag);

            if (EditorGUI.EndChangeCheck())
            {
                this.m_Tag.stringValue = str;
                Undo.RecordObjects(this.targets, "Change Tag of " + this.targetTitle);
                foreach (UnityEngine.Object target2 in this.targets)
                {
                    (target2 as GameObject).tag = str;
                }
            }
            EditorGUI.EndProperty();
            EditorGUIUtility.labelWidth = GameObjectInspector.s_styles.layerFieldWidth;
            rect = new Rect(52f + EditorGUIUtility.fieldWidth + num2, 24f + y, EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth, 16f);
            EditorGUI.BeginProperty(rect, GUIContent.none, this.m_Layer);
            EditorGUI.BeginChangeCheck();
            int layer = EditorGUI.LayerField(rect, EditorGUIUtility.TempContent("Layer"), target1.layer);

            if (EditorGUI.EndChangeCheck())
            {
                GameObjectUtility.ShouldIncludeChildren shouldIncludeChildren = GameObjectUtility.DisplayUpdateChildrenDialogIfNeeded(this.targets.OfType <GameObject>(), "Change Layer", "Do you want to set layer to " + InternalEditorUtility.GetLayerName(layer) + " for all child objects as well?");
                if (shouldIncludeChildren != GameObjectUtility.ShouldIncludeChildren.Cancel)
                {
                    this.m_Layer.intValue = layer;
                    this.SetLayer(layer, shouldIncludeChildren == GameObjectUtility.ShouldIncludeChildren.IncludeChildren);
                }
            }
            EditorGUI.EndProperty();
            if (this.m_HasInstance && !EditorApplication.isPlayingOrWillChangePlaymode)
            {
                float      width3    = (float)(((double)width1 - 52.0 - 5.0) / 3.0);
                Rect       position2 = new Rect((float)(52.0 + (double)width3 * 0.0), 44f + y, width3, 15f);
                Rect       position3 = new Rect((float)(52.0 + (double)width3 * 1.0), 44f + y, width3, 15f);
                Rect       position4 = new Rect((float)(52.0 + (double)width3 * 2.0), 44f + y, width3, 15f);
                Rect       position5 = new Rect(52f, 44f + y, width3 * 3f, 15f);
                GUIContent content   = this.targets.Length <= 1 ? GameObjectInspector.s_styles.goTypeLabel[(int)prefabType] : GameObjectInspector.s_styles.goTypeLabelMultiple;
                if (content != null)
                {
                    float x = GUI.skin.label.CalcSize(content).x;
                    if (prefabType == PrefabType.DisconnectedModelPrefabInstance || prefabType == PrefabType.MissingPrefabInstance || prefabType == PrefabType.DisconnectedPrefabInstance)
                    {
                        GUI.contentColor = GUI.skin.GetStyle("CN StatusWarn").normal.textColor;
                        if (prefabType == PrefabType.MissingPrefabInstance)
                        {
                            GUI.Label(new Rect(52f, 44f + y, (float)((double)width1 - 52.0 - 5.0), 18f), content, EditorStyles.whiteLabel);
                        }
                        else
                        {
                            GUI.Label(new Rect((float)(52.0 - (double)x - 5.0), 44f + y, (float)((double)width1 - 52.0 - 5.0), 18f), content, EditorStyles.whiteLabel);
                        }
                        GUI.contentColor = Color.white;
                    }
                    else
                    {
                        GUI.Label(new Rect((float)(52.0 - (double)x - 5.0), 44f + y, x, 18f), content);
                    }
                }
                if (this.targets.Length > 1)
                {
                    GUI.Label(position5, "Instance Management Disabled", GameObjectInspector.s_styles.instanceManagementInfo);
                }
                else
                {
                    if (prefabType != PrefabType.MissingPrefabInstance && GUI.Button(position2, "Select", (GUIStyle)"MiniButtonLeft"))
                    {
                        Selection.activeObject = PrefabUtility.GetPrefabParent(this.target);
                        EditorGUIUtility.PingObject(Selection.activeObject);
                    }
                    if ((prefabType == PrefabType.DisconnectedModelPrefabInstance || prefabType == PrefabType.DisconnectedPrefabInstance) && GUI.Button(position3, "Revert", (GUIStyle)"MiniButtonMid"))
                    {
                        Undo.RegisterFullObjectHierarchyUndo((UnityEngine.Object)target1, "Revert to prefab");
                        PrefabUtility.ReconnectToLastPrefab(target1);
                        PrefabUtility.RevertPrefabInstance(target1);
                        this.CalculatePrefabStatus();
                        Undo.RegisterCreatedObjectUndo((UnityEngine.Object)target1, "Reconnect prefab");
                        GUIUtility.ExitGUI();
                    }
                    bool enabled2 = GUI.enabled;
                    GUI.enabled = GUI.enabled && !AnimationMode.InAnimationMode();
                    if ((prefabType == PrefabType.ModelPrefabInstance || prefabType == PrefabType.PrefabInstance) && GUI.Button(position3, "Revert", (GUIStyle)"MiniButtonMid"))
                    {
                        Undo.RegisterFullObjectHierarchyUndo((UnityEngine.Object)target1, "Revert Prefab Instance");
                        PrefabUtility.RevertPrefabInstance(target1);
                        this.CalculatePrefabStatus();
                        Undo.RegisterCreatedObjectUndo((UnityEngine.Object)target1, "Revert prefab");
                        GUIUtility.ExitGUI();
                    }
                    if (prefabType == PrefabType.PrefabInstance || prefabType == PrefabType.DisconnectedPrefabInstance)
                    {
                        GameObject prefabInstanceRoot = PrefabUtility.FindValidUploadPrefabInstanceRoot(target1);
                        GUI.enabled = (UnityEngine.Object)prefabInstanceRoot != (UnityEngine.Object)null && !AnimationMode.InAnimationMode();
                        if (GUI.Button(position4, "Apply", (GUIStyle)"MiniButtonRight"))
                        {
                            UnityEngine.Object prefabParent = PrefabUtility.GetPrefabParent((UnityEngine.Object)prefabInstanceRoot);
                            if (Provider.PromptAndCheckoutIfNeeded(new string[1] {
                                AssetDatabase.GetAssetPath(prefabParent)
                            }, "The version control requires you to check out the prefab before applying changes."))
                            {
                                PrefabUtility.ReplacePrefab(prefabInstanceRoot, prefabParent, ReplacePrefabOptions.ConnectToPrefab);
                                this.CalculatePrefabStatus();
                                EditorSceneManager.MarkSceneDirty(prefabInstanceRoot.scene);
                                GUIUtility.ExitGUI();
                            }
                        }
                    }
                    GUI.enabled = enabled2;
                    if ((prefabType == PrefabType.DisconnectedModelPrefabInstance || prefabType == PrefabType.ModelPrefabInstance) && GUI.Button(position4, "Open", (GUIStyle)"MiniButtonRight"))
                    {
                        AssetDatabase.OpenAsset(PrefabUtility.GetPrefabParent(this.target));
                        GUIUtility.ExitGUI();
                    }
                }
            }
            EditorGUI.EndDisabledGroup();
            this.serializedObject.ApplyModifiedProperties();
            return(true);
        }
 internal bool DrawInspector(Rect contentRect)
 {
   if (GameObjectInspector.s_styles == null)
     GameObjectInspector.s_styles = new GameObjectInspector.Styles();
   this.serializedObject.Update();
   GameObject target1 = this.target as GameObject;
   EditorGUIUtility.labelWidth = 52f;
   bool enabled1 = GUI.enabled;
   GUI.enabled = true;
   GUI.Label(new Rect(contentRect.x, contentRect.y, contentRect.width, contentRect.height + 3f), GUIContent.none, EditorStyles.inspectorBig);
   GUI.enabled = enabled1;
   float width1 = contentRect.width;
   float y = contentRect.y;
   GUIContent guiContent = (GUIContent) null;
   PrefabType prefabType = PrefabType.None;
   if (this.m_AllOfSamePrefabType)
   {
     prefabType = PrefabUtility.GetPrefabType((UnityEngine.Object) target1);
     switch (prefabType)
     {
       case PrefabType.None:
         guiContent = GameObjectInspector.s_styles.goIcon;
         break;
       case PrefabType.Prefab:
       case PrefabType.PrefabInstance:
       case PrefabType.DisconnectedPrefabInstance:
         guiContent = GameObjectInspector.s_styles.prefabIcon;
         break;
       case PrefabType.ModelPrefab:
       case PrefabType.ModelPrefabInstance:
       case PrefabType.DisconnectedModelPrefabInstance:
         guiContent = GameObjectInspector.s_styles.modelIcon;
         break;
       case PrefabType.MissingPrefabInstance:
         guiContent = GameObjectInspector.s_styles.prefabIcon;
         break;
     }
   }
   else
     guiContent = GameObjectInspector.s_styles.typelessIcon;
   EditorGUI.ObjectIconDropDown(new Rect(3f, 4f + y, 24f, 24f), this.targets, true, guiContent.image as Texture2D, this.m_Icon);
   EditorGUI.BeginDisabledGroup(prefabType == PrefabType.ModelPrefab);
   EditorGUI.PropertyField(new Rect(34f, 4f + y, 14f, 14f), this.m_IsActive, GUIContent.none);
   float num1 = GameObjectInspector.s_styles.staticFieldToggleWidth + 15f;
   float width2 = (float) ((double) width1 - 52.0 - (double) num1 - 5.0);
   EditorGUI.DelayedTextField(new Rect(52f, (float) (4.0 + (double) y + 1.0), width2, 16f), this.m_Name, GUIContent.none);
   Rect totalPosition = new Rect(width1 - num1, 4f + y, GameObjectInspector.s_styles.staticFieldToggleWidth, 16f);
   EditorGUI.BeginProperty(totalPosition, GUIContent.none, this.m_StaticEditorFlags);
   EditorGUI.BeginChangeCheck();
   Rect position1 = totalPosition;
   EditorGUI.showMixedValue |= GameObjectInspector.ShowMixedStaticEditorFlags((StaticEditorFlags) this.m_StaticEditorFlags.intValue);
   Event current = Event.current;
   EventType type = current.type;
   bool flag = current.type == EventType.MouseDown && current.button != 0;
   if (flag)
     current.type = EventType.Ignore;
   bool flagValue = EditorGUI.ToggleLeft(position1, "Static", target1.isStatic);
   if (flag)
     current.type = type;
   EditorGUI.showMixedValue = false;
   if (EditorGUI.EndChangeCheck())
   {
     SceneModeUtility.SetStaticFlags(this.targets, -1, flagValue);
     this.serializedObject.SetIsDifferentCacheDirty();
   }
   EditorGUI.EndProperty();
   EditorGUI.BeginChangeCheck();
   EditorGUI.showMixedValue = this.m_StaticEditorFlags.hasMultipleDifferentValues;
   int changedFlags;
   bool changedToValue;
   EditorGUI.EnumMaskField(new Rect(totalPosition.x + GameObjectInspector.s_styles.staticFieldToggleWidth, totalPosition.y, 10f, 14f), (Enum) GameObjectUtility.GetStaticEditorFlags(target1), GameObjectInspector.s_styles.staticDropdown, out changedFlags, out changedToValue);
   EditorGUI.showMixedValue = false;
   if (EditorGUI.EndChangeCheck())
   {
     SceneModeUtility.SetStaticFlags(this.targets, changedFlags, changedToValue);
     this.serializedObject.SetIsDifferentCacheDirty();
   }
   float num2 = 4f;
   float num3 = 4f;
   EditorGUIUtility.fieldWidth = (float) (((double) width1 - (double) num2 - 52.0 - (double) GameObjectInspector.s_styles.layerFieldWidth - (double) num3) / 2.0);
   string tag;
   try
   {
     tag = target1.tag;
   }
   catch (Exception ex)
   {
     tag = "Undefined";
   }
   EditorGUIUtility.labelWidth = GameObjectInspector.s_styles.tagFieldWidth;
   Rect rect = new Rect(52f - EditorGUIUtility.labelWidth, 24f + y, EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth, 16f);
   EditorGUI.BeginProperty(rect, GUIContent.none, this.m_Tag);
   EditorGUI.BeginChangeCheck();
   string str = EditorGUI.TagField(rect, EditorGUIUtility.TempContent("Tag"), tag);
   if (EditorGUI.EndChangeCheck())
   {
     this.m_Tag.stringValue = str;
     Undo.RecordObjects(this.targets, "Change Tag of " + this.targetTitle);
     foreach (UnityEngine.Object target2 in this.targets)
       (target2 as GameObject).tag = str;
   }
   EditorGUI.EndProperty();
   EditorGUIUtility.labelWidth = GameObjectInspector.s_styles.layerFieldWidth;
   rect = new Rect(52f + EditorGUIUtility.fieldWidth + num2, 24f + y, EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth, 16f);
   EditorGUI.BeginProperty(rect, GUIContent.none, this.m_Layer);
   EditorGUI.BeginChangeCheck();
   int layer = EditorGUI.LayerField(rect, EditorGUIUtility.TempContent("Layer"), target1.layer);
   if (EditorGUI.EndChangeCheck())
   {
     GameObjectUtility.ShouldIncludeChildren shouldIncludeChildren = GameObjectUtility.DisplayUpdateChildrenDialogIfNeeded(this.targets.OfType<GameObject>(), "Change Layer", "Do you want to set layer to " + InternalEditorUtility.GetLayerName(layer) + " for all child objects as well?");
     if (shouldIncludeChildren != GameObjectUtility.ShouldIncludeChildren.Cancel)
     {
       this.m_Layer.intValue = layer;
       this.SetLayer(layer, shouldIncludeChildren == GameObjectUtility.ShouldIncludeChildren.IncludeChildren);
     }
   }
   EditorGUI.EndProperty();
   if (this.m_HasInstance && !EditorApplication.isPlayingOrWillChangePlaymode)
   {
     float width3 = (float) (((double) width1 - 52.0 - 5.0) / 3.0);
     Rect position2 = new Rect((float) (52.0 + (double) width3 * 0.0), 44f + y, width3, 15f);
     Rect position3 = new Rect((float) (52.0 + (double) width3 * 1.0), 44f + y, width3, 15f);
     Rect position4 = new Rect((float) (52.0 + (double) width3 * 2.0), 44f + y, width3, 15f);
     Rect position5 = new Rect(52f, 44f + y, width3 * 3f, 15f);
     GUIContent content = this.targets.Length <= 1 ? GameObjectInspector.s_styles.goTypeLabel[(int) prefabType] : GameObjectInspector.s_styles.goTypeLabelMultiple;
     if (content != null)
     {
       float x = GUI.skin.label.CalcSize(content).x;
       if (prefabType == PrefabType.DisconnectedModelPrefabInstance || prefabType == PrefabType.MissingPrefabInstance || prefabType == PrefabType.DisconnectedPrefabInstance)
       {
         GUI.contentColor = GUI.skin.GetStyle("CN StatusWarn").normal.textColor;
         if (prefabType == PrefabType.MissingPrefabInstance)
           GUI.Label(new Rect(52f, 44f + y, (float) ((double) width1 - 52.0 - 5.0), 18f), content, EditorStyles.whiteLabel);
         else
           GUI.Label(new Rect((float) (52.0 - (double) x - 5.0), 44f + y, (float) ((double) width1 - 52.0 - 5.0), 18f), content, EditorStyles.whiteLabel);
         GUI.contentColor = Color.white;
       }
       else
         GUI.Label(new Rect((float) (52.0 - (double) x - 5.0), 44f + y, x, 18f), content);
     }
     if (this.targets.Length > 1)
     {
       GUI.Label(position5, "Instance Management Disabled", GameObjectInspector.s_styles.instanceManagementInfo);
     }
     else
     {
       if (prefabType != PrefabType.MissingPrefabInstance && GUI.Button(position2, "Select", (GUIStyle) "MiniButtonLeft"))
       {
         Selection.activeObject = PrefabUtility.GetPrefabParent(this.target);
         EditorGUIUtility.PingObject(Selection.activeObject);
       }
       if ((prefabType == PrefabType.DisconnectedModelPrefabInstance || prefabType == PrefabType.DisconnectedPrefabInstance) && GUI.Button(position3, "Revert", (GUIStyle) "MiniButtonMid"))
       {
         Undo.RegisterFullObjectHierarchyUndo((UnityEngine.Object) target1, "Revert to prefab");
         PrefabUtility.ReconnectToLastPrefab(target1);
         PrefabUtility.RevertPrefabInstance(target1);
         this.CalculatePrefabStatus();
         Undo.RegisterCreatedObjectUndo((UnityEngine.Object) target1, "Reconnect prefab");
         GUIUtility.ExitGUI();
       }
       bool enabled2 = GUI.enabled;
       GUI.enabled = GUI.enabled && !AnimationMode.InAnimationMode();
       if ((prefabType == PrefabType.ModelPrefabInstance || prefabType == PrefabType.PrefabInstance) && GUI.Button(position3, "Revert", (GUIStyle) "MiniButtonMid"))
       {
         Undo.RegisterFullObjectHierarchyUndo((UnityEngine.Object) target1, "Revert Prefab Instance");
         PrefabUtility.RevertPrefabInstance(target1);
         this.CalculatePrefabStatus();
         Undo.RegisterCreatedObjectUndo((UnityEngine.Object) target1, "Revert prefab");
         GUIUtility.ExitGUI();
       }
       if (prefabType == PrefabType.PrefabInstance || prefabType == PrefabType.DisconnectedPrefabInstance)
       {
         GameObject prefabInstanceRoot = PrefabUtility.FindValidUploadPrefabInstanceRoot(target1);
         GUI.enabled = (UnityEngine.Object) prefabInstanceRoot != (UnityEngine.Object) null && !AnimationMode.InAnimationMode();
         if (GUI.Button(position4, "Apply", (GUIStyle) "MiniButtonRight"))
         {
           UnityEngine.Object prefabParent = PrefabUtility.GetPrefabParent((UnityEngine.Object) prefabInstanceRoot);
           if (Provider.PromptAndCheckoutIfNeeded(new string[1]{ AssetDatabase.GetAssetPath(prefabParent) }, "The version control requires you to check out the prefab before applying changes."))
           {
             PrefabUtility.ReplacePrefab(prefabInstanceRoot, prefabParent, ReplacePrefabOptions.ConnectToPrefab);
             this.CalculatePrefabStatus();
             EditorSceneManager.MarkSceneDirty(prefabInstanceRoot.scene);
             GUIUtility.ExitGUI();
           }
         }
       }
       GUI.enabled = enabled2;
       if ((prefabType == PrefabType.DisconnectedModelPrefabInstance || prefabType == PrefabType.ModelPrefabInstance) && GUI.Button(position4, "Open", (GUIStyle) "MiniButtonRight"))
       {
         AssetDatabase.OpenAsset(PrefabUtility.GetPrefabParent(this.target));
         GUIUtility.ExitGUI();
       }
     }
   }
   EditorGUI.EndDisabledGroup();
   this.serializedObject.ApplyModifiedProperties();
   return true;
 }
		internal bool DrawInspector(Rect contentRect)
		{
			if (GameObjectInspector.s_styles == null)
			{
				GameObjectInspector.s_styles = new GameObjectInspector.Styles();
			}
			base.serializedObject.Update();
			GameObject gameObject = this.target as GameObject;
			EditorGUIUtility.labelWidth = 52f;
			bool enabled = GUI.enabled;
			GUI.enabled = true;
			GUI.Label(new Rect(contentRect.x, contentRect.y, contentRect.width, contentRect.height + 3f), GUIContent.none, EditorStyles.inspectorBig);
			GUI.enabled = enabled;
			float width = contentRect.width;
			float y = contentRect.y;
			GUIContent gUIContent = null;
			PrefabType prefabType = PrefabType.None;
			if (this.m_AllOfSamePrefabType)
			{
				prefabType = PrefabUtility.GetPrefabType(gameObject);
				switch (prefabType)
				{
				case PrefabType.None:
					gUIContent = GameObjectInspector.s_styles.goIcon;
					break;
				case PrefabType.Prefab:
				case PrefabType.PrefabInstance:
				case PrefabType.DisconnectedPrefabInstance:
					gUIContent = GameObjectInspector.s_styles.prefabIcon;
					break;
				case PrefabType.ModelPrefab:
				case PrefabType.ModelPrefabInstance:
				case PrefabType.DisconnectedModelPrefabInstance:
					gUIContent = GameObjectInspector.s_styles.modelIcon;
					break;
				case PrefabType.MissingPrefabInstance:
					gUIContent = GameObjectInspector.s_styles.prefabIcon;
					break;
				}
			}
			else
			{
				gUIContent = GameObjectInspector.s_styles.typelessIcon;
			}
			EditorGUI.ObjectIconDropDown(new Rect(3f, 4f + y, 24f, 24f), base.targets, true, gUIContent.image as Texture2D, this.m_Icon);
			EditorGUI.BeginDisabledGroup(prefabType == PrefabType.ModelPrefab);
			EditorGUI.PropertyField(new Rect(34f, 4f + y, 14f, 14f), this.m_IsActive, GUIContent.none);
			float num = GameObjectInspector.s_styles.staticFieldToggleWidth + 15f;
			float width2 = width - 52f - num - 5f;
			EditorGUI.BeginChangeCheck();
			EditorGUI.showMixedValue = this.m_Name.hasMultipleDifferentValues;
			string name = EditorGUI.DelayedTextField(new Rect(52f, 4f + y + 1f, width2, 16f), gameObject.name, null, EditorStyles.textField);
			EditorGUI.showMixedValue = false;
			if (EditorGUI.EndChangeCheck())
			{
				UnityEngine.Object[] targets = base.targets;
				for (int i = 0; i < targets.Length; i++)
				{
					UnityEngine.Object @object = targets[i];
					ObjectNames.SetNameSmart(@object as GameObject, name);
				}
			}
			Rect rect = new Rect(width - num, 4f + y, GameObjectInspector.s_styles.staticFieldToggleWidth, 16f);
			EditorGUI.BeginProperty(rect, GUIContent.none, this.m_StaticEditorFlags);
			EditorGUI.BeginChangeCheck();
			Rect position = rect;
			EditorGUI.showMixedValue |= GameObjectInspector.ShowMixedStaticEditorFlags((StaticEditorFlags)this.m_StaticEditorFlags.intValue);
			Event current = Event.current;
			EventType type = current.type;
			bool flag = current.type == EventType.MouseDown && current.button != 0;
			if (flag)
			{
				current.type = EventType.Ignore;
			}
			bool flagValue = EditorGUI.ToggleLeft(position, "Static", gameObject.isStatic);
			if (flag)
			{
				current.type = type;
			}
			EditorGUI.showMixedValue = false;
			if (EditorGUI.EndChangeCheck())
			{
				SceneModeUtility.SetStaticFlags(base.targets, -1, flagValue);
				base.serializedObject.SetIsDifferentCacheDirty();
			}
			EditorGUI.EndProperty();
			EditorGUI.BeginChangeCheck();
			EditorGUI.showMixedValue = this.m_StaticEditorFlags.hasMultipleDifferentValues;
			int changedFlags;
			bool flagValue2;
			EditorGUI.EnumMaskField(new Rect(rect.x + GameObjectInspector.s_styles.staticFieldToggleWidth, rect.y, 10f, 14f), GameObjectUtility.GetStaticEditorFlags(gameObject), GameObjectInspector.s_styles.staticDropdown, out changedFlags, out flagValue2);
			EditorGUI.showMixedValue = false;
			if (EditorGUI.EndChangeCheck())
			{
				SceneModeUtility.SetStaticFlags(base.targets, changedFlags, flagValue2);
				base.serializedObject.SetIsDifferentCacheDirty();
			}
			float num2 = 4f;
			float num3 = 4f;
			EditorGUIUtility.fieldWidth = (width - num2 - 52f - GameObjectInspector.s_styles.layerFieldWidth - num3) / 2f;
			string tag = null;
			try
			{
				tag = gameObject.tag;
			}
			catch (Exception)
			{
				tag = "Undefined";
			}
			EditorGUIUtility.labelWidth = GameObjectInspector.s_styles.tagFieldWidth;
			Rect rect2 = new Rect(52f - EditorGUIUtility.labelWidth, 24f + y, EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth, 16f);
			EditorGUI.BeginProperty(rect2, GUIContent.none, this.m_Tag);
			EditorGUI.BeginChangeCheck();
			string text = EditorGUI.TagField(rect2, EditorGUIUtility.TempContent("Tag"), tag);
			if (EditorGUI.EndChangeCheck())
			{
				this.m_Tag.stringValue = text;
				Undo.RecordObjects(base.targets, "Change Tag of " + this.targetTitle);
				UnityEngine.Object[] targets2 = base.targets;
				for (int j = 0; j < targets2.Length; j++)
				{
					UnityEngine.Object object2 = targets2[j];
					(object2 as GameObject).tag = text;
				}
			}
			EditorGUI.EndProperty();
			EditorGUIUtility.labelWidth = GameObjectInspector.s_styles.layerFieldWidth;
			rect2 = new Rect(52f + EditorGUIUtility.fieldWidth + num2, 24f + y, EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth, 16f);
			EditorGUI.BeginProperty(rect2, GUIContent.none, this.m_Layer);
			EditorGUI.BeginChangeCheck();
			int num4 = EditorGUI.LayerField(rect2, EditorGUIUtility.TempContent("Layer"), gameObject.layer);
			if (EditorGUI.EndChangeCheck())
			{
				GameObjectUtility.ShouldIncludeChildren shouldIncludeChildren = GameObjectUtility.DisplayUpdateChildrenDialogIfNeeded(base.targets.OfType<GameObject>(), "Change Layer", "Do you want to set layer to " + InternalEditorUtility.GetLayerName(num4) + " for all child objects as well?");
				if (shouldIncludeChildren != GameObjectUtility.ShouldIncludeChildren.Cancel)
				{
					this.m_Layer.intValue = num4;
					this.SetLayer(num4, shouldIncludeChildren == GameObjectUtility.ShouldIncludeChildren.IncludeChildren);
				}
			}
			EditorGUI.EndProperty();
			if (this.m_HasInstance && !EditorApplication.isPlayingOrWillChangePlaymode)
			{
				float num5 = (width - 52f - 5f) / 3f;
				Rect position2 = new Rect(52f + num5 * 0f, 44f + y, num5, 15f);
				Rect position3 = new Rect(52f + num5 * 1f, 44f + y, num5, 15f);
				Rect position4 = new Rect(52f + num5 * 2f, 44f + y, num5, 15f);
				Rect position5 = new Rect(52f, 44f + y, num5 * 3f, 15f);
				GUIContent gUIContent2 = (base.targets.Length <= 1) ? GameObjectInspector.s_styles.goTypeLabel[(int)prefabType] : GameObjectInspector.s_styles.goTypeLabelMultiple;
				if (gUIContent2 != null)
				{
					float x = GUI.skin.label.CalcSize(gUIContent2).x;
					if (prefabType == PrefabType.DisconnectedModelPrefabInstance || prefabType == PrefabType.MissingPrefabInstance || prefabType == PrefabType.DisconnectedPrefabInstance)
					{
						GUI.contentColor = GUI.skin.GetStyle("CN StatusWarn").normal.textColor;
						if (prefabType == PrefabType.MissingPrefabInstance)
						{
							GUI.Label(new Rect(52f, 44f + y, width - 52f - 5f, 18f), gUIContent2, EditorStyles.whiteLabel);
						}
						else
						{
							GUI.Label(new Rect(52f - x - 5f, 44f + y, width - 52f - 5f, 18f), gUIContent2, EditorStyles.whiteLabel);
						}
						GUI.contentColor = Color.white;
					}
					else
					{
						Rect position6 = new Rect(52f - x - 5f, 44f + y, x, 18f);
						GUI.Label(position6, gUIContent2);
					}
				}
				if (base.targets.Length > 1)
				{
					GUI.Label(position5, "Instance Management Disabled", GameObjectInspector.s_styles.instanceManagementInfo);
				}
				else
				{
					if (prefabType != PrefabType.MissingPrefabInstance && GUI.Button(position2, "Select", "MiniButtonLeft"))
					{
						Selection.activeObject = PrefabUtility.GetPrefabParent(this.target);
						EditorGUIUtility.PingObject(Selection.activeObject);
					}
					if ((prefabType == PrefabType.DisconnectedModelPrefabInstance || prefabType == PrefabType.DisconnectedPrefabInstance) && GUI.Button(position3, "Revert", "MiniButtonMid"))
					{
						Undo.RegisterFullObjectHierarchyUndo(gameObject, "Revert to prefab");
						PrefabUtility.ReconnectToLastPrefab(gameObject);
						PrefabUtility.RevertPrefabInstance(gameObject);
						this.CalculatePrefabStatus();
						Undo.RegisterCreatedObjectUndo(gameObject, "Reconnect prefab");
						GUIUtility.ExitGUI();
					}
					bool enabled2 = GUI.enabled;
					GUI.enabled = (GUI.enabled && !AnimationMode.InAnimationMode());
					if ((prefabType == PrefabType.ModelPrefabInstance || prefabType == PrefabType.PrefabInstance) && GUI.Button(position3, "Revert", "MiniButtonMid"))
					{
						Undo.RegisterFullObjectHierarchyUndo(gameObject, "Revert Prefab Instance");
						PrefabUtility.RevertPrefabInstance(gameObject);
						this.CalculatePrefabStatus();
						GUIUtility.ExitGUI();
					}
					if (prefabType == PrefabType.PrefabInstance || prefabType == PrefabType.DisconnectedPrefabInstance)
					{
						GameObject gameObject2 = PrefabUtility.FindValidUploadPrefabInstanceRoot(gameObject);
						GUI.enabled = (gameObject2 != null && !AnimationMode.InAnimationMode());
						if (GUI.Button(position4, "Apply", "MiniButtonRight"))
						{
							UnityEngine.Object prefabParent = PrefabUtility.GetPrefabParent(gameObject2);
							string assetPath = AssetDatabase.GetAssetPath(prefabParent);
							bool flag2 = Provider.PromptAndCheckoutIfNeeded(new string[]
							{
								assetPath
							}, "The version control requires you to checkout the prefab before applying changes.");
							if (flag2)
							{
								PrefabUtility.ReplacePrefab(gameObject2, prefabParent, ReplacePrefabOptions.ConnectToPrefab);
								this.CalculatePrefabStatus();
								GUIUtility.ExitGUI();
							}
						}
					}
					GUI.enabled = enabled2;
					if ((prefabType == PrefabType.DisconnectedModelPrefabInstance || prefabType == PrefabType.ModelPrefabInstance) && GUI.Button(position4, "Open", "MiniButtonRight"))
					{
						AssetDatabase.OpenAsset(PrefabUtility.GetPrefabParent(this.target));
						GUIUtility.ExitGUI();
					}
				}
			}
			EditorGUI.EndDisabledGroup();
			base.serializedObject.ApplyModifiedProperties();
			return true;
		}