com.wallstop-studios.dxmessaging 3.1.0 → 3.2.1

package/Editor/CustomEditors/MessageAwareComponentInspectorOverlay.cs

@@ -9,17 +9,18 @@ namespace DxMessaging.Editor.CustomEditors
     using UnityEditor;
     using UnityEditorInternal;
     using UnityEngine;
+    using UnityEngine.UIElements;
 
     /// <summary>
     /// Header-injection overlay for every Inspector showing a <see cref="MessageAwareComponent"/> subclass.
     /// </summary>
     /// <remarks>
-    /// We hook <see cref="Editor.finishedDefaultHeaderGUI"/> rather than registering a
-    /// <c>[CustomEditor(typeof(MessageAwareComponent), editorForChildClasses: true)]</c> so we never
-    /// clobber a user's own custom editor. The overlay reads its data from
-    /// <see cref="DxMessagingConsoleHarvester"/> (which reflects directly into Unity's
-    /// <c>UnityEditor.LogEntries</c> console store) and from <see cref="DxMessagingSettings"/>
-    /// (project-wide ignore list and master toggle).
+    /// The package-owned fallback editor hosts the UI Toolkit warning view for subclasses without
+    /// a more specific user editor. This header hook remains for user-defined custom editors, so
+    /// they can keep their own Inspector body while still seeing DxMessaging base-call warnings.
+    /// The overlay reads its data from <see cref="DxMessagingConsoleHarvester"/> (which reflects
+    /// directly into Unity's <c>UnityEditor.LogEntries</c> console store) and from
+    /// <see cref="DxMessagingSettings"/> (project-wide ignore list and master toggle).
     ///
     /// <para>
     /// <b>Layout/Repaint control-count invariant.</b> When the overlay renders from inside an
@@ -58,6 +59,27 @@ namespace DxMessaging.Editor.CustomEditors
         // and Repaint passes; that asymmetry would corrupt the inspector's layout cache.
         private static readonly HashSet<int> _renderedThisRepaint = new();
 
+        internal static System.Action<System.Action> AssetDatabaseMutationScheduler { get; set; } =
+            DxMessagingEditorIdle.ScheduleAssetDatabaseMutation;
+
+        internal static System.Action<System.Action> TransientRefreshScheduler { get; set; } =
+            DxMessagingEditorIdle.ScheduleAssetDatabaseMutation;
+
+        internal static System.Action InspectorRepaintAction { get; set; } = RepaintAllInspectors;
+
+        internal static System.Func<bool> InspectorResolutionTransientBlocker { get; set; } =
+            () => EditorApplication.isCompiling || EditorApplication.isUpdating;
+
+        internal static System.Func<MessageAwareComponent, bool> ImGuiRenderAction { get; set; } =
+            BuildAndRenderOverlay;
+
+        internal static System.Action<
+            MessageAwareComponent,
+            BaseCallReportEntry
+        > OpenScriptAction { get; set; } = OpenScriptForComponentCore;
+
+        internal static event System.Action InspectorStateInvalidated;
+
         static MessageAwareComponentInspectorOverlay()
         {
             Editor.finishedDefaultHeaderGUI += DrawHeader;
@@ -84,60 +106,72 @@ namespace DxMessaging.Editor.CustomEditors
         }
 
         private static void DrawHeader(Editor editor)
+        {
+            TryRenderHeaderHook(editor, Event.current != null ? Event.current.type : null);
+        }
+
+        internal static bool TryRenderHeaderHook(Editor editor, EventType? eventType)
+        {
+            if (!ShouldRenderHeaderHook(editor))
+            {
+                return false;
+            }
+
+            return TryRenderForHeaderHook(editor.target, eventType);
+        }
+
+        internal static bool ShouldRenderHeaderHook(Editor editor)
         {
             if (editor == null)
             {
-                return;
+                return false;
             }
+
             // If our own fallback CustomEditor is the editor instance, skip the header path
-            // entirely; the editor's OnInspectorGUI will call RenderInsideOnInspectorGUI and we
-            // would otherwise render twice. Unconditional skip (not gated on EventType) keeps
+            // entirely; CreateInspectorGUI or OnInspectorGUI owns package fallback rendering and
+            // we would otherwise render twice. Unconditional skip (not gated on EventType) keeps
             // control counts balanced on both Layout and Repaint passes.
-            if (editor is MessageAwareComponentFallbackEditor)
-            {
-                return;
-            }
-            RenderForHeaderHook(editor.target);
+            return editor is not MessageAwareComponentFallbackEditor;
         }
 
         /// <summary>
