private static void Testing_Invoke(string klass, string method, params object[] prms)
{
try
{
AppDomain currentDomain = AppDomain.CurrentDomain;
Assembly[] assemblies = currentDomain.GetAssemblies();
for (int i = 0; i < assemblies.Length; i++)
{
Assembly assembly = assemblies[i];
if (assembly.GetName().Name != "UnityEditor" && assembly.GetName().Name != "UnityEngine")
{
Type[] typesFromAssembly = AssemblyHelper.GetTypesFromAssembly(assembly);
for (int j = 0; j < typesFromAssembly.Length; j++)
{
Type type = typesFromAssembly[j];
if (type.Name == klass)
{
type.InvokeMember(method, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.InvokeMethod, null, null, prms);
}
}
}
}
}
catch (Exception ex)
{
if (GUIUtility.ShouldRethrowException(ex))
{
throw;
}
ASEditorBackend.Testing_Invoke(AssetServer.GetString("s_ExceptionHandlerClass"), AssetServer.GetString("s_ExceptionHandlerFunction"), new object[]
{
ex
});
}
}
private static void Testing_Invoke(string klass, string method, params object[] prms)
{
try
{
AppDomain currentDomain = AppDomain.CurrentDomain;
foreach (Assembly assembly in currentDomain.GetAssemblies())
{
if ((assembly.GetName().Name != "UnityEditor") && (assembly.GetName().Name != "UnityEngine"))
{
foreach (System.Type type in AssemblyHelper.GetTypesFromAssembly(assembly))
{
if (type.Name == klass)
{
type.InvokeMember(method, BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static, null, null, prms);
}
}
}
}
}
catch (Exception exception)
{
if (GUIUtility.ShouldRethrowException(exception))
{
throw;
}
object[] objArray1 = new object[] { exception };
Testing_Invoke(AssetServer.GetString("s_ExceptionHandlerClass"), AssetServer.GetString("s_ExceptionHandlerFunction"), objArray1);
}
}
private static bool EndContainerGUIFromException(Exception exception)
{
if (UIElementsUtility.s_ContainerStack.Count > 0)
{
GUIUtility.EndContainer();
UIElementsUtility.s_ContainerStack.Pop();
}
return(GUIUtility.ShouldRethrowException(exception));
}
private static bool EndContainerGUIFromException(Exception exception)
{
foreach (var uiElementsUtility in s_Utilities)
{
if (uiElementsUtility.EndContainerGUIFromException(exception))
{
return(true);
}
}
return(GUIUtility.ShouldRethrowException(exception));
}
private static bool EndContainerGUIFromException(Exception exception)
{
// only End if we have a current container
if (s_ContainerStack.Count > 0)
{
GUIUtility.EndContainer();
s_ContainerStack.Pop();
}
return(GUIUtility.ShouldRethrowException(exception));
}
private static bool EndContainerGUIFromException(Exception exception)
{
bool result;
foreach (IUIElementsUtility current in UIEventRegistration.s_Utilities)
{
bool flag = current.EndContainerGUIFromException(exception);
if (flag)
{
result = true;
return(result);
}
}
result = GUIUtility.ShouldRethrowException(exception);
return(result);
}
private VisualElement CreateIMGUIInspectorFromEditor(SerializedObject serializedObject, Editor editor,
bool reuseIMGUIContainer)
{
if ((mode & (Mode.IMGUICustom | Mode.IMGUIDefault)) == 0)
{
return(null);
}
if ((mode & Mode.IMGUICustom) > 0 && (mode & Mode.IMGUIDefault) == 0 && editor is GenericInspector)
{
return(null);
}
if ((mode & Mode.IMGUICustom) == 0 && (mode & Mode.IMGUIDefault) > 0 && !(editor is GenericInspector))
{
editor = ScriptableObject.CreateInstance <GenericInspector>();
editor.hideFlags = HideFlags.HideAndDontSave;
editor.InternalSetTargets(new[] { serializedObject.targetObject });
}
if (editor is GenericInspector)
{
AddToClassList(iMGUIDefaultVariantUssClassName);
if ((mode & Mode.DebugMod) > 0)
{
AddToClassList(debugVariantUssClassName);
editor.inspectorMode = InspectorMode.Debug;
}
else if ((mode & Mode.DebugInternalMod) > 0)
{
AddToClassList(debugInternalVariantUssClassName);
editor.inspectorMode = InspectorMode.DebugInternal;
}
}
else
{
AddToClassList(iMGUICustomVariantUssClassName);
}
IMGUIContainer inspector;
// Reusing the existing IMGUIContainer allows us to re-use the existing gui state, when we are drawing the same inspector this will let us keep the same control ids
if (reuseIMGUIContainer && m_IMGUIContainer != null)
{
inspector = m_IMGUIContainer;
}
else
{
inspector = new IMGUIContainer();
}
m_IgnoreOnInspectorGUIErrors = false;
inspector.onGUIHandler = () =>
{
// It's possible to run 2-3 frames after the tracker of this inspector window has
// been recreated, and with it the Editor and its SerializedObject. One example of
// when this happens is when the Preview window is detached from a *second* instance
// of an InspectorWindow and re-attached.
//
// This is only a problem for the *second* (or third, forth, etc) instance of
// the InspectorWindow because only the first instance can use the
// ActiveEditorTracker.sharedTracker in InspectorWindow.CreateTracker(). The
// other instances have to create a new tracker...each time.
//
// Not an ideal solution, but basically we temporarily hold the printing to console
// for errors for which GUIUtility.ShouldRethrowException(e) returns false.
// The errors that may occur during this brief "bad state" are SerializedProperty
// errors. If the custom Editor created and remembered references to some
// SerializedProperties during its OnEnable(), those references will be invalid
// when the tracker is refreshed, until this GUIHandler is reassigned. This fix
// just ignores those errors.
//
// We don't simply early return here because that can break some tests that
// rely heavily on yields and timing of UI redraws. Yes..
//
// case 1119612
if (editor.m_SerializedObject == null)
{
editor.Repaint();
m_IgnoreOnInspectorGUIErrors = true;
}
if ((editor.target == null && !GenericInspector.ObjectIsMonoBehaviourOrScriptableObject(editor.target)) ||
!editor.serializedObject.isValid)
{
return;
}
EditorGUIUtility.ResetGUIState();
using (new EditorGUI.DisabledScope(!editor.IsEnabled()))
{
var genericEditor = editor as GenericInspector;
if (genericEditor != null)
{
switch (mode)
{
case Mode.Normal:
genericEditor.inspectorMode = InspectorMode.Normal;
break;
case Mode.Default:
genericEditor.inspectorMode = InspectorMode.Debug;
break;
case Mode.Custom:
genericEditor.inspectorMode = InspectorMode.DebugInternal;
break;
case Mode.IMGUI:
break;
}
}
//set the current PropertyHandlerCache to the current editor
ScriptAttributeUtility.propertyHandlerCache = editor.propertyHandlerCache;
var originalHierarchyMode = EditorGUIUtility.hierarchyMode;
EditorGUIUtility.hierarchyMode = true;
var originalWideMode = SetWideModeForWidth(inspector);
GUIStyle editorWrapper = (editor.UseDefaultMargins()
? EditorStyles.inspectorDefaultMargins
: GUIStyle.none);
try
{
GUI.changed = false;
using (new InspectorWindowUtils.LayoutGroupChecker())
{
EditorGUILayout.BeginVertical(editorWrapper);
{
// we have no guarantees regarding what happens in the try/catch block below,
// so we need to save state here and restore it afterwards,
// the natural thing to do would be using SavedGUIState,
// but it implicitly resets keyboards bindings and it breaks functionality.
// We have identified issues with layout so we just save that for the time being.
var layoutCache = new GUILayoutUtility.LayoutCache(GUILayoutUtility.current);
try
{
var rebuildOptimizedGUIBlocks = GetRebuildOptimizedGUIBlocks(editor.target);
rebuildOptimizedGUIBlocks |= editor.isInspectorDirty;
float height;
if (editor.GetOptimizedGUIBlock(rebuildOptimizedGUIBlocks, visible, out height))
{
var contentRect = GUILayoutUtility.GetRect(0, visible ? height : 0);
// Layout events are ignored in the optimized code path
// The exception is when we are drawing a GenericInspector, they always use the optimized path and must therefore run at least one layout calculation in it
if (Event.current.type == EventType.Layout && !(editor is GenericInspector))
{
return;
}
InspectorWindowUtils.DrawAddedComponentBackground(contentRect, editor.targets);
// Draw content
if (visible)
{
GUI.changed = false;
editor.OnOptimizedInspectorGUI(contentRect);
}
}
else
{
InspectorWindowUtils.DrawAddedComponentBackground(contentRect, editor.targets);
editor.OnInspectorGUI();
}
}
catch (Exception e)
{
if (GUIUtility.ShouldRethrowException(e))
{
throw;
}
if (!m_IgnoreOnInspectorGUIErrors)
{
Debug.LogException(e);
}
}
finally
{
GUILayoutUtility.current = layoutCache;
}
}
EditorGUILayout.EndVertical();
}
}
finally
{
if (GUI.changed)
{
// This forces a relayout of all imguicontainers in this inspector window.
// fixes part of case 1148706
var element = inspector.GetFirstAncestorOfType <EditorElement>();
if (element != null)
{
EditorElement.InvalidateIMGUILayouts(element.parent);
}
}
EditorGUIUtility.wideMode = originalWideMode;
EditorGUIUtility.hierarchyMode = originalHierarchyMode;
}
}
};
inspector.style.overflow = Overflow.Visible;
m_IMGUIContainer = inspector;
if (!(editor is GenericInspector))
{
inspector.AddToClassList(customInspectorUssClassName);
}
inspector.AddToClassList(iMGUIContainerUssClassName);
AddToClassList(iMGUIInspectorVariantUssClassName);
return(inspector);
}