647 lines
24 KiB
C#
647 lines
24 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using UnityEditor;
|
|
using UnityEditor.UIElements;
|
|
using UnityEngine;
|
|
using UnityEngine.UIElements;
|
|
using EasyChart;
|
|
|
|
namespace EasyChart.Editor
|
|
{
|
|
public partial class EasyChartLibraryWindow
|
|
{
|
|
private void OnTreeItemContextClick(ContextClickEvent evt)
|
|
{
|
|
var el = evt.currentTarget as VisualElement;
|
|
var path = el?.userData as string;
|
|
if (string.IsNullOrEmpty(path)) return;
|
|
|
|
var menu = new GenericMenu();
|
|
bool isFolder = AssetDatabase.IsValidFolder(path);
|
|
if (isFolder)
|
|
{
|
|
menu.AddItem(new GUIContent("New Folder..."), false, () => CreateNewFolderUnder(path));
|
|
menu.AddItem(new GUIContent("New Chart..."), false, () => CreateNewProfileInFolder(path));
|
|
menu.AddSeparator(string.Empty);
|
|
|
|
if (HasProfileInClipboard()) menu.AddItem(new GUIContent("Paste (As New)"), false, () => PasteProfileAsNewFromClipboard(path));
|
|
else menu.AddDisabledItem(new GUIContent("Paste (As New)"));
|
|
|
|
menu.AddSeparator(string.Empty);
|
|
menu.AddItem(new GUIContent("Export Folder to UXML (Mirror)"), false, () => ExportFolderToUxmlMirror(path));
|
|
menu.AddItem(new GUIContent("Export Folder to UXML (Backup)"), false, () => ExportFolderToUxmlMirrorBackup(path));
|
|
menu.AddItem(new GUIContent("Rename..."), false, () => RenameAssetOrFolder(path));
|
|
menu.AddItem(new GUIContent("Delete"), false, () => DeleteAssetOrFolder(path));
|
|
}
|
|
else
|
|
{
|
|
bool isProfile = IsChartProfileAsset(path);
|
|
if (isProfile) menu.AddItem(new GUIContent("Copy"), false, () => CopyProfileToClipboard(path));
|
|
else menu.AddDisabledItem(new GUIContent("Copy"));
|
|
|
|
if (isProfile && HasProfileInClipboard()) menu.AddItem(new GUIContent("Paste (Overwrite)"), false, () => PasteProfileOverwriteFromClipboard(path));
|
|
else menu.AddDisabledItem(new GUIContent("Paste (Overwrite)"));
|
|
|
|
string folder = Path.GetDirectoryName(path)?.Replace('\\', '/');
|
|
if (HasProfileInClipboard() && !string.IsNullOrEmpty(folder) && AssetDatabase.IsValidFolder(folder))
|
|
menu.AddItem(new GUIContent("Paste (As New)"), false, () => PasteProfileAsNewFromClipboard(folder));
|
|
else
|
|
menu.AddDisabledItem(new GUIContent("Paste (As New)"));
|
|
|
|
menu.AddSeparator(string.Empty);
|
|
menu.AddItem(new GUIContent("Export to UXML"), false, () =>
|
|
{
|
|
var profile = AssetDatabase.LoadAssetAtPath<ChartProfile>(path);
|
|
if (profile != null)
|
|
{
|
|
_selectedProfile = profile;
|
|
ExportToUxml();
|
|
}
|
|
});
|
|
if (isProfile) menu.AddItem(new GUIContent("Clone"), false, () => CloneProfile(path));
|
|
else menu.AddDisabledItem(new GUIContent("Clone"));
|
|
menu.AddSeparator(string.Empty);
|
|
menu.AddItem(new GUIContent("Rename..."), false, () => RenameAssetOrFolder(path));
|
|
menu.AddItem(new GUIContent("Ping"), false, () =>
|
|
{
|
|
var obj = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(path);
|
|
if (obj != null) EditorGUIUtility.PingObject(obj);
|
|
});
|
|
menu.AddItem(new GUIContent("Delete"), false, () => DeleteAssetOrFolder(path));
|
|
}
|
|
|
|
menu.ShowAsContext();
|
|
evt.StopPropagation();
|
|
}
|
|
|
|
private void OnTreeDragUpdated(DragUpdatedEvent evt)
|
|
{
|
|
var folderPath = TryGetDropTargetFolderUnderTreeMouse(evt.localMousePosition);
|
|
var draggedPath = GetDraggedChartAssetPath();
|
|
|
|
bool canDrop = false;
|
|
if (!string.IsNullOrEmpty(folderPath) && AssetDatabase.IsValidFolder(folderPath) && !string.IsNullOrEmpty(draggedPath))
|
|
{
|
|
if (AssetDatabase.IsValidFolder(draggedPath))
|
|
{
|
|
if (!string.Equals(folderPath, draggedPath, StringComparison.OrdinalIgnoreCase) &&
|
|
!IsSubFolderOf(folderPath, draggedPath))
|
|
{
|
|
canDrop = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string srcFolder = Path.GetDirectoryName(draggedPath)?.Replace("\\", "/");
|
|
canDrop = string.IsNullOrEmpty(srcFolder) || !string.Equals(srcFolder, folderPath, StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
}
|
|
|
|
DragAndDrop.visualMode = canDrop ? DragAndDropVisualMode.Move : DragAndDropVisualMode.Rejected;
|
|
evt.StopPropagation();
|
|
}
|
|
|
|
private void OnTreeDragPerform(DragPerformEvent evt)
|
|
{
|
|
var folderPath = TryGetDropTargetFolderUnderTreeMouse(evt.localMousePosition);
|
|
var draggedPath = GetDraggedChartAssetPath();
|
|
if (string.IsNullOrEmpty(folderPath) || !AssetDatabase.IsValidFolder(folderPath)) return;
|
|
if (string.IsNullOrEmpty(draggedPath)) return;
|
|
|
|
if (AssetDatabase.IsValidFolder(draggedPath))
|
|
{
|
|
if (string.Equals(folderPath, draggedPath, StringComparison.OrdinalIgnoreCase)) return;
|
|
if (IsSubFolderOf(folderPath, draggedPath)) return;
|
|
|
|
string folderName = Path.GetFileName(draggedPath);
|
|
if (string.IsNullOrEmpty(folderName)) return;
|
|
|
|
string destFolderPath = $"{folderPath}/{folderName}";
|
|
if (string.Equals(destFolderPath, draggedPath, StringComparison.OrdinalIgnoreCase)) return;
|
|
if (AssetPathExists(destFolderPath)) return;
|
|
|
|
DragAndDrop.AcceptDrag();
|
|
|
|
string err = AssetDatabase.MoveAsset(draggedPath, destFolderPath);
|
|
if (!string.IsNullOrEmpty(err))
|
|
{
|
|
EditorUtility.DisplayDialog("Error", err, "OK");
|
|
return;
|
|
}
|
|
|
|
AssetDatabase.SaveAssets();
|
|
RefreshTree();
|
|
evt.StopPropagation();
|
|
return;
|
|
}
|
|
|
|
string srcFolder = Path.GetDirectoryName(draggedPath)?.Replace("\\", "/");
|
|
if (!string.IsNullOrEmpty(srcFolder) && AssetDatabase.IsValidFolder(srcFolder) && string.Equals(srcFolder, folderPath, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return;
|
|
}
|
|
|
|
string fileName = Path.GetFileName(draggedPath);
|
|
if (string.IsNullOrEmpty(fileName)) return;
|
|
|
|
string destPath = $"{folderPath}/{fileName}";
|
|
if (string.Equals(destPath, draggedPath, StringComparison.OrdinalIgnoreCase)) return;
|
|
if (AssetPathExists(destPath)) return;
|
|
|
|
DragAndDrop.AcceptDrag();
|
|
|
|
string err2 = AssetDatabase.MoveAsset(draggedPath, destPath);
|
|
if (!string.IsNullOrEmpty(err2))
|
|
{
|
|
EditorUtility.DisplayDialog("Error", err2, "OK");
|
|
return;
|
|
}
|
|
|
|
AssetDatabase.SaveAssets();
|
|
RefreshTree();
|
|
evt.StopPropagation();
|
|
}
|
|
|
|
private string TryGetDropTargetFolderUnderTreeMouse(Vector2 treeLocalMousePosition)
|
|
{
|
|
if (_folderTree == null) return null;
|
|
if (_folderTree.panel == null) return null;
|
|
|
|
Vector2 world = _folderTree.LocalToWorld(treeLocalMousePosition);
|
|
var picked = _folderTree.panel.Pick(world);
|
|
while (picked != null)
|
|
{
|
|
var path = picked.userData as string;
|
|
if (!string.IsNullOrEmpty(path))
|
|
{
|
|
if (AssetDatabase.IsValidFolder(path))
|
|
{
|
|
return path;
|
|
}
|
|
|
|
var folder = Path.GetDirectoryName(path)?.Replace('\\', '/');
|
|
if (!string.IsNullOrEmpty(folder) && AssetDatabase.IsValidFolder(folder))
|
|
{
|
|
return folder;
|
|
}
|
|
return null;
|
|
}
|
|
picked = picked.parent;
|
|
}
|
|
|
|
if (_folderTree.contentRect.Contains(treeLocalMousePosition))
|
|
{
|
|
return GetActiveProfileRootPath();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static string GetDraggedChartAssetPath()
|
|
{
|
|
var draggedPath = DragAndDrop.GetGenericData(DragDataKey) as string;
|
|
if (!string.IsNullOrEmpty(draggedPath)) return draggedPath;
|
|
|
|
if (DragAndDrop.objectReferences != null)
|
|
{
|
|
for (int i = 0; i < DragAndDrop.objectReferences.Length; i++)
|
|
{
|
|
var obj = DragAndDrop.objectReferences[i];
|
|
if (obj == null) continue;
|
|
if (obj is ChartProfile)
|
|
{
|
|
return AssetDatabase.GetAssetPath(obj);
|
|
}
|
|
}
|
|
|
|
if (DragAndDrop.objectReferences.Length > 0)
|
|
{
|
|
var p = AssetDatabase.GetAssetPath(DragAndDrop.objectReferences[0]);
|
|
if (!string.IsNullOrEmpty(p) && p.EndsWith(".asset", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return p;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (DragAndDrop.paths != null && DragAndDrop.paths.Length > 0)
|
|
{
|
|
for (int i = 0; i < DragAndDrop.paths.Length; i++)
|
|
{
|
|
var p = DragAndDrop.paths[i];
|
|
if (!string.IsNullOrEmpty(p) && AssetDatabase.IsValidFolder(p))
|
|
{
|
|
return p;
|
|
}
|
|
if (!string.IsNullOrEmpty(p) && p.EndsWith(".asset", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var profile = AssetDatabase.LoadAssetAtPath<ChartProfile>(p);
|
|
if (profile != null) return p;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private void OnTreePointerDown(PointerDownEvent evt)
|
|
{
|
|
if (evt.button != 0) return;
|
|
if (_folderTree == null || _folderTree.panel == null) return;
|
|
|
|
var pos2 = new Vector2(evt.localPosition.x, evt.localPosition.y);
|
|
var path = TryGetPathUnderTreeMouse(pos2);
|
|
if (string.IsNullOrEmpty(path)) return;
|
|
|
|
if (evt.clickCount == 2)
|
|
{
|
|
ClearDragState();
|
|
RenameAssetOrFolder(path);
|
|
evt.StopPropagation();
|
|
evt.PreventDefault();
|
|
return;
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(_inlineRenamePath))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_dragCandidateAssetPath = path;
|
|
_dragStartPos = pos2;
|
|
_dragPointerId = evt.pointerId;
|
|
_dragInProgress = false;
|
|
|
|
if (!_folderTree.HasPointerCapture(evt.pointerId))
|
|
{
|
|
_folderTree.CapturePointer(evt.pointerId);
|
|
}
|
|
}
|
|
|
|
private void OnTreePointerMove(PointerMoveEvent evt)
|
|
{
|
|
if (!string.IsNullOrEmpty(_inlineRenamePath)) return;
|
|
if (_dragPointerId != evt.pointerId) return;
|
|
if (string.IsNullOrEmpty(_dragCandidateAssetPath)) return;
|
|
if (_dragInProgress) return;
|
|
|
|
var pos2 = new Vector2(evt.localPosition.x, evt.localPosition.y);
|
|
float sqrDist = (pos2 - _dragStartPos).sqrMagnitude;
|
|
if (sqrDist < DragStartThreshold * DragStartThreshold) return;
|
|
|
|
var obj = AssetDatabase.LoadMainAssetAtPath(_dragCandidateAssetPath);
|
|
if (obj == null)
|
|
{
|
|
ClearDragState();
|
|
return;
|
|
}
|
|
|
|
DragAndDrop.PrepareStartDrag();
|
|
DragAndDrop.objectReferences = new[] { obj };
|
|
DragAndDrop.SetGenericData(DragDataKey, _dragCandidateAssetPath);
|
|
DragAndDrop.visualMode = DragAndDropVisualMode.Move;
|
|
string dragLabel = AssetDatabase.IsValidFolder(_dragCandidateAssetPath)
|
|
? Path.GetFileName(_dragCandidateAssetPath)
|
|
: Path.GetFileNameWithoutExtension(_dragCandidateAssetPath);
|
|
DragAndDrop.StartDrag(dragLabel);
|
|
_dragInProgress = true;
|
|
}
|
|
|
|
private void OnTreePointerUp(PointerUpEvent evt)
|
|
{
|
|
if (_folderTree != null && _folderTree.HasPointerCapture(evt.pointerId))
|
|
{
|
|
_folderTree.ReleasePointer(evt.pointerId);
|
|
}
|
|
ClearDragState();
|
|
}
|
|
|
|
private string TryGetPathUnderTreeMouse(Vector2 treeLocalMousePosition)
|
|
{
|
|
if (_folderTree == null) return null;
|
|
if (_folderTree.panel == null) return null;
|
|
|
|
Vector2 world = _folderTree.LocalToWorld(treeLocalMousePosition);
|
|
var picked = _folderTree.panel.Pick(world);
|
|
while (picked != null)
|
|
{
|
|
var path = picked.userData as string;
|
|
if (!string.IsNullOrEmpty(path))
|
|
{
|
|
return path;
|
|
}
|
|
picked = picked.parent;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void ClearDragState()
|
|
{
|
|
_dragCandidateAssetPath = null;
|
|
_dragPointerId = -1;
|
|
_dragInProgress = false;
|
|
}
|
|
|
|
private void RenameAssetOrFolder(string path)
|
|
{
|
|
BeginInlineRename(path);
|
|
}
|
|
|
|
private void BeginInlineRename(string path)
|
|
{
|
|
if (string.IsNullOrEmpty(path)) return;
|
|
_inlineRenamePath = path;
|
|
_inlineRenamePendingFocusPath = path;
|
|
_inlineRenameField = null;
|
|
if (_folderTree != null) _folderTree.Rebuild();
|
|
}
|
|
|
|
private void CancelInlineRename()
|
|
{
|
|
_inlineRenamePath = null;
|
|
_inlineRenamePendingFocusPath = null;
|
|
_inlineRenameField = null;
|
|
if (_folderTree != null) _folderTree.Rebuild();
|
|
}
|
|
|
|
private void CommitInlineRename(string path, string newName)
|
|
{
|
|
if (string.IsNullOrEmpty(path))
|
|
{
|
|
CancelInlineRename();
|
|
return;
|
|
}
|
|
|
|
string currentName = AssetDatabase.IsValidFolder(path)
|
|
? Path.GetFileName(path)
|
|
: Path.GetFileNameWithoutExtension(path);
|
|
|
|
newName = SanitizeFileName(newName);
|
|
if (string.IsNullOrWhiteSpace(newName) || newName == currentName)
|
|
{
|
|
CancelInlineRename();
|
|
return;
|
|
}
|
|
|
|
string ext = Path.GetExtension(path);
|
|
string parent = Path.GetDirectoryName(path)?.Replace('\\', '/');
|
|
string renamedPath = string.IsNullOrEmpty(parent) ? null : $"{parent}/{newName}{ext}";
|
|
|
|
string err = AssetDatabase.RenameAsset(path, newName);
|
|
if (!string.IsNullOrEmpty(err))
|
|
{
|
|
EditorUtility.DisplayDialog("Error", err, "OK");
|
|
CancelInlineRename();
|
|
return;
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(renamedPath) && ext.Equals(".asset", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var profile = AssetDatabase.LoadAssetAtPath<ChartProfile>(renamedPath);
|
|
if (profile != null)
|
|
{
|
|
if (!string.Equals(profile.name, newName, StringComparison.Ordinal))
|
|
{
|
|
profile.name = newName;
|
|
EditorUtility.SetDirty(profile);
|
|
}
|
|
|
|
if (!string.Equals(profile.chartName, newName, StringComparison.Ordinal))
|
|
{
|
|
profile.chartName = newName;
|
|
EditorUtility.SetDirty(profile);
|
|
}
|
|
}
|
|
}
|
|
|
|
_inlineRenamePath = null;
|
|
_inlineRenamePendingFocusPath = null;
|
|
_inlineRenameField = null;
|
|
AssetDatabase.SaveAssets();
|
|
RefreshTree();
|
|
}
|
|
|
|
private void OnRootPointerDownForInlineRename(PointerDownEvent evt)
|
|
{
|
|
if (evt.button != 0) return;
|
|
if (string.IsNullOrEmpty(_inlineRenamePath)) return;
|
|
if (_inlineRenameField == null) return;
|
|
|
|
if (evt.target is VisualElement target && _inlineRenameField.Contains(target))
|
|
{
|
|
return;
|
|
}
|
|
|
|
string path = _inlineRenameField.userData as string;
|
|
string value = _inlineRenameField.value;
|
|
|
|
rootVisualElement.schedule.Execute(() =>
|
|
{
|
|
if (!string.IsNullOrEmpty(_inlineRenamePath))
|
|
{
|
|
CommitInlineRename(path, value);
|
|
}
|
|
});
|
|
}
|
|
|
|
private void RefreshTree()
|
|
{
|
|
EnsureSharedIconsLoaded();
|
|
|
|
var expandedFolderPaths = CaptureExpandedFolderPaths();
|
|
EnsureActiveLibraryFolders();
|
|
|
|
int idCounter = 0;
|
|
_treeRoots = BuildTreeRecursive(GetActiveProfileRootPath(), ref idCounter);
|
|
_folderTree.SetRootItems(_treeRoots);
|
|
_folderTree.Rebuild();
|
|
|
|
RestoreExpandedFolderPaths(expandedFolderPaths);
|
|
}
|
|
|
|
private HashSet<string> CaptureExpandedFolderPaths()
|
|
{
|
|
var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
if (_folderTree == null) return set;
|
|
if (_treeRoots == null) return set;
|
|
|
|
CaptureExpandedFolderPathsRecursive(_treeRoots, set);
|
|
return set;
|
|
}
|
|
|
|
private void CaptureExpandedFolderPathsRecursive(IEnumerable<TreeViewItemData<string>> items, HashSet<string> set)
|
|
{
|
|
if (items == null) return;
|
|
foreach (var item in items)
|
|
{
|
|
var path = item.data;
|
|
if (!string.IsNullOrEmpty(path) && AssetDatabase.IsValidFolder(path) && _folderTree.IsExpanded(item.id))
|
|
{
|
|
set.Add(path);
|
|
}
|
|
|
|
if (item.children != null && item.children.Any())
|
|
{
|
|
CaptureExpandedFolderPathsRecursive(item.children, set);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RestoreExpandedFolderPaths(HashSet<string> expandedFolderPaths)
|
|
{
|
|
if (_folderTree == null) return;
|
|
if (expandedFolderPaths == null || expandedFolderPaths.Count == 0) return;
|
|
if (_treeRoots == null) return;
|
|
|
|
RestoreExpandedFolderPathsRecursive(_treeRoots, expandedFolderPaths);
|
|
}
|
|
|
|
private void ExpandAllFolders()
|
|
{
|
|
if (_folderTree == null) return;
|
|
if (_treeRoots == null) return;
|
|
ExpandAllFoldersRecursive(_treeRoots);
|
|
}
|
|
|
|
private void ExpandAllFoldersRecursive(IEnumerable<TreeViewItemData<string>> items)
|
|
{
|
|
if (items == null) return;
|
|
foreach (var item in items)
|
|
{
|
|
var path = item.data;
|
|
if (!string.IsNullOrEmpty(path) && AssetDatabase.IsValidFolder(path))
|
|
{
|
|
_folderTree.ExpandItem(item.id);
|
|
}
|
|
|
|
if (item.children != null && item.children.Any())
|
|
{
|
|
ExpandAllFoldersRecursive(item.children);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CollapseAllFolders()
|
|
{
|
|
if (_folderTree == null) return;
|
|
if (_treeRoots == null) return;
|
|
CollapseAllFoldersRecursive(_treeRoots);
|
|
}
|
|
|
|
private void CollapseAllFoldersRecursive(IEnumerable<TreeViewItemData<string>> items)
|
|
{
|
|
if (items == null) return;
|
|
foreach (var item in items)
|
|
{
|
|
var path = item.data;
|
|
if (!string.IsNullOrEmpty(path) && AssetDatabase.IsValidFolder(path))
|
|
{
|
|
_folderTree.CollapseItem(item.id);
|
|
}
|
|
|
|
if (item.children != null && item.children.Any())
|
|
{
|
|
CollapseAllFoldersRecursive(item.children);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RestoreExpandedFolderPathsRecursive(IEnumerable<TreeViewItemData<string>> items, HashSet<string> expandedFolderPaths)
|
|
{
|
|
if (items == null) return;
|
|
foreach (var item in items)
|
|
{
|
|
var path = item.data;
|
|
if (!string.IsNullOrEmpty(path) && AssetDatabase.IsValidFolder(path) && expandedFolderPaths.Contains(path))
|
|
{
|
|
_folderTree.ExpandItem(item.id);
|
|
}
|
|
|
|
if (item.children != null && item.children.Any())
|
|
{
|
|
RestoreExpandedFolderPathsRecursive(item.children, expandedFolderPaths);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static bool IsSubFolderOf(string candidateFolder, string parentFolder)
|
|
{
|
|
if (string.IsNullOrEmpty(candidateFolder) || string.IsNullOrEmpty(parentFolder)) return false;
|
|
string candidate = candidateFolder.Replace('\\', '/').TrimEnd('/') + "/";
|
|
string parent = parentFolder.Replace('\\', '/').TrimEnd('/') + "/";
|
|
return candidate.StartsWith(parent, StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
|
|
private List<TreeViewItemData<string>> BuildTreeRecursive(string path, ref int idCounter)
|
|
{
|
|
var items = new List<TreeViewItemData<string>>();
|
|
|
|
string[] dirs = Directory.GetDirectories(path);
|
|
Array.Sort(dirs, StringComparer.OrdinalIgnoreCase);
|
|
foreach (var dir in dirs)
|
|
{
|
|
string unityPath = dir.Replace("\\", "/");
|
|
var children = BuildTreeRecursive(unityPath, ref idCounter);
|
|
var item = new TreeViewItemData<string>(idCounter++, unityPath, children);
|
|
items.Add(item);
|
|
}
|
|
|
|
var orderedFiles = GetProfilesInFolderSortedByName(path);
|
|
for (int i = 0; i < orderedFiles.Count; i++)
|
|
{
|
|
var file = orderedFiles[i];
|
|
var asset = AssetDatabase.LoadAssetAtPath<ChartProfile>(file);
|
|
if (asset != null)
|
|
{
|
|
items.Add(new TreeViewItemData<string>(idCounter++, file));
|
|
}
|
|
}
|
|
|
|
return items;
|
|
}
|
|
|
|
private List<string> GetProfilesInFolder(string folderPath)
|
|
{
|
|
var list = new List<string>();
|
|
if (string.IsNullOrEmpty(folderPath)) return list;
|
|
if (!AssetDatabase.IsValidFolder(folderPath)) return list;
|
|
|
|
string[] files;
|
|
try
|
|
{
|
|
files = Directory.GetFiles(folderPath, "*.asset");
|
|
}
|
|
catch
|
|
{
|
|
return list;
|
|
}
|
|
|
|
for (int i = 0; i < files.Length; i++)
|
|
{
|
|
var file = files[i].Replace('\\', '/');
|
|
var asset = AssetDatabase.LoadAssetAtPath<ChartProfile>(file);
|
|
if (asset != null)
|
|
{
|
|
list.Add(file);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
private List<string> GetProfilesInFolderSortedByName(string folderPath)
|
|
{
|
|
var list = GetProfilesInFolder(folderPath);
|
|
list.Sort((a, b) => string.Compare(GetProfileDisplayNameForSort(a), GetProfileDisplayNameForSort(b), StringComparison.OrdinalIgnoreCase));
|
|
return list;
|
|
}
|
|
|
|
private static string GetProfileDisplayNameForSort(string assetPath)
|
|
{
|
|
if (string.IsNullOrEmpty(assetPath)) return string.Empty;
|
|
return Path.GetFileNameWithoutExtension(assetPath);
|
|
}
|
|
}
|
|
}
|