-        /// Header-hook entry point. Fires after Unity's default header has been drawn, so the
+        /// Header-hook render body. Fires after Unity's default header has been drawn, so the
         /// inspector's layout pass for this editor has already completed. Safe to gate on
         /// <see cref="EventType.Repaint"/> here -- we are not inside an OnInspectorGUI body.
         /// </summary>
-        private static void RenderForHeaderHook(Object target)
+        private static bool TryRenderForHeaderHook(Object target, EventType? eventType)
         {
             if (target == null)
             {
-                return;
+                return false;
             }
             if (target is not MessageAwareComponent messageAwareComponent)
             {
-                return;
+                return false;
             }
-
-            Event currentEvent = Event.current;
-            if (currentEvent == null)
+            if (!eventType.HasValue)
             {
-                return;
+                return false;
             }
-            if (currentEvent.type == EventType.Layout)
+            if (eventType.Value == EventType.Layout)
             {
                 // Start of a fresh GUI cycle; wipe the per-Repaint latch.
                 _renderedThisRepaint.Clear();
-                return;
+                return false;
             }
-            if (currentEvent.type != EventType.Repaint)
+            if (eventType.Value != EventType.Repaint)
             {
-                return;
+                return false;
             }
             int instanceId = DxMessaging.Core.InstanceId.StableId(messageAwareComponent);
             if (!_renderedThisRepaint.Add(instanceId))
             {
-                return;
+                return false;
             }
 
-            BuildAndRenderOverlay(messageAwareComponent);
+            System.Func<MessageAwareComponent, bool> render =
+                ImGuiRenderAction ?? BuildAndRenderOverlay;
+            return render.Invoke(messageAwareComponent);
         }
 
         /// <summary>
