private void CreatePackage()
{
if (string.IsNullOrEmpty(G.Module.ModuleStateConfig.Json.CurrentUserConfigName))
{
G.Module.DisplayDialog("请先选择配置或创建一个空配置");
return;
}
G.Module.IsDirty = true;
PackageTreeItem package = new PackageTreeItem()
{
id = --packageID,
depth = 0,
icon = compressionIcon,
displayName = "New Package",
isPackage = true,
packageColor = UnityEngine.Random.ColorHSV(0, 1, 0.5f, 1f, 1, 1)
};
package.package = package; //这个packageItem所属的package是自己
rootItem.AddChild(package);
packageCount++;
BeginRename(package);
BuildRows(rootItem);
FrameItem(package.id);
Packages.Add(package);
}
protected override void RenameEnded(RenameEndedArgs args)
{
if (args.acceptedRename)
{
args.newName = args.newName.Trim();
if (args.newName == "")
{
args.newName = args.originalName;
}
char[] invalidChars = Path.GetInvalidFileNameChars();
int invalidCharsIndex = args.newName.IndexOfAny(invalidChars);
if (invalidCharsIndex >= 0)
{
G.Module.DisplayDialog("新包名：" + args.newName + " 包含非法字符！");
return;
}
string newName = args.newName;
int i = 0;
while (!CheckName(newName, args.itemID))
{
newName = args.newName + " " + ++i;
}
if (i > 0)
{
G.Module.DisplayDialog("包名：" + args.newName + " 已存在! 自动改为：\n" + newName);
}
PackageTreeItem item = FindItem(args.itemID, rootItem) as PackageTreeItem;
item.displayName = newName;
G.Module.IsDirty = true;
}
UpdateAllFileName();
}
private void RecursiveDeleteItem(PackageTreeItem packageItem)
{
while (packageItem.hasChildren)
{
RecursiveDeleteItem((PackageTreeItem)packageItem.children[0]);
}
if (packageItem.bundleItem != null)
{
packageItem.bundleItem.packageItems.Remove(packageItem);
}
if (packageItem.isPackage)
{
packageCount--;
Packages.Remove(packageItem); //仅用于处理单独存放包的packages
}
else if (packageItem.bundleItem.isFolder)
{
folderCount--;
}
else
{
bundleCount--;
}
packageItem.parent.children.Remove(packageItem);
}
private void FindOrCreateBundleItemByBundleName(PackageTreeItem parent, string bundleName, string relativePath)
{
if (parent.hasChildren)
{
foreach (PackageTreeItem item in parent.children)
{
if (item.bundleItem.displayName == bundleName)
{
return;
}
}
}
var newBundle = new PackageTreeItem()
{
lost = true,
id = ++bundleID,
package = parent.package,
bundleItem = new BundleTreeItem()
{
icon = G.g.bundleTree.bundleIcon,
displayName = bundleName,
relativePath = relativePath
}
};
parent.AddChild(newBundle);
}
private PackageTreeItem FindOrCreateFolderItemByFolderName(PackageTreeItem parent, string folderName, string relativePath)
{
if (parent.hasChildren)
{
foreach (PackageTreeItem item in parent.children)
{
if (item.bundleItem.isFolder && item.bundleItem.displayName == folderName)
{
return(item);
}
}
}
PackageTreeItem folderItem = new PackageTreeItem()
{
lost = true,
id = --folderID,
package = parent.package,
bundleItem = new BundleTreeItem()
{
displayName = folderName,
icon = G.g.bundleTree.folderIcon,
isFolder = true,
relativePath = relativePath
}
};
parent.AddChild(folderItem);
return(folderItem);
}
private void BuildPackageTree_lostItems(Configs.UserConfig.JsonClass.Package package, PackageTreeItem p)
{
//遍历bundles数组添加所有丢失的bundle
foreach (string bundlePath in package.Bundles)
{
string[] folderNames = bundlePath.Split('/'); //路径字符串中必须全部为/ 不能有\
PackageTreeItem parent = p;
string relativePath = "";
int i;
for (i = 0; i < folderNames.Length - 1; i++)
{
relativePath += folderNames[i];
parent = FindOrCreateFolderItemByFolderName(parent, folderNames[i], relativePath);
relativePath += "/";
}
string bundleName = Path.GetFileNameWithoutExtension(folderNames[i]);
relativePath += bundleName;
FindOrCreateBundleItemByBundleName(parent, bundleName, relativePath);
}
//遍历所有空文件夹数组添加丢失的空文件夹
foreach (string folderPath in package.EmptyFolders)
{
string[] folderNames = folderPath.Split('/');
PackageTreeItem parent = p;
string relativePath = "";
int i;
for (i = 0; i < folderNames.Length; i++)
{
relativePath += folderNames[i];
parent = FindOrCreateFolderItemByFolderName(parent, folderNames[i], relativePath);
relativePath += "/";
}
}
}
private void RecursiveCheckItem(PackageTreeItem packageItem)
{
if (packageItem.hasChildren)
{
foreach (PackageTreeItem item in packageItem.children)
{
RecursiveCheckItem(item);
}
}
else
{
if (packageItem.isPackage)
{
emptyItems.Add(packageItem);
}
else if (packageItem.lost)
{
wrongItems.Add(packageItem);
}
else if (packageItem.bundleItem.isFolder)
{
emptyItems.Add(packageItem);
}
else if (!packageItem.bundleItem.verify)
{
wrongItems.Add(packageItem);
}
}
}
private void BuildTreeFromMap(TreeViewItem root)
{
foreach (var package in G.Module.UserConfig.Json.Packages)
{
Color color = Color.black;
ColorUtility.TryParseHtmlString("#" + package.Color, out color);
var p = new PackageTreeItem()
{
id = --packageID,
depth = 0,
displayName = package.PackageName,
packageColor = color,
isPackage = true,
icon = compressionIcon,
necessery = package.Necessery,
deploymentLocation = package.DeploymentLocation,
copyToStreaming = package.CopyToStreaming
};
p.package = p;
BuildPackageTreeFromBundleTree(package, p);
BuildPackageTree_lostItems(package, p);
root.AddChild(p);
Packages.Add(p);
}
UpdateAllFileName();
}
private void RecursiveConnectWithBundleItem(PackageTreeItem packageItem, Dictionary <string, BundleTreeItem> bundleDic, Dictionary <string, BundleTreeItem> folderDic)
{
Dictionary <string, BundleTreeItem> dic = packageItem.bundleItem.isFolder ? folderDic : bundleDic;
if (dic.ContainsKey(packageItem.bundleItem.relativePath))
{
packageItem.lost = false;
packageItem.bundleItem = dic[packageItem.bundleItem.relativePath];
packageItem.bundleItem.packageItems.Add(packageItem);
}
else
{
packageItem.lost = true;
packageItem.bundleItem = new BundleTreeItem()
{
relativePath = packageItem.bundleItem.relativePath,
displayName = packageItem.bundleItem.displayName,
isFolder = packageItem.bundleItem.isFolder,
icon = packageItem.bundleItem.icon,
};
}
if (packageItem.hasChildren)
{
foreach (PackageTreeItem child in packageItem.children)
{
RecursiveConnectWithBundleItem(child, bundleDic, folderDic);
}
}
}
private void AddBundlesToPackage(PackageTreeItem packageItem, BundleTreeItem item)
{
var p = RecursiveAddParents(item, packageItem);
if (item.isFolder && item.hasChildren)
{
RecursiveAddChildren(item, p, packageItem);
}
}
public void AddBundlesToPackage(PackageTreeItem packageItem, List <TreeViewItem> bundleItems)
{
G.Module.IsDirty = true;
foreach (BundleTreeItem item in bundleItems)
{
AddBundlesToPackage(packageItem, item);
}
SetupDepthsFromParentsAndChildren(packageItem);
BuildRows(rootItem);
}
private void Locate(PackageTreeItem item)
{
var ids = new int[] { item.bundleItem.id };
G.g.bundleTree.SetSelection(ids);
foreach (var id in ids)
{
G.g.bundleTree.FrameItem(id);
}
G.g.bundleTree.SetFocus();
}
void RecursiveAddChildren(BundleTreeItem bundleItemParent, PackageTreeItem packageParent, PackageTreeItem packageItem)
{
foreach (BundleTreeItem item in bundleItemParent.children)
{
var p = FindOrCreatePackageItem(item, packageParent, packageItem);
if (item.isFolder && item.hasChildren)
{
RecursiveAddChildren(item, p, packageItem);
}
}
}
/// <summary>
/// 递归添加父节点
/// </summary>
/// <param name="bundleItem">要添加的bundle</param>
/// <param name="packageItem">在此package里添加</param>
/// <returns></returns>
PackageTreeItem RecursiveAddParents(BundleTreeItem bundleItem, PackageTreeItem packageItem)
{
if (bundleItem.parent.depth < 0)
{
return(FindOrCreatePackageItem(bundleItem, packageItem, packageItem));//在packageItem下找到或创建一个以bundleItem为内容的packageItem
}
else
{
var parent = RecursiveAddParents((BundleTreeItem)bundleItem.parent, packageItem);
return(FindOrCreatePackageItem(bundleItem, parent, packageItem));
}
}
protected override void DoubleClickedItem(int id)
{
PackageTreeItem item = FindItem(id, rootItem) as PackageTreeItem;
if (item.isPackage || item.hasChildren)
{
SetExpanded(id, !IsExpanded(id));
}
else
{
Locate(item);
}
}
protected override TreeViewItem BuildRoot()
{
Packages.Clear();
PackageTreeItem root = new PackageTreeItem()
{
id = 0,
depth = -1,
displayName = "Root",
};
BuildTreeFromMap(root);
SetupDepthsFromParentsAndChildren(root);
return(root);
}
private void DeletePackageItem(IList <int> list)
{
G.Module.IsDirty = true;
foreach (var id in list)
{
PackageTreeItem item = (PackageTreeItem)FindItem(id, rootItem);
if (item != null)
{
PackageTreeItem parent = (PackageTreeItem)item.parent;
RecursiveDeleteItem(item);
if (!item.lost)
{
RecursiveUpdateParentComplete(parent);
}
}
}
BuildRows(rootItem);
}
/// <summary>
/// 从任意一个packageItem节点的第一层children中找到包含bundleItem内容的packageItem，若没有则创建一个
/// </summary>
/// <param name="bundleItem">要找的内容</param>
/// <param name="parent">在该parent节点的第一层子节点中查找</param>
/// <param name="packageItem">要添加到bundleItem中的包信息</param>
/// <returns></returns>
private PackageTreeItem FindOrCreatePackageItem(BundleTreeItem bundleItem, PackageTreeItem parent, PackageTreeItem packageItem)
{
PackageTreeItem child = null;
if (parent.hasChildren)
{
foreach (PackageTreeItem c in parent.children)
{
if (c.bundleItem == bundleItem)
{
child = c;
break;
}
}
}
if (child == null)
{
child = new PackageTreeItem()
{
bundleItem = bundleItem,
id = bundleItem.isFolder ? --folderID : ++bundleID,
package = packageItem,
complete = bundleItem.hasChildren ? false : true
};
if (!child.bundleItem.packageItems.Exists(x => x.package == packageItem))
{
child.bundleItem.packageItems.Add(child);
}
if (child.bundleItem.isFolder)
{
folderCount++;
}
else
{
bundleCount++;
}
parent.AddChild(child);
RecursiveUpdateParentComplete(parent);
}
return(child);
}
private void RecursiveAddItem(PackageTreeItem packageItem, Configs.UserConfig.JsonClass.Package package)
{
if (packageItem.hasChildren)
{
foreach (PackageTreeItem item in packageItem.children)
{
RecursiveAddItem(item, package);
}
}
else
{
if (!packageItem.bundleItem.isFolder)
{
package.Bundles.Add(packageItem.bundleItem.relativePath);
}
else
{
package.EmptyFolders.Add(packageItem.bundleItem.relativePath);
}
}
}
private void RecursiveUpdateParentComplete(PackageTreeItem parent)
{
if (parent.isPackage || parent == rootItem)
{
return;
}
if (!parent.hasChildren && !parent.bundleItem.hasChildren)
{
parent.complete = true;
return;
}
int count = 0;
foreach (PackageTreeItem item in parent.children)
{
if (!item.lost)
{
count++;
}
}
if (count == parent.bundleItem.children.Count)
{
parent.complete = true;
foreach (PackageTreeItem item in parent.children)
{
if (!item.lost && item.complete == false)
{
parent.complete = false;
break;
}
}
}
else
{
parent.complete = false;
}
RecursiveUpdateParentComplete((PackageTreeItem)parent.parent);
}
private void BuildPackageTreeFromBundleTree(Configs.UserConfig.JsonClass.Package package, PackageTreeItem p)
{
foreach (string bundlePath in package.Bundles)
{
if (G.g.bundleTree.bundleDic.ContainsKey(bundlePath))
{
RecursiveAddParents(G.g.bundleTree.bundleDic[bundlePath], p);
}
}
foreach (string emptyFolderPath in package.EmptyFolders)
{
if (G.g.bundleTree.folderDic.ContainsKey(emptyFolderPath))
{
RecursiveAddParents(G.g.bundleTree.folderDic[emptyFolderPath], p);
}
}
}
private void CellGUI(Rect rect, PackageTreeItem item, ColumnEnum column, ref RowGUIArgs args)
{
CenterRectUsingSingleLineHeight(ref rect);
switch (column)
{
case ColumnEnum.Name:
//args.rowRect = rect;
float space = 5 + foldoutWidth + depthIndentWidth * item.depth;
GUI.DrawTexture(new Rect(rect.x + space, rect.y, rect.height, rect.height), item.isPackage ? item.icon : item.bundleItem.icon, ScaleMode.ScaleToFit);
GUI.Label(new Rect(rect.x + space + rect.height, rect.y, rect.width - space - rect.height, rect.height),
item.isPackage ? item.displayName : item.bundleItem.displayName,
item.lost ? labelErrorStyle : (item.isPackage ? EditorStyles.label : item.bundleItem.style));
break;
case ColumnEnum.Connection:
Color color = EditorGUI.ColorField(new Rect(rect.x /* + Packages.IndexOf(item.package) * (rect.height + 4)*/,
rect.y, rect.height, rect.height), GUIContent.none, item.package.packageColor, false, false, false, colorPickerHDRConfig);
if (color != item.package.packageColor)
{
item.package.packageColor = color;
}
break;
case ColumnEnum.FileName:
if (item.isPackage)
{
GUI.Label(rect, item.fileName);
}
break;
case ColumnEnum.Necessery:
if (item.isPackage && G.Module.UserConfig.Json.PackageMode == "Addon")
{
int index = G.NecesseryEnum.IndexOf(item.necessery);
int index_new = EditorGUI.Popup(rect, index, G.NecesseryEnum, inDropDownStyle);
if (index_new != index)
{
item.necessery = G.NecesseryEnum[index_new];
G.Module.IsDirty = true;
}
}
break;
case ColumnEnum.DeploymentLocation:
if (item.isPackage && G.Module.UserConfig.Json.PackageMode == "Addon")
{
int index = G.DeploymentLocationEnum.IndexOf(item.deploymentLocation);
int index_new = EditorGUI.Popup(rect, index, G.DeploymentLocationEnum, inDropDownStyle);
if (index_new != index)
{
item.deploymentLocation = G.DeploymentLocationEnum[index_new];
G.Module.IsDirty = true;
}
}
break;
case ColumnEnum.CopyToStreaming:
if (item.isPackage && G.Module.UserConfig.Json.PackageMode == "Addon")
{
Rect rect_new = new Rect(rect.x + rect.width / 2 - 8, rect.y, 16, rect.height);
bool selected = EditorGUI.Toggle(rect_new, item.copyToStreaming, inToggleStyle);
if (selected != item.copyToStreaming)
{
item.copyToStreaming = selected;
G.Module.IsDirty = true;
}
}
break;
default:
break;
}
}
