nandi/frq · 16df4e0

nandi/frqpublic⑂ Fork 0

⑂ 16df4e0

Let the tiles actually grow

The ceiling was a fixed 240 points, which two people in a 520-wide window
were already against — so dragging the window to twice the size changed the
tiles by six points, and the resizing looked broken because in every way
that mattered it was.

The ceiling now comes from the wall's share of the height, so a bigger
window really does make the faces bigger: three people go from 153 points
at 520x700 to 277 at 900x700 to 449 on a 1080p screen. The fixed cap is
still there but generous, and only answers on a screen tall enough that the
height never binds.

Columns are picked by trying every arrangement from one row to one column
and keeping the roomiest, because neither axis alone decides it — more
columns buy height by spending width, and which is worth more depends on
the shape of the window.

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

nandi committed 2026-08-30T17:47:08-07:00 Browse files

16df4e0 parent: 4917912

modified src/frq/av.jolt +40 -37 Viewed

@@ -495,11 +495,14 @@
495	495	;; is people looking at each other, not a contact sheet.
496	496	(def ^:private want-tile 160)
497	497
498		-;; A tile narrower than this is not a face, it is a thumbnail of one. The
499		-;; ceiling is where a tile stops being a tile and starts being the screen — at
500		-;; which point the person wants the picture, not the call.
	498	+;; A tile narrower than this is not a face, it is a thumbnail of one.
501	499	(def ^:private min-tile 96)
502		-(def ^:private max-tile 240)
	500	+
	501	+;; And an upper bound, so that one person alone does not become a wall-sized
	502	+;; portrait in a maximised window. Generous rather than tight — what actually
	503	+;; stops tiles growing is the height budget below, and this is only here so
	504	+;; there is an answer on a screen tall enough not to bind.
	505	+(def ^:private max-tile 480)
503	506
504	507	;; What a tile costs in height beyond its picture: the name under it, and the
505	508	;; gap to the row below.
@@ -510,46 +513,45 @@
510	513	;; being that and starts being a video app with a chat box attached.
511	514	(def ^:private wall-share 0.34)
512	515
513		-(defn- tile-height [width] (+ (long (* width 0.75)) tile-label))
514		-
515	516	(defn- rows-for [n cols] (max 1 (quot (+ n (dec cols)) cols)))
516	517
517	518	(defn tile-width
518		- "How wide each of `n` tiles across should be in a window of `width` points.
519		-
520		- A wider window makes everyone bigger, which is the point of dragging one
521		- wider during a call; a second person appearing shrinks the first rather than
522		- pushing them off the edge."
523		- [width n]
	519	+ "How wide a tile is with `n` across and `rows` down, in a window of `width`
	520	+ by `height` points.
	521	+
	522	+ Bounded by both axes, and the height is usually the one that binds. That is
	523	+ deliberate: a fixed ceiling meant a window dragged from half the screen to
	524	+ all of it changed the tiles by six points, because they were already against
	525	+ it. Deriving the ceiling from the wall's share of the height means a taller
	526	+ window really does make the faces bigger."
	527	+ [width height n rows]
524	528	(let [n (max 1 n)
525		- usable (max 0 (- (or width 0) wall-chrome (* tile-gap (dec n))))]
526		- (-> (quot usable n)
	529	+ rows (max 1 rows)
	530	+ across (max 0 (- (or width 0) wall-chrome (* tile-gap (dec n))))
	531	+ by-width (quot across n)
	532	+ ;; What the row height allows, once the name and the gap are paid for.
	533	+ down (- (quot (long (* (or height 0) wall-share)) rows) tile-gap tile-label)
	534	+ by-height (long (/ (max 0 down) 0.75))]
	535	+ (-> (min by-width by-height)
527	536	(max min-tile)
528	537	(min max-tile))))
529	538
530	539	(defn columns
531		- "How many tiles to put across a window of `width` by `height` points.
532		-
533		- Two pressures, and the second is why this is not simply a division. Across:
534		- tiles are kept near the size they want rather than crammed to the minimum,
535		- because four faces at a hundred points each is worse than two rows of two at
536		- twice that. Down: the whole wall has to fit its share of the window, so when
537		- the rows that follow from a comfortable width would be taller than that, it
538		- takes more columns and smaller tiles instead — which is what stops five
539		- people in a narrow window from stacking five rows deep and pushing the
540		- conversation off the screen."
	540	+ "How many tiles to put across, for the biggest tiles the window allows.
	541	+
	542	+ Every arrangement from one row to one column is tried and the roomiest wins,
	543	+ because neither axis alone decides it: more columns buy height by spending
	544	+ width, and which is worth more depends on the shape of the window. Ties go to
	545	+ fewer columns, which is the arrangement with fewer rows."
541	546	[width height n]
542		- (let [n (max 1 n)
543		- usable (- (or width 0) wall-chrome)
544		- want (-> (quot (+ usable tile-gap) (+ want-tile tile-gap)) (max 1) (min n))
545		- budget (* (or height 0) wall-share)
546		- fits? (fn [cols]
547		- (<= (* (rows-for n cols) (+ (tile-height (tile-width width cols)) tile-gap))
548		- budget))]
549		- ;; From the width we would like, widen until the wall fits its share. The
550		- ;; last candidate is every tile on one row, which is as short as the wall
551		- ;; can be made — if that still does not fit, it is the best on offer.
552		- (or (first (filter fits? (range want (inc n)))) n)))
	547	+ (let [n (max 1 n)]
	548	+ (reduce (fn [best cols]
	549	+ (if (> (tile-width width height cols (rows-for n cols))
	550	+ (tile-width width height best (rows-for n best)))
	551	+ cols
	552	+ best))
	553	+ 1
	554	+ (range 2 (inc n)))))
