nandi/frq · ef6123f

nandi/frqpublic⑂ Fork 0

⑂ ef6123f

Show the reader which message a jump landed on

Arriving at a screenful of messages says nothing about which one was asked
for. The message a reply chip sent you to now wears a surface of its own for
two seconds, so it answers for itself rather than leaving the reader to count
rows. The scroll target could not do this itself: it is cleared the frame
after it scrolls, since one that stayed set would pin the view.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

nandi committed 2026-08-30T12:16:36-07:00 Browse files

ef6123f parent: 7bc82bd

modified src/frq/app.jolt +59 -46 Viewed

@@ -237,9 +237,17 @@
237	237	(if-let [target (s/message-by-id channel id)]
238	238	[:button {:label (str "↩ " (:from target) ": " (summarise target 48))
239	239	:on-click #(do (reset! s/jump-to id)
	240	+ (reset! s/highlight id)
240	241	;; Off again once the frame that scrolled has
241	242	;; been painted, so the reader keeps the view.
242		- (vidya/after! 120 (fn [] (reset! s/jump-to nil))))}]
	243	+ (vidya/after! 120 (fn [] (reset! s/jump-to nil)))
	244	+ ;; The highlight stays long enough to be read,
	245	+ ;; and only clears itself: a later jump elsewhere
	246	+ ;; owns the highlight from then on.
	247	+ (vidya/after! 2000
	248	+ (fn []
	249	+ (when (= id @s/highlight)
	250	+ (reset! s/highlight nil)))))}]
243	251	;; The message it answers is older than this buffer goes.
244	252	[:dim-label {:label "↩ replying to an earlier message"}])])
245	253
@@ -254,55 +262,60 @@
254	262	(let [same-sender? (and prev
255	263	(not (:system? m))
256	264	(not (:system? prev))
257		- (= (:from prev) (:from m)))]
	265	+ (= (:from prev) (:from m)))
	266	+ ;; What a jump landed on wears a surface of its own for a moment, so
	267	+ ;; the answer to "which one was I sent to" is on the screen rather
	268	+ ;; than in the reader's count of rows.
	269	+ highlit? (boolean (and (:id m) (= (:id m) @s/highlight)))]
