private void ResetWithoutAffectingChildren()
{
var transform = Transform;
var temp = (new GameObject()).transform;
temp.parent = transform.parent;
temp.localPosition = transform.localPosition;
temp.localEulerAngles = transform.localEulerAngles;
temp.localScale = transform.localScale;
int childCount = transform.childCount;
var children = ArrayPool <Transform> .Create(childCount);
for (int n = childCount - 1; n >= 0; n--)
{
var child = transform.GetChild(n);
children[n] = transform.GetChild(n);
child.parent = temp;
}
DoReset();
for (int n = childCount - 1; n >= 0; n--)
{
var child = temp.GetChild(n);
child.parent = transform;
}
ArrayPool <Transform> .Dispose(ref children);
Platform.Active.Destroy(temp.gameObject);
}
/// <inheritdoc />
public override void Dispose()
{
ArrayPool <Type> .Dispose(ref implementingNonUnityObjectTypes);
ArrayPool <Type> .Dispose(ref implementingUnityObjectTypes);
base.Dispose();
}
public static void ResetWithoutAffectingChildren([NotNull] this Transform transform)
{
int childCount = transform.childCount;
if (childCount == 0)
{
transform.localPosition = Vector3.zero;
transform.localEulerAngles = Vector3.zero;
transform.localScale = Vector3.one;
return;
}
var rectTransform = transform as RectTransform;
if (rectTransform != null)
{
rectTransform.ResetWithoutAffectingChildren();
return;
}
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(!(transform is RectTransform));
#endif
var temp = (new GameObject()).transform;
temp.parent = transform.parent;
temp.localPosition = transform.localPosition;
temp.localEulerAngles = transform.localEulerAngles;
temp.localScale = transform.localScale;
var children = ArrayPool <Transform> .Create(childCount);
for (int n = childCount - 1; n >= 0; n--)
{
var child = transform.GetChild(n);
children[n] = transform.GetChild(n);
child.parent = temp;
}
transform.localPosition = Vector3.zero;
transform.localEulerAngles = Vector3.zero;
transform.localScale = Vector3.one;
for (int n = childCount - 1; n >= 0; n--)
{
var child = temp.GetChild(n);
child.parent = transform;
}
ArrayPool <Transform> .Dispose(ref children);
Platform.Active.Destroy(temp.gameObject);
}
protected void ClearCategorizedBuildList()
{
foreach (var componentsList in categorizedBuildList.Values)
{
for (int n = componentsList.Count - 1; n >= 0; n--)
{
var array = componentsList[n];
ArrayPool <Component> .Dispose(ref array);
}
componentsList.Clear();
componentsListPool.Push(componentsList);
}
categorizedBuildList.Clear();
}
public void Dispose()
{
int genericTypeCount = genericTypeIds.Length;
if (genericTypeCount > 0)
{
for (int n = 0; n < genericTypeCount; n++)
{
var genericTypeId = genericTypeIds[n];
genericTypeId.Dispose();
}
ArrayPool <TypeId> .Dispose(ref genericTypeIds);
}
}
/// <summary> Dock EditorWindow as tab on the parent host view of the existing EditorWindow. </summary>
/// <param name="window"> The window whose host view to dock on. </param>
/// <param name="tab"> The EditorWindow to dock. </param>
public static void AddTab([NotNull] this EditorWindow window, EditorWindow tab)
{
var dockArea = window.ParentHostView();
if (dockArea == null)
{
#if DEV_MODE
Debug.LogWarning("m_Parent of target window " + window.GetType().Name + " (\"" + window.name + "\") was null; can't add " + tab.GetType().Name + " (\"" + tab.name + "\") as tab. You might want to revert Layout to factory settings.");
#endif
return;
}
var dockAreaType = Types.GetInternalEditorType("UnityEditor.DockArea");
var parentHostViewType = dockArea.GetType();
if (parentHostViewType != dockAreaType && !parentHostViewType.IsSubclassOf(dockAreaType))
{
#if DEV_MODE
Debug.LogWarning("m_Parent of target window " + window.GetType().Name + " (\"" + window.name + "\") was not a DockArea (but " + parentHostViewType.Name + "); can't add " + tab.GetType().Name + " (\"" + tab.name + "\") as tab.");
#endif
return;
}
#if UNITY_2018_3_OR_NEWER
var types = ArrayPool <Type> .Create(2);
types[1] = Types.Bool;
#else
var types = ArrayPool <Type> .Create(1);
#endif
types[0] = typeof(EditorWindow);
var addTabMethod = dockAreaType.GetMethod("AddTab", BindingFlags.Public | BindingFlags.Instance, null, CallingConventions.Any, types, null);
ArrayPool <Type> .Dispose(ref types);
#if UNITY_2018_3_OR_NEWER
var parameters = ArrayPool <object> .Create(2);
parameters[1] = true;
#else
var parameters = ArrayPool <object> .Create(1);
#endif
parameters[0] = tab;
addTabMethod.Invoke(dockArea, parameters);
}
/// <summary>
/// The smaller the result, the closer the match
/// </summary>
public static int FuzzyCompare(FuzzyComparable searchString, FuzzyComparable testAgainst)
{
int sCount = searchString.splitPoints.Length;
int finalResult = 0;
int[] sCompare = ArrayPool <int> .Create(0);
int sFrom = 0;
int sTo;
int wordResult;
for (int s = 0; s < sCount; s++)
{
sTo = searchString.splitPoints[s];
searchString.GetCompareSubsection(sFrom, sTo, ref sCompare);
#if DEV_MODE
//I think this can happen when a string starts with a space, ends with a space, or has multiple spaces in a row
Debug.Assert(sCompare.Length > 0, "sCompare was empty with sFrom=" + sFrom + ", sTo=" + sTo + ", searchString=\"" + searchString.text + "\"");
#endif
wordResult = FuzzyCompareWord(sCompare, testAgainst);
finalResult += wordResult;
sFrom = sTo + 1;
}
sTo = searchString.Length;
searchString.GetCompareSubsection(sFrom, sTo, ref sCompare);
wordResult = FuzzyCompareWord(sCompare, testAgainst);
finalResult += wordResult;
finalResult /= sCount + 1;
#if DEV_MODE && DEBUG_RESULT
debugWords.Sort();
debugResults.Add("----------FINAL RESULT: " + finalResult.ToString("D4") + " \"" + testAgainst.Text + "\".FuzzyCompare(\"" + searchString.Text + "\")----------\n" + string.Join("\n", debugWords.ToArray()));
debugWords.Clear();
#endif
ArrayPool <int> .Dispose(ref sCompare);
return(finalResult);
}
public static void ResetWithoutAffectingChildren([NotNull] this RectTransform transform)
{
int childCount = transform.childCount;
if (childCount == 0)
{
transform.localPosition = Vector3.zero;
transform.localEulerAngles = Vector3.zero;
transform.localScale = Vector3.one;
return;
}
var temp = (new GameObject("", typeof(RectTransform))).transform;
temp.parent = transform.parent;
temp.localPosition = transform.localPosition;
temp.localEulerAngles = transform.localEulerAngles;
temp.localScale = transform.localScale;
var children = ArrayPool <Transform> .Create(childCount);
for (int n = childCount - 1; n >= 0; n--)
{
var child = transform.GetChild(n);
children[n] = transform.GetChild(n);
child.parent = temp;
}
transform.localPosition = Vector3.zero;
transform.localEulerAngles = Vector3.zero;
transform.localScale = Vector3.one;
for (int n = childCount - 1; n >= 0; n--)
{
var child = temp.GetChild(n);
child.parent = transform;
}
ArrayPool <Transform> .Dispose(ref children);
Platform.Active.Destroy(temp.gameObject);
}
public static string CharInArrayToString(int[] ints)
{
int count = ints.Length;
var chars = ArrayPool <char> .Create(count);
for (int n = 0; n < count; n++)
{
//chars[n] = (char)ints[n];
//new test - maybe temp
char c = (char)ints[n];
#if DEV_MODE
Debug.Assert(c != '\0', "ints[" + n + "] / " + n + " was null!");
#endif
chars[n] = c == '\0' ? '~' : c;
}
var result = new string(chars);
ArrayPool <char> .Dispose(ref chars);
return(result);
}
/// <summary> Sets up an instance of the drawers for usage. </summary>
/// <param name="setTargets"> The targets that the drawers represent. Can not be null. </param>
/// <param name="setEditorTargets"> The targets for which the main Editor is created. E.g. the asset importers for targets. Can be null. </param>
/// <param name="setParent"> The parent drawers of the created drawers. Can be null. </param>
/// <param name="setInspector"> The inspector in which the IDrawer are contained. Can not be null. </param>
/// <param name="setEditorType"> The type of the custom editor. Can be null. </param>
protected virtual void Setup([NotNull] Object[] setTargets, [CanBeNull] Object[] setEditorTargets, [CanBeNull] Type setEditorType, [CanBeNull] IParentDrawer setParent, [NotNull] IInspector setInspector)
{
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(setTargets.Length > 0);
#endif
headerHeight = DrawGUI.Active.AssetTitlebarHeight(false);
headerHeightDetermined = false;
allSameType = setTargets.AllSameType();
if (setEditorTargets == null)
{
if (!allSameType)
{
setEditorTargets = setTargets;
}
else
{
if (AssetImporters.TryGet(setTargets, ref setEditorTargets))
{
var assetImporterType = setEditorTargets[0].GetType();
CustomEditorUtility.TryGetCustomEditorType(assetImporterType, out setEditorType);
}
else
{
setEditorTargets = setTargets;
}
}
}
else if (setEditorTargets[0] == null)
{
ArrayPool <Object> .Dispose(ref setEditorTargets);
setEditorTargets = setTargets;
}
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(setEditorTargets != null || !allSameType);
Debug.Assert(!allSameType || setEditorTargets.Length > 0);
#endif
editorTargets = setEditorTargets;
Sisus.AssetLabels.Get(setTargets, ref assetLabels, ref assetLabelsOnlyOnSomeTargets);
Sisus.AssetLabels.OnAssetLabelsChanged += OnAssetLabelsChanged;
var target = setTargets[0];
localPath = setTargets.Length == 1 ? AssetDatabase.GetAssetPath(target) : "";
isPackageAsset = FileUtility.IsPackageAsset(localPath);
// base handles calling UpdateEditor
base.Setup(setTargets, setParent, setInspector, setEditorType);
FetchAssetEditor();
#if DEV_MODE && PI_ASSERTATIONS && UNITY_2017_2_OR_NEWER
if (!isAssetImporter && editor != HeaderEditor)
{
#if DEV_MODE && DEBUG_SETUP_EDITOR
Debug.LogError(Msg(ToString(), " non-asset importer editor did not match HeaderEditor! - targets=", StringUtils.TypesToString(setTargets), ", editorTargets=", StringUtils.TypesToString(setEditorTargets), ", editorType=", setEditorType, ", editor=", StringUtils.TypeToString(editor), ", HeaderEditor=", HeaderEditor));
#endif
}
#endif
#if DEV_MODE && DEBUG_SETUP_EDITOR
Debug.Log(Msg(ToString(), " Setup with targets=", StringUtils.TypesToString(setTargets), ", editorTargets=", StringUtils.TypesToString(setEditorTargets), ", editorType=", setEditorType, ", editor=", StringUtils.TypeToString(editor)));
#endif
#if DEV_MODE && PI_ASSERTATIONS
if (editor == null)
{
Debug.LogWarning(Msg(ToString(), " editor was null after Setup with canHaveEditor=", canHaveEditor, " and targets: ", StringUtils.TypesToString(targets)));
}
#endif
#if DEV_MODE && PI_ASSERTATIONS
if (assetEditor == null)
{
Debug.LogWarning(Msg(ToString(), " headerEditor was null after Setup with canHaveEditor=", canHaveEditor, " and targets: ", StringUtils.TypesToString(targets)));
}
#endif
}
/// <summary>
/// The smaller the result, the closer the match
/// </summary>
public static int FuzzyCompareWord(int[] sCompare, FuzzyComparable testAgainst)
{
#if DEV_MODE && DEBUG_WORD
var debugSteps = "";
#endif
int tCount = testAgainst.splitPoints.Length;
int stepResult;
int[] tCompare = ArrayPool <int> .Create(0);
int tFrom = 0;
int tTo;
int wordResult = int.MaxValue;
for (int t = 0; t < tCount; t++)
{
tTo = testAgainst.splitPoints[t];
if (tTo > tFrom)
{
testAgainst.GetCompareSubsection(tFrom, tTo, ref tCompare);
#if DEV_MODE
//I think this can happen when a string starts with a space, ends with a space, or has multiple spaces in a row
Debug.Assert(tCompare.Length > 0, "tCompare was empty with tFrom=" + tFrom + ", tTo=" + tTo + ", testAgainst=\"" + testAgainst.text + "\" (WORD NOW: " + wordResult + ")");
#endif
if (tCompare.Length > 0)
{
stepResult = FuzzyCompare(sCompare, tCompare);
if (stepResult < wordResult)
{
wordResult = stepResult;
}
}
#if DEV_MODE && DEBUG_WORD
else
{
stepResult = int.MaxValue;
}
debugSteps += "\n\"" + testAgainst.Text + "\".GetCompareSubsection(\"" + CharInArrayToString(sCompare) + "\") vs \"" + CharInArrayToString(tCompare) + "\" STEP: " + stepResult + " (WORD NOW: " + wordResult + ")";
#endif
}
tFrom = tTo + 1;
}
tTo = testAgainst.Length;
testAgainst.GetCompareSubsection(tFrom, tTo, ref tCompare);
stepResult = FuzzyCompare(sCompare, tCompare);
if (stepResult < wordResult)
{
wordResult = stepResult;
}
#if DEV_MODE && DEBUG_WORD
debugSteps += "\n\"" + testAgainst.Text + "\".GetCompareSubsection(\"" + CharInArrayToString(sCompare) + "\") vs \"" + CharInArrayToString(tCompare) + "\" STEP: " + stepResult + " (WORD NOW: " + wordResult + ")";
debugWords.Add("\"" + testAgainst.Text + "\" WORD RESULT: " + wordResult + " for word " + CharInArrayToString(sCompare) + debugSteps);
#endif
ArrayPool <int> .Dispose(ref tCompare);
return(wordResult);
}
/// <summary>
/// Minimized the target window. If window is already minimized, nothing happens.
///
/// Currently minimizing is only supported if EditorWindow is not docked, or it is docked
/// in a split view with another window in such a way that the minimized window resides
/// below the other window.
/// </summary>
public void Minimize()
{
if (minimized)
{
return;
}
positionBeforeMinimize = window.position;
minSizeBeforeMinimize = window.minSize;
maxSizeBeforeMinimize = window.maxSize;
splitViewIndexBeforeMinimize = -1;
var dockArea = window.ParentHostView();
if (dockArea == null)
{
var setPosition = window.position;
setPosition.height = 11f;
window.position = setPosition;
window.minSize = new Vector2(window.minSize.x, 11f);
window.maxSize = new Vector2(window.maxSize.x, 11f);
minimized = true;
}
else
{
var parentProperty = dockArea.GetType().GetProperty("parent", BindingFlags.Instance | BindingFlags.Public);
if (parentProperty == null)
{
#if DEV_MODE
Debug.LogError("Minimize: parent property not found.");
#endif
return;
}
var splitView = parentProperty.GetValue(dockArea, null);
if (splitView != null && string.Equals(splitView.GetType().Name, "SplitView"))
{
var splitStateField = splitView.GetType().GetField("splitState", BindingFlags.Instance | BindingFlags.NonPublic);
if (splitStateField == null)
{
#if DEV_MODE
Debug.LogError("Minimize: splitState field not found.");
#endif
return;
}
var splitState = splitStateField.GetValue(splitView);
if (splitState == null)
{
var setupSplitterMethod = splitView.GetType().GetMethod("SetupSplitter", BindingFlags.Instance | BindingFlags.NonPublic);
if (setupSplitterMethod == null)
{
#if DEV_MODE
Debug.LogError("Minimize: SetupSplitter method not found.");
#endif
return;
}
setupSplitterMethod.Invoke(splitView);
splitState = splitStateField.GetValue(splitView);
if (splitState == null)
{
#if DEV_MODE
Debug.LogError("Minimize: splitState was null event after calling SetupSplitter.");
#endif
return;
}
}
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(splitState != null);
#endif
var realSizesField = splitState.GetType().GetField("realSizes", BindingFlags.Instance | BindingFlags.Public);
if (realSizesField == null)
{
#if DEV_MODE
Debug.LogError("Minimize: realSizesField field not found.");
#endif
return;
}
var realSizes = (int[])realSizesField.GetValue(splitState);
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(realSizes != null);
#endif
if (realSizes.Length == 1)
{
#if DEV_MODE && DEBUG_MINIMIZE
Debug.Log("minimizing with realSizes count 1");
#endif
var setPosition = window.position;
setPosition.height = 11f;
window.position = setPosition;
window.minSize = new Vector2(window.minSize.x, 11f);
window.maxSize = new Vector2(window.maxSize.x, 11f);
minimized = true;
minimizedDimensions = window.position.size;
return;
}
// minimizing in horizontal split not supported yet
var verticalField = splitView.GetType().GetField("vertical", BindingFlags.Instance | BindingFlags.Public);
if (verticalField == null)
{
#if DEV_MODE
Debug.LogError("Minimize: vertical field not found.");
#endif
return;
}
bool vertical = (bool)verticalField.GetValue(splitView);
if (!vertical)
{
#if DEV_MODE && DEBUG_MINIMIZE
Debug.Log("aborting minimize because horizontal splits are not supported");
#endif
return;
}
if (splitViewSizesBeforeMinimize != null)
{
ArrayPool <int> .Dispose(ref splitViewSizesBeforeMinimize);
}
splitViewSizesBeforeMinimize = ArrayPool <int> .Create(realSizes.Length);
Array.Copy(realSizes, splitViewSizesBeforeMinimize, realSizes.Length);
splitViewIndexBeforeMinimize = realSizes.Length - 1;
splitViewPositionBeforeMinimize = 0f;
for (int n = 0; n < splitViewIndexBeforeMinimize; n++)
{
splitViewPositionBeforeMinimize += realSizes[n];
}
#if DEV_MODE && DEBUG_MINIMIZE
Debug.Log("splitViewIndexWas=" + splitViewIndexBeforeMinimize + ", sizesBeforeMinimize=" + StringUtils.ToString(splitViewSizesBeforeMinimize) + ", splitViewPositionWas=" + splitViewPositionBeforeMinimize);
#endif
var placeView = splitView.GetType().GetMethod("PlaceView", BindingFlags.Instance | BindingFlags.NonPublic);
if (placeView == null)
{
#if DEV_MODE
Debug.LogError("Minimize: PlaceView method not found.");
#endif
return;
}
const float SetSize = 11f; //vertical ? 11f : 80f;
float sizeChanged = splitViewSizesBeforeMinimize[splitViewIndexBeforeMinimize] - SetSize;
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(sizeChanged > 0f);
#endif
var parameters = new object[] { splitViewIndexBeforeMinimize, splitViewPositionBeforeMinimize + sizeChanged, SetSize };
placeView.Invoke(splitView, parameters);
var reflowMethod = splitView.GetType().GetMethod("Reflow", BindingFlags.Instance | BindingFlags.NonPublic);
if (reflowMethod == null)
{
#if DEV_MODE
Debug.LogError("Minimize: Reflow method not found.");
#endif
return;
}
reflowMethod.Invoke(splitView);
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(vertical);
#endif
window.minSize = new Vector2(window.minSize.x, SetSize);
window.maxSize = new Vector2(window.maxSize.x, SetSize);
minimized = true;
}
else
{
#if DEV_MODE && DEBUG_MINIMIZE
Debug.Log("dockArea.parent: " + (splitView == null ? "null" : splitView.GetType().Name));
Debug.Log("aborting minimize because splitView was null, with dockArea.parent=" + (splitView == null ? "null" : splitView.GetType().Name));
#endif
}
}
minimizedDimensions = window.position.size;
}
