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 void RecursiveComputeEnabledStateForFolders(PackageExportTreeView.PackageExportTreeViewItem pitem, HashSet <PackageExportTreeView.PackageExportTreeViewItem> done)
{
ExportPackageItem item = pitem.item;
if (item != null && !item.isFolder)
{
return;
}
if (pitem.hasChildren)
{
foreach (TreeViewItem current in pitem.children)
{
this.RecursiveComputeEnabledStateForFolders(current as PackageExportTreeView.PackageExportTreeViewItem, done);
}
}
if (item != null && !done.Contains(pitem))
{
PackageExportTreeView.EnabledState folderChildrenEnabledState = this.GetFolderChildrenEnabledState(pitem);
item.enabledStatus = (int)folderChildrenEnabledState;
if (folderChildrenEnabledState == PackageExportTreeView.EnabledState.Mixed)
{
done.Add(pitem);
for (PackageExportTreeView.PackageExportTreeViewItem packageExportTreeViewItem = pitem.parent as PackageExportTreeView.PackageExportTreeViewItem; packageExportTreeViewItem != null; packageExportTreeViewItem = (packageExportTreeViewItem.parent as PackageExportTreeView.PackageExportTreeViewItem))
{
ExportPackageItem item2 = packageExportTreeViewItem.item;
if (item2 != null && !done.Contains(packageExportTreeViewItem))
{
item2.enabledStatus = 2;
done.Add(packageExportTreeViewItem);
}
}
}
}
}
private PackageExportTreeView.EnabledState GetFolderChildrenEnabledState(PackageExportTreeView.PackageExportTreeViewItem folder)
{
ExportPackageItem item = folder.item;
if (item != null && !item.isFolder)
{
Debug.LogError("Should be a folder item!");
}
if (!folder.hasChildren)
{
return(PackageExportTreeView.EnabledState.None);
}
PackageExportTreeView.EnabledState enabledState = PackageExportTreeView.EnabledState.NotSet;
PackageExportTreeView.PackageExportTreeViewItem packageExportTreeViewItem = folder.children[0] as PackageExportTreeView.PackageExportTreeViewItem;
ExportPackageItem item2 = packageExportTreeViewItem.item;
int num = (item2 != null) ? item2.enabledStatus : 1;
for (int i = 1; i < folder.children.Count; i++)
{
item2 = (folder.children[i] as PackageExportTreeView.PackageExportTreeViewItem).item;
if (num != item2.enabledStatus)
{
enabledState = PackageExportTreeView.EnabledState.Mixed;
break;
}
}
if (enabledState == PackageExportTreeView.EnabledState.NotSet)
{
enabledState = ((num != 1) ? PackageExportTreeView.EnabledState.None : PackageExportTreeView.EnabledState.All);
}
return(enabledState);
}
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);
}
}
}
}
}
}
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);
}
}
}
protected override Texture GetIconForNode(TreeViewItem tItem)
{
ExportPackageItem exportPackageItem = (tItem as PackageExportTreeView.PackageExportTreeViewItem).item;
if (exportPackageItem == null || exportPackageItem.isFolder)
{
return((Texture)PackageExportTreeView.PackageExportTreeViewGUI.Constants.folderIcon);
}
Texture cachedIcon = AssetDatabase.GetCachedIcon(exportPackageItem.assetPath);
if ((UnityEngine.Object)cachedIcon != (UnityEngine.Object)null)
{
return(cachedIcon);
}
return((Texture)InternalEditorUtility.GetIconForFile(exportPackageItem.assetPath));
}
public void OnGUI(Rect rect)
{
int controlID = GUIUtility.GetControlID(FocusType.Keyboard);
this.m_TreeView.OnGUI(rect, controlID);
if ((((Event.current.type == EventType.KeyDown) && (Event.current.keyCode == KeyCode.Space)) && ((this.m_Selection != null) && (this.m_Selection.Count > 0))) && (GUIUtility.keyboardControl == controlID))
{
ExportPackageItem item = this.m_Selection[0].item;
if (item != null)
{
int num2 = (item.enabledStatus != 0) ? 0 : 1;
item.enabledStatus = num2;
this.ItemWasToggled(this.m_Selection[0]);
}
Event.current.Use();
}
}
protected override Texture GetIconForItem(TreeViewItem tItem)
{
PackageExportTreeView.PackageExportTreeViewItem item = tItem as PackageExportTreeView.PackageExportTreeViewItem;
ExportPackageItem item2 = item.item;
if ((item2 == null) || item2.isFolder)
{
return(Constants.folderIcon);
}
Texture cachedIcon = AssetDatabase.GetCachedIcon(item2.assetPath);
if (cachedIcon != null)
{
return(cachedIcon);
}
return(InternalEditorUtility.GetIconForFile(item2.assetPath));
}
private void EnableChildrenRecursive(TreeViewItem parentItem, int enabled)
{
if (!parentItem.hasChildren)
{
return;
}
foreach (TreeViewItem current in parentItem.children)
{
PackageExportTreeView.PackageExportTreeViewItem packageExportTreeViewItem = current as PackageExportTreeView.PackageExportTreeViewItem;
ExportPackageItem item = packageExportTreeViewItem.item;
if (item != null)
{
item.enabledStatus = enabled;
}
this.EnableChildrenRecursive(packageExportTreeViewItem, enabled);
}
}
private static void Toggle(ExportPackageItem[] items, PackageExportTreeView.PackageExportTreeViewItem pitem, Rect toggleRect)
{
ExportPackageItem item = pitem.item;
if (item != null)
{
bool flag = item.enabledStatus > 0;
GUIStyle toggle = EditorStyles.toggle;
if (item.isFolder && (item.enabledStatus == 2))
{
toggle = EditorStyles.toggleMixed;
}
bool flag3 = GUI.Toggle(toggleRect, flag, GUIContent.none, toggle);
if (flag3 != flag)
{
item.enabledStatus = !flag3 ? 0 : 1;
}
}
}
public override void FetchData()
{
int depth = -1;
this.m_RootItem = new PackageExportTreeView.PackageExportTreeViewItem(null, "Assets".GetHashCode(), depth, null, "InvisibleAssetsFolder");
bool flag = true;
if (flag)
{
this.m_TreeView.state.expandedIDs.Add(this.m_RootItem.id);
}
ExportPackageItem[] items = this.m_PackageExportView.items;
Dictionary <string, PackageExportTreeView.PackageExportTreeViewItem> dictionary = new Dictionary <string, PackageExportTreeView.PackageExportTreeViewItem>();
for (int i = 0; i < items.Length; i++)
{
ExportPackageItem exportPackageItem = items[i];
if (!PackageImport.HasInvalidCharInFilePath(exportPackageItem.assetPath))
{
string fileName = Path.GetFileName(exportPackageItem.assetPath);
string directoryName = Path.GetDirectoryName(exportPackageItem.assetPath);
TreeViewItem treeViewItem = this.EnsureFolderPath(directoryName, dictionary, flag);
if (treeViewItem != null)
{
int hashCode = exportPackageItem.assetPath.GetHashCode();
PackageExportTreeView.PackageExportTreeViewItem packageExportTreeViewItem = new PackageExportTreeView.PackageExportTreeViewItem(exportPackageItem, hashCode, treeViewItem.depth + 1, treeViewItem, fileName);
treeViewItem.AddChild(packageExportTreeViewItem);
if (flag)
{
this.m_TreeView.state.expandedIDs.Add(hashCode);
}
if (exportPackageItem.isFolder)
{
dictionary[exportPackageItem.assetPath] = packageExportTreeViewItem;
}
}
}
}
if (flag)
{
this.m_TreeView.state.expandedIDs.Sort();
}
}
public override void FetchData()
{
int depth = -1;
base.m_RootItem = new PackageExportTreeView.PackageExportTreeViewItem(null, "Assets".GetHashCode(), depth, null, "InvisibleAssetsFolder");
bool initExpandedState = true;
if (initExpandedState)
{
base.m_TreeView.state.expandedIDs.Add(base.m_RootItem.id);
}
ExportPackageItem[] items = this.m_PackageExportView.items;
Dictionary <string, PackageExportTreeView.PackageExportTreeViewItem> treeViewFolders = new Dictionary <string, PackageExportTreeView.PackageExportTreeViewItem>();
for (int i = 0; i < items.Length; i++)
{
ExportPackageItem itemIn = items[i];
if (!PackageImport.HasInvalidCharInFilePath(itemIn.assetPath))
{
string fileName = Path.GetFileName(itemIn.assetPath);
string directoryName = Path.GetDirectoryName(itemIn.assetPath);
TreeViewItem parent = this.EnsureFolderPath(directoryName, treeViewFolders, initExpandedState);
if (parent != null)
{
int hashCode = itemIn.assetPath.GetHashCode();
PackageExportTreeView.PackageExportTreeViewItem child = new PackageExportTreeView.PackageExportTreeViewItem(itemIn, hashCode, parent.depth + 1, parent, fileName);
parent.AddChild(child);
if (initExpandedState)
{
base.m_TreeView.state.expandedIDs.Add(hashCode);
}
if (itemIn.isFolder)
{
treeViewFolders[itemIn.assetPath] = child;
}
}
}
}
if (initExpandedState)
{
base.m_TreeView.state.expandedIDs.Sort();
}
}
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();
}
}
public override void FetchData()
{
this.m_RootItem = (TreeViewItem) new PackageExportTreeView.PackageExportTreeViewItem((ExportPackageItem)null, "Assets".GetHashCode(), -1, (TreeViewItem)null, "InvisibleAssetsFolder");
bool initExpandedState = true;
if (initExpandedState)
{
this.m_TreeView.state.expandedIDs.Add(this.m_RootItem.id);
}
ExportPackageItem[] items = this.m_PackageExportView.items;
Dictionary <string, PackageExportTreeView.PackageExportTreeViewItem> treeViewFolders = new Dictionary <string, PackageExportTreeView.PackageExportTreeViewItem>();
for (int index = 0; index < items.Length; ++index)
{
ExportPackageItem itemIn = items[index];
if (!PackageImport.HasInvalidCharInFilePath(itemIn.assetPath))
{
string fileName = Path.GetFileName(itemIn.assetPath);
TreeViewItem parent = this.EnsureFolderPath(Path.GetDirectoryName(itemIn.assetPath), treeViewFolders, initExpandedState);
if (parent != null)
{
int hashCode = itemIn.assetPath.GetHashCode();
PackageExportTreeView.PackageExportTreeViewItem exportTreeViewItem = new PackageExportTreeView.PackageExportTreeViewItem(itemIn, hashCode, parent.depth + 1, parent, fileName);
parent.AddChild((TreeViewItem)exportTreeViewItem);
if (initExpandedState)
{
this.m_TreeView.state.expandedIDs.Add(hashCode);
}
if (itemIn.isFolder)
{
treeViewFolders[itemIn.assetPath] = exportTreeViewItem;
}
}
}
}
if (!initExpandedState)
{
return;
}
this.m_TreeView.state.expandedIDs.Sort();
}
private void Export()
{
string text = EditorUtility.SaveFilePanel("Export package ...", string.Empty, string.Empty, "unitypackage");
if (text != string.Empty)
{
List <string> list = new List <string>();
ExportPackageItem[] exportPackageItems = this.m_ExportPackageItems;
for (int i = 0; i < exportPackageItems.Length; i++)
{
ExportPackageItem exportPackageItem = exportPackageItems[i];
if (exportPackageItem.enabledStatus > 0)
{
list.Add(exportPackageItem.guid);
}
}
PackageUtility.ExportPackage(list.ToArray(), text);
base.Close();
GUIUtility.ExitGUI();
}
}
protected override Texture GetIconForItem(TreeViewItem tItem)
{
PackageExportTreeView.PackageExportTreeViewItem packageExportTreeViewItem = tItem as PackageExportTreeView.PackageExportTreeViewItem;
ExportPackageItem item = packageExportTreeViewItem.item;
Texture result;
if (item == null || item.isFolder)
{
result = PackageExportTreeView.PackageExportTreeViewGUI.Constants.folderIcon;
}
else
{
Texture cachedIcon = AssetDatabase.GetCachedIcon(item.assetPath);
if (cachedIcon != null)
{
result = cachedIcon;
}
else
{
result = InternalEditorUtility.GetIconForFile(item.assetPath);
}
}
return(result);
}
private static void Toggle(ExportPackageItem[] items, PackageExportTreeView.PackageExportTreeViewItem pitem, Rect toggleRect)
{
bool flag1 = pitem.enabledState > PackageExportTreeView.EnabledState.None;
GUIStyle style = EditorStyles.toggle;
if (pitem.isFolder && pitem.enabledState == PackageExportTreeView.EnabledState.Mixed)
style = EditorStyles.toggleMixed;
bool flag2 = GUI.Toggle(toggleRect, flag1, GUIContent.none, style);
if (flag2 == flag1)
return;
pitem.enabledState = !flag2 ? PackageExportTreeView.EnabledState.None : PackageExportTreeView.EnabledState.All;
}
public PackageExportTreeViewItem(ExportPackageItem itemIn, int id, int depth, TreeViewItem parent, string displayName)
: base(id, depth, parent, displayName)
{
this.item = itemIn;
}
public PackageExportTreeViewItem(ExportPackageItem itemIn, int id, int depth, TreeViewItem parent, string displayName) : base(id, depth, parent, displayName)
{
this.m_EnabledState = PackageExportTreeView.EnabledState.NotSet;
this.item = itemIn;
}
public PackageExportTreeViewItem(ExportPackageItem itemIn, int id, int depth, TreeViewItem parent, string displayName)
: base(id, depth, parent, displayName)
{
this.item = itemIn;
}
public PackageExportTreeViewItem(ExportPackageItem itemIn, int id, int depth, TreeViewItem parent, string displayName) : base(id, depth, parent, displayName)
{
this.m_EnabledState = PackageExportTreeView.EnabledState.NotSet;
this.item = itemIn;
}
private static void Toggle(ExportPackageItem[] items, PackageExportTreeView.PackageExportTreeViewItem pitem, Rect toggleRect)
{
bool flag = pitem.enabledState > PackageExportTreeView.EnabledState.None;
GUIStyle toggle = EditorStyles.toggle;
if (pitem.isFolder && (pitem.enabledState == PackageExportTreeView.EnabledState.Mixed))
{
toggle = EditorStyles.toggleMixed;
}
bool flag3 = GUI.Toggle(toggleRect, flag, GUIContent.none, toggle);
if (flag3 != flag)
{
pitem.enabledState = !flag3 ? PackageExportTreeView.EnabledState.None : PackageExportTreeView.EnabledState.All;
}
}
