static bool IsDropTargetUserModifiable(GameObjectTreeViewItem targetItem, DropPosition dropPos) { switch (dropPos) { case DropPosition.Upon: if (targetItem.objectPPTR != null) { return(IsUserModifiable(targetItem.objectPPTR)); } break; case DropPosition.Below: case DropPosition.Above: var targetParent = targetItem.parent as GameObjectTreeViewItem; if (targetParent != null && targetParent.objectPPTR != null) { return(IsUserModifiable(targetParent.objectPPTR)); } break; default: throw new ArgumentOutOfRangeException(nameof(dropPos), dropPos, null); } return(true); }
public float PrefabModeButton(GameObjectTreeViewItem item, Rect selectionRect) { float contentRectRight = selectionRect.xMax; if (item.showPrefabModeButton) { float yOffset = (selectionRect.height - GameObjectStyles.rightArrow.fixedWidth) / 2; Rect buttonRect = new Rect( selectionRect.xMax - GameObjectStyles.rightArrow.fixedWidth - GameObjectStyles.rightArrow.margin.right, selectionRect.y + yOffset, GameObjectStyles.rightArrow.fixedWidth, GameObjectStyles.rightArrow.fixedHeight); int instanceID = item.id; GUIContent content = buttonRect.Contains(Event.current.mousePosition) ? PrefabStageUtility.GetPrefabButtonContent(instanceID) : GUIContent.none; if (GUI.Button(buttonRect, content, GameObjectStyles.rightArrow)) { GameObject go = EditorUtility.InstanceIDToObject(instanceID) as GameObject; string assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(go); Object originalSource = AssetDatabase.LoadMainAssetAtPath(assetPath); if (originalSource != null) { var prefabStageMode = PrefabStageUtility.GetPrefabStageModeFromModifierKeys(); PrefabStageUtility.OpenPrefab(assetPath, go, prefabStageMode, StageNavigationManager.Analytics.ChangeType.EnterViaInstanceHierarchyRightArrow); } } contentRectRight = buttonRect.xMin; } return(contentRectRight); }
protected void DoAdditionalSceneHeaderGUI(GameObjectTreeViewItem goItem, Rect rect) { Rect position = new Rect(rect.width - 16f - 4f, rect.y + (rect.height - 6f) * 0.5f, 16f, rect.height); if (Event.current.type == EventType.Repaint) { GameObjectTreeViewGUI.GameObjectStyles.optionsButtonStyle.Draw(position, false, false, false, false); } position.y = rect.y; position.height = rect.height; position.width = 24f; if (EditorGUI.DropdownButton(position, GUIContent.none, FocusType.Passive, GUIStyle.none)) { this.m_TreeView.SelectionClick(goItem, true); this.m_TreeView.contextClickItemCallback(goItem.id); } if (GameObjectTreeViewGUI.OnPostHeaderGUI != null) { float num = rect.width - position.x; float width = rect.width - num - 4f; float x = 0f; float y = rect.y; float height = rect.height; Rect availableRect = new Rect(x, y, width, height); GameObjectTreeViewGUI.OnPostHeaderGUI(availableRect, goItem.scene.path); } }
int GetDropTargetInstanceID(GameObjectTreeViewItem hierarchyTargetItem, DropPosition dropPosition) { if (SubSceneGUI.IsUsingSubScenes()) { var gameObjectDropTarget = hierarchyTargetItem.objectPPTR as GameObject; if (gameObjectDropTarget != null) { if (dropPosition == DropPosition.Above) { return(hierarchyTargetItem.id); } if (SubSceneGUI.IsSubSceneHeader(gameObjectDropTarget)) { Scene subScene = SubSceneGUI.GetSubScene(gameObjectDropTarget); if (subScene.IsValid()) { return(subScene.handle); } else { return(0); } } } } return(hierarchyTargetItem.id); }
void SetItemIcon(GameObjectTreeViewItem item) { var go = item.objectPPTR as GameObject; if (go == null) { if (IsPrefabStageHeader(item)) { string prefabAssetPath = PrefabStageUtility.GetCurrentPrefabStage().prefabAssetPath; item.icon = (Texture2D)AssetDatabase.GetCachedIcon(prefabAssetPath); } else { item.icon = GameObjectStyles.sceneAssetIcon; } } else { if (SubSceneGUI.IsSubSceneHeader(go)) { item.icon = GameObjectStyles.sceneAssetIcon; } else { item.icon = PrefabUtility.GetIconForGameObject(go); } } }
protected override void OnAdditionalGUI(Rect rect, int row, TreeViewItem item, bool selected, bool focused) { GameObjectTreeViewItem goItem = item as GameObjectTreeViewItem; if (goItem == null) { return; } m_ContentRectRight = 0; if (goItem.isSceneHeader) { m_ContentRectRight = DoAdditionalSceneHeaderGUI(goItem, rect); } else { m_ContentRectRight = PrefabModeButton(goItem, rect); if (SubSceneGUI.IsUsingSubScenes() && !showingSearchResults) { SubSceneGUI.DrawVerticalLine(rect, k_BaseIndent, k_IndentWidth, (GameObject)goItem.objectPPTR); } HandlePrefabInstanceOverrideStatus(goItem, rect, selected, focused); } if (SceneHierarchy.s_Debug) { GUI.Label(new Rect(rect.xMax - 70, rect.y, 70, rect.height), "" + row + " (" + goItem.id + ")", EditorStyles.boldLabel); } }
private void InitTreeViewItem(GameObjectTreeViewItem item, int itemID, Scene scene, bool isSceneHeader, int colorCode, UnityEngine.Object pptrObject, bool hasChildren, int depth) { item.children = null; item.userData = null; item.id = itemID; item.depth = depth; item.parent = null; if (isSceneHeader) { item.displayName = ((!string.IsNullOrEmpty(scene.name)) ? scene.name : "Untitled"); } else { item.displayName = null; } item.colorCode = colorCode; item.objectPPTR = pptrObject; item.shouldDisplay = true; item.isSceneHeader = isSceneHeader; item.scene = scene; item.icon = ((!isSceneHeader) ? null : EditorGUIUtility.FindTexture("SceneAsset Icon")); if (hasChildren) { item.children = LazyTreeViewDataSource.CreateChildListForCollapsedParent(); } }
protected float DoAdditionalSceneHeaderGUI(GameObjectTreeViewItem goItem, Rect rect) { const float margin = 4f; Rect buttonRect; if (DoOptionsButton(rect, out buttonRect)) { // Ensure item is selected before using context menu (menu logic is based on selection) m_TreeView.SelectionClick(goItem, true); m_TreeView.contextClickItemCallback(goItem.id); } float availableRectLeft = buttonRect.xMin; if (null != OnPostHeaderGUI) { float optionsWidth = (rect.width - buttonRect.x); float width = (rect.width - optionsWidth - margin); float x = 0; float y = rect.y; float height = rect.height; Rect availableRect = new Rect(x, y, width, height); availableRectLeft = Math.Min(availableRectLeft, OnPostHeaderGUI(availableRect, goItem.scene.path)); } return(availableRectLeft); }
static DragAndDropVisualMode PrefabModeDraggingHandler(GameObjectTreeViewItem parentItem, GameObjectTreeViewItem targetItem, TreeViewDragging.DropPosition dropPos, bool perform) { var stage = StageNavigationManager.instance.currentItem; if (!stage.isPrefabStage) { throw new InvalidOperationException("PrefabModeDraggingHandler should only be called in Prefab Mode"); } // Disallow dropping as sibling to the prefab instance root (In Prefab Mode we only want to show one root). if (parentItem != null && parentItem.parent == null && dropPos != TreeViewDragging.DropPosition.Upon) { return(DragAndDropVisualMode.Rejected); } // Check for cyclic nesting (only on perform since it is an expensive operation) if (perform) { var prefabAssetThatIsAddedTo = AssetDatabase.LoadMainAssetAtPath(stage.prefabAssetPath); foreach (var dragged in DragAndDrop.objectReferences) { if (dragged is GameObject && EditorUtility.IsPersistent(dragged)) { var prefabAssetThatWillBeAdded = dragged; if (PrefabUtility.CheckIfAddingPrefabWouldResultInCyclicNesting(prefabAssetThatIsAddedTo, prefabAssetThatWillBeAdded)) { PrefabUtility.ShowCyclicNestingWarningDialog(); return(DragAndDropVisualMode.Rejected); } } } } return(DragAndDropVisualMode.None); }
private void InitTreeViewItem(GameObjectTreeViewItem item, int itemID, Scene scene, bool isSceneHeader, int colorCode, Object pptrObject, bool hasChildren, int depth) { item.children = null; item.id = itemID; item.depth = depth; item.parent = null; if (isSceneHeader) { item.displayName = string.IsNullOrEmpty(scene.name) ? "Untitled" : scene.name; } else { item.displayName = null; // For GameObject, name is empty as the name gets set from the objectPPTR if the Item is used in GameObjectTreeViewGUI. } item.colorCode = colorCode; item.objectPPTR = pptrObject; item.shouldDisplay = true; item.isSceneHeader = isSceneHeader; item.scene = scene; item.icon = isSceneHeader ? EditorGUIUtility.FindTexture(typeof(SceneAsset)) : null; if (hasChildren) { item.children = CreateChildListForCollapsedParent(); // add a dummy child in children list to ensure we show the collapse arrow (because we do not fetch data for collapsed items) } }
public override bool BeginRename(TreeViewItem item, float delay) { GameObjectTreeViewItem gameObjectTreeViewItem = item as GameObjectTreeViewItem; bool result; if (gameObjectTreeViewItem == null) { result = false; } else if (gameObjectTreeViewItem.isSceneHeader) { result = false; } else { UnityEngine.Object objectPPTR = gameObjectTreeViewItem.objectPPTR; if ((objectPPTR.hideFlags & HideFlags.NotEditable) != HideFlags.None) { Debug.LogWarning("Unable to rename a GameObject with HideFlags.NotEditable."); result = false; } else { result = base.BeginRename(item, delay); } } return(result); }
private void HandleContextClick() { Event current = Event.current; if (current.type == EventType.ContextClick) { current.Use(); GenericMenu menu = new GenericMenu(); menu.AddItem(EditorGUIUtility.TextContent("Copy"), false, new GenericMenu.MenuFunction(this.CopyGO)); menu.AddItem(EditorGUIUtility.TextContent("Paste"), false, new GenericMenu.MenuFunction(this.PasteGO)); menu.AddSeparator(string.Empty); if (!base.hasSearchFilter && (this.m_TreeViewState.selectedIDs.Count == 1)) { menu.AddItem(EditorGUIUtility.TextContent("Rename"), false, new GenericMenu.MenuFunction(this.RenameGO)); } else { menu.AddDisabledItem(EditorGUIUtility.TextContent("Rename")); } menu.AddItem(EditorGUIUtility.TextContent("Duplicate"), false, new GenericMenu.MenuFunction(this.DuplicateGO)); menu.AddItem(EditorGUIUtility.TextContent("Delete"), false, new GenericMenu.MenuFunction(this.DeleteGO)); menu.AddSeparator(string.Empty); bool flag = false; if (this.m_TreeViewState.selectedIDs.Count == 1) { GameObjectTreeViewItem item = this.treeView.FindNode(this.m_TreeViewState.selectedIDs[0]) as GameObjectTreeViewItem; if (item != null) {
void SetItemOverlayIcon(GameObjectTreeViewItem item) { item.overlayIcon = null; var go = item.objectPPTR as GameObject; if (go == null) { return; } if (PrefabUtility.IsAddedGameObjectOverride(go)) { item.overlayIcon = EditorGUIUtility.LoadIcon("PrefabOverlayAdded Icon"); } if (!EditorApplication.isPlaying) { Asset asset = GetAsset(item); if (asset != null && !m_HierarchyPrefabToAssetIDMap.ContainsKey(item.id)) { string metaPath = asset.path.Trim('/') + ".meta"; Asset metaAsset = Provider.GetAssetByPath(metaPath); Asset[] assets = new[] { asset, metaAsset }; m_HierarchyPrefabToAssetIDMap.Add(item.id, assets); } } }
protected void DoAdditionalSceneHeaderGUI(GameObjectTreeViewItem goItem, Rect rect) { // Options button const float optionsButtonWidth = 16f; const float optionsButtonHeight = 6f; const float margin = 4f; Rect buttonRect = new Rect(rect.width - optionsButtonWidth - margin, rect.y + (rect.height - optionsButtonHeight) * 0.5f, optionsButtonWidth, rect.height); if (Event.current.type == EventType.Repaint) { GameObjectStyles.optionsButtonStyle.Draw(buttonRect, false, false, false, false); } // We want larger click area than the button icon buttonRect.y = rect.y; buttonRect.height = rect.height; buttonRect.width = 24f; if (EditorGUI.DropdownButton(buttonRect, GUIContent.none, FocusType.Passive, GUIStyle.none)) { // Ensure item is selected before using context menu (menu logic is based on selection) m_TreeView.SelectionClick(goItem, true); m_TreeView.contextClickItemCallback(goItem.id); } if (null != OnPostHeaderGUI) { float optionsWidth = (rect.width - buttonRect.x); float width = (rect.width - optionsWidth - margin); float x = 0; float y = rect.y; float height = rect.height; Rect availableRect = new Rect(x, y, width, height); OnPostHeaderGUI(availableRect, goItem.scene.path); } }
private void InitTreeViewItem(GameObjectTreeViewItem item, int itemID, Scene scene, bool isSceneHeader, int colorCode, Object pptrObject, bool hasChildren, int depth) { item.children = null; item.id = itemID; item.depth = depth; item.parent = null; item.icon = null; if (isSceneHeader) { item.displayName = string.IsNullOrEmpty(scene.name) ? "Untitled" : scene.name; } else { item.displayName = null; // For GameObject, name is empty as the name gets set from the objectPPTR if the Item is used in GameObjectTreeViewGUI. } item.colorCode = colorCode; item.objectPPTR = pptrObject; item.isSceneHeader = isSceneHeader; item.scene = scene; item.lazyInitializationDone = false; item.showPrefabModeButton = false; item.overlayIcon = null; if (hasChildren) { item.children = CreateChildListForCollapsedParent(); // add a dummy child in children list to ensure we show the collapse arrow (because we do not fetch data for collapsed items) } }
override protected void DoItemGUI(Rect rect, int row, TreeViewItem item, bool selected, bool focused, bool useBoldFont) { GameObjectTreeViewItem goItem = item as GameObjectTreeViewItem; if (goItem == null) { return; } // Scene header background (make it slightly transparent to hint it // is not the normal scene header) if (goItem.isSceneHeader) { Color oldColor = GUI.color; GUI.color = GUI.color * new Color(1, 1, 1, 0.9f); GUI.Label(rect, GUIContent.none, GameObjectStyles.sceneHeaderBg); GUI.color = oldColor; } base.DoItemGUI(rect, row, item, selected, focused, useBoldFont); // Scene header extras if (goItem.isSceneHeader) { DoAdditionalSceneHeaderGUI(goItem, rect); } if (SceneHierarchyWindow.s_Debug) { GUI.Label(new Rect(rect.xMax - 70, rect.y, 70, rect.height), "" + row + " (" + goItem.id + ")", EditorStyles.boldLabel); } }
private int InitializeSearchResults(HierarchyProperty property, int minAllowedDepth) { int currentSceneHandle = -1; int row = 0; while (property.NextWithDepthCheck((int[])null, minAllowedDepth)) { GameObjectTreeViewItem objectTreeViewItem = this.EnsureCreatedItem(row); if (this.AddSceneHeaderToSearchIfNeeded(objectTreeViewItem, property, ref currentSceneHandle)) { ++row; if (!this.IsSceneHeader(property)) { objectTreeViewItem = this.EnsureCreatedItem(row); } else { continue; } } this.InitTreeViewItem(objectTreeViewItem, property, false, 0); ++row; } return(row); }
void SetItemSelectedIcon(GameObjectTreeViewItem item) { if (item.icon != null) { item.selectedIcon = EditorUtility.GetIconInActiveState(item.icon) as Texture2D; } }
protected override void DoItemGUI(Rect rect, int row, TreeViewItem item, bool selected, bool focused, bool useBoldFont) { GameObjectTreeViewItem gameObjectTreeViewItem = item as GameObjectTreeViewItem; if (gameObjectTreeViewItem == null) { return; } if (gameObjectTreeViewItem.isSceneHeader) { Color color = GUI.color; GUI.color *= new Color(1f, 1f, 1f, 0.9f); GUI.Label(rect, GUIContent.none, GameObjectTreeViewGUI.s_GOStyles.sceneHeaderBg); GUI.color = color; } base.DoItemGUI(rect, row, item, selected, focused, useBoldFont); if (gameObjectTreeViewItem.isSceneHeader) { this.DoAdditionalSceneHeaderGUI(gameObjectTreeViewItem, rect); } if (SceneHierarchyWindow.s_Debug) { GUI.Label(new Rect(rect.xMax - 70f, rect.y, 70f, rect.height), string.Concat(new object[] { string.Empty, row, " (", gameObjectTreeViewItem.id, ")" }), EditorStyles.boldLabel); } }
protected override void DrawIconAndLabel(Rect rect, TreeViewItem item, string label, bool selected, bool focused, bool useBoldFont, bool isPinging) { GameObjectTreeViewItem objectTreeViewItem = item as GameObjectTreeViewItem; if (objectTreeViewItem == null) { return; } if (objectTreeViewItem.isSceneHeader) { if (objectTreeViewItem.scene.isDirty) { label += "*"; } if (!objectTreeViewItem.scene.isLoaded) { label += " (not loaded)"; } bool useBoldFont1 = objectTreeViewItem.scene == SceneManager.GetActiveScene(); EditorGUI.BeginDisabledGroup(!objectTreeViewItem.scene.isLoaded); base.DrawIconAndLabel(rect, item, label, selected, focused, useBoldFont1, isPinging); EditorGUI.EndDisabledGroup(); } else { if (!isPinging) { float contentIndent = this.GetContentIndent(item); rect.x += contentIndent; rect.width -= contentIndent; } int colorCode = objectTreeViewItem.colorCode; if (string.IsNullOrEmpty(item.displayName)) { objectTreeViewItem.displayName = !(objectTreeViewItem.objectPPTR != (UnityEngine.Object)null) ? "deleted gameobject" : objectTreeViewItem.objectPPTR.name; label = objectTreeViewItem.displayName; } GUIStyle guiStyle = TreeViewGUI.s_Styles.lineStyle; if (!objectTreeViewItem.shouldDisplay) { guiStyle = GameObjectTreeViewGUI.s_GOStyles.disabledLabel; } else if ((colorCode & 3) == 0) { guiStyle = colorCode >= 4 ? GameObjectTreeViewGUI.s_GOStyles.disabledLabel : TreeViewGUI.s_Styles.lineStyle; } else if ((colorCode & 3) == 1) { guiStyle = colorCode >= 4 ? GameObjectTreeViewGUI.s_GOStyles.disabledPrefabLabel : GameObjectTreeViewGUI.s_GOStyles.prefabLabel; } else if ((colorCode & 3) == 2) { guiStyle = colorCode >= 4 ? GameObjectTreeViewGUI.s_GOStyles.disabledBrokenPrefabLabel : GameObjectTreeViewGUI.s_GOStyles.brokenPrefabLabel; } guiStyle.padding.left = (int)this.k_SpaceBetweenIconAndText; guiStyle.Draw(rect, label, false, false, selected, focused); } }
void EnsureLazyInitialization(GameObjectTreeViewItem item) { if (!item.lazyInitializationDone) { item.lazyInitializationDone = true; SetItemIcon(item); SetItemOverlayIcon(item); SetPrefabModeButtonVisibility(item); } }
public static void DoItemGUI(Rect rect, GameObjectTreeViewItem goItem, bool isSelected, bool isHovered, bool isFocused, bool isDragging) { if (Event.current.isKey || Event.current.type == EventType.Layout) { return; } Rect iconRect = rect; iconRect.xMin += k_VisibilityIconPadding; iconRect.width = k_IconWidth; isHovered = isHovered && !isDragging; bool isIconHovered = !isDragging && iconRect.Contains(Event.current.mousePosition); Rect icon2Rect = rect; icon2Rect.xMin += 2 * k_VisibilityIconPadding + k_IconWidth; icon2Rect.width = k_IconWidth; bool isIcon2Hovered = !isDragging && icon2Rect.Contains(Event.current.mousePosition); if (isHovered) { GUIView.current.MarkHotRegion(GUIClip.UnclipToWindow(iconRect)); GUIView.current.MarkHotRegion(GUIClip.UnclipToWindow(icon2Rect)); } GameObject gameObject = goItem.objectPPTR as GameObject; if (gameObject) { // The scene header overlaps it's next item by some pixels. Displace the background so it doesn't draw on top of the scene header. // Don't displace when selected or hovered (They already show on top of the header) if (m_PrevItemWasScene && !isSelected && !isHovered) { rect.yMin += k_sceneHeaderOverflow; } DrawItemBackground(rect, false, isSelected, isHovered, isFocused); DrawGameObjectItemVisibility(iconRect, gameObject, isHovered, isIconHovered); DrawGameObjectItemPicking(icon2Rect, gameObject, isHovered, isIcon2Hovered); m_PrevItemWasScene = false; } else { Scene scene = goItem.scene; if (scene.IsValid()) { DrawItemBackground(rect, true, isSelected, isHovered, isFocused); DrawSceneItemVisibility(iconRect, scene, isHovered, isIconHovered); DrawSceneItemPicking(icon2Rect, scene, isHovered, isIcon2Hovered); m_PrevItemWasScene = true; } } }
private void DoStickySceneHeaders() { int firstRowVisible; int lastRowVisible; this.GetFirstAndLastRowVisible(out firstRowVisible, out lastRowVisible); if (firstRowVisible < 0 || lastRowVisible < 0) { return; } // ISSUE: object of a compiler-generated type is created // ISSUE: variable of a compiler-generated type GameObjectTreeViewGUI.\u003CDoStickySceneHeaders\u003Ec__AnonStorey79 headersCAnonStorey79 = new GameObjectTreeViewGUI.\u003CDoStickySceneHeaders\u003Ec__AnonStorey79(); float y = this.m_TreeView.state.scrollPos.y; if (firstRowVisible == 0 && (double)y <= (double)this.topRowMargin) { return; } // ISSUE: reference to a compiler-generated field headersCAnonStorey79.firstItem = (GameObjectTreeViewItem)this.m_TreeView.data.GetItem(firstRowVisible); GameObjectTreeViewItem objectTreeViewItem = (GameObjectTreeViewItem)this.m_TreeView.data.GetItem(firstRowVisible + 1); // ISSUE: reference to a compiler-generated field bool flag = headersCAnonStorey79.firstItem.scene != objectTreeViewItem.scene; float width = GUIClip.visibleRect.width; Rect rowRect = this.GetRowRect(firstRowVisible, width); // ISSUE: reference to a compiler-generated field if (headersCAnonStorey79.firstItem.isSceneHeader && Mathf.Approximately(y, rowRect.y)) { return; } if (!flag) { rowRect.y = y; } // ISSUE: reference to a compiler-generated method GameObjectTreeViewItem sceneHeaderItem = ((GameObjectTreeViewDataSource)this.m_TreeView.data).sceneHeaderItems.FirstOrDefault <GameObjectTreeViewItem>(new Func <GameObjectTreeViewItem, bool>(headersCAnonStorey79.\u003C\u003Em__117)); if (sceneHeaderItem == null) { return; } bool selected = this.m_TreeView.IsItemDragSelectedOrSelected((TreeViewItem)sceneHeaderItem); bool focused = this.m_TreeView.HasFocus(); bool useBoldFont = sceneHeaderItem.scene == SceneManager.GetActiveScene(); this.DoNodeGUI(rowRect, firstRowVisible, (TreeViewItem)sceneHeaderItem, selected, focused, useBoldFont); if (GUI.Button(new Rect(rowRect.x, rowRect.y, rowRect.height, rowRect.height), GUIContent.none, GUIStyle.none)) { this.m_TreeView.Frame(sceneHeaderItem.id, true, false); } this.m_TreeView.HandleUnusedMouseEventsForNode(rowRect, (TreeViewItem)sceneHeaderItem, false); this.HandleStickyHeaderContextClick(rowRect, sceneHeaderItem); }
internal override Texture GetIconForSelectedItem(TreeViewItem item) { GameObjectTreeViewItem goItem = item as GameObjectTreeViewItem; if (goItem != null) { return(goItem.selectedIcon); } return(item.icon); }
public override bool BeginRename(TreeViewItem item, float delay) { GameObjectTreeViewItem item2 = item as GameObjectTreeViewItem; if ((item2.objectPPTR.hideFlags & HideFlags.NotEditable) != HideFlags.None) { Debug.LogWarning("Unable to rename a GameObject with HideFlags.NotEditable."); return(false); } return(base.BeginRename(item, delay)); }
private bool AddSceneHeaderToSearchIfNeeded(GameObjectTreeViewItem item, HierarchyProperty property, ref int currentSceneHandle) { Scene scene = property.GetScene(); if (currentSceneHandle != scene.handle) { currentSceneHandle = scene.handle; this.InitTreeViewItem(item, scene.handle, scene, true, 0, null, false, 0); return(true); } return(false); }
protected override void DrawIconAndLabel(Rect rect, TreeViewItem item, string label, bool selected, bool focused, bool useBoldFont, bool isPinging) { if (!isPinging) { float contentIndent = this.GetContentIndent(item); rect.x += contentIndent; rect.width -= contentIndent; } GameObjectTreeViewItem gameObjectTreeViewItem = item as GameObjectTreeViewItem; int colorCode = gameObjectTreeViewItem.colorCode; if (string.IsNullOrEmpty(item.displayName)) { if (gameObjectTreeViewItem.objectPPTR != null) { gameObjectTreeViewItem.displayName = gameObjectTreeViewItem.objectPPTR.name; } else { gameObjectTreeViewItem.displayName = "deleted gameobject"; } label = gameObjectTreeViewItem.displayName; } GUIStyle gUIStyle = TreeViewGUI.s_Styles.lineStyle; if (!gameObjectTreeViewItem.shouldDisplay) { gUIStyle = GameObjectTreeViewGUI.s_GOStyles.disabledLabel; } else { if ((colorCode & 3) == 0) { gUIStyle = ((colorCode >= 4) ? GameObjectTreeViewGUI.s_GOStyles.disabledLabel : TreeViewGUI.s_Styles.lineStyle); } else { if ((colorCode & 3) == 1) { gUIStyle = ((colorCode >= 4) ? GameObjectTreeViewGUI.s_GOStyles.disabledPrefabLabel : GameObjectTreeViewGUI.s_GOStyles.prefabLabel); } else { if ((colorCode & 3) == 2) { gUIStyle = ((colorCode >= 4) ? GameObjectTreeViewGUI.s_GOStyles.disabledBrokenPrefabLabel : GameObjectTreeViewGUI.s_GOStyles.brokenPrefabLabel); } } } } gUIStyle.padding.left = (int)this.k_SpaceBetweenIconAndText; gUIStyle.Draw(rect, label, false, false, selected, focused); }
private void HandleContextClick() { Event current = Event.current; if (current.type != EventType.ContextClick) { return; } current.Use(); GenericMenu genericMenu = new GenericMenu(); genericMenu.AddItem(EditorGUIUtility.TextContent("HierarchyPopupCopy"), false, new GenericMenu.MenuFunction(this.CopyGO)); genericMenu.AddItem(EditorGUIUtility.TextContent("HierarchyPopupPaste"), false, new GenericMenu.MenuFunction(this.PasteGO)); genericMenu.AddSeparator(string.Empty); if (!base.hasSearchFilter && this.m_TreeViewState.selectedIDs.Count == 1) { genericMenu.AddItem(EditorGUIUtility.TextContent("HierarchyPopupRename"), false, new GenericMenu.MenuFunction(this.RenameGO)); } else { genericMenu.AddDisabledItem(EditorGUIUtility.TextContent("HierarchyPopupRename")); } genericMenu.AddItem(EditorGUIUtility.TextContent("HierarchyPopupDuplicate"), false, new GenericMenu.MenuFunction(this.DuplicateGO)); genericMenu.AddItem(EditorGUIUtility.TextContent("HierarchyPopupDelete"), false, new GenericMenu.MenuFunction(this.DeleteGO)); genericMenu.AddSeparator(string.Empty); bool flag = false; if (this.m_TreeViewState.selectedIDs.Count == 1) { GameObjectTreeViewItem gameObjectTreeViewItem = this.treeView.FindNode(this.m_TreeViewState.selectedIDs[0]) as GameObjectTreeViewItem; if (gameObjectTreeViewItem != null) { UnityEngine.Object prefab = PrefabUtility.GetPrefabParent(gameObjectTreeViewItem.objectPPTR); if (prefab != null) { genericMenu.AddItem(EditorGUIUtility.TextContent("HierarchyPopupSelectPrefab"), false, delegate { Selection.activeObject = prefab; EditorGUIUtility.PingObject(prefab.GetInstanceID()); }); flag = true; } } } if (!flag) { genericMenu.AddDisabledItem(EditorGUIUtility.TextContent("HierarchyPopupSelectPrefab")); } genericMenu.AddSeparator(string.Empty); this.AddCreateGameObjectItemsToMenu(genericMenu, Selection.objects, false); genericMenu.ShowAsContext(); }
void SetPrefabModeButtonVisibility(GameObjectTreeViewItem item) { item.showPrefabModeButton = false; GameObject go = item.objectPPTR as GameObject; if (go == null) { return; } if (!PrefabUtility.IsPartOfAnyPrefab(go)) { return; } if (!PrefabUtility.IsAnyPrefabInstanceRoot(go)) { return; } // Don't show button if prefab asset is missing if (PrefabUtility.GetPrefabInstanceStatus(go) == PrefabInstanceStatus.Connected) { var source = PrefabUtility.GetOriginalSourceOrVariantRoot(go); if (source == null) { return; } // Don't show buttons for model prefabs but allow buttons for other immutables if (PrefabUtility.IsPartOfModelPrefab(source)) { return; } } else if (PrefabUtility.GetPrefabInstanceHandle(go) == null) { return; } else { var assetPath = PrefabUtility.GetAssetPathOfSourcePrefab(go); var broken = AssetDatabase.LoadMainAssetAtPath(assetPath) as BrokenPrefabAsset; if (broken == null || !broken.isPrefabFileValid) { return; } } item.showPrefabModeButton = true; }
private GameObjectTreeViewItem CreateTreeViewItem(HierarchyProperty property, bool hasSearchString, int depth, bool shouldDisplay) { GameObjectTreeViewItem item = new GameObjectTreeViewItem(property.instanceID, depth, null, string.Empty) { colorCode = property.colorCode, objectPPTR = property.pptrValue, shouldDisplay = shouldDisplay }; if (!hasSearchString && property.hasChildren) { item.children = LazyTreeViewDataSource.CreateChildListForCollapsedParent(); } return item; }
static string GetAssetGUID(GameObjectTreeViewItem item) { var go = (GameObject)item.objectPPTR; if (!go || PrefabUtility.GetNearestPrefabInstanceRoot(go) != go) { return(null); } var assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(go); return(AssetDatabase.AssetPathToGUID(assetPath)); }
protected void DoAdditionalSceneHeaderGUI(GameObjectTreeViewItem goItem, Rect rect) { Rect position = new Rect((float) ((double) rect.width - 16.0 - 4.0), rect.y + (float) (((double) rect.height - 6.0) * 0.5), 16f, rect.height); if (Event.current.type == EventType.Repaint) GameObjectTreeViewGUI.s_GOStyles.optionsButtonStyle.Draw(position, false, false, false, false); position.y = rect.y; position.height = rect.height; position.width = 24f; if (!EditorGUI.ButtonMouseDown(position, GUIContent.none, FocusType.Passive, GUIStyle.none)) return; this.m_TreeView.SelectionClick((TreeViewItem) goItem, true); this.m_TreeView.contextClickItemCallback(goItem.id); }
private bool AddSceneHeaderToSearchIfNeeded(GameObjectTreeViewItem item, HierarchyProperty property, ref int currentSceneHandle) { if (SceneManager.sceneCount <= 1) return false; Scene scene = property.GetScene(); if (currentSceneHandle == scene.handle) return false; currentSceneHandle = scene.handle; this.InitTreeViewItem(item, scene.handle, scene, true, 0, (UnityEngine.Object) null, false, 0); return true; }
private DragAndDropVisualMode DoDragScenes(GameObjectTreeViewItem parentItem, GameObjectTreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos) { List<Scene> genericData = DragAndDrop.GetGenericData("SceneHeaderList") as List<Scene>; bool flag1 = genericData != null; bool flag2 = false; if (!flag1 && DragAndDrop.objectReferences.Length > 0) { int num = 0; foreach (UnityEngine.Object objectReference in DragAndDrop.objectReferences) { if (objectReference is SceneAsset) ++num; } flag2 = num == DragAndDrop.objectReferences.Length; } if (!flag1 && !flag2) return DragAndDropVisualMode.None; if (perform) { List<Scene> sceneList = (List<Scene>) null; if (flag2) { List<Scene> source = new List<Scene>(); foreach (UnityEngine.Object objectReference in DragAndDrop.objectReferences) { string assetPath = AssetDatabase.GetAssetPath(objectReference); Scene sceneByPath = SceneManager.GetSceneByPath(assetPath); if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(sceneByPath)) { this.m_TreeView.Frame(sceneByPath.handle, true, true); } else { Scene scene = !Event.current.alt ? EditorSceneManager.OpenScene(assetPath, OpenSceneMode.Additive) : EditorSceneManager.OpenScene(assetPath, OpenSceneMode.AdditiveWithoutLoading); if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(scene)) source.Add(scene); } } if (targetItem != null) sceneList = source; if (SceneManager.sceneCount - source.Count == 1) ((TreeViewDataSource) this.m_TreeView.data).SetExpanded(SceneManager.GetSceneAt(0).handle, true); if (source.Count > 0) { Selection.instanceIDs = source.Select<Scene, int>((Func<Scene, int>) (x => x.handle)).ToArray<int>(); this.m_TreeView.Frame(source.Last<Scene>().handle, true, false); } } else sceneList = genericData; if (sceneList != null) { if (targetItem != null) { Scene scene = targetItem.scene; if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(scene)) { if (!targetItem.isSceneHeader || dropPos == TreeViewDragging.DropPosition.Upon) dropPos = TreeViewDragging.DropPosition.Below; if (dropPos == TreeViewDragging.DropPosition.Above) { for (int index = 0; index < sceneList.Count; ++index) EditorSceneManager.MoveSceneBefore(sceneList[index], scene); } else if (dropPos == TreeViewDragging.DropPosition.Below) { for (int index = sceneList.Count - 1; index >= 0; --index) EditorSceneManager.MoveSceneAfter(sceneList[index], scene); } } } else { Scene sceneAt = SceneManager.GetSceneAt(SceneManager.sceneCount - 1); for (int index = sceneList.Count - 1; index >= 0; --index) EditorSceneManager.MoveSceneAfter(sceneList[index], sceneAt); } } } return DragAndDropVisualMode.Move; }
private GameObjectTreeViewItem EnsureCreatedItem(int row) { if (row >= this.m_VisibleRows.Count) this.m_VisibleRows.Add((TreeViewItem) null); GameObjectTreeViewItem objectTreeViewItem = (GameObjectTreeViewItem) this.m_VisibleRows[row]; if (objectTreeViewItem == null) { objectTreeViewItem = new GameObjectTreeViewItem(0, 0, (TreeViewItem) null, (string) null); this.m_VisibleRows[row] = (TreeViewItem) objectTreeViewItem; } return objectTreeViewItem; }
private void InitTreeViewItem(GameObjectTreeViewItem item, HierarchyProperty property, bool itemHasChildren, int itemDepth) { this.InitTreeViewItem(item, property.instanceID, property.GetScene(), this.IsSceneHeader(property), property.colorCode, property.pptrValue, itemHasChildren, itemDepth); }
private void InitTreeViewItem(GameObjectTreeViewItem item, int itemID, Scene scene, bool isSceneHeader, int colorCode, UnityEngine.Object pptrObject, bool hasChildren, int depth) { item.children = (List<TreeViewItem>) null; item.userData = (object) null; item.id = itemID; item.depth = depth; item.parent = (TreeViewItem) null; item.displayName = !isSceneHeader ? (string) null : (!string.IsNullOrEmpty(scene.path) ? scene.name : "Untitled"); item.colorCode = colorCode; item.objectPPTR = pptrObject; item.shouldDisplay = true; item.isSceneHeader = isSceneHeader; item.scene = scene; item.icon = !isSceneHeader ? (Texture2D) null : EditorGUIUtility.FindTexture("SceneAsset Icon"); if (!hasChildren) return; item.children = LazyTreeViewDataSource.CreateChildListForCollapsedParent(); }
private void CreateSceneHeaderItems() { this.m_StickySceneHeaderItems.Clear(); int sceneCount = SceneManager.sceneCount; for (int index = 0; index < sceneCount; ++index) { Scene sceneAt = SceneManager.GetSceneAt(index); GameObjectTreeViewItem objectTreeViewItem = new GameObjectTreeViewItem(0, 0, (TreeViewItem) null, (string) null); this.InitTreeViewItem(objectTreeViewItem, sceneAt.handle, sceneAt, true, 0, (UnityEngine.Object) null, false, 0); this.m_StickySceneHeaderItems.Add(objectTreeViewItem); } }
private void HandleStickyHeaderContextClick(Rect rect, GameObjectTreeViewItem sceneHeaderItem) { Event current = Event.current; if (Application.platform == RuntimePlatform.OSXEditor) { if ((current.type != EventType.MouseDown || current.button != 1) && current.type != EventType.ContextClick || !rect.Contains(Event.current.mousePosition)) return; current.Use(); this.m_TreeView.contextClickItemCallback(sceneHeaderItem.id); } else { if (Application.platform != RuntimePlatform.WindowsEditor || current.type != EventType.MouseDown || (current.button != 1 || !rect.Contains(Event.current.mousePosition))) return; current.Use(); } }