JonKazama-Hellion
39a8e95581
The layout fingerprint tracked font size, density, both name modes and content width, but not ImGuiHelpers.GlobalScale. Scale feeds CalcWordWrapPositionA, so changing it rewraps every row while the cached heights stay put and the clipper dummies drift against the scrollbar. Two further problems came out of the same code: The fingerprint lived in a single field on MessageList while the cache it guards is per tab. Resizing in tab A marked the new value applied, so tab B kept measuring against the old width. It is now a gate per tab identifier. Acting on every fingerprint change is too eager. A window resize or a drag on the Dalamud UI-scale slider moves the value on every frame, and each change drops the cache and forces the linear measure path over the whole tab (up to Config.MaxLinesToRender rows). The gate now waits for the value to settle for 200ms, which turns a drag into one rebuild instead of one per frame. The settle logic sits in Util/LayoutFingerprint.cs as a plain value type so the build suite can pin it without standing up an ImGui frame.
363 lines
15 KiB
C#
363 lines
15 KiB
C#
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Numerics;
|
|
using Dalamud.Bindings.ImGui;
|
|
using Dalamud.Interface.Utility;
|
|
using HellionChat.Resources;
|
|
using HellionChat.Util;
|
|
|
|
namespace HellionChat.Ui.Components;
|
|
|
|
// Virtualised message list. Compact mode uses ImGuiListClipper (constant row
|
|
// height); card mode rows wrap to arbitrary heights, so it runs its own
|
|
// prefix-sum clipper (CardClipPlanner) over a per-message height cache, dropped
|
|
// whenever the layout fingerprint (font/density/name-mode/width) changes.
|
|
internal sealed class MessageList
|
|
{
|
|
private const float CompactRowHeight = 18f;
|
|
|
|
private readonly FontManager _fonts;
|
|
private readonly ChunkRenderer _chunkRenderer;
|
|
|
|
private PayloadHandler? _handler;
|
|
|
|
// B3-5: scroll-to-bottom state. Per-instance, so pop-out windows (own
|
|
// MessageList instance, PluginHostFactory.cs:263-266) isolate automatically —
|
|
// the old 1.5.6 updateScrollState flag is NOT needed here.
|
|
private bool _scrolledUp;
|
|
private bool _scrollToBottomRequested;
|
|
|
|
// B2: the height cache is only valid while these inputs are unchanged.
|
|
// FontManager's own fingerprint covers font sizes only, not density / the two
|
|
// name-display modes / width — a stale height would misplace the clipper dummies.
|
|
// Per tab, not per list: the old single field let a width change in tab A mark
|
|
// itself applied, so tab B kept measuring against the previous width.
|
|
private readonly Dictionary<Guid, LayoutFingerprintGate> _fingerprintGates = [];
|
|
|
|
// §6.2: setter-injection breaks the PayloadHandler → MainWindow → MessageList → PayloadHandler 3-cycle.
|
|
// Wired by PayloadHandlerInitHostedService.StartAsync after both singletons exist.
|
|
internal void AttachPayloadHandler(PayloadHandler handler)
|
|
{
|
|
_handler = handler;
|
|
}
|
|
|
|
public MessageList(FontManager fonts, ChunkRenderer chunkRenderer)
|
|
{
|
|
_fonts = fonts;
|
|
_chunkRenderer = chunkRenderer;
|
|
}
|
|
|
|
// Deterministic and ImGui-free: encapsulates the snap decision AND the
|
|
// request reset, so the reset invariant is covered. Called by the real Draw.
|
|
internal bool ResolveSnapToBottom(bool pinnedToBottom)
|
|
{
|
|
var snap = pinnedToBottom || _scrollToBottomRequested;
|
|
_scrollToBottomRequested = false;
|
|
return snap;
|
|
}
|
|
|
|
// SelfTest hook (B3-5 reset-invariant, REQUIRED — not optional). Lets
|
|
// ScrollSnapDecisionStep flip the request flag without a real click, so the
|
|
// post-snap reset can be asserted; without it only the OR branch is testable.
|
|
internal void RequestScrollToBottomForSelfTest() => _scrollToBottomRequested = true;
|
|
|
|
// SelfTest hook (B2): runs the real planner against a caller fixture so the
|
|
// step asserts the plan without a live scroll child (GetScrollY is garbage headless).
|
|
internal CardClipPlan PlanCardClipForSelfTest(
|
|
IReadOnlyList<float> heights,
|
|
float scrollY,
|
|
float viewportHeight
|
|
) => CardClipPlanner.Plan(heights, scrollY, viewportHeight);
|
|
|
|
// SelfTest hook (B2): drives the live invalidation, returns the tab's remaining
|
|
// cached-height count so the step can assert the drop.
|
|
internal int RunHeightCacheInvalidationForSelfTest(Tab tab, float contentWidth)
|
|
{
|
|
InvalidateHeightCacheIfLayoutChanged(tab, contentWidth);
|
|
using var messages = tab.Messages.GetReadOnly(3);
|
|
return messages.Count(m => m.Height.ContainsKey(tab.Identifier));
|
|
}
|
|
|
|
// Width is passed in (ContentRegionAvail is only valid inside the draw child);
|
|
// enum modes widened to int so the record stays comparable. UiScale is in here
|
|
// because it feeds CalcWordWrapPositionA -- a scale change rewraps every row.
|
|
private LayoutFingerprint BuildLayoutFingerprint(float contentWidth)
|
|
{
|
|
var (global, symbols) = _fonts.EffectiveFontFingerprint();
|
|
return new LayoutFingerprint(
|
|
global,
|
|
symbols,
|
|
Plugin.Config.UseCompactDensity,
|
|
(int)Plugin.Config.NameFormMode,
|
|
(int)Plugin.Config.WorldSuffixMode,
|
|
contentWidth,
|
|
ImGuiHelpers.GlobalScale
|
|
);
|
|
}
|
|
|
|
// Drop the tab's cached heights once the layout fingerprint has settled — one
|
|
// record compare per frame, a clear only after a real settings/resize change
|
|
// stopped moving. The gate is what keeps a slider drag from rebuilding the
|
|
// whole tab on every frame.
|
|
private void InvalidateHeightCacheIfLayoutChanged(Tab tab, float contentWidth)
|
|
{
|
|
if (!_fingerprintGates.TryGetValue(tab.Identifier, out var gate))
|
|
{
|
|
gate = new LayoutFingerprintGate();
|
|
_fingerprintGates[tab.Identifier] = gate;
|
|
}
|
|
|
|
if (!gate.ShouldInvalidate(BuildLayoutFingerprint(contentWidth), Environment.TickCount64))
|
|
return;
|
|
|
|
using var messages = tab.Messages.GetReadOnly(3);
|
|
foreach (var msg in messages)
|
|
{
|
|
msg.Height.Remove(tab.Identifier);
|
|
msg.IsVisible.Remove(tab.Identifier);
|
|
}
|
|
}
|
|
|
|
public void Draw(Tab tab)
|
|
{
|
|
if (!_fonts.FontsReady)
|
|
{
|
|
ImGui.TextUnformatted("Loading fonts…");
|
|
return;
|
|
}
|
|
|
|
// No own ImRaii.Child here — MainWindow already wraps the message
|
|
// area in one. Nesting would give the window two stacked scrolls
|
|
// and a runaway content-height computation.
|
|
var compact = Plugin.Config.UseCompactDensity;
|
|
|
|
// B2: drop stale cached heights before the snapshot draw (card path only —
|
|
// compact rows are constant height). Width read here while it is valid.
|
|
if (!compact)
|
|
InvalidateHeightCacheIfLayoutChanged(tab, ImGui.GetContentRegionAvail().X);
|
|
|
|
using var messages = tab.Messages.GetReadOnly(3);
|
|
|
|
// Track whether the user was pinned to the bottom before this frame
|
|
// so newly arriving rows do not yank them up. The check runs against
|
|
// the parent child's scroll state, which is the one MainWindow owns.
|
|
var pinnedToBottom = ImGui.GetScrollY() >= ImGui.GetScrollMaxY() - 1f;
|
|
|
|
if (compact)
|
|
DrawCompact(messages);
|
|
else
|
|
DrawCard(tab, messages);
|
|
|
|
// B3-5: scroll values are frame-constant inside the child, so this
|
|
// reflects the current frame's state wherever it runs; kept after the
|
|
// render to mirror the 1.5.6 end-of-DrawMessageLog placement.
|
|
_scrolledUp = ImGui.GetScrollMaxY() - ImGui.GetScrollY() > 1f;
|
|
|
|
if (ResolveSnapToBottom(pinnedToBottom))
|
|
ImGui.SetScrollHereY(1f);
|
|
|
|
DrawScrollToBottomBar();
|
|
|
|
// OpenPopup in Click() and BeginPopup here share the ##hellion-main-area scope -> Popup-ID matches.
|
|
_handler?.Draw();
|
|
}
|
|
|
|
// B3-5: Discord-style full-width bar pinned to the bottom edge of the
|
|
// visible region while the user is scrolled up. Geometry comes from window
|
|
// pos + size (visible region), never from the content flow: when scrolled
|
|
// up the visible bottom sits above the content bottom, so the
|
|
// InvisibleButton stays inside the existing content rect and cannot grow
|
|
// GetScrollMaxY(). Drawn on the WINDOW drawlist so the enclosing child
|
|
// clips it; submitted after every payload chunk so the button wins the
|
|
// hit-test and PostPayload clicks underneath do not double-fire.
|
|
private void DrawScrollToBottomBar()
|
|
{
|
|
if (!_scrolledUp)
|
|
return;
|
|
|
|
var winPos = ImGui.GetWindowPos();
|
|
var winSize = ImGui.GetWindowSize();
|
|
var barHeight = ImGui.GetFrameHeight();
|
|
// The bar only renders while content overflows, so the vertical
|
|
// scrollbar is always up — keep the bar clear of it.
|
|
var barWidth = winSize.X - ImGui.GetStyle().ScrollbarSize;
|
|
var barTopLeft = new Vector2(winPos.X, winPos.Y + winSize.Y - barHeight);
|
|
var barBottomRight = barTopLeft + new Vector2(barWidth, barHeight);
|
|
|
|
var theme = Plugin.Instance.ThemeRegistry.Active;
|
|
var hovered = ImGui.IsMouseHoveringRect(barTopLeft, barBottomRight);
|
|
var fill = ColourUtil.RgbaToAbgr(
|
|
hovered ? theme.Colors.SurfaceHover : theme.Colors.Surface
|
|
);
|
|
var rounding = 4f * ImGuiHelpers.GlobalScale;
|
|
var dl = ImGui.GetWindowDrawList();
|
|
dl.AddRectFilled(barTopLeft, barBottomRight, fill, rounding);
|
|
dl.AddRect(
|
|
barTopLeft,
|
|
barBottomRight,
|
|
ColourUtil.RgbaToAbgr(theme.Colors.Border),
|
|
rounding
|
|
);
|
|
|
|
var label = HellionStrings.ChatLog_ScrollToBottom_Tooltip;
|
|
var textSize = ImGui.CalcTextSize(label);
|
|
var textPos =
|
|
barTopLeft + new Vector2((barWidth - textSize.X) / 2f, (barHeight - textSize.Y) / 2f);
|
|
dl.AddText(textPos, ColourUtil.RgbaToAbgr(theme.Colors.Accent), label);
|
|
|
|
// Click target after the visuals; nothing advances the cursor past the
|
|
// button, so content height is identical with and without the bar.
|
|
ImGui.SetCursorScreenPos(barTopLeft);
|
|
ImGui.InvisibleButton("##scroll-to-bottom-bar", new Vector2(barWidth, barHeight));
|
|
if (ImGui.IsItemClicked())
|
|
_scrollToBottomRequested = true;
|
|
}
|
|
|
|
private void DrawCompact(IReadOnlyList<Message> messages)
|
|
{
|
|
unsafe
|
|
{
|
|
var clipper = new ImGuiListClipperPtr(ImGuiNative.ImGuiListClipper());
|
|
try
|
|
{
|
|
clipper.Begin(messages.Count, CompactRowHeight);
|
|
while (clipper.Step())
|
|
{
|
|
for (var i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
|
|
DrawCompactRow(messages[i]);
|
|
}
|
|
clipper.End();
|
|
}
|
|
finally
|
|
{
|
|
clipper.Destroy();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawCompactRow(Message message)
|
|
{
|
|
// B2-1/B2-2: render the sender through DrawChunks (the name-aware path
|
|
// that applies WorldSuffixMode/NameFormMode via ForDisplay), not as a
|
|
// flat SenderSource.TextValue string. message.Sender already carries the
|
|
// channel brackets/colon as ChunkSource.None wrappers (MessageManager
|
|
// .cs:300-314), so the separator is rendered by the chunks. 1.5.6 parity
|
|
// (ChatLogWindow.cs:1965: DrawChunks(message.Sender) + SameLine).
|
|
var timestamp = FormatTimestamp(message.Date);
|
|
if (message.Sender.Count > 0)
|
|
{
|
|
ImGui.TextUnformatted($"{timestamp} ");
|
|
ImGui.SameLine(0f, 0f);
|
|
_chunkRenderer.DrawChunks(message.Sender, wrap: true, handler: _handler, lineWidth: 0f);
|
|
ImGui.SameLine(0f, 0f);
|
|
}
|
|
else
|
|
{
|
|
ImGui.TextUnformatted(timestamp);
|
|
ImGui.SameLine(0f, 0f);
|
|
}
|
|
_chunkRenderer.DrawChunks(message.Content, wrap: true, handler: _handler, lineWidth: 0f);
|
|
}
|
|
|
|
private void DrawCard(Tab tab, IReadOnlyList<Message> messages)
|
|
{
|
|
var tabId = tab.Identifier;
|
|
var count = messages.Count;
|
|
if (count == 0)
|
|
return;
|
|
|
|
// A row with no cached height yet can't be planned (first frame / post-
|
|
// invalidation), so draw everything once to fill the cache, plan next frame.
|
|
var heights = new float[count];
|
|
var allCached = true;
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
if (messages[i].Height.TryGetValue(tabId, out var cached) && cached is float h)
|
|
heights[i] = h;
|
|
else
|
|
allCached = false;
|
|
}
|
|
|
|
if (!allCached)
|
|
{
|
|
DrawCardLinearAndMeasure(tabId, messages);
|
|
return;
|
|
}
|
|
|
|
var plan = CardClipPlanner.Plan(heights, ImGui.GetScrollY(), ImGui.GetWindowSize().Y);
|
|
|
|
// Cached heights already include one trailing ItemSpacing.y; a dummy adds its
|
|
// own, which would shove the first visible row down one spacing (jitter).
|
|
// Subtract one spacing per dummy so offset AND total content height stay exact.
|
|
var spacingY = ImGui.GetStyle().ItemSpacing.Y;
|
|
float CompensatedDummy(float planned) => Math.Max(0f, planned - spacingY);
|
|
|
|
if (plan.FirstVisible < 0)
|
|
{
|
|
// Scrolled into a gap: one full-height dummy keeps the scrollbar honest.
|
|
var gap = CompensatedDummy(plan.LeadDummyHeight + plan.EndDummyHeight);
|
|
ImGui.Dummy(new Vector2(10f, gap));
|
|
return;
|
|
}
|
|
|
|
if (plan.LeadDummyHeight > 0f)
|
|
ImGui.Dummy(new Vector2(10f, CompensatedDummy(plan.LeadDummyHeight)));
|
|
|
|
for (var i = plan.FirstVisible; i <= plan.LastVisible; i++)
|
|
{
|
|
var msg = messages[i];
|
|
var before = ImGui.GetCursorPosY();
|
|
DrawCardRow(msg);
|
|
var after = ImGui.GetCursorPosY();
|
|
msg.Height[tabId] = after - before;
|
|
msg.IsVisible[tabId] = true;
|
|
}
|
|
|
|
if (plan.EndDummyHeight > 0f)
|
|
ImGui.Dummy(new Vector2(10f, CompensatedDummy(plan.EndDummyHeight)));
|
|
}
|
|
|
|
// First-frame / post-invalidation fallback: draw + measure every row into the
|
|
// cache so the next frame can take the planned path.
|
|
private void DrawCardLinearAndMeasure(Guid tabId, IReadOnlyList<Message> messages)
|
|
{
|
|
foreach (var msg in messages)
|
|
{
|
|
var before = ImGui.GetCursorPosY();
|
|
DrawCardRow(msg);
|
|
var after = ImGui.GetCursorPosY();
|
|
msg.Height[tabId] = after - before;
|
|
msg.IsVisible[tabId] = ImGui.IsItemVisible();
|
|
}
|
|
}
|
|
|
|
private void DrawCardRow(Message message)
|
|
{
|
|
// B2-1/B2-2: sender via DrawChunks (name-aware path), on its own line
|
|
// with content below — 1.5.6 card parity (ChatLogWindow.cs:1913, no
|
|
// SameLine after the sender). The 1.5.6 channel-colour push on the
|
|
// sender is deferred styling polish (masterplan §6 -> v1.9.0); plain
|
|
// text here.
|
|
var timestamp = FormatTimestamp(message.Date);
|
|
if (message.Sender.Count > 0)
|
|
{
|
|
ImGui.TextUnformatted($"{timestamp} ");
|
|
ImGui.SameLine(0f, 0f);
|
|
_chunkRenderer.DrawChunks(message.Sender, wrap: true, handler: _handler, lineWidth: 0f);
|
|
}
|
|
else
|
|
{
|
|
ImGui.TextUnformatted(timestamp);
|
|
}
|
|
_chunkRenderer.DrawChunks(message.Content, wrap: true, handler: _handler, lineWidth: 0f);
|
|
}
|
|
|
|
private static string FormatTimestamp(DateTimeOffset date)
|
|
{
|
|
var local = date.ToLocalTime();
|
|
return Plugin.Config.Use24HourClock
|
|
? local.ToString("HH:mm", CultureInfo.InvariantCulture)
|
|
: local.ToString("h:mm tt", CultureInfo.InvariantCulture);
|
|
}
|
|
}
|