EnabledState GetFolderChildrenEnabledState(PackageExportTreeViewItem folder) { if (!folder.isFolder) { Debug.LogError("Should be a folder item!"); } if (!folder.hasChildren) { return(EnabledState.None); } EnabledState amount = EnabledState.NotSet; var firstChild = folder.children[0] as PackageExportTreeViewItem; EnabledState initial = firstChild.enabledState; for (int i = 1; i < folder.children.Count; ++i) { var child = folder.children[i] as PackageExportTreeViewItem; if (initial != child.enabledState) { amount = EnabledState.Mixed; break; } } if (amount == EnabledState.NotSet) { amount = initial == EnabledState.All ? EnabledState.All : EnabledState.None; } return(amount); }
private void RecursiveComputeEnabledStateForFolders(PackageExportTreeViewItem pitem, HashSet <PackageExportTreeViewItem> done) { if (pitem.isFolder) { if (pitem.hasChildren) { foreach (TreeViewItem item in pitem.children) { this.RecursiveComputeEnabledStateForFolders(item as PackageExportTreeViewItem, done); } } if (!done.Contains(pitem)) { EnabledState folderChildrenEnabledState = this.GetFolderChildrenEnabledState(pitem); pitem.enabledState = folderChildrenEnabledState; if (folderChildrenEnabledState == EnabledState.Mixed) { done.Add(pitem); for (PackageExportTreeViewItem item2 = pitem.parent as PackageExportTreeViewItem; item2 != null; item2 = item2.parent as PackageExportTreeViewItem) { if (!done.Contains(item2)) { item2.enabledState = EnabledState.Mixed; done.Add(item2); } } } } } }
private EnabledState GetFolderChildrenEnabledState(PackageExportTreeViewItem folder) { ExportPackageItem item = folder.item; if ((item != null) && !item.isFolder) { Debug.LogError("Should be a folder item!"); } if (!folder.hasChildren) { return(EnabledState.None); } EnabledState notSet = EnabledState.NotSet; PackageExportTreeViewItem item2 = folder.children[0] as PackageExportTreeViewItem; ExportPackageItem item3 = item2.item; int num = (item3 != null) ? item3.enabledStatus : 1; for (int i = 1; i < folder.children.Count; i++) { item3 = (folder.children[i] as PackageExportTreeViewItem).item; if (num != item3.enabledStatus) { notSet = EnabledState.Mixed; break; } } if (notSet == EnabledState.NotSet) { notSet = (num != 1) ? EnabledState.None : EnabledState.All; } return(notSet); }
private EnabledState GetFolderChildrenEnabledState(PackageExportTreeViewItem folder) { if (!folder.isFolder) { UnityEngine.Debug.LogError("Should be a folder item!"); } if (!folder.hasChildren) { return(EnabledState.None); } EnabledState notSet = EnabledState.NotSet; PackageExportTreeViewItem item = folder.children[0] as PackageExportTreeViewItem; EnabledState enabledState = item.enabledState; for (int i = 1; i < folder.children.Count; i++) { PackageExportTreeViewItem item2 = folder.children[i] as PackageExportTreeViewItem; if (enabledState != item2.enabledState) { notSet = EnabledState.Mixed; break; } } if (notSet == EnabledState.NotSet) { notSet = (enabledState != EnabledState.All) ? EnabledState.None : EnabledState.All; } return(notSet); }
private EnabledState GetFolderChildrenEnabledState(PackageExportTreeViewItem folder) { if (!folder.isFolder) { Debug.LogError("Should be a folder item!"); } if (!folder.hasChildren) { return EnabledState.None; } EnabledState notSet = EnabledState.NotSet; PackageExportTreeViewItem item = folder.children[0] as PackageExportTreeViewItem; EnabledState enabledState = item.enabledState; for (int i = 1; i < folder.children.Count; i++) { PackageExportTreeViewItem item2 = folder.children[i] as PackageExportTreeViewItem; if (enabledState != item2.enabledState) { notSet = EnabledState.Mixed; break; } } if (notSet == EnabledState.NotSet) { notSet = (enabledState != EnabledState.All) ? EnabledState.None : EnabledState.All; } return notSet; }
private void RecursiveComputeEnabledStateForFolders(PackageExportTreeViewItem pitem, HashSet <PackageExportTreeViewItem> done) { ExportPackageItem item = pitem.item; if ((item == null) || item.isFolder) { if (pitem.hasChildren) { foreach (TreeViewItem item2 in pitem.children) { this.RecursiveComputeEnabledStateForFolders(item2 as PackageExportTreeViewItem, done); } } if ((item != null) && !done.Contains(pitem)) { EnabledState folderChildrenEnabledState = this.GetFolderChildrenEnabledState(pitem); item.enabledStatus = (int)folderChildrenEnabledState; if (folderChildrenEnabledState == EnabledState.Mixed) { done.Add(pitem); for (PackageExportTreeViewItem item3 = pitem.parent as PackageExportTreeViewItem; item3 != null; item3 = item3.parent as PackageExportTreeViewItem) { ExportPackageItem item4 = item3.item; if ((item4 != null) && !done.Contains(item3)) { item4.enabledStatus = 2; done.Add(item3); } } } } } }
public override void FetchData() { int rootDepth = -1; // -1 so its children will have 0 depth m_RootItem = new PackageExportTreeViewItem(null, "Assets".GetHashCode(), rootDepth, null, "InvisibleAssetsFolder"); bool initExpandedState = true; if (initExpandedState) { m_TreeView.state.expandedIDs.Add(m_RootItem.id); } ExportPackageItem[] items = m_PackageExportView.items; Dictionary <string, PackageExportTreeViewItem> treeViewFolders = new Dictionary <string, PackageExportTreeViewItem>(); for (int i = 0; i < items.Length; i++) { var item = items[i]; if (PackageImport.HasInvalidCharInFilePath(item.assetPath)) { continue; // Do not add invalid paths (we already warn the user with a dialog in PackageImport.cs) } string filename = Path.GetFileName(item.assetPath).ConvertSeparatorsToUnity(); string folderPath = Path.GetDirectoryName(item.assetPath).ConvertSeparatorsToUnity(); // Ensure folders. This is for when installed packages have been moved to other folders. TreeViewItem targetFolder = EnsureFolderPath(folderPath, treeViewFolders, initExpandedState); // Add file to folder if (targetFolder != null) { int id = item.assetPath.GetHashCode(); var newItem = new PackageExportTreeViewItem(item, id, targetFolder.depth + 1, targetFolder, filename); targetFolder.AddChild(newItem); if (initExpandedState) { m_TreeView.state.expandedIDs.Add(id); } // We need to ensure that the folder is available for // EnsureFolderPath on subsequent iterations. if (item.isFolder) { treeViewFolders[item.assetPath] = newItem; } } } if (initExpandedState) { m_TreeView.state.expandedIDs.Sort(); } }
private void ComputeEnabledStateForFolders() { PackageExportTreeViewItem root = this.m_TreeView.data.root as PackageExportTreeViewItem; HashSet <PackageExportTreeViewItem> done = new HashSet <PackageExportTreeViewItem> { root }; this.RecursiveComputeEnabledStateForFolders(root, done); }
private void EnableChildrenRecursive(TreeViewItem parentItem, EnabledState enabled) { if (parentItem.hasChildren) { foreach (TreeViewItem item in parentItem.children) { PackageExportTreeViewItem item2 = item as PackageExportTreeViewItem; item2.enabledState = enabled; this.EnableChildrenRecursive(item2, enabled); } } }
void DoIconAndText(PackageExportTreeViewItem item, Rect contentRect, bool selected, bool focused) { EditorGUIUtility.SetIconSize(new Vector2(k_IconWidth, k_IconWidth)); // If not set we see icons scaling down if text is being cropped lineStyle = Styles.lineStyle; lineStyle.padding.left = 0; // padding could have been set by other tree views contentRect.height += 5; // with the default row height, underscore and lower parts of characters like g, p, etc. were not visible if (Event.current.type == EventType.Repaint) { lineStyle.Draw(contentRect, GUIContent.Temp(item.displayName, GetIconForItem(item)), false, false, selected, focused); } EditorGUIUtility.SetIconSize(Vector2.zero); }
private void ItemWasToggled(PackageExportTreeViewItem pitem) { if (this.m_Selection.Count <= 1) { this.EnableChildrenRecursive(pitem, pitem.enabledState); } else { foreach (PackageExportTreeViewItem item in this.m_Selection) { item.enabledState = pitem.enabledState; } } this.ComputeEnabledStateForFolders(); }
private void SelectionChanged(int[] selectedIDs) { this.m_Selection = new List <PackageExportTreeViewItem>(); foreach (TreeViewItem item in this.m_TreeView.data.GetRows()) { if (selectedIDs.Contains <int>(item.id)) { PackageExportTreeViewItem item2 = item as PackageExportTreeViewItem; if (item2 != null) { this.m_Selection.Add(item2); } } } }
private void EnableChildrenRecursive(TreeViewItem parentItem, int enabled) { if (parentItem.hasChildren) { foreach (TreeViewItem item in parentItem.children) { PackageExportTreeViewItem item2 = item as PackageExportTreeViewItem; ExportPackageItem item3 = item2.item; if (item3 != null) { item3.enabledStatus = enabled; } this.EnableChildrenRecursive(item2, enabled); } } }
void ItemWasToggled(PackageExportTreeViewItem pitem) { if (m_Selection.Count <= 1) { EnableChildrenRecursive(pitem, pitem.enabledState); } else { foreach (var i in m_Selection) { i.enabledState = pitem.enabledState; } } ComputeEnabledStateForFolders(); }
static void Toggle(ExportPackageItem[] items, PackageExportTreeViewItem pitem, Rect toggleRect) { bool enabled = pitem.enabledState > EnabledState.None; GUIStyle style = EditorStyles.toggle; bool setMixed = pitem.isFolder && (pitem.enabledState == EnabledState.Mixed); if (setMixed) { style = EditorStyles.toggleMixed; } bool newEnabled = GUI.Toggle(toggleRect, enabled, GUIContent.none, style); if (newEnabled != enabled) { pitem.enabledState = newEnabled ? EnabledState.All : EnabledState.None; } }
private void ItemWasToggled(PackageExportTreeViewItem pitem) { ExportPackageItem item = pitem.item; if (item != null) { if (this.m_Selection.Count <= 1) { this.EnableChildrenRecursive(pitem, item.enabledStatus); } else { foreach (PackageExportTreeViewItem item2 in this.m_Selection) { item2.item.enabledStatus = item.enabledStatus; } } this.ComputeEnabledStateForFolders(); } }
void DoToggle(PackageExportTreeViewItem pitem, Rect toggleRect) { // Toggle on/off EditorGUI.BeginChangeCheck(); Toggle(m_PackageExportView.items, pitem, toggleRect); if (EditorGUI.EndChangeCheck()) { // Only change selection if we already have single selection (Keep multi-selection when toggling) if (m_TreeView.GetSelection().Length <= 1 || !m_TreeView.GetSelection().Contains(pitem.id)) { m_TreeView.SetSelection(new int[] { pitem.id }, false); m_TreeView.NotifyListenersThatSelectionChanged(); } if (itemWasToggled != null) { itemWasToggled(pitem); } Event.current.Use(); } }
void RecursiveComputeEnabledStateForFolders(PackageExportTreeViewItem pitem, HashSet <PackageExportTreeViewItem> done) { if (!pitem.isFolder) { return; } // Depth first recursion to allow parent folders be dependant on child folders // Recurse if (pitem.hasChildren) { foreach (var child in pitem.children) { RecursiveComputeEnabledStateForFolders(child as PackageExportTreeViewItem, done); } } // Now do logic if (!done.Contains(pitem)) { EnabledState enabledState = GetFolderChildrenEnabledState(pitem); pitem.enabledState = enabledState; // If 'item' is mixed then all of its parents will also be mixed if (enabledState == EnabledState.Mixed) { done.Add(pitem); var current = pitem.parent as PackageExportTreeViewItem; while (current != null) { if (!done.Contains(current)) { current.enabledState = EnabledState.Mixed; done.Add(current); } current = current.parent as PackageExportTreeViewItem; } } } }
private void RecursiveComputeEnabledStateForFolders(PackageExportTreeViewItem pitem, HashSet<PackageExportTreeViewItem> done) { if (pitem.isFolder) { if (pitem.hasChildren) { foreach (TreeViewItem item in pitem.children) { this.RecursiveComputeEnabledStateForFolders(item as PackageExportTreeViewItem, done); } } if (!done.Contains(pitem)) { EnabledState folderChildrenEnabledState = this.GetFolderChildrenEnabledState(pitem); pitem.enabledState = folderChildrenEnabledState; if (folderChildrenEnabledState == EnabledState.Mixed) { done.Add(pitem); for (PackageExportTreeViewItem item2 = pitem.parent as PackageExportTreeViewItem; item2 != null; item2 = item2.parent as PackageExportTreeViewItem) { if (!done.Contains(item2)) { item2.enabledState = EnabledState.Mixed; done.Add(item2); } } } } } }
TreeViewItem EnsureFolderPath(string folderPath, Dictionary <string, PackageExportTreeViewItem> treeViewFolders, bool initExpandedState) { // We're in the root folder, so just return the root item as the parent. if (folderPath == "") { return(m_RootItem); } // Does folder path exist? int id = folderPath.GetHashCode(); TreeViewItem item = TreeViewUtility.FindItem(id, m_RootItem); if (item != null) { return(item); } // Add folders as needed string[] splitPath = folderPath.Split('/'); string currentPath = ""; TreeViewItem currentItem = m_RootItem; int folderDepth = -1; // Will be incremented to the right depth in the loop. for (int depth = 0; depth < splitPath.Length; ++depth) { string folder = splitPath[depth]; if (currentPath != "") { currentPath += '/'; } currentPath += folder; // Dont create a 'Assets' folder (we already have that as a hidden root) if (depth == 0 && currentPath == "Assets") { continue; } // Only increment the folder depth if we are past the root "Assets" folder. ++folderDepth; id = currentPath.GetHashCode(); PackageExportTreeViewItem foundItem; if (treeViewFolders.TryGetValue(currentPath, out foundItem)) { currentItem = foundItem; } else { // If we do not have a tree view item for this folder we create one var folderItem = new PackageExportTreeViewItem(null, id, folderDepth, currentItem, folder); // Add to children array of the parent currentItem.AddChild(folderItem); currentItem = folderItem; // Auto expand all folder items if (initExpandedState) { m_TreeView.state.expandedIDs.Add(id); } // For faster finding of folders treeViewFolders[currentPath] = folderItem; } } return(currentItem); }