@@ -166,15 +200,100 @@ namespace DxMessaging.Editor.CustomEditors
         /// <returns>True if the HelpBox + buttons were drawn; false if we drew nothing.</returns>
         private static bool BuildAndRenderOverlay(MessageAwareComponent messageAwareComponent)
         {
-            // ---- Gating phase: every "should we draw?" decision happens here, before any
-            // EditorGUILayout call. The result is a single bool: shouldRender. ----
+            MessageAwareComponentInspectorState state = ResolveInspectorState(
+                messageAwareComponent
+            );
+
+            if (state.Kind == MessageAwareComponentInspectorStateKind.None)
+            {
+                return false;
+            }
+
+            // ---- Render phase: straight-line EditorGUILayout calls, identical sequence on
+            // every pass. Wrapped in a vertical group so any internal mismatch we missed cannot
+            // propagate to sibling inspectors. ----
+            EditorGUILayout.BeginVertical();
+            try
+            {
+                switch (state.Kind)
+                {
+                    case MessageAwareComponentInspectorStateKind.HarvesterUnavailable:
+                        EditorGUILayout.HelpBox(
+                            "DxMessaging inspector overlay is disabled on this Unity version. "
+                                + "Check the console for DXMSG006/007/009 warnings instead.",
+                            MessageType.Info
+                        );
+                        break;
+                    case MessageAwareComponentInspectorStateKind.IgnoredType:
+                        DrawIgnoredBox(state.Component, state.Settings, state.FullName);
+                        break;
+                    case MessageAwareComponentInspectorStateKind.MissingBaseCallWarning:
+                        DrawWarningBox(
+                            state.Component,
+                            state.Settings,
+                            state.FullName,
+                            state.Entry,
+                            state.IsFreshThisSession
+                        );
+                        break;
+                }
+            }
+            finally
+            {
+                EditorGUILayout.EndVertical();
+            }
+
+            return true;
+        }
+
+        internal static VisualElement CreateInspectorView(Object target)
+        {
+            return CreateInspectorView(ResolveInspectorState(target));
+        }
+
+        internal static VisualElement CreateInspectorView(MessageAwareComponentInspectorState state)
+        {
+            return MessageAwareComponentInspectorView.Create(state, CreateInspectorViewActions());
+        }
+
+        internal static void ResetTestSeams()
+        {
+            _renderedThisRepaint.Clear();
+            AssetDatabaseMutationScheduler = DxMessagingEditorIdle.ScheduleAssetDatabaseMutation;
+            TransientRefreshScheduler = DxMessagingEditorIdle.ScheduleAssetDatabaseMutation;
+            InspectorRepaintAction = RepaintAllInspectors;
+            InspectorResolutionTransientBlocker = () =>
+                EditorApplication.isCompiling || EditorApplication.isUpdating;
+            ImGuiRenderAction = BuildAndRenderOverlay;
+            OpenScriptAction = OpenScriptForComponentCore;
+        }
+
+        internal static bool IsInspectorResolutionTransientlyBlocked()
+        {
+            System.Func<bool> isBlocked =
+                InspectorResolutionTransientBlocker
+                ?? (() => EditorApplication.isCompiling || EditorApplication.isUpdating);
+            return isBlocked.Invoke();
+        }
+
+        internal static MessageAwareComponentInspectorState ResolveInspectorState(Object target)
+        {
+            if (target == null)
+            {
+                return MessageAwareComponentInspectorState.None;
+            }
 
             // Mid-compile / mid-import is the worst time to dereference the settings asset:
             // AssetDatabase may be in a transitional state. Bail and let the next OnGUI redraw
             // pick up where we left off.
-            if (EditorApplication.isCompiling || EditorApplication.isUpdating)
+            if (IsInspectorResolutionTransientlyBlocked())
             {
-                return false;
+                return MessageAwareComponentInspectorState.None;
+            }
+
+            if (target is not MessageAwareComponent messageAwareComponent)
+            {
+                return MessageAwareComponentInspectorState.None;
             }
 
             DxMessagingSettings settings;
@@ -185,101 +304,157 @@ namespace DxMessaging.Editor.CustomEditors
             catch (System.Exception ex)
             {
                 DxMessagingEditorLog.LogWarning("Inspector overlay could not load settings.", ex);
-                return false;
+                return MessageAwareComponentInspectorState.None;
+            }
+
+            string fullName = GetOverlayTypeName(messageAwareComponent);
+            BaseCallReportEntry entry = null;
+            if (!string.IsNullOrEmpty(fullName) && DxMessagingConsoleHarvester.IsAvailable)
+            {
+                DxMessagingConsoleHarvester.TryGetEntry(fullName, out entry);
+            }
+
+            return ResolveInspectorState(
+                messageAwareComponent,
+                settings,
+                DxMessagingConsoleHarvester.IsAvailable,
+                DxMessagingConsoleHarvester.IsFreshThisSession,
+                entry
+            );
+        }
+
+        internal static MessageAwareComponentInspectorState ResolveInspectorState(
+            Object target,
+            DxMessagingSettings settings,
+            bool harvesterAvailable,
+            bool isFreshThisSession,
+            BaseCallReportEntry entry
+        )
+        {
+            if (target == null)
+            {
+                return MessageAwareComponentInspectorState.None;
             }
 
+            if (target is not MessageAwareComponent messageAwareComponent)
+            {
+                return MessageAwareComponentInspectorState.None;
+            }
             if (settings == null || !settings._baseCallCheckEnabled)
             {
-                return false;
+                return MessageAwareComponentInspectorState.None;
             }
 
             // S6: System.Type.FullName renders nested types as `Outer+Nested`, but the analyzer's
             // `containingType.ToDisplayString()` (which produces the FQN we key the snapshot by)
             // renders them as `Outer.Nested`. Without this normalization the lookup misses for
             // every nested MessageAwareComponent subclass and the HelpBox never shows.
-            System.Type targetType = messageAwareComponent.GetType();
-            string fullName = (targetType.FullName ?? string.Empty).Replace('+', '.');
+            string fullName = GetOverlayTypeName(messageAwareComponent);
             if (string.IsNullOrEmpty(fullName))
             {
-                return false;
+                return MessageAwareComponentInspectorState.None;
             }
 
-            // Decide which of the three render shapes (if any) to draw.
-            // 0 = render nothing; 1 = harvester-unavailable info; 2 = ignored-type info; 3 = warning.
-            int shape = 0;
-            BaseCallReportEntry entry = null;
-            bool isIgnored = false;
-
-            if (!DxMessagingConsoleHarvester.IsAvailable)
+            if (!harvesterAvailable)
             {
-                shape = 1;
+                return MessageAwareComponentInspectorState.ForHarvesterUnavailable(
+                    messageAwareComponent,
+                    settings,
+                    fullName,
+                    isFreshThisSession
+                );
             }
-            else
+
+            bool isIgnored =
+                settings._baseCallIgnoredTypes != null
+                && settings._baseCallIgnoredTypes.Any(e =>
+                    string.Equals(e, fullName, System.StringComparison.Ordinal)
+                );
+            if (isIgnored)
             {
-                isIgnored =
-                    settings._baseCallIgnoredTypes != null
-                    && settings._baseCallIgnoredTypes.Any(e =>
-                        string.Equals(e, fullName, System.StringComparison.Ordinal)
-                    );
-                if (isIgnored)
-                {
-                    shape = 2;
-                }
-                else if (
-                    DxMessagingConsoleHarvester.TryGetEntry(fullName, out entry)
-                    && entry != null
-                    && entry.missingBaseFor != null
-                    && entry.missingBaseFor.Count > 0
-                )
-                {
-                    shape = 3;
-                }
+                return MessageAwareComponentInspectorState.ForIgnoredType(
+                    messageAwareComponent,
+                    settings,
+                    fullName,
+                    isFreshThisSession
+                );
             }
 
-            if (shape == 0)
+            if (entry != null && entry.missingBaseFor != null && entry.missingBaseFor.Count > 0)
             {
-                // "Render nothing" branch: emit ZERO EditorGUILayout calls. This must hold on
-                // both Layout and Repaint passes when called from OnInspectorGUI, so Unity's
-                // layout cache stays consistent.
-                return false;
+                return MessageAwareComponentInspectorState.ForMissingBaseCallWarning(
+                    messageAwareComponent,
+                    settings,
+                    fullName,
+                    entry,
+                    isFreshThisSession
+                );
             }
 
-            // ---- Render phase: straight-line EditorGUILayout calls, identical sequence on
-            // every pass. Wrapped in a vertical group so any internal mismatch we missed cannot
-            // propagate to sibling inspectors. ----
-            EditorGUILayout.BeginVertical();
+            // "Render nothing" branch: emit ZERO EditorGUILayout calls. This must hold on
+            // both Layout and Repaint passes when called from OnInspectorGUI, so Unity's
+            // layout cache stays consistent.
+            return MessageAwareComponentInspectorState.None;
+        }
+
+        private static MessageAwareComponentInspectorViewActions CreateInspectorViewActions()
+        {
+            return new MessageAwareComponentInspectorViewActions(
+                onOpenScript: state => OpenScriptForComponent(state.Component, state.Entry),
+                onIgnoreType: state => TryAddIgnoredType(state.Settings, state.FullName),
+                onStopIgnoring: state => TryRemoveIgnoredType(state.Settings, state.FullName)
+            );
+        }
+
+        private static void NotifyInspectorStateInvalidated()
+        {
+            System.Action repaint = InspectorRepaintAction ?? RepaintAllInspectors;
             try
             {
-                switch (shape)
-                {
-                    case 1:
-                        EditorGUILayout.HelpBox(
-                            "DxMessaging inspector overlay is disabled on this Unity version. "
-                                + "Check the console for DXMSG006/007/009 warnings instead.",
-                            MessageType.Info
-                        );
-                        break;
-                    case 2:
-                        DrawIgnoredBox(messageAwareComponent, settings, fullName);
-                        break;
-                    case 3:
-                        DrawWarningBox(messageAwareComponent, settings, fullName, entry);
-                        break;
-                }
+                repaint.Invoke();
             }
-            finally
+            catch (System.Exception ex)
             {
-                EditorGUILayout.EndVertical();
+                DxMessagingEditorLog.LogWarning(
+                    "Failed to repaint inspectors after state change.",
+                    ex
+                );
             }
 
-            return true;
+            System.Action invalidated = InspectorStateInvalidated;
+            if (invalidated == null)
+            {
+                return;
+            }
+
+            foreach (System.Delegate callback in invalidated.GetInvocationList())
+            {
+                try
+                {
+                    ((System.Action)callback).Invoke();
+                }
+                catch (System.Exception ex)
+                {
+                    DxMessagingEditorLog.LogWarning(
+                        "Failed to refresh MessageAwareComponent inspectors after state change.",
+                        ex
+                    );
+                }
+            }
+        }
+
+        private static string GetOverlayTypeName(MessageAwareComponent messageAwareComponent)
+        {
+            System.Type targetType = messageAwareComponent.GetType();
+            return (targetType.FullName ?? string.Empty).Replace('+', '.');
         }
 
         private static void DrawWarningBox(
             MessageAwareComponent component,
             DxMessagingSettings settings,
             string fullName,
-            BaseCallReportEntry entry
+            BaseCallReportEntry entry,
+            bool isFreshThisSession
         )
         {
             string missingMethods = string.Join(", ", entry.missingBaseFor);
@@ -303,7 +478,7 @@ namespace DxMessaging.Editor.CustomEditors
             // `Library/DxMessaging/baseCallReport.json` and the first post-reload scan has not
             // yet completed; once the scan flips IsFreshThisSession to true and RepaintAllInspectors
             // fires, the overlay redraws without the suffix.
-            string freshnessSuffix = DxMessagingConsoleHarvester.IsFreshThisSession
+            string freshnessSuffix = isFreshThisSession
                 ? string.Empty
                 : "\n(cached from previous session; refreshing...)";
             string message =
@@ -349,6 +524,16 @@ namespace DxMessaging.Editor.CustomEditors
             MessageAwareComponent component,
             BaseCallReportEntry entry
         )
