public override void FetchData()
{
bool firstInitialize = !isInitialized;
m_RootItem = new TreeViewItem(0, 0, null, "Invisible Root Item");
SetExpanded(m_RootItem, true); // ensure always visible
// We want three roots: Favorites, Assets, and Packages
List <TreeViewItem> visibleRoots = new List <TreeViewItem>();
// Favorites root
TreeViewItem savedFiltersRootItem = SavedSearchFilters.ConvertToTreeView();
visibleRoots.Add(savedFiltersRootItem);
// Assets root
int assetsFolderInstanceID = AssetDatabase.GetMainAssetOrInProgressProxyInstanceID("Assets");
int depth = 0;
string displayName = "Assets";
AssetsTreeViewDataSource.RootTreeItem assetRootItem = new AssetsTreeViewDataSource.RootTreeItem(assetsFolderInstanceID, depth, m_RootItem, displayName);
assetRootItem.icon = s_FolderIcon;
visibleRoots.Add(assetRootItem);
// Packages root
displayName = PackageManager.Folders.GetPackagesPath();
AssetsTreeViewDataSource.RootTreeItem packagesRootItem = new AssetsTreeViewDataSource.RootTreeItem(ProjectBrowser.kPackagesFolderInstanceId, depth, m_RootItem, displayName);
packagesRootItem.icon = s_FolderIcon;
visibleRoots.Add(packagesRootItem);
m_RootItem.children = visibleRoots;
// Set global expanded state for roots from EditorPrefs (must be before building the rows)
if (firstInitialize)
{
foreach (TreeViewItem item in m_RootItem.children)
{
// Do not expand Packages root item
if (item.id == ProjectBrowser.kPackagesFolderInstanceId)
{
continue;
}
bool expanded = EditorPrefs.GetBool(kProjectBrowserString + item.displayName, true);
SetExpanded(item, expanded);
}
}
// Build rows
//-----------
m_Rows = new List <TreeViewItem>(100);
// Favorites
savedFiltersRootItem.parent = m_RootItem;
m_Rows.Add(savedFiltersRootItem);
if (IsExpanded(savedFiltersRootItem))
{
foreach (var f in savedFiltersRootItem.children)
{
m_Rows.Add(f);
}
}
else
{
savedFiltersRootItem.children = CreateChildListForCollapsedParent();
}
// Asset folders
m_Rows.Add(assetRootItem);
ReadAssetDatabase("Assets", assetRootItem, depth + 1, m_Rows);
// Individual Package folders (under the Packages root item)
m_Rows.Add(packagesRootItem);
var packages = PackageManagerUtilityInternal.GetAllVisiblePackages(skipHiddenPackages);
if (IsExpanded(packagesRootItem))
{
depth++;
foreach (var package in packages)
{
var packageFolderInstanceId = AssetDatabase.GetMainAssetOrInProgressProxyInstanceID(package.assetPath);
displayName = !string.IsNullOrEmpty(package.displayName) ? package.displayName : package.name;
AssetsTreeViewDataSource.PackageTreeItem packageItem = new AssetsTreeViewDataSource.PackageTreeItem(packageFolderInstanceId, depth, packagesRootItem, displayName);
packageItem.icon = s_FolderIcon;
packagesRootItem.AddChild(packageItem);
m_Rows.Add(packageItem);
ReadAssetDatabase(package.assetPath, packageItem, depth + 1, m_Rows);
}
}
else
{
if (packages.Length > 0)
{
packagesRootItem.children = CreateChildListForCollapsedParent();
}
}
m_NeedRefreshRows = false;
}
public PackageImportTreeViewItem(ImportPackageItem itemIn, int id, int depth, TreeViewItem parent, string displayName)
: base(id, depth, parent, displayName)
{
item = itemIn;
if (item == null)
{
m_EnableState = EnabledState.All;
}
else
{
m_EnableState = (EnabledState)item.enabledStatus;
}
}
public override bool IsRenamingItemAllowed(TreeViewItem item)
{
return(false);
}
public override bool CanBeMultiSelected(TreeViewItem item)
{
return (ProjectBrowser.GetItemType(item.id) != ProjectBrowser.ItemType.SavedFilter);
}
public override bool IsExpandable(TreeViewItem item)
{
return (item.hasChildren && ((item != base.m_RootItem) || base.rootIsCollapsable));
}
public bool IsItemDragSelectedOrSelected(TreeViewItem item)
{
return((this.m_DragSelection.Count <= 0) ? this.state.selectedIDs.Contains(item.id) : this.m_DragSelection.Contains(item.id));
}
public override int GetNumRowsOnPageUpDown(TreeViewItem fromItem, bool pageUp, float heightOfTreeView)
{
return((int)Mathf.Floor(heightOfTreeView / this.k_LineHeight) - 1);
}
public abstract void OnRowGUI(Rect rowRect, TreeViewItem item, int row, bool selected, bool focused);
protected virtual float AddSpaceBefore(TreeViewItem item)
{
return(0f);
}
public int GetNumRowsOnPageUpDown(TreeViewItem fromItem, bool pageUp, float heightOfTreeView)
{
Debug.LogError("GetNumRowsOnPageUpDown: Not impemented");
return((int)Mathf.Floor(heightOfTreeView / 30f));
}
protected virtual Vector2 GetSizeOfRow(TreeViewItem item)
{
return(new Vector2(this.m_TreeView.GetTotalRect().width, 16f));
}
// Returns true if input gameobject or any of its descendants have modifications, otherwise returns false.
bool AddTreeViewItemRecursive(TreeViewItem parentItem, GameObject gameObject, Dictionary <int, PrefabOverrides> prefabOverrideMap, IdSequence idSequence)
{
var gameObjectItem = new PrefabOverridesTreeViewItem
(
idSequence.get(),
parentItem.depth + 1,
gameObject.name
);
gameObjectItem.obj = gameObject;
// We don't know yet if this item should be added to the parent.
bool shouldAddGameObjectItemToParent = false;
PrefabOverrides objectModifications;
prefabOverrideMap.TryGetValue(gameObject.GetInstanceID(), out objectModifications);
if (objectModifications != null)
{
// Added GameObject - note that this earlies out!
AddedGameObject addedGameObjectData = objectModifications.addedGameObjects.Find(x => x.instanceGameObject == gameObject);
if (addedGameObjectData != null)
{
gameObjectItem.singleModification = addedGameObjectData;
gameObjectItem.type = ItemType.ADDED_OBJECT;
parentItem.AddChild(gameObjectItem);
return(true);
}
else
{
// Modified GameObject
ObjectOverride modifiedGameObjectData = objectModifications.objectOverrides.Find(x => x.instanceObject == gameObject);
if (modifiedGameObjectData != null)
{
gameObjectItem.singleModification = modifiedGameObjectData;
gameObjectItem.type = ItemType.PREFAB_OBJECT;
shouldAddGameObjectItemToParent = true;
}
}
// Added components and component modifications
foreach (var component in gameObject.GetComponents(typeof(Component)))
{
var componentItem = new PrefabOverridesTreeViewItem
(
idSequence.get(),
gameObjectItem.depth + 1,
ObjectNames.GetInspectorTitle(component)
);
componentItem.obj = component;
AddedComponent addedComponentData = objectModifications.addedComponents.Find(x => x.instanceComponent == component);
if (addedComponentData != null)
{
componentItem.singleModification = addedComponentData;
componentItem.type = ItemType.ADDED_OBJECT;
gameObjectItem.AddChild(componentItem);
shouldAddGameObjectItemToParent = true;
}
else
{
ObjectOverride modifiedObjectData = objectModifications.objectOverrides.Find(x => x.instanceObject == component);
if (modifiedObjectData != null)
{
componentItem.singleModification = modifiedObjectData;
componentItem.type = ItemType.PREFAB_OBJECT;
gameObjectItem.AddChild(componentItem);
shouldAddGameObjectItemToParent = true;
}
}
}
// Removed components
foreach (var removedComponent in objectModifications.removedComponents)
{
var removedComponentItem = new PrefabOverridesTreeViewItem
(
idSequence.get(),
gameObjectItem.depth + 1,
ObjectNames.GetInspectorTitle(removedComponent.assetComponent)
);
removedComponentItem.obj = removedComponent.assetComponent;
removedComponentItem.singleModification = removedComponent;
removedComponentItem.type = ItemType.REMOVED_OBJECT;
gameObjectItem.AddChild(removedComponentItem);
shouldAddGameObjectItemToParent = true;
}
}
// Recurse into children
foreach (Transform childTransform in gameObject.transform)
{
var childGameObject = childTransform.gameObject;
shouldAddGameObjectItemToParent |= AddTreeViewItemRecursive(gameObjectItem, childGameObject, prefabOverrideMap, idSequence);
}
if (shouldAddGameObjectItemToParent)
{
parentItem.AddChild(gameObjectItem);
return(true);
}
return(false);
}
override public int GetNumRowsOnPageUpDown(TreeViewItem fromItem, bool pageUp, float heightOfTreeView)
{
return((int)Mathf.Floor(heightOfTreeView / k_LineHeight) - 1); // -1 is fast fix for space between roots
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, DropPosition dropPos)
{
if (targetItem == null)
{
return(DragAndDropVisualMode.None);
}
object savedFilterData = DragAndDrop.GetGenericData(ProjectWindowUtil.k_DraggingFavoriteGenericData);
// Dragging saved filter
if (savedFilterData != null)
{
int instanceID = (int)savedFilterData;
if (targetItem is SearchFilterTreeItem && parentItem is SearchFilterTreeItem)// && targetItem.id != draggedInstanceID && parentItem.id != draggedInstanceID)
{
bool validMove = SavedSearchFilters.CanMoveSavedFilter(instanceID, parentItem.id, targetItem.id, dropPos == DropPosition.Below);
if (validMove && perform)
{
SavedSearchFilters.MoveSavedFilter(instanceID, parentItem.id, targetItem.id, dropPos == DropPosition.Below);
m_TreeView.SetSelection(new[] { instanceID }, false);
m_TreeView.NotifyListenersThatSelectionChanged();
}
return(validMove ? DragAndDropVisualMode.Copy : DragAndDropVisualMode.None);
}
return(DragAndDropVisualMode.None);
}
// Dragging of folders into filters
else
{
// Check if we are dragging a single folder
if (targetItem is SearchFilterTreeItem)
{
string genericData = DragAndDrop.GetGenericData(ProjectWindowUtil.k_IsFolderGenericData) as string;
if (genericData == "isFolder")
{
if (perform)
{
Object[] objs = DragAndDrop.objectReferences;
if (objs.Length > 0)
{
string path = AssetDatabase.GetAssetPath(objs[0].GetInstanceID());
if (!string.IsNullOrEmpty(path))
{
// TODO: Fix with new AssetDatabase API when it is ready (GetName)
string folderName = new DirectoryInfo(path).Name;
SearchFilter searchFilter = new SearchFilter();
searchFilter.folders = new[] { path };
bool addAsChild = targetItem == parentItem;
float previewSize = ProjectBrowserColumnOneTreeViewGUI.GetListAreaGridSize();
int instanceID = SavedSearchFilters.AddSavedFilterAfterInstanceID(folderName, searchFilter, previewSize, targetItem.id, addAsChild);
m_TreeView.SetSelection(new[] { instanceID }, false);
m_TreeView.NotifyListenersThatSelectionChanged();
}
else
{
Debug.Log("Could not get asset path from id " + objs[0].GetInstanceID());
}
}
}
return(DragAndDropVisualMode.Copy); // Allow dragging folders to filters
}
return(DragAndDropVisualMode.None); // Assets that are not folders are not allowed to be dragged to filters
}
}
// Assets are handled by base
return(base.DoDrag(parentItem, targetItem, perform, dropPos));
}
internal static int GetItemControlID(TreeViewItem item)
{
return(((item == null) ? 0 : item.id) + 10000000);
}
public virtual void BeginPingNode(TreeViewItem item, float topPixelOfRow, float availableWidth)
{
throw new NotImplementedException();
}
public void HandleUnusedMouseEventsForNode(Rect rect, TreeViewItem item, bool firstItem)
{
int itemControlID = TreeView.GetItemControlID(item);
Event current = Event.current;
EventType typeForControl = current.GetTypeForControl(itemControlID);
switch (typeForControl)
{
case EventType.MouseDown:
if (rect.Contains(Event.current.mousePosition))
{
if (Event.current.button == 0)
{
GUIUtility.keyboardControl = this.m_KeyboardControlID;
this.Repaint();
if (Event.current.clickCount == 2)
{
if (this.itemDoubleClickedCallback != null)
{
this.itemDoubleClickedCallback(item.id);
}
}
else
{
if (this.dragging == null || this.dragging.CanStartDrag(item, this.m_DragSelection, Event.current.mousePosition))
{
this.m_DragSelection = this.GetNewSelection(item, true, false);
DragAndDropDelay dragAndDropDelay = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), itemControlID);
dragAndDropDelay.mouseDownPosition = Event.current.mousePosition;
}
GUIUtility.hotControl = itemControlID;
}
current.Use();
}
else if (Event.current.button == 1)
{
bool keepMultiSelection = true;
this.SelectionClick(item, keepMultiSelection);
}
}
return;
case EventType.MouseUp:
if (GUIUtility.hotControl == itemControlID)
{
GUIUtility.hotControl = 0;
this.m_DragSelection.Clear();
current.Use();
if (rect.Contains(current.mousePosition))
{
float contentIndent = this.gui.GetContentIndent(item);
Rect rect2 = new Rect(rect.x + contentIndent, rect.y, rect.width - contentIndent, rect.height);
List <int> selectedIDs = this.state.selectedIDs;
if (this.m_AllowRenameOnMouseUp && selectedIDs != null && selectedIDs.Count == 1 && selectedIDs[0] == item.id && rect2.Contains(current.mousePosition) && !EditorGUIUtility.HasHolddownKeyModifiers(current))
{
this.BeginNameEditing(0.5f);
}
else
{
this.SelectionClick(item, false);
}
}
}
return;
case EventType.MouseMove:
IL_2D:
if (typeForControl == EventType.DragUpdated || typeForControl == EventType.DragPerform)
{
if (this.dragging != null && this.dragging.DragElement(item, rect, firstItem))
{
GUIUtility.hotControl = 0;
}
return;
}
if (typeForControl != EventType.ContextClick)
{
return;
}
if (rect.Contains(current.mousePosition) && this.contextClickItemCallback != null)
{
this.contextClickItemCallback(item.id);
}
return;
case EventType.MouseDrag:
if (GUIUtility.hotControl == itemControlID && this.dragging != null)
{
DragAndDropDelay dragAndDropDelay2 = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), itemControlID);
if (dragAndDropDelay2.CanStartDrag() && this.dragging.CanStartDrag(item, this.m_DragSelection, dragAndDropDelay2.mouseDownPosition))
{
this.dragging.StartDrag(item, this.m_DragSelection);
GUIUtility.hotControl = 0;
}
current.Use();
}
return;
}
goto IL_2D;
}
public virtual bool BeginRename(TreeViewItem item, float delay)
{
throw new NotImplementedException();
}
private void KeyboardGUI()
{
if (this.m_KeyboardControlID != GUIUtility.keyboardControl || !GUI.enabled)
{
return;
}
if (this.keyboardInputCallback != null)
{
this.keyboardInputCallback();
}
if (Event.current.type == EventType.KeyDown)
{
KeyCode keyCode = Event.current.keyCode;
switch (keyCode)
{
case KeyCode.KeypadEnter:
goto IL_2FB;
case KeyCode.KeypadEquals:
case KeyCode.Insert:
case KeyCode.F1:
IL_8E:
if (keyCode != KeyCode.Return)
{
if (Event.current.keyCode <= KeyCode.A || Event.current.keyCode < KeyCode.Z)
{
}
return;
}
goto IL_2FB;
case KeyCode.UpArrow:
Event.current.Use();
this.OffsetSelection(-1);
return;
case KeyCode.DownArrow:
Event.current.Use();
this.OffsetSelection(1);
return;
case KeyCode.RightArrow:
foreach (int current in this.state.selectedIDs)
{
int row;
TreeViewItem itemAndRowIndex = this.GetItemAndRowIndex(current, out row);
if (itemAndRowIndex != null)
{
if (this.data.IsExpandable(itemAndRowIndex) && !this.data.IsExpanded(itemAndRowIndex))
{
this.UserInputChangedExpandedState(itemAndRowIndex, row, true);
}
else if (this.state.selectedIDs.Count == 1)
{
this.HandleFastExpand(itemAndRowIndex, row);
}
}
}
Event.current.Use();
return;
case KeyCode.LeftArrow:
foreach (int current2 in this.state.selectedIDs)
{
int row2;
TreeViewItem itemAndRowIndex2 = this.GetItemAndRowIndex(current2, out row2);
if (itemAndRowIndex2 != null)
{
if (this.data.IsExpandable(itemAndRowIndex2) && this.data.IsExpanded(itemAndRowIndex2))
{
this.UserInputChangedExpandedState(itemAndRowIndex2, row2, false);
}
else if (this.state.selectedIDs.Count == 1)
{
this.HandleFastCollapse(itemAndRowIndex2, row2);
}
}
}
Event.current.Use();
return;
case KeyCode.Home:
Event.current.Use();
this.OffsetSelection(-1000000);
return;
case KeyCode.End:
Event.current.Use();
this.OffsetSelection(1000000);
return;
case KeyCode.PageUp:
{
Event.current.Use();
TreeViewItem treeViewItem = this.data.FindItem(this.state.lastClickedID);
if (treeViewItem != null)
{
int numRowsOnPageUpDown = this.gui.GetNumRowsOnPageUpDown(treeViewItem, true, this.m_TotalRect.height);
this.OffsetSelection(-numRowsOnPageUpDown);
}
return;
}
case KeyCode.PageDown:
{
Event.current.Use();
TreeViewItem treeViewItem2 = this.data.FindItem(this.state.lastClickedID);
if (treeViewItem2 != null)
{
int numRowsOnPageUpDown2 = this.gui.GetNumRowsOnPageUpDown(treeViewItem2, true, this.m_TotalRect.height);
this.OffsetSelection(numRowsOnPageUpDown2);
}
return;
}
case KeyCode.F2:
if (Application.platform == RuntimePlatform.WindowsEditor && this.BeginNameEditing(0f))
{
Event.current.Use();
}
return;
}
goto IL_8E;
IL_2FB:
if (Application.platform == RuntimePlatform.OSXEditor && this.BeginNameEditing(0f))
{
Event.current.Use();
}
}
}
public virtual float GetContentIndent(TreeViewItem item)
{
return(this.GetFoldoutIndent(item) + this.m_FoldoutWidth);
}
private bool IsVisibleRootNode(TreeViewItem item)
{
return((this.m_TreeView.data as ProjectBrowserColumnOneTreeViewDataSource).IsVisibleRootNode(item));
}
public PackageExportTreeViewItem(ExportPackageItem itemIn, int id, int depth, TreeViewItem parent, string displayName)
: base(id, depth, parent, displayName)
{
item = itemIn;
}
public override bool CanBeParent(TreeViewItem item)
{
return (!(item is SearchFilterTreeItem) || SavedSearchFilters.AllowsHierarchy());
}
private void SelectionByKey(TreeViewItem itemSelected)
{
this.state.selectedIDs = this.GetNewSelection(itemSelected, false, true);
this.state.lastClickedID = itemSelected.id;
this.NotifyListenersThatSelectionChanged();
}
public bool IsVisibleRootNode(TreeViewItem item)
{
return ((item.parent != null) && (item.parent.parent == null));
}
public void SelectionClick(TreeViewItem itemClicked, bool keepMultiSelection)
{
this.state.selectedIDs = this.GetNewSelection(itemClicked, keepMultiSelection, false);
this.state.lastClickedID = ((itemClicked == null) ? 0 : itemClicked.id);
this.NotifyListenersThatSelectionChanged();
}
override public void OnRowGUI(Rect rowRect, TreeViewItem tvItem, int row, bool selected, bool focused)
{
k_IndentWidth = 18;
k_FoldoutWidth = 18;
const float k_ToggleWidth = 18f;
var pitem = tvItem as PackageImportTreeViewItem;
var item = pitem.item;
bool repainting = Event.current.type == EventType.Repaint;
// 0. Selection row rect
if (selected && repainting)
{
selectionStyle.Draw(rowRect, false, false, true, focused);
}
bool validItem = (item != null);
bool isFolder = (item != null) ? item.isFolder : true;
bool assetChanged = (item != null) ? item.assetChanged : false;
bool pathConflict = (item != null) ? item.pathConflict : false;
bool GUIDOverride = (item != null) ? item.existingAssetPath != string.Empty && item.existingAssetPath != item.destinationAssetPath : false;
bool exists = (item != null) ? item.exists : true;
bool projectAsset = (item != null) ? item.projectAsset : false;
// 1. Foldout
if (m_TreeView.data.IsExpandable(tvItem))
{
DoFoldout(rowRect, tvItem, row);
}
// 2. Toggle only for items that are actually in the package.
Rect toggleRect = new Rect(k_BaseIndent + tvItem.depth * indentWidth + k_FoldoutWidth, rowRect.y, k_ToggleWidth, rowRect.height);
if ((isFolder && !projectAsset) || (validItem && !projectAsset && assetChanged))
{
DoToggle(pitem, toggleRect);
}
using (new EditorGUI.DisabledScope(!validItem || projectAsset))
{
// 3. Icon & Text
Rect contentRect = new Rect(toggleRect.xMax, rowRect.y, rowRect.width, rowRect.height);
DoIconAndText(tvItem, contentRect, selected, focused);
// 4. Preview popup
DoPreviewPopup(pitem, rowRect);
// 4. Warning about file/GUID clashing.
if (repainting && validItem)
{
if (pathConflict)
{
Rect labelRect = new Rect(rowRect.xMax - 58, rowRect.y, rowRect.height, rowRect.height);
EditorGUIUtility.SetIconSize(new Vector2(rowRect.height, rowRect.height));
GUI.Label(labelRect, Constants.badgeWarnPathConflict, Constants.paddinglessStyle);
EditorGUIUtility.SetIconSize(Vector2.zero);
}
else if (GUIDOverride)
{
Rect labelRect = new Rect(rowRect.xMax - 58, rowRect.y, rowRect.height, rowRect.height);
EditorGUIUtility.SetIconSize(new Vector2(rowRect.height, rowRect.height));
GUIContent badgeWarnGUIDConflict = EditorGUIUtility.TrIconContent("console.warnicon", "Warning: A file exists in this project with the same GUID. This Asset being imported will be assigned a new GUID. References to the asset being imported in other imported Assets will be replaced with a reference to: " + item.existingAssetPath);
GUI.Label(labelRect, badgeWarnGUIDConflict, Constants.paddinglessStyle);
EditorGUIUtility.SetIconSize(Vector2.zero);
}
}
// 5. Optional badge ("New")
if (repainting && validItem && !(exists || pathConflict))
{
// FIXME: Need to enable tooltips here.
Texture badge = Constants.badgeNew.image;
Rect labelRect = new Rect(rowRect.xMax - badge.width - 6, rowRect.y, badge.width, badge.height);
GUI.Label(labelRect, Constants.badgeNew, Constants.paddinglessStyle);
}
// 7. Show what stuff has changed
if (repainting && validItem && (exists || pathConflict) && assetChanged)
{
if (PackageImportWizard.instance.IsProjectSettingStep)
{
Texture badge = Constants.badgeOverride.image;
Rect labelRect = new Rect(rowRect.xMax - badge.width - 6, rowRect.y, badge.width, badge.height);
GUI.Label(labelRect, Constants.badgeOverride, Constants.paddinglessStyle);
}
else
{
Texture badge = Constants.badgeChange.image;
Rect labelRect = new Rect(rowRect.xMax - badge.width - 6, rowRect.y, rowRect.height, rowRect.height);
GUI.Label(labelRect, Constants.badgeChange, Constants.paddinglessStyle);
}
}
}
}
public void UserExpandedNode(TreeViewItem item)
{
}
TreeViewItem EnsureFolderPath(string folderPath, Dictionary <string, TreeViewItem> 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();
TreeViewItem 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 PackageImportTreeViewItem(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);
}
public bool IsVisibleRootNode(TreeViewItem item)
{
// The main root Item is invisible the next level is visible root items
return(item.parent != null && item.parent.parent == null);
}
