735 lines
16 KiB
C#
735 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
|
|
namespace vietlabs.fr2
|
|
{
|
|
public interface IWindow
|
|
{
|
|
bool IsFocusingDuplicate { get; }
|
|
bool WillRepaint { get; set; }
|
|
void Repaint();
|
|
void OnSelectionChange();
|
|
Dictionary<string, FR2_Ref> GetUsedByRefs();
|
|
}
|
|
|
|
internal interface IRefDraw
|
|
{
|
|
IWindow window { get; }
|
|
int ElementCount();
|
|
bool Draw();
|
|
}
|
|
|
|
internal class RefDrawConfig
|
|
{
|
|
public bool drawGlobal;
|
|
public bool drawInTop;
|
|
public bool isDraw;
|
|
public bool isDrawTool;
|
|
public IRefDraw refDrawer;
|
|
|
|
public RefDrawConfig(IRefDraw drawer)
|
|
{
|
|
refDrawer = drawer;
|
|
}
|
|
}
|
|
// internal class ShareData
|
|
// {
|
|
// //internal static Dictionary<string, FR2_Ref> UsedBy;
|
|
// }
|
|
|
|
public abstract class FR2_WindowBase : EditorWindow, IWindow
|
|
{
|
|
public virtual bool ShowScene { get; }
|
|
|
|
internal class Icon
|
|
{
|
|
static Icon _icon;
|
|
|
|
public GUIContent Refresh;
|
|
public GUIContent Lock;
|
|
public GUIContent LockOn;
|
|
public GUIContent Setting;
|
|
|
|
public static Icon icons => _icon ??= new Icon
|
|
{
|
|
Refresh = EditorGUIUtility.IconContent("d_Refresh"),
|
|
Lock = EditorGUIUtility.IconContent("LockIcon"),
|
|
LockOn = EditorGUIUtility.IconContent("LockIcon-On"),
|
|
Setting = EditorGUIUtility.IconContent("d_SettingsIcon", "Settings")
|
|
};
|
|
}
|
|
|
|
protected int selectedTab;
|
|
|
|
protected bool IsFocusingUses
|
|
{
|
|
get { return selectedTab == 0; }
|
|
}
|
|
|
|
protected bool IsFocusingUsedBy
|
|
{
|
|
get { return selectedTab == 1; }
|
|
}
|
|
|
|
public bool IsFocusingDuplicate
|
|
{
|
|
get { return selectedTab == 2; }
|
|
}
|
|
|
|
protected bool IsFocusingUnused
|
|
{
|
|
get { return selectedTab == 4; }
|
|
}
|
|
|
|
protected bool IsFocusingGUIDs
|
|
{
|
|
get { return selectedTab == 3; }
|
|
}
|
|
|
|
protected bool IsFocusingUsedInBuild
|
|
{
|
|
get { return selectedTab == 5; }
|
|
}
|
|
|
|
protected bool IsFocusingFindInScene
|
|
{
|
|
get { return selectedTab == 1; }
|
|
}
|
|
|
|
protected bool IsFocusingSceneToAsset
|
|
{
|
|
get { return selectedTab == 0; }
|
|
}
|
|
|
|
protected bool IsFocusingSceneInScene
|
|
{
|
|
get { return selectedTab == 1; }
|
|
}
|
|
|
|
public bool WillRepaint { get; set; }
|
|
protected bool showFilter, showSetting, showIgnore;
|
|
|
|
protected static GUIContent[] TOOLBARS =
|
|
{
|
|
new GUIContent("Uses"),
|
|
new GUIContent("Used By"),
|
|
new GUIContent("Duplicate"),
|
|
new GUIContent("GUIDs"),
|
|
new GUIContent("Unused Assets"),
|
|
new GUIContent("Uses In Build")
|
|
};
|
|
|
|
[NonSerialized] protected bool lockSelection;
|
|
[NonSerialized] internal List<FR2_Asset> Selected;
|
|
public float sizeRatio = 0.5f;
|
|
protected Rect resizer;
|
|
protected bool isResizing;
|
|
protected GUIStyle resizerStyle;
|
|
|
|
public static bool isNoticeIgnore;
|
|
|
|
public void AddItemsToMenu(GenericMenu menu)
|
|
{
|
|
FR2_Cache api = FR2_Cache.Api;
|
|
if (api == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
menu.AddDisabledItem(new GUIContent("FR2 - v2.4.3"));
|
|
menu.AddSeparator(string.Empty);
|
|
|
|
menu.AddItem(new GUIContent("Enable"), !api.disabled, () => { api.disabled = !api.disabled; });
|
|
|
|
menu.AddItem(new GUIContent("Clear Selection"), false, () => { FR2_Selection.ClearSelection(); });
|
|
|
|
menu.AddItem(new GUIContent("Commit Selection (" + FR2_Selection.SelectionCount + ")"), false,
|
|
FR2_Selection.Commit);
|
|
|
|
menu.AddItem(new GUIContent("Refresh"), false, () =>
|
|
{
|
|
FR2_Asset.lastRefreshTS = Time.realtimeSinceStartup;
|
|
FR2_Cache.Api.Check4Changes(true, true);
|
|
FR2_SceneCache.Api.SetDirty();
|
|
});
|
|
|
|
#if FR2_DEV
|
|
menu.AddItem(new GUIContent("Refresh Usage"), false, () => FR2_Cache.Api.Check4Usage());
|
|
menu.AddItem(new GUIContent("Refresh Selected"), false, ()=> FR2_Cache.Api.RefreshSelection());
|
|
menu.AddItem(new GUIContent("Clear Cache"), false, () => FR2_Cache.Api.Clear());
|
|
#endif
|
|
}
|
|
|
|
protected virtual void OnTabChanged() { }
|
|
|
|
protected abstract void InitIfNeeded();
|
|
public abstract void OnSelectionChange();
|
|
protected abstract void OnGUI();
|
|
protected abstract void RefreshSort();
|
|
protected abstract void maskDirty();
|
|
protected abstract bool checkNoticeFilter();
|
|
protected abstract bool checkNoticeIgnore();
|
|
|
|
protected abstract void OnReady();
|
|
|
|
|
|
#if UNITY_2018_OR_NEWER
|
|
protected void OnSceneChanged(Scene arg0, Scene arg1)
|
|
{
|
|
if (IsFocusingFindInScene || IsFocusingSceneToAsset || IsFocusingSceneInScene)
|
|
{
|
|
OnSelectionChange();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
protected bool willRepaint;
|
|
|
|
protected bool CheckDrawHeader()
|
|
{
|
|
if (EditorApplication.isCompiling)
|
|
{
|
|
EditorGUILayout.HelpBox("Compiling scripts, please wait!", MessageType.Warning);
|
|
Repaint();
|
|
return false;
|
|
}
|
|
|
|
if (EditorApplication.isUpdating)
|
|
{
|
|
EditorGUILayout.HelpBox("Importing assets, please wait!", MessageType.Warning);
|
|
Repaint();
|
|
return false;
|
|
}
|
|
|
|
InitIfNeeded();
|
|
|
|
if (EditorSettings.serializationMode != SerializationMode.ForceText)
|
|
{
|
|
EditorGUILayout.HelpBox("FR2 requires serialization mode set to FORCE TEXT!", MessageType.Warning);
|
|
if (GUILayout.Button("FORCE TEXT"))
|
|
{
|
|
EditorSettings.serializationMode = SerializationMode.ForceText;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (FR2_Cache.hasCache && !FR2_Cache.CheckSameVersion())
|
|
{
|
|
EditorGUILayout.HelpBox("Incompatible cache version found, need a full refresh may take time!",
|
|
MessageType.Warning);
|
|
if (GUILayout.Button("Scan project"))
|
|
{
|
|
FR2_Cache.DeleteCache();
|
|
FR2_Cache.CreateCache();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!FR2_Cache.isReady)
|
|
{
|
|
if (!FR2_Cache.hasCache)
|
|
{
|
|
EditorGUILayout.HelpBox(
|
|
"FR2 cache not found!\nFirst scan may takes quite some time to finish but you would be able to work normally while the scan works in background...",
|
|
MessageType.Warning);
|
|
if (GUILayout.Button("Scan project"))
|
|
{
|
|
FR2_Cache.CreateCache();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (!DrawEnable())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
FR2_Cache api = FR2_Cache.Api;
|
|
string text = "Refreshing ... " + (int) (api.progress * api.workCount) + " / " + api.workCount;
|
|
Rect rect = GUILayoutUtility.GetRect(1f, Screen.width, 18f, 18f);
|
|
EditorGUI.ProgressBar(rect, api.progress, text);
|
|
Repaint();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (!DrawEnable())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
willRepaint = Event.current.type == EventType.ScrollWheel;
|
|
int newTab = selectedTab;
|
|
|
|
GUILayout.BeginHorizontal(EditorStyles.toolbar);
|
|
{
|
|
Color color = GUI.contentColor;
|
|
GUI.contentColor = EditorGUIUtility.isProSkin
|
|
? new Color(0.9f, 0.9f, 0.9f, 1f)
|
|
: new Color(0.1f, 0.1f, 0.1f, 1f);
|
|
|
|
GUIContent icon = Icon.icons.Lock;
|
|
if (lockSelection)
|
|
{
|
|
icon = Icon.icons.LockOn;
|
|
}
|
|
|
|
bool v = GUILayout.Toggle(lockSelection, icon, EditorStyles.toolbarButton, GUILayout.Width(21f));
|
|
|
|
GUI.contentColor = color;
|
|
|
|
if (v != lockSelection)
|
|
{
|
|
lockSelection = v;
|
|
if (lockSelection == false)
|
|
{
|
|
OnSelectionChange();
|
|
}
|
|
|
|
willRepaint = true;
|
|
}
|
|
|
|
|
|
for (var i = 0; i < TOOLBARS.Length; i++)
|
|
{
|
|
if (ShowScene && i > 1)
|
|
{
|
|
break;
|
|
}
|
|
|
|
bool isSelected = selectedTab == i;
|
|
bool b = GUILayout.Toggle(isSelected, TOOLBARS[i], EditorStyles.toolbarButton);
|
|
if (b != isSelected)
|
|
{
|
|
newTab = i;
|
|
}
|
|
}
|
|
|
|
// newTab = GUILayout.Toolbar(selectedTab, TOOLBARS);
|
|
}
|
|
GUILayout.EndHorizontal();
|
|
|
|
if (newTab != selectedTab)
|
|
{
|
|
selectedTab = newTab;
|
|
OnTabChanged();
|
|
// Check4Changes means delay calls to OnReady :: Refresh !
|
|
//if (FR2_Cache.Api.isReady) FR2_Cache.Api.Check4Changes();
|
|
OnReady();
|
|
}
|
|
|
|
if (Selected == null)
|
|
{
|
|
Selected = new List<FR2_Asset>();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
protected void OnAfterGUI(int drawCount)
|
|
{
|
|
if (willRepaint || WillRepaint || !FR2_SceneCache.ready)
|
|
{
|
|
WillRepaint = false;
|
|
Repaint();
|
|
}
|
|
|
|
if (drawCount > 1)
|
|
{
|
|
DrawResizer();
|
|
ProcessEvents(Event.current);
|
|
}
|
|
|
|
if (GUI.changed)
|
|
{
|
|
Repaint();
|
|
}
|
|
}
|
|
|
|
protected bool DrawEnable()
|
|
{
|
|
FR2_Cache api = FR2_Cache.Api;
|
|
if (api == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool v = api.disabled;
|
|
|
|
if (v)
|
|
{
|
|
EditorGUILayout.HelpBox("Find References 2 is disabled!", MessageType.Warning);
|
|
if (GUILayout.Button("Enable"))
|
|
{
|
|
api.disabled = !api.disabled;
|
|
Repaint();
|
|
}
|
|
|
|
return !api.disabled;
|
|
}
|
|
|
|
if (!api.ready)
|
|
{
|
|
float w = EditorGUIUtility.labelWidth;
|
|
EditorGUIUtility.labelWidth = 70f;
|
|
api.priority = EditorGUILayout.IntSlider("Priority", api.priority, 0, 5);
|
|
EditorGUIUtility.labelWidth = w;
|
|
}
|
|
|
|
return !api.disabled;
|
|
}
|
|
|
|
protected bool AnyToolInBot
|
|
{
|
|
get { return FR2_Setting.showSettings || showIgnore || showFilter; }
|
|
}
|
|
|
|
internal bool GetDrawConfig(IRefDraw refDrawer, out RefDrawConfig config)
|
|
{
|
|
bool drawTool = AnyToolInBot;
|
|
config = new RefDrawConfig(refDrawer);
|
|
config.drawGlobal = !drawTool;
|
|
config.drawInTop = drawTool;
|
|
config.isDraw = true;
|
|
return drawTool;
|
|
}
|
|
|
|
internal bool GetDrawConfig(IRefDraw refTop, IRefDraw refBot, out RefDrawConfig config1,
|
|
out RefDrawConfig config2)
|
|
{
|
|
var drawTool = true;
|
|
config1 = new RefDrawConfig(refTop);
|
|
config2 = new RefDrawConfig(refBot);
|
|
config1.isDraw = config1.refDrawer.ElementCount() > 0;
|
|
config2.isDraw = config2.refDrawer.ElementCount() > 0;
|
|
|
|
if (AnyToolInBot)
|
|
{
|
|
if (refTop.ElementCount() > 0)
|
|
{
|
|
config1.drawInTop = true;
|
|
if (refBot.ElementCount() > 0)
|
|
{
|
|
drawTool = false;
|
|
config2.isDrawTool = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
config2.drawInTop = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
drawTool = false;
|
|
if (refTop.ElementCount() > 0)
|
|
{
|
|
config1.drawInTop = true;
|
|
if (refBot.ElementCount() > 0)
|
|
{
|
|
config2.drawInTop = false;
|
|
}
|
|
else
|
|
{
|
|
config1.drawGlobal = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// config2.drawInTop = true;
|
|
config2.drawGlobal = true;
|
|
}
|
|
}
|
|
|
|
return drawTool;
|
|
}
|
|
|
|
internal int DrawConfig(RefDrawConfig config, Rect rectTop, Rect rectBot, ref bool WillRepaint)
|
|
{
|
|
if (config == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (config.refDrawer == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (!config.isDraw)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
var willRepaint = false;
|
|
if (config.drawGlobal)
|
|
{
|
|
willRepaint = config.refDrawer.Draw();
|
|
}
|
|
else
|
|
{
|
|
if (config.drawInTop)
|
|
{
|
|
GUILayout.BeginArea(rectTop);
|
|
willRepaint = config.refDrawer.Draw();
|
|
GUILayout.EndArea();
|
|
}
|
|
else if (config.isDrawTool)
|
|
{
|
|
GUILayout.BeginArea(rectBot);
|
|
willRepaint = config.refDrawer.Draw();
|
|
DrawTool();
|
|
GUILayout.EndArea();
|
|
}
|
|
else
|
|
{
|
|
GUILayout.BeginArea(rectBot);
|
|
willRepaint = config.refDrawer.Draw();
|
|
GUILayout.EndArea();
|
|
}
|
|
}
|
|
|
|
if (willRepaint)
|
|
{
|
|
WillRepaint = true;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
protected void DrawTool()
|
|
{
|
|
if (showFilter)
|
|
{
|
|
if (AssetType.DrawSearchFilter())
|
|
{
|
|
maskDirty();
|
|
}
|
|
}
|
|
else if (showIgnore)
|
|
{
|
|
GUILayout.BeginHorizontal(EditorStyles.toolbar);
|
|
GUILayout.Label("Ignores");
|
|
// showContent = EditorGUILayout.Foldout(showContent, searchLable);
|
|
GUILayout.EndHorizontal();
|
|
|
|
if (AssetType.DrawIgnoreFolder())
|
|
{
|
|
maskDirty();
|
|
}
|
|
}
|
|
else if (FR2_Setting.showSettings)
|
|
{
|
|
FR2_Setting.s.DrawSettings();
|
|
}
|
|
}
|
|
|
|
public Rect GetTopPanelRect()
|
|
{
|
|
return new Rect(0, 17, position.width, position.height * sizeRatio - 20);
|
|
}
|
|
|
|
public Rect GetBotPanelRect()
|
|
{
|
|
return new Rect(0, position.height * sizeRatio + 5, position.width,
|
|
position.height * (1 - sizeRatio) - 5 - paddingBot);
|
|
}
|
|
|
|
private void DrawResizer()
|
|
{
|
|
resizer = new Rect(0, position.height * sizeRatio - 5f, position.width, 10f);
|
|
|
|
Vector2 a = resizer.position + Vector2.up * 5f;
|
|
GUILayout.BeginArea(new Rect(a.x, a.y, position.width, 1), resizerStyle);
|
|
// GUILayout.BeginArea(new Rect(resizer.position + (Vector2.up * 5f), new Vector2(position.width, 1)), resizerStyle);
|
|
GUILayout.EndArea();
|
|
|
|
EditorGUIUtility.AddCursorRect(resizer, MouseCursor.ResizeVertical);
|
|
}
|
|
|
|
protected void ProcessEvents(Event e)
|
|
{
|
|
switch (e.type)
|
|
{
|
|
case EventType.MouseDown:
|
|
if (e.button == 0 && resizer.Contains(e.mousePosition))
|
|
{
|
|
isResizing = true;
|
|
}
|
|
|
|
break;
|
|
#if UNITY_5_3_OR_NEWER
|
|
case EventType.MouseLeaveWindow:
|
|
#endif
|
|
case EventType.MouseUp:
|
|
isResizing = false;
|
|
break;
|
|
}
|
|
|
|
Resize(e);
|
|
}
|
|
|
|
private void Resize(Event e)
|
|
{
|
|
if (isResizing)
|
|
{
|
|
sizeRatio = e.mousePosition.y / position.height;
|
|
normalizeSize();
|
|
Repaint();
|
|
}
|
|
}
|
|
|
|
private void normalizeSize()
|
|
{
|
|
if (sizeRatio * position.height < paddingTop)
|
|
{
|
|
sizeRatio = paddingTop / position.height;
|
|
}
|
|
|
|
if (position.height - sizeRatio * position.height < paddingBot)
|
|
{
|
|
sizeRatio = (position.height - paddingBot) * 1f / position.height;
|
|
}
|
|
}
|
|
|
|
private const float paddingTop = 70;
|
|
private const float paddingBot = 25;
|
|
|
|
protected void DrawFooter()
|
|
{
|
|
GUILayout.FlexibleSpace();
|
|
|
|
|
|
GUILayout.BeginHorizontal(EditorStyles.toolbar);
|
|
{
|
|
Color color = GUI.contentColor;
|
|
GUI.contentColor = EditorGUIUtility.isProSkin
|
|
? new Color(0.9f, 0.9f, 0.9f, 1f)
|
|
: new Color(0.1f, 0.1f, 0.1f, 1f);
|
|
|
|
if (FR2_Unity.DrawToggleToolbar(ref FR2_Setting.showSettings, Icon.icons.Setting, 21f))
|
|
{
|
|
maskDirty();
|
|
if (FR2_Setting.showSettings)
|
|
{
|
|
showFilter = showIgnore = false;
|
|
}
|
|
}
|
|
|
|
GUI.contentColor = color;
|
|
|
|
bool v = checkNoticeFilter();
|
|
string content = !FR2_Setting.IsIncludeAllType() ? "*Filter" : "Filter";
|
|
if (v)
|
|
{
|
|
Color oc = GUI.backgroundColor;
|
|
GUI.backgroundColor = Color.red;
|
|
v = GUILayout.Toggle(showFilter, content, EditorStyles.toolbarButton, GUILayout.Width(50f));
|
|
GUI.backgroundColor = oc;
|
|
}
|
|
else
|
|
{
|
|
v = GUILayout.Toggle(showFilter, content, EditorStyles.toolbarButton, GUILayout.Width(50f));
|
|
}
|
|
|
|
if (v != showFilter)
|
|
{
|
|
showFilter = v;
|
|
if (showFilter)
|
|
{
|
|
FR2_Setting.showSettings = showIgnore = false;
|
|
}
|
|
}
|
|
|
|
v = checkNoticeIgnore();
|
|
content = FR2_Setting.IgnoreAsset.Count > 0 ? "*Ignore" : "Ignore";
|
|
if (v)
|
|
{
|
|
Color oc = GUI.backgroundColor;
|
|
GUI.backgroundColor = Color.red;
|
|
v = GUILayout.Toggle(showIgnore, content, EditorStyles.toolbarButton, GUILayout.Width(50f));
|
|
GUI.backgroundColor = oc;
|
|
}
|
|
else
|
|
{
|
|
v = GUILayout.Toggle(showIgnore, content, EditorStyles.toolbarButton, GUILayout.Width(50f));
|
|
}
|
|
|
|
// var i = GUILayout.Toggle(showIgnore, content, EditorStyles.toolbarButton, GUILayout.Width(50f));
|
|
if (v != showIgnore)
|
|
{
|
|
showIgnore = v;
|
|
if (v)
|
|
{
|
|
showFilter = FR2_Setting.showSettings = false;
|
|
}
|
|
}
|
|
|
|
bool ss = FR2_Setting.ShowSelection;
|
|
v = GUILayout.Toggle(ss, "Selection", EditorStyles.toolbarButton, GUILayout.Width(60f));
|
|
if (v != ss)
|
|
{
|
|
FR2_Setting.ShowSelection = v;
|
|
maskDirty();
|
|
}
|
|
|
|
if (FR2_Selection.SelectionCount > 0)
|
|
{
|
|
if (GUILayout.Button("Commit Selection [" + FR2_Selection.SelectionCount + "]",
|
|
EditorStyles.toolbarButton))
|
|
{
|
|
FR2_Selection.Commit();
|
|
}
|
|
|
|
if (GUILayout.Button("Clear Selection", EditorStyles.toolbarButton))
|
|
{
|
|
FR2_Selection.ClearSelection();
|
|
}
|
|
}
|
|
|
|
|
|
GUILayout.FlexibleSpace();
|
|
|
|
|
|
if (!IsFocusingDuplicate && !IsFocusingGUIDs)
|
|
{
|
|
float o = EditorGUIUtility.labelWidth;
|
|
EditorGUIUtility.labelWidth = 42f;
|
|
|
|
FR2_RefDrawer.Mode ov = FR2_Setting.GroupMode;
|
|
var vv = (FR2_RefDrawer.Mode) EditorGUILayout.EnumPopup("Group", ov, GUILayout.Width(122f));
|
|
if (vv != ov)
|
|
{
|
|
FR2_Setting.GroupMode = vv;
|
|
maskDirty();
|
|
}
|
|
|
|
GUILayout.Space(4f);
|
|
EditorGUIUtility.labelWidth = 30f;
|
|
|
|
FR2_RefDrawer.Sort s = FR2_Setting.SortMode;
|
|
var vvv = (FR2_RefDrawer.Sort) EditorGUILayout.EnumPopup("Sort", s, GUILayout.Width(100f));
|
|
if (vvv != s)
|
|
{
|
|
FR2_Setting.SortMode = vvv;
|
|
RefreshSort();
|
|
}
|
|
|
|
EditorGUIUtility.labelWidth = o;
|
|
}
|
|
}
|
|
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
|
|
public Dictionary<string, FR2_Ref> GetUsedByRefs()
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
} |