void OnDropDraggedElements(List <TreeViewItem> draggedRows, AssetTreeItem <AssetTreeData> parent)
{
if (parent.depth != 0)
{
Debug.LogErrorFormat("{0} depth error ", parent);
return;
}
var draggedElements = ListPool <AssetTreeData> .Get();
foreach (var value in draggedRows)
{
AssetTreeItem <AssetTreeData> assetval = value as AssetTreeItem <AssetTreeData>;
if (assetval != null)
{
draggedElements.Add(assetval.GetData());
}
}
var selectedIDs = new List <int>();
foreach (var data in draggedElements)
{
selectedIDs.Add(data.Id);
}
//m_TreeModel.MoveElements(parent, insertIndex, draggedElements);
_treeView.SetSelection(selectedIDs, TreeViewSelectionOptions.RevealAndFrame);
//reset assetbundle
foreach (var data in draggedElements)
{
var import = AssetImporter.GetAtPath(data.FilePath);
if (import != null)
{
var oldname = import.assetBundleName;
var newname = parent.displayName;
GuiShowMsg msg = new GuiShowMsg();
msg.Time = 3f;
msg.MessageType = MessageType.Info;
msg.Message = string.Format("{0} assetbundlename rename from {1} to {2}", data.FilePath, oldname, newname);
import.assetBundleName = newname;
import.SaveAndReimport();
_tips.Enqueue(msg);
}
}
bool update = draggedElements.Count > 0;
ListPool <AssetTreeData> .Release(draggedElements);
if (update)
{
//refresh
EditorContexts.mIns.ForceModeChange(EditorContexts.mIns.Mode);
}
}
int SortResTypeFunc(TreeViewItem left, TreeViewItem right)
{
AssetTreeItem <DependencyTreeData> leftItem = left as AssetTreeItem <DependencyTreeData>;
AssetTreeItem <DependencyTreeData> rightItem = right as AssetTreeItem <DependencyTreeData>;
if (leftItem != null && rightItem != null)
{
int leftrestype = (int)leftItem.GetData().EditorInfo.RuntimeInfo.AssetResType;
int rightrestype = (int)rightItem.GetData().EditorInfo.RuntimeInfo.AssetResType;
return(_sortval * (leftrestype - rightrestype));
}
return(0);
}
int SortDependcyFunc(TreeViewItem left, TreeViewItem right)
{
AssetTreeItem <AssetTreeData> leftItem = left as AssetTreeItem <AssetTreeData>;
AssetTreeItem <AssetTreeData> rightItem = right as AssetTreeItem <AssetTreeData>;
if (leftItem != null && rightItem != null)
{
int leftsize = leftItem.GetData().EditorInfo.RuntimeInfo.DependenciesCnt;
int rightsize = rightItem.GetData().EditorInfo.RuntimeInfo.DependenciesCnt;
return(_sortval * (leftsize - rightsize));
}
return(0);
}
void OnDropDraggedElements(List <TreeViewItem> draggedRows, AssetTreeItem <SpriteTrackData> parent)
{
var draggedElements = ListPool <SpriteTrackData> .Get();
foreach (var value in draggedRows)
{
AssetTreeItem <SpriteTrackData> assetval = value as AssetTreeItem <SpriteTrackData>;
if (assetval != null)
{
draggedElements.Add(assetval.GetData());
}
}
var selectedIDs = new List <int>();
foreach (var data in draggedElements)
{
selectedIDs.Add(data.Id);
}
//m_TreeModel.MoveElements(parent, insertIndex, draggedElements);
_treeView.SetSelection(selectedIDs, TreeViewSelectionOptions.RevealAndFrame);
string parentTag = parent.displayName;
if (!string.IsNullOrEmpty(parentTag))
{
foreach (var data in draggedElements)
{
var import = AssetImporter.GetAtPath(data.AtlasData.SprData.AssetPath) as TextureImporter;
if (import != null)
{
import.spritePackingTag = parentTag;
import.SaveAndReimport();
}
}
bool update = draggedElements.Count > 0;
ListPool <SpriteTrackData> .Release(draggedElements);
if (update)
{
//refresh
EditorContexts.mIns.ForceModeChange(EditorContexts.mIns.Mode);
}
}
else
{
Debug.LogError("Parent Tag is Empty");
}
}
void TryAddChildren(AssetTreeItem <T> rootitem, List <TreeViewItem> list, AssetTreeModel <T> model, int depth)
{
if (model.HasChildren(rootitem.DataId))
{
List <T> children = model.GetChildren(rootitem.DataId);
Stack <AssetTreeItem <T> > stack = StackPool <AssetTreeItem <T> > .Get();
for (int i = children.Count - 1; i >= 0; i--)
{
var child = children[i];
//create item
var childItem = CreateItem(ref child, depth + 1);
stack.Push(childItem);
}
ListPool <T> .Release(children);
while (stack.Count > 0)
{
var stackChild = stack.Pop();
list.Add(stackChild);
if (model.HasChildren(stackChild.DataId))
{
if (IsExpanded(stackChild.id))
{
children = model.GetChildren(stackChild.DataId);
//
//stackChild.children = new List<TreeViewItem>();
for (int i = children.Count - 1; i >= 0; i--)
{
var child = children[i];
//create item
var childItem = CreateItem(ref child, stackChild.depth + 1);
stack.Push(childItem);
//stackChild.children.Add(childItem);
}
ListPool <T> .Release(children);
}
else
{
stackChild.children = CreateChildListForCollapsedParent();
}
}
}
StackPool <AssetTreeItem <T> > .Release(stack);
}
}
int SortSelfFileSizeFunc(TreeViewItem left, TreeViewItem right)
{
AssetTreeItem <DependencyTreeData> leftItem = left as AssetTreeItem <DependencyTreeData>;
AssetTreeItem <DependencyTreeData> rightItem = right as AssetTreeItem <DependencyTreeData>;
if (leftItem != null && rightItem != null)
{
var ld = leftItem.GetData();
var rd = rightItem.GetData();
long leftsize = AssetBundleEditorHelper.GetSelfFileSize(ref ld, left.depth == 0, _model);
long rightsize = AssetBundleEditorHelper.GetSelfFileSize(ref rd, left.depth == 0, _model);
return(_sortval * (int)(leftsize - rightsize));
}
return(0);
}
public void Drag(ref AssetDragAndDropArgs dragargs, ref DragAndDropVisualMode dragmd)
{
var draggedRows = DragAndDrop.GetGenericData("AssetTreeViewDragging") as List <TreeViewItem>;
if (draggedRows != null)
{
switch (dragargs.dragAndDropPosition)
{
case AssetDragAndDropArgs.DragAndDropPosition.UponItem:
case AssetDragAndDropArgs.DragAndDropPosition.BetweenItems:
{
bool validDrag = dragargs.parentItem.depth != 0;
if (dragargs.performDrop && validDrag)
{
if (dragargs.parentItem.parent != null)
{
AssetTreeItem <SpriteTrackData> itemdata = dragargs.parentItem as AssetTreeItem <SpriteTrackData>;
if (itemdata != null && itemdata.GetData().ShowMode == SpriteShowMode.Atlas && itemdata.depth == 1)
{
OnDropDraggedElements(draggedRows, itemdata);
}
}
}
dragmd = validDrag ? DragAndDropVisualMode.Move : DragAndDropVisualMode.None;
break;
}
case AssetDragAndDropArgs.DragAndDropPosition.OutsideItems:
{
dragmd = DragAndDropVisualMode.Move;
break;
}
default:
Debug.LogError("Unhandled enum " + dragargs.dragAndDropPosition);
dragmd = DragAndDropVisualMode.None;
break;
}
}
else
{
dragmd = DragAndDropVisualMode.None;
}
}
protected override IList <TreeViewItem> BuildRows(TreeViewItem rootitem)
{
var selections = GetSelection();
_rows.Clear();
AssetTreeItem <T> root = rootitem as AssetTreeItem <T>;
if (root != null)
{
if (!string.IsNullOrEmpty(searchString))
{
SearchItem(_rows, _model, root.DataId);
}
else
{
TryAddChildren(root, _rows, _model, -1);
}
SetupParentsAndChildrenFromDepths(rootitem, _rows);
var render = AssetTreeManager.mIns.GetGuiRender(EditorContexts.mIns.Mode);
if (render != null)
{
foreach (var subrender in render)
{
if (subrender.TypeMode == _viewMode)
{
IGuiTree treeRender = subrender as IGuiTree;
if (treeRender != null)
{
treeRender.Rebuild();
}
}
}
}
}
if (selections != null && selections.Count > 0)
{
FrameItem(selections[0]);
}
return(_rows);
}
public bool CellGui(TreeViewItem item, ref AssetRowGuiArgs args)
{
if (item is AssetTreeItem <SpriteTrackData> )
{
AssetTreeItem <SpriteTrackData> trackItem = item as AssetTreeItem <SpriteTrackData>;
GUI.skin.label.richText = true;
SpriteTopMenu topMenu = (SpriteTopMenu)args.Column;
SpriteTrackData data = trackItem.GetData();
if (topMenu == SpriteTopMenu.Name)
{
return(false);
}
else if (topMenu == SpriteTopMenu.Type)
{
if (data.ShowMode == SpriteShowMode.Scene)
{
GUI.Label(args.CellRect, "Scene");
}
else if (data.ShowMode == SpriteShowMode.Prefabs)
{
GUI.Label(args.CellRect, "GameObject");
}
else if (data.ShowMode == SpriteShowMode.Atlas)
{
GUI.Label(args.CellRect, "Atlas");
}
}
else if (topMenu == SpriteTopMenu.BundleName)
{
if (data.ShowMode == SpriteShowMode.Scene)
{
GUI.Label(args.CellRect, data.SceneData.SprData.BundleName);
}
else if (data.ShowMode == SpriteShowMode.Prefabs)
{
GUI.Label(args.CellRect, data.GameObjectData.SprData.BundleName);
}
else if (data.ShowMode == SpriteShowMode.Atlas)
{
GUI.Label(args.CellRect, data.AtlasData.SprData.BundleName);
}
}
else if (topMenu == SpriteTopMenu.AtlasName)
{
if (data.ShowMode == SpriteShowMode.Scene)
{
if (item.depth == 2)
{
if (string.IsNullOrEmpty(data.SceneData.SprData.PackingTag) == false)
{
string newval = GUI.TextField(args.CellRect, data.SceneData.SprData.PackingTag);
if (CheckTag(newval, data.SceneData.SprData.PackingTag))
{
data.SceneData.SprData.Importer.spritePackingTag = newval;
data.SceneData.SprData.PackingTag = newval;
data.SceneData.SprData.Importer.SaveAndReimport();
trackItem.SetData(data);
}
}
}
}
else if (data.ShowMode == SpriteShowMode.Prefabs)
{
if (item.depth == 3)
{
if (string.IsNullOrEmpty(data.GameObjectData.SprData.PackingTag) == false)
{
string newval = GUI.TextField(args.CellRect, data.GameObjectData.SprData.PackingTag);
if (CheckTag(newval, data.GameObjectData.SprData.PackingTag))
{
data.GameObjectData.SprData.Importer.spritePackingTag = newval;
data.GameObjectData.SprData.PackingTag = newval;
data.GameObjectData.SprData.Importer.SaveAndReimport();
trackItem.SetData(data);
}
}
}
}
else if (data.ShowMode == SpriteShowMode.Atlas)
{
if (item.depth == 2)
{
if (string.IsNullOrEmpty(data.AtlasData.SprData.PackingTag) == false)
{
string newval = GUI.TextField(args.CellRect, data.AtlasData.SprData.PackingTag);
if (CheckTag(newval, data.AtlasData.SprData.PackingTag))
{
data.AtlasData.SprData.Importer.spritePackingTag = newval;
data.AtlasData.SprData.PackingTag = newval;
data.AtlasData.SprData.Importer.SaveAndReimport();
trackItem.SetData(data);
}
}
}
}
}
else if (topMenu == SpriteTopMenu.UsedCount)
{
if (item.depth > 0 && (data.ShowMode == SpriteShowMode.Scene || data.ShowMode == SpriteShowMode.Prefabs))
{
GUI.Label(args.CellRect, data.UsedRefCount.ToString());
}
}
else if (topMenu == SpriteTopMenu.MemSize)
{
if (data.ShowMode == SpriteShowMode.Scene)
{
if (item.depth == 2)
{
GUI.Label(args.CellRect, "Spr:" + data.SceneData.SprData.MemSize + " Tex:" + data.SceneData.SprData.TexMemSize);
}
else if (item.depth > 0)
{
GUI.Label(args.CellRect, "Script:" + data.SceneData.MemSize);
}
}
else if (data.ShowMode == SpriteShowMode.Prefabs)
{
if (item.depth == 3)
{
GUI.Label(args.CellRect, "Spr:" + data.GameObjectData.SprData.MemSize + " Tex:" + data.GameObjectData.SprData.TexMemSize);
}
else if (item.depth > 0)
{
GUI.Label(args.CellRect, "Go:" + data.GameObjectData.GoData.MemSize);
}
}
else if (data.ShowMode == SpriteShowMode.Atlas)
{
if (item.depth == 2)
{
GUI.Label(args.CellRect, "Spr:" + data.AtlasData.SprData.MemSize + " Tex:" + data.AtlasData.SprData.TexMemSize);
}
else if (item.depth > 1)
{
GUI.Label(args.CellRect, "Ref:" + data.AtlasData.RefData.MemSize);
}
}
}
else if (topMenu == SpriteTopMenu.Size)
{
if (data.ShowMode == SpriteShowMode.Atlas)
{
if (data.AtlasData.SprData.Sprite != null)
{
GUI.Label(args.CellRect, data.AtlasData.SprData.TexSize.ToString());
}
}
}
else if (topMenu == SpriteTopMenu.Info)
{
if (data.ShowMode == SpriteShowMode.Scene)
{
if (item.depth == 1)
{
if (data.SceneData.CsReferences)
{
GUI.Label(args.CellRect, string.Format("Type :{0} Path:{1} ",
AssetBundleEditorHelper.GetColorText("{0}", Color.black, data.SceneData.CsReferences),
AssetBundleEditorHelper.GetColorText("{0}", Color.white, data.SceneData.Path)
));
}
}
else if (item.depth == 2)
{
if (data.SceneData.SprData.Sprite)
{
GUI.Label(args.CellRect, GetSprInfo(ref data.SceneData.SprData));
}
}
}
else if (data.ShowMode == SpriteShowMode.Prefabs)
{
if (item.depth == 1)
{
GUI.Label(args.CellRect, string.Format("AssetPath :{0} Path:{1} PrefabType:{2}",
AssetBundleEditorHelper.GetColorText("{0}", Color.black, data.GameObjectData.GoData.AssetPath),
AssetBundleEditorHelper.GetColorText("{0}", Color.white, data.GameObjectData.GoData.Path),
AssetBundleEditorHelper.GetColorText("{0}", Color.yellow, data.GameObjectData.GoData.PrefabType)));
}
else if (item.depth == 2)
{
GUI.Label(args.CellRect, GetSprInfo(ref data.GameObjectData.SprData));
}
else if (item.depth == 3)
{
if (data.GameObjectData.SprData.Sprite)
{
GUI.Label(args.CellRect, GetSprInfo(ref data.GameObjectData.SprData));
}
}
}
else if (data.ShowMode == SpriteShowMode.Atlas)
{
if (item.depth == 2)
{
if (data.AtlasData.SprData.Sprite)
{
GUI.Label(args.CellRect, GetSprInfo(ref data.AtlasData.SprData));
}
}
else if (item.depth == 3)
{
if (data.AtlasData.RefData.Target)
{
GUI.Label(args.CellRect, string.Format("{0} Path:{1}",
AssetBundleEditorHelper.GetColorText("{0}", Color.black, data.AtlasData.RefData.Target),
AssetBundleEditorHelper.GetColorText("{0}", Color.white, data.AtlasData.RefData.Path)));
}
}
}
}
GUI.skin.label.richText = false;
}
else
{
return(false);
}
return(true);
}
AssetTreeItem <T> CreateItem(ref T data, int depth)
{
AssetTreeItem <T> viewItem = new AssetTreeItem <T>(ref data, depth);
return(viewItem);
}
public void Drag(ref AssetDragAndDropArgs dragargs, ref DragAndDropVisualMode dragmd)
{
var draggedRows = DragAndDrop.GetGenericData("AssetTreeViewDragging") as List <TreeViewItem>;
if (draggedRows != null)
{
switch (dragargs.dragAndDropPosition)
{
case AssetDragAndDropArgs.DragAndDropPosition.UponItem:
case AssetDragAndDropArgs.DragAndDropPosition.BetweenItems:
{
bool validDrag = dragargs.parentItem.depth != 0;
if (dragargs.performDrop && validDrag)
{
if (dragargs.parentItem.parent != null)
{
AssetTreeItem <AssetTreeData> itemdata = dragargs.parentItem.parent as AssetTreeItem <AssetTreeData>;
if (itemdata != null)
{
OnDropDraggedElements(draggedRows, itemdata);
}
}
}
dragmd = validDrag ? DragAndDropVisualMode.Move : DragAndDropVisualMode.None;
break;
}
case AssetDragAndDropArgs.DragAndDropPosition.OutsideItems:
{
//if (dragargs.performDrop)
//{
// int index = dragargs.insertAtIndex == -1 ? 0 : dragargs.insertAtIndex;
// var rows = dragargs.parentItem.children;
// if (index < rows.Count)
// {
// AssetTreeItem<AssetTreeData> itemdata = rows[index] as AssetTreeItem<AssetTreeData>;
// if (itemdata != null)
// OnDropDraggedElements(draggedRows, itemdata);
// }
// else
// {
// Debug.LogError("drag index error");
// }
//}
dragmd = DragAndDropVisualMode.Move;
break;
}
default:
Debug.LogError("Unhandled enum " + dragargs.dragAndDropPosition);
dragmd = DragAndDropVisualMode.None;
break;
}
}
else
{
dragmd = DragAndDropVisualMode.None;
}
}