258	270	[:vbox {:key i :spacing 2 :margin 0
259	271	;; The jump target is what a "go to message" click scrolls to.
260	272	:scroll-here (boolean (and (:id m) (= (:id m) @s/jump-to)))}
261		- [:vbox {:key :reply-chip}
262		- (when-let [reply-to (:reply-to m)]
263		- [reply-chip @s/current reply-to])]
264		- ;; A run from one person reads as one block; repeating the nick on every
265		- ;; line is what made a busy channel look like a list of headers. The time
266		- ;; rides on that same line, for the same reason: once per run, not once
267		- ;; per line.
268		- [:vbox {:key :who}
269		- (when-not (or same-sender? (:system? m))
270		- ;; Everything that is about the person rather than the line: their
271		- ;; picture, their name, and when they started saying this.
272		- [:hbox {:spacing 6}
273		- ;; Always an avatar, picture or not: the initial stands in until the
274		- ;; fetch lands, and for the guests who have no profile at all, which
275		- ;; is what keeps the column of faces straight down the left.
276		- ;; Reading the tick subscribes this row to a fetch finishing.
	273	+ [(if highlit? :card :vbox) {:key :body :spacing 2 :margin 0}
	274	+ [:vbox {:key :reply-chip}
	275	+ (when-let [reply-to (:reply-to m)]
	276	+ [reply-chip @s/current reply-to])]
	277	+ ;; A run from one person reads as one block; repeating the nick on every
	278	+ ;; line is what made a busy channel look like a list of headers. The time
	279	+ ;; rides on that same line, for the same reason: once per run, not once
	280	+ ;; per line.
	281	+ [:vbox {:key :who}
	282	+ (when-not (or same-sender? (:system? m))
	283	+ ;; Everything that is about the person rather than the line: their
	284	+ ;; picture, their name, and when they started saying this.
	285	+ [:hbox {:spacing 6}
	286	+ ;; Always an avatar, picture or not: the initial stands in until the
	287	+ ;; fetch lands, and for the guests who have no profile at all, which
	288	+ ;; is what keeps the column of faces straight down the left.
	289	+ ;; Reading the tick subscribes this row to a fetch finishing.
	290	+ (let [_ @s/media-tick]
	291	+ [:avatar {:label (:from m)
	292	+ :src (or (avatars/path-when-ready (:actor m)) "")
	293	+ :size 22}])
	294	+ [:dim-label {:label (:from m)}]
	295	+ (when-let [at (:at m)]
	296	+ [:dim-label {:label (clock/clock-time at)}])
	297	+ ;; Answering is offered where the sender is named — a run of lines
	298	+ ;; from one person is answered as the thing it is — and against the
	299	+ ;; right edge, out of the way of the name and the time, which are what
	300	+ ;; the eye is going down the column for.
	301	+ [:hbox {:key :reply-action :align :end}
	302	+ (when (:id m)
	303	+ [:button {:label "↩" :on-click #(s/reply-to! m)}])]])]
	304	+ [:vbox {:key :text :spacing 2}
	305	+ (map-indexed (fn [j run] (run-node j run (:system? m)))
	306	+ (text-runs (:text m)))]
	307	+ ;; Pictures under the line that linked them. The link stays: it is what a
	308	+ ;; failed fetch, an unsupported format, or a phone with no TLS leaves you.
	309	+ [:vbox {:key :images :spacing 4}
	310	+ (when (seq (:images m))
	311	+ ;; Reading the tick is what subscribes this row to a fetch finishing.
277	312	(let [_ @s/media-tick]
278		- [:avatar {:label (:from m)
279		- :src (or (avatars/path-when-ready (:actor m)) "")
280		- :size 22}])
281		- [:dim-label {:label (:from m)}]
282		- (when-let [at (:at m)]
283		- [:dim-label {:label (clock/clock-time at)}])
284		- ;; Answering is offered where the sender is named — a run of lines
285		- ;; from one person is answered as the thing it is — and against the
286		- ;; right edge, out of the way of the name and the time, which are what
287		- ;; the eye is going down the column for.
288		- [:hbox {:key :reply-action :align :end}
289		- (when (:id m)
290		- [:button {:label "↩" :on-click #(s/reply-to! m)}])]])]
291		- [:vbox {:key :text :spacing 2}
292		- (map-indexed (fn [j run] (run-node j run (:system? m)))
293		- (text-runs (:text m)))]
294		- ;; Pictures under the line that linked them. The link stays: it is what a
295		- ;; failed fetch, an unsupported format, or a phone with no TLS leaves you.
296		- [:vbox {:key :images :spacing 4}
297		- (when (seq (:images m))
298		- ;; Reading the tick is what subscribes this row to a fetch finishing.
299		- (let [_ @s/media-tick]
300		- (for [url (:images m)]
301		- (when-let [path (media/path-when-ready url)]
302		- [:image {:key url
303		- :src path
304		- :max-height 260
305		- :on-click #(reset! s/lightbox {:path path :url url})}]))))]]))
	313	+ (for [url (:images m)]
	314	+ (when-let [path (media/path-when-ready url)]
	315	+ [:image {:key url
	316	+ :src path
	317	+ :max-height 260
	318	+ :on-click #(reset! s/lightbox {:path path :url url})}]))))]]]))
306	319
307	320	(defn- day-separator [day-key label]
308	321	[:vbox {:key day-key :spacing 4 :margin 0}

     (if-let [target (s/message-by-id channel id)]
       [:button {:label (str "↩ " (:from target) ": " (summarise target 48))
                 :on-click #(do (reset! s/jump-to id)
++                              (reset! s/highlight id)
                                ;; Off again once the frame that scrolled has
                                ;; been painted, so the reader keeps the view.
--                              (vidya/after! 120 (fn [] (reset! s/jump-to nil))))}]
++                              (vidya/after! 120 (fn [] (reset! s/jump-to nil)))
++                              ;; The highlight stays long enough to be read,
++                              ;; and only clears itself: a later jump elsewhere
++                              ;; owns the highlight from then on.
++                              (vidya/after! 2000
++                                            (fn []
++                                              (when (= id @s/highlight)
++                                                (reset! s/highlight nil)))))}]
       ;; The message it answers is older than this buffer goes.
       [:dim-label {:label "↩ replying to an earlier message"}])])
    (let [same-sender? (and prev
                            (not (:system? m))
                            (not (:system? prev))
--                          (= (:from prev) (:from m)))]
++                          (= (:from prev) (:from m)))
++        ;; What a jump landed on wears a surface of its own for a moment, so
++        ;; the answer to "which one was I sent to" is on the screen rather
++        ;; than in the reader's count of rows.
++        highlit? (boolean (and (:id m) (= (:id m) @s/highlight)))]
      [:vbox {:key i :spacing 2 :margin 0
              ;; The jump target is what a "go to message" click scrolls to.
              :scroll-here (boolean (and (:id m) (= (:id m) @s/jump-to)))}
--     [:vbox {:key :reply-chip}
++     [(if highlit? :card :vbox) {:key :body :spacing 2 :margin 0}
--      (when-let [reply-to (:reply-to m)]
++      [:vbox {:key :reply-chip}
--        [reply-chip @s/current reply-to])]
++       (when-let [reply-to (:reply-to m)]
--     ;; A run from one person reads as one block; repeating the nick on every
++         [reply-chip @s/current reply-to])]
--     ;; line is what made a busy channel look like a list of headers. The time
++      ;; A run from one person reads as one block; repeating the nick on every
--     ;; rides on that same line, for the same reason: once per run, not once
++      ;; line is what made a busy channel look like a list of headers. The time
--     ;; per line.
++      ;; rides on that same line, for the same reason: once per run, not once
--     [:vbox {:key :who}
++      ;; per line.
--      (when-not (or same-sender? (:system? m))
++      [:vbox {:key :who}
--        ;; Everything that is about the person rather than the line: their
++       (when-not (or same-sender? (:system? m))
--        ;; picture, their name, and when they started saying this.
++         ;; Everything that is about the person rather than the line: their
--        [:hbox {:spacing 6}
++         ;; picture, their name, and when they started saying this.
--         ;; Always an avatar, picture or not: the initial stands in until the
++         [:hbox {:spacing 6}
--         ;; fetch lands, and for the guests who have no profile at all, which
++          ;; Always an avatar, picture or not: the initial stands in until the
--         ;; is what keeps the column of faces straight down the left.
++          ;; fetch lands, and for the guests who have no profile at all, which
--         ;; Reading the tick subscribes this row to a fetch finishing.
++          ;; is what keeps the column of faces straight down the left.
++          ;; Reading the tick subscribes this row to a fetch finishing.
++          (let [_ @s/media-tick]
++            [:avatar {:label (:from m)
++                      :src (or (avatars/path-when-ready (:actor m)) "")
++                      :size 22}])
++          [:dim-label {:label (:from m)}]
++          (when-let [at (:at m)]
++            [:dim-label {:label (clock/clock-time at)}])
++          ;; Answering is offered where the sender is named — a run of lines
++          ;; from one person is answered as the thing it is — and against the
++          ;; right edge, out of the way of the name and the time, which are what
++          ;; the eye is going down the column for.
++          [:hbox {:key :reply-action :align :end}
++           (when (:id m)
++             [:button {:label "↩" :on-click #(s/reply-to! m)}])]])]
++      [:vbox {:key :text :spacing 2}
++       (map-indexed (fn [j run] (run-node j run (:system? m)))
++                    (text-runs (:text m)))]
++      ;; Pictures under the line that linked them. The link stays: it is what a
++      ;; failed fetch, an unsupported format, or a phone with no TLS leaves you.
++      [:vbox {:key :images :spacing 4}
++       (when (seq (:images m))
++         ;; Reading the tick is what subscribes this row to a fetch finishing.
           (let [_ @s/media-tick]
--           [:avatar {:label (:from m)
++           (for [url (:images m)]
--                     :src (or (avatars/path-when-ready (:actor m)) "")
++             (when-let [path (media/path-when-ready url)]
--                     :size 22}])
++               [:image {:key url
--         [:dim-label {:label (:from m)}]
++                      :src path
--         (when-let [at (:at m)]
++                      :max-height 260
--           [:dim-label {:label (clock/clock-time at)}])
++                      :on-click #(reset! s/lightbox {:path path :url url})}]))))]]]))
--         ;; Answering is offered where the sender is named — a run of lines
--         ;; from one person is answered as the thing it is — and against the
--         ;; right edge, out of the way of the name and the time, which are what
--         ;; the eye is going down the column for.
--         [:hbox {:key :reply-action :align :end}
--          (when (:id m)
--            [:button {:label "↩" :on-click #(s/reply-to! m)}])]])]
--     [:vbox {:key :text :spacing 2}
--      (map-indexed (fn [j run] (run-node j run (:system? m)))
--                   (text-runs (:text m)))]
--     ;; Pictures under the line that linked them. The link stays: it is what a
--     ;; failed fetch, an unsupported format, or a phone with no TLS leaves you.
--     [:vbox {:key :images :spacing 4}
--      (when (seq (:images m))
--        ;; Reading the tick is what subscribes this row to a fetch finishing.
--        (let [_ @s/media-tick]
--          (for [url (:images m)]
--            (when-let [path (media/path-when-ready url)]
--              [:image {:key url
--                     :src path
--                     :max-height 260
--                     :on-click #(reset! s/lightbox {:path path :url url})}]))))]]))
  (defn- day-separator [day-key label]
    [:vbox {:key day-key :spacing 4 :margin 0}

modified src/frq/state.jolt +5 -0 Viewed

@@ -506,6 +506,11 @@
506	506	;; view there and take scrolling away from the reader.
507	507	(defonce jump-to (atom nil))
508	508
	509	+;; The message a jump has just landed on. It outlives the scroll: arriving at a
	510	+;; screenful of messages says nothing about which one was asked for, so the one
	511	+;; that was answers for itself until the reader has had time to see it.
	512	+(defonce highlight (atom nil))
	513	+
509	514
510	515
511	516	(defn last-preview [buffer]

  ;; view there and take scrolling away from the reader.
  (defonce jump-to (atom nil))
++;; The message a jump has just landed on. It outlives the scroll: arriving at a
++;; screenful of messages says nothing about which one was asked for, so the one
++;; that was answers for itself until the reader has had time to see it.
++(defonce highlight (atom nil))
++
  (defn last-preview [buffer]