553	555
554	556	(defn tile-rows
555	557	"The tiles as `[width [[key ...] ...]]` — one width, and the rows to draw.
@@ -559,6 +561,7 @@
559	561	as though something had gone wrong rather than as a layout."
560	562	([] (tile-rows @window-width @window-height (tiles)))
561	563	([width height keys]
562		- (let [cols (columns width height (count keys))]
563		- [(tile-width width cols)
	564	+ (let [n (count keys)
	565	+ cols (columns width height n)]
	566	+ [(tile-width width height cols (rows-for n cols))
564	567	(mapv vec (partition-all cols keys))])))

  ;; is people looking at each other, not a contact sheet.
  (def ^:private want-tile 160)
--;; A tile narrower than this is not a face, it is a thumbnail of one. The
++;; A tile narrower than this is not a face, it is a thumbnail of one.
--;; ceiling is where a tile stops being a tile and starts being the screen — at
--;; which point the person wants the picture, not the call.
  (def ^:private min-tile 96)
--(def ^:private max-tile 240)
++
++;; And an upper bound, so that one person alone does not become a wall-sized
++;; portrait in a maximised window. Generous rather than tight — what actually
++;; stops tiles growing is the height budget below, and this is only here so
++;; there is an answer on a screen tall enough not to bind.
++(def ^:private max-tile 480)
  ;; What a tile costs in height beyond its picture: the name under it, and the
  ;; gap to the row below.
  ;; being that and starts being a video app with a chat box attached.
  (def ^:private wall-share 0.34)
--(defn- tile-height [width] (+ (long (* width 0.75)) tile-label))
--
  (defn- rows-for [n cols] (max 1 (quot (+ n (dec cols)) cols)))
  (defn tile-width
--  "How wide each of `n` tiles across should be in a window of `width` points.
++  "How wide a tile is with `n` across and `rows` down, in a window of `width`
--
++  by `height` points.
--  A wider window makes everyone bigger, which is the point of dragging one
++
--  wider during a call; a second person appearing shrinks the first rather than
++  Bounded by both axes, and the height is usually the one that binds. That is
--  pushing them off the edge."
++  deliberate: a fixed ceiling meant a window dragged from half the screen to
--  [width n]
++  all of it changed the tiles by six points, because they were already against
++  it. Deriving the ceiling from the wall's share of the height means a taller
++  window really does make the faces bigger."
++  [width height n rows]
    (let [n (max 1 n)
--        usable (max 0 (- (or width 0) wall-chrome (* tile-gap (dec n))))]
++        rows (max 1 rows)
--    (-> (quot usable n)
++        across (max 0 (- (or width 0) wall-chrome (* tile-gap (dec n))))
++        by-width (quot across n)
++        ;; What the row height allows, once the name and the gap are paid for.
++        down (- (quot (long (* (or height 0) wall-share)) rows) tile-gap tile-label)
++        by-height (long (/ (max 0 down) 0.75))]
++    (-> (min by-width by-height)
          (max min-tile)
          (min max-tile))))
  (defn columns
--  "How many tiles to put across a window of `width` by `height` points.
++  "How many tiles to put across, for the biggest tiles the window allows.
--
++
--  Two pressures, and the second is why this is not simply a division. Across:
++  Every arrangement from one row to one column is tried and the roomiest wins,
--  tiles are kept near the size they want rather than crammed to the minimum,
++  because neither axis alone decides it: more columns buy height by spending
--  because four faces at a hundred points each is worse than two rows of two at
++  width, and which is worth more depends on the shape of the window. Ties go to
--  twice that. Down: the whole wall has to fit its share of the window, so when
++  fewer columns, which is the arrangement with fewer rows."
--  the rows that follow from a comfortable width would be taller than that, it
--  takes more columns and smaller tiles instead — which is what stops five
--  people in a narrow window from stacking five rows deep and pushing the
--  conversation off the screen."
    [width height n]
--  (let [n (max 1 n)
++  (let [n (max 1 n)]
--        usable (- (or width 0) wall-chrome)
++    (reduce (fn [best cols]
--        want (-> (quot (+ usable tile-gap) (+ want-tile tile-gap)) (max 1) (min n))
++              (if (> (tile-width width height cols (rows-for n cols))
--        budget (* (or height 0) wall-share)
++                     (tile-width width height best (rows-for n best)))
--        fits? (fn [cols]
++                cols
--                (<= (* (rows-for n cols) (+ (tile-height (tile-width width cols)) tile-gap))
++                best))
--                    budget))]
++            1
--    ;; From the width we would like, widen until the wall fits its share. The
++            (range 2 (inc n)))))
--    ;; last candidate is every tile on one row, which is as short as the wall
--    ;; can be made — if that still does not fit, it is the best on offer.
--    (or (first (filter fits? (range want (inc n)))) n)))
  (defn tile-rows
    "The tiles as `[width [[key ...] ...]]` — one width, and the rows to draw.
    as though something had gone wrong rather than as a layout."
    ([] (tile-rows @window-width @window-height (tiles)))
    ([width height keys]
--   (let [cols (columns width height (count keys))]
++   (let [n (count keys)
--     [(tile-width width cols)
++         cols (columns width height n)]
++     [(tile-width width height cols (rows-for n cols))
        (mapv vec (partition-all cols keys))])))