+        {
+            System.Action<MessageAwareComponent, BaseCallReportEntry> openScript =
+                OpenScriptAction ?? OpenScriptForComponentCore;
+            openScript.Invoke(component, entry);
+        }
+
+        private static void OpenScriptForComponentCore(
+            MessageAwareComponent component,
+            BaseCallReportEntry entry
+        )
         {
             try
             {
@@ -380,7 +565,10 @@ namespace DxMessaging.Editor.CustomEditors
             // frame, corrupting Unity's per-window layout cache. delayCall fires AFTER the
             // current GUI cycle, so the next frame's Layout pass sees the new state and
             // both passes emit consistent control counts.
-            DxMessagingEditorIdle.ScheduleAssetDatabaseMutation(() =>
+            System.Action<System.Action> schedule =
+                AssetDatabaseMutationScheduler
+                ?? DxMessagingEditorIdle.ScheduleAssetDatabaseMutation;
+            schedule(() =>
             {
                 if (settings == null)
                 {
@@ -389,6 +577,7 @@ namespace DxMessaging.Editor.CustomEditors
                 try
                 {
                     settings.AddIgnoredType(fullName);
+                    NotifyInspectorStateInvalidated();
                 }
                 catch (System.Exception ex)
                 {
@@ -405,7 +594,10 @@ namespace DxMessaging.Editor.CustomEditors
             // Same reasoning as TryAddIgnoredType: defer mutation past the current GUI cycle so
             // the overlay's shape gating remains identical on Layout and Repaint passes of THIS
             // frame. The next frame's Layout pass observes the new state; both passes agree.
-            DxMessagingEditorIdle.ScheduleAssetDatabaseMutation(() =>
+            System.Action<System.Action> schedule =
+                AssetDatabaseMutationScheduler
+                ?? DxMessagingEditorIdle.ScheduleAssetDatabaseMutation;
+            schedule(() =>
             {
                 if (settings == null)
                 {
@@ -414,6 +606,7 @@ namespace DxMessaging.Editor.CustomEditors
                 try
                 {
                     settings.RemoveIgnoredType(fullName);
+                    NotifyInspectorStateInvalidated();
                 }
                 catch (System.Exception ex)
                 {
@@ -425,5 +618,107 @@ namespace DxMessaging.Editor.CustomEditors
             });
         }
     }
+
+    internal enum MessageAwareComponentInspectorStateKind
+    {
+        None,
+        HarvesterUnavailable,
+        IgnoredType,
+        MissingBaseCallWarning,
+    }
+
+    internal readonly struct MessageAwareComponentInspectorState
+    {
+        private MessageAwareComponentInspectorState(
+            MessageAwareComponentInspectorStateKind kind,
+            MessageAwareComponent component,
+            DxMessagingSettings settings,
+            string fullName,
+            BaseCallReportEntry entry,
+            bool isFreshThisSession
+        )
+        {
+            Kind = kind;
+            Component = component;
+            Settings = settings;
+            FullName = fullName ?? string.Empty;
+            Entry = entry;
+            IsFreshThisSession = isFreshThisSession;
+        }
+
+        internal static MessageAwareComponentInspectorState None { get; } =
+            new(
+                MessageAwareComponentInspectorStateKind.None,
+                null,
+                null,
+                string.Empty,
+                null,
+                isFreshThisSession: true
+            );
+
+        internal MessageAwareComponentInspectorStateKind Kind { get; }
+
+        internal MessageAwareComponent Component { get; }
+
+        internal DxMessagingSettings Settings { get; }
+
+        internal string FullName { get; }
+
+        internal BaseCallReportEntry Entry { get; }
+
+        internal bool IsFreshThisSession { get; }
+
+        internal static MessageAwareComponentInspectorState ForHarvesterUnavailable(
+            MessageAwareComponent component,
+            DxMessagingSettings settings,
+            string fullName,
+            bool isFreshThisSession
+        )
+        {
+            return new MessageAwareComponentInspectorState(
+                MessageAwareComponentInspectorStateKind.HarvesterUnavailable,
+                component,
+                settings,
+                fullName,
+                null,
+                isFreshThisSession
+            );
+        }
+
+        internal static MessageAwareComponentInspectorState ForIgnoredType(
+            MessageAwareComponent component,
+            DxMessagingSettings settings,
+            string fullName,
+            bool isFreshThisSession
+        )
+        {
+            return new MessageAwareComponentInspectorState(
+                MessageAwareComponentInspectorStateKind.IgnoredType,
+                component,
+                settings,
+                fullName,
+                null,
+                isFreshThisSession
+            );
+        }
+
+        internal static MessageAwareComponentInspectorState ForMissingBaseCallWarning(
+            MessageAwareComponent component,
+            DxMessagingSettings settings,
+            string fullName,
+            BaseCallReportEntry entry,
+            bool isFreshThisSession
+        )
+        {
+            return new MessageAwareComponentInspectorState(
+                MessageAwareComponentInspectorStateKind.MissingBaseCallWarning,
+                component,
+                settings,
+                fullName,
+                entry,
+                isFreshThisSession
+            );
+        }
+    }
 #endif
 }

package/Editor/CustomEditors/MessageAwareComponentInspectorOverlay.cs.meta

@@ -6,6 +6,6 @@ MonoImporter:
   defaultReferences: []
   executionOrder: 0
   icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+  userData:
+  assetBundleName:
+  assetBundleVariant: