Fix six things in the native heads (#846)

* Fix five things in the native heads

Escape with the Linux context menu open reached the managed side as quit, which
closes the menu and then runs the command, so dismissing the menu closed the viewer
- and on Linux there is no tray to open it again from, so the queue went to staging.
A click outside the menu reported nothing at all, leaving it floating until a row, a
button or a key was hit, which is not what docs/viewer.md says of it. Both are
dismissals now.

WindowShouldClose waits on events while the window is minimised, and it is called
inside deview_present, so minimising the Linux viewer stopped the managed loop being
pumped: a snapshot arriving after that was accepted by the listener and never shown.
FLAG_WINDOW_ALWAYS_RUN keeps the loop running, and a focus restores a minimised
window rather than leaving it in the taskbar.

The ImGui backend did not declare RendererHasVtxOffset and the renderer ignored the
vertex offset, so a draw list past 65535 vertices - a maximised 4K window of dense
long lines reaches that - wrapped its sixteen bit indices and drew scrambled panes,
with IM_ASSERT compiled out of the release build to say nothing about it.

A failed queue row on Linux was coloured and left unmarked, while the other three
heads and the docs show " !" after the label.

Trackpad scrolling: the Linux head truncated fractional wheel offsets to zero, and
the Mac head rounded points to notches - so an ordinary flick, which is tens of
points, arrived as tens of notches and the managed side multiplied it by three,
while slow movement rounded away to nothing. Both accumulate now, and macOS converts
points and lines separately.

macOS tooltips: refreshToolTips removed and re-added every tracking rectangle on
every frame, and AppKit times its tooltip delay from the moment the cursor enters
one, so the delay was restarted before it could elapse and queue tooltips never
appeared. The rectangles are rebuilt only when they change.

The binaries these compile into are committed, so the build-native workflow's
rebuild has to land on this branch before it is merged.

* Carry the pending count across the ABI

The macOS head derived "Pending (N)" from the queue it was handed, which is the
visible slice: sized to the body, and with the members of folded groups left out. So
thirty pending in a sixteen row body read "Pending (16)" beside "inline 1 of 30",
and folding a group lowered it further. The ASCII and WinForms heads use
Screen.PendingCount, which the shim had no field for.

DeviewScreen carries it now, so DEVIEW_VERSION goes to 7 and the binaries have to be
rebuilt with this. DeviewStructTests holds the two sides together and is the part of
this a machine with no toolchain can still check.

* Rebuild native renderer binaries

---------

Co-authored-by: SimonCropp <122666+SimonCropp@users.noreply.github.com>

Author: SimonCropp

native/include/deview.h

@@ -127,6 +127,13 @@ typedef struct DeviewScreen {
     const DeviewQueueItem* queue;
     int32_t queueCount;
 
+    /*
+     * How many entries are pending in total, which is not queueCount: that is the visible slice,
+     * sized to the body and with the members of folded groups left out. A head that counted the
+     * slice reported "Pending (16)" beside "inline 1 of 30", and folding a group lowered it.
+     */
+    int32_t pendingCount;
+
     int32_t titleOffset;
     int32_t titleLength;
     int32_t subtitleOffset;
@@ -215,7 +222,7 @@ typedef struct DeviewInput {
  *    described. A widened array element, so an older library reads every pane after the first at
  *    the wrong offset — this is the bump that matters most to honour.
  */
-#define DEVIEW_VERSION 6
+#define DEVIEW_VERSION 7
 
 /*
  * The Swift implementation imports this header for the struct layouts, because Swift does not

native/src/deview.cpp

@@ -110,6 +110,15 @@ struct State
     ImGuiContext* context = nullptr;
     DeviewInput input{};
 
+    /* Whether the last screen carried a context menu, which is what makes Escape and a click
+     * outside it a dismissal rather than what they would otherwise mean. */
+    bool menuOpen = false;
+
+    /* What a wheel message left over. A notch is 1.0, and a touchpad sends fractions of one:
+     * truncating each frame's value on its own threw all of them away, so a touchpad scrolled
+     * nothing at all. */
+    float scrollRemainder = 0.0f;
+
     /*
      * The queue column, owned here rather than by the table.
      *
@@ -384,6 +393,7 @@ void UpdateTexture(ImTextureData* texture)
 void RenderTriangles(
     unsigned int count,
     unsigned int indexStart,
+    unsigned int vertexOffset,
     const ImVector<ImDrawIdx>& indices,
     const ImVector<ImDrawVert>& vertices,
     ImTextureID textureId)
@@ -400,7 +410,12 @@ void RenderTriangles(
     {
         for (unsigned int corner = 0; corner < 3; corner++)
         {
-            const ImDrawVert& vertex = vertices[indices[indexStart + index + corner]];
+            /* Plus the command's own vertex offset. ImDrawIdx is sixteen bits, so a draw list
+             * that runs past 65535 vertices - a maximised 4K window of dense long lines gets
+             * there - is split by ImGui into commands whose indices restart from a base recorded
+             * here. Without adding it the indices wrapped and the panes drew scrambled, and in a
+             * release build, with IM_ASSERT compiled out, nothing said so. */
+            const ImDrawVert& vertex = vertices[vertexOffset + indices[indexStart + index + corner]];
             const ImColor colour = ImColor(vertex.col);
             rlColor4f(colour.Value.x, colour.Value.y, colour.Value.z, colour.Value.w);
             rlTexCoord2f(vertex.uv.x, vertex.uv.y);
@@ -448,6 +463,7 @@ void RenderDrawData(ImDrawData* drawData)
             RenderTriangles(
                 command.ElemCount,
                 command.IdxOffset,
+                command.VtxOffset,
                 commands->IdxBuffer,
                 commands->VtxBuffer,
                 command.GetTexID());
@@ -695,6 +711,10 @@ void DrawPaneImage(const DeviewScreen* screen, const DeviewPane& pane, const Pan
 
 void BuildFrame(const DeviewScreen* screen)
 {
+    /* Read by the input pass, which has no screen of its own: Escape means dismiss while one of
+     * these is up, and quit otherwise. */
+    state.menuOpen = screen->menuCount > 0;
+
     const ImGuiViewport* viewport = ImGui::GetMainViewport();
     ImGui::SetNextWindowPos(viewport->WorkPos);
     ImGui::SetNextWindowSize(viewport->WorkSize);
@@ -785,7 +805,7 @@ void BuildFrame(const DeviewScreen* screen)
                 if (index < screen->queueCount)
                 {
                     const DeviewQueueItem& item = screen->queue[index];
-                    const std::string label = Copy(screen, item.labelOffset, item.labelLength);
+                    std::string label = Copy(screen, item.labelOffset, item.labelLength);
                     if (item.flags & DEVIEW_QUEUE_HEADER)
                     {
                         /* A heading is dimmed like the subtitle, and never carries the selection.
@@ -805,9 +825,14 @@ void BuildFrame(const DeviewScreen* screen)
                     else
                     {
                         const bool selected = (item.flags & DEVIEW_QUEUE_SELECTED) != 0;
-                        if (item.flags & DEVIEW_QUEUE_FAILED)
+                        const bool failed = (item.flags & DEVIEW_QUEUE_FAILED) != 0;
+                        if (failed)
                         {
                             ImGui::PushStyleColor(ImGuiCol_Text, RowColour(DEVIEW_ROW_REMOVED));
+                            /* The marker the other three heads and docs/viewer.md show. Colour
+                             * alone says nothing to a reader who cannot tell this red from the
+                             * one a removed line is drawn in, or from any other. */
+                            label += " !";
                         }
 
                         ImGui::PushID(index);
@@ -817,7 +842,7 @@ void BuildFrame(const DeviewScreen* screen)
                         }
 
                         ImGui::PopID();
-                        if (item.flags & DEVIEW_QUEUE_FAILED)
+                        if (failed)
                         {
                             ImGui::PopStyleColor();
                         }
@@ -981,9 +1006,22 @@ void BuildFrame(const DeviewScreen* screen)
             ImGui::PopID();
         }
 
+        /* Asked before End, which is what makes it about this window. A click anywhere else is a
+         * dismissal: the menu used to float until a row, a button or a key was hit, contrary to
+         * what docs/viewer.md says of it. A right click elsewhere opens the next menu, and the
+         * managed side ignores a dismissal that arrives with one of those. */
+        const bool overMenu = ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows);
+
         ImGui::End();
         ImGui::PopStyleVar();
         ImGui::PopStyleColor();
+
+        if (!overMenu &&
+            (ImGui::IsMouseClicked(ImGuiMouseButton_Left) ||
+             ImGui::IsMouseClicked(ImGuiMouseButton_Right)))
+        {
+            state.input.menuClosed = 1;
+        }
     }
 
     for (int index = 0; index < screen->buttonCount; index++)
@@ -1070,7 +1108,11 @@ int32_t deview_init(
     /* No MSAA. ImGui draws axis aligned quads with pre-antialiased glyph textures, so multisampling
      * buys nothing visually, and it is a real source of difference between a GPU and the software
      * rasteriser the pixel snapshots are pinned to. */
-    unsigned int flags = FLAG_WINDOW_RESIZABLE;
+    /* ALWAYS_RUN because WindowShouldClose waits on events while the window is minimised, and
+     * that call is inside deview_present: without it the managed loop stops being pumped the
+     * moment the window is minimised, so a snapshot arriving after that is accepted by the
+     * listener and never shown. */
+    unsigned int flags = FLAG_WINDOW_RESIZABLE | FLAG_WINDOW_ALWAYS_RUN;
     if (hidden != 0)
     {
         flags |= FLAG_WINDOW_HIDDEN;
@@ -1090,6 +1132,10 @@ int32_t deview_init(
     ImGui::SetCurrentContext(state.context);
     ImGuiIO& io = ImGui::GetIO();
     io.BackendFlags |= ImGuiBackendFlags_RendererHasTextures;
+    /* Declared, so ImGui splits a long draw list into commands with a vertex offset rather than
+     * refusing to let one grow past what a sixteen bit index can address. RenderTriangles applies
+     * the offset. */
+    io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset;
     io.IniFilename = nullptr;
     io.LogFilename = nullptr;
     ApplyStyle();
@@ -1164,8 +1210,25 @@ void deview_poll_input(DeviewInput* input)
     if (state.initialised)
     {
         state.input.key = ReadKey();
+
+        /* Escape with a menu up dismisses the menu. It reached the managed side as quit, which
+         * closes the menu and then runs the command, so Esc-to-dismiss closed the viewer - and on
+         * Linux there is no tray to open it again from, so the queue went to staging. */
+        if (state.menuOpen &&
+            state.input.key == DEVIEW_KEY_QUIT &&
+            IsKeyPressed(KEY_ESCAPE))
+        {
+            state.input.key = DEVIEW_KEY_NONE;
+            state.input.menuClosed = 1;
+        }
+
+        /* Whole notches, keeping the fraction. A touchpad sends a fraction of one per frame and
+         * truncating each frame on its own threw every one of them away. */
         const Vector2 wheel = GetMouseWheelMoveV();
-        state.input.scrollDelta = static_cast<int32_t>(wheel.y);
+        state.scrollRemainder += wheel.y;
+        const int32_t notches = static_cast<int32_t>(state.scrollRemainder);
+        state.input.scrollDelta = notches;
+        state.scrollRemainder -= static_cast<float>(notches);
         MeasureGrid();
     }
 
@@ -1252,6 +1315,13 @@ void deview_focus(void)
     }
 
     ClearWindowState(FLAG_WINDOW_HIDDEN);
+    /* A minimised window stays minimised through SetWindowFocused, so a focus for a new snapshot
+     * left it in the taskbar. */
+    if (IsWindowMinimized())
+    {
+        RestoreWindow();
+    }
+
     SetWindowFocused();
 }
 

native/swift/Sources/Deview/Frame.swift

@@ -10,6 +10,11 @@ struct Frame {
     var subtitle = ""
     var status = ""
     var queue: [QueueItem] = []
+
+    /// Everything pending, which `queue` is not: that is the visible slice, sized to the body and
+    /// with the members of folded groups left out.
+    var pendingCount: Int32 = 0
+
     var buttons: [Button] = []
     var left = Pane()
     var right = Pane()
@@ -63,6 +68,7 @@ struct Frame {
         frame.title = string(screen, screen.titleOffset, screen.titleLength)
         frame.subtitle = string(screen, screen.subtitleOffset, screen.subtitleLength)
         frame.status = string(screen, screen.statusOffset, screen.statusLength)
+        frame.pendingCount = screen.pendingCount
 
         if let items = screen.queue {
             for index in 0 ..< Int(screen.queueCount) {

native/swift/Sources/Deview/Renderer.swift

@@ -172,9 +172,10 @@ final class Renderer {
 
         let headerTop = firstRule + Renderer.gap
         if hasQueue {
-            // Entries only: the rows include group headings, which are not pending anything.
-            let pending = frame.queue.filter { !$0.header }.count
-            text("Pending (\(pending))", in: rect(top: headerTop, left: Renderer.padding, width: queue, height: line, size), Palette.text, context)
+            // The count the managed side carries, not one derived from `queue`: that is the
+            // visible slice, so thirty pending in a sixteen row body read as "Pending (16)" beside
+            // "inline 1 of 30", and folding a group lowered it further.
+            text("Pending (\(frame.pendingCount))", in: rect(top: headerTop, left: Renderer.padding, width: queue, height: line, size), Palette.text, context)
         }
 
         text(frame.left.header, in: rect(top: headerTop, left: panesLeft, width: half, height: line, size), Palette.text, context)

native/swift/Sources/Deview/ViewerView.swift

@@ -52,14 +52,28 @@ final class ViewerView: NSView, NSViewToolTipOwner {
     ///
     /// The text is answered on demand below rather than stored here, so a row whose label changed
     /// under a resting cursor still reads correctly.
+    /// Rebuilt only when the regions themselves changed. AppKit times its tooltip delay from the
+    /// moment the cursor enters a tracking rectangle, and this runs on every frame, so removing
+    /// and re-adding the rectangle under a resting cursor restarted that delay before it could
+    /// ever elapse - which is to say queue tooltips never appeared on macOS at all.
     func refreshToolTips() {
+        let wanted = layout.queueItems.enumerated()
+            .filter { $0.offset < model.queue.count && !model.queue[$0.offset].tooltip.isEmpty }
+            .map(\.element)
+        guard wanted != toolTipRects else {
+            return
+        }
+
+        toolTipRects = wanted
         removeAllToolTips()
-        for (index, bounds) in layout.queueItems.enumerated()
-        where index < model.queue.count && !model.queue[index].tooltip.isEmpty {
+        for bounds in wanted {
             _ = addToolTip(bounds, owner: self, userData: nil)
         }
     }
 
+    /// What the tips are registered on, so an unchanged frame can leave them alone.
+    private var toolTipRects: [NSRect] = []
+
     /// Composed by the managed side, so this only finds the row under the cursor.
     func view(_ view: NSView, stringForToolTip tag: NSView.ToolTipTag, point: NSPoint, userData: UnsafeMutableRawPointer?) -> String {
         guard let index = layout.queueItems.firstIndex(where: { $0.contains(point) }),
@@ -132,12 +146,26 @@ final class ViewerView: NSView, NSViewToolTipOwner {
         super.rightMouseDown(with: event)
     }
 
-    /// Accumulated, because a trackpad delivers many small deltas between two polls and the
-    /// managed side amplifies whatever it is given.
+    /// A notch of a wheel, in the points a precise device reports one movement of it as.
+    ///
+    /// AppKit reports a wheel in lines and a trackpad in points, and rounding both to an integer
+    /// number of notches treated them as the same thing: an ordinary flick of a trackpad reads as
+    /// tens of points, so it arrived as tens of notches and the managed side then multiplied it
+    /// by three. Slow movement rounded to nothing at all.
+    private static let pointsPerNotch = 16.0
+
+    /// What is left over between events, because a trackpad delivers many small deltas between
+    /// two polls and dropping each one on its own is what made slow movement do nothing.
+    private var scrollRemainder = 0.0
+
     override func scrollWheel(with event: NSEvent) {
-        let notches = Int32(event.scrollingDeltaY.rounded())
+        scrollRemainder += event.hasPreciseScrollingDeltas
+            ? event.scrollingDeltaY / ViewerView.pointsPerNotch
+            : event.scrollingDeltaY
+        let notches = scrollRemainder.rounded(.towardZero)
+        scrollRemainder -= notches
         if notches != 0 {
-            Runtime.shared.input.scrollDelta += notches
+            Runtime.shared.input.scrollDelta += Int32(notches)
         }
     }
 

src/DiffEngineViewer.Linux/runtimes/linux-arm64/native/libdiffengine_viewer.so

@@ -10,7 +10,7 @@ static unsafe partial class Deview
     /// Must match DEVIEW_VERSION in native/include/deview.h. Bumped whenever the structs change,
     /// so a stale native library is reported rather than read as garbage.
     /// </summary>
-    public const int ExpectedVersion = 6;
+    public const int ExpectedVersion = 7;
 
     [LibraryImport(library, EntryPoint = "deview_version")]
     public static partial int Version();