akkartik/snap.love - Change FWCILHZLHSMW2RQF4ZTJVABMHTD6IR4KPCHUEJFTQT2MXHV75XDQC

snapshot: a whole new approach to panning

Basic idea: If the goal is for the cursor to be on the viewport, focus the code on ensuring that constraint by construction.

Motivation: The downstream driver.love fork still has persistent bugs. And I'm seeing some inconclusive signs that edit.lua might be failing to change screen_top some of the time when it needs to. But this only happens in driver.love, never in lines.love. So the null hypothesis is that there's some subtle assumption in lines.love that we're violating when rendering it on a surface.

What do you do with such subtleties? It might actually be counterproductive to fix them at source. You end up with complexity upstream that won't actually matter there if it breaks. Which is a recipe for it to break silently and far away from the downstream fork that might actually care about it. Or it might confuse people in future who don't care about the downstream forks, just lines.love.

Maybe it makes sense to modify edit.lua here and take the hit on all possible future merge conflicts. But considering the cost of tracking this down, it seems simplest to: a) come up with the constraint I care about, and b) modify outside edit.lua, either what it sees or its results, to preserve the new constraint.

Long ago I used to have this assertion in pensieve.love that the cursor must be within the viewport, but I ended up taking it out because it kept breaking for me when I was trying to do real work. It seems clear that there are possible assertions that are useful and yet counterproductive. If you can't keep it out of the product in the course of testing, then it annoys users where ignoring it would be a more graceful experience. Even when the user is just yourself! So it turns out this is not a problem only for large teams of extrinsically motivated people who don't eat their own dog food. No, for some things you have to fix the problem by construction, not just verify it with an assertion.

This plan isn't fully working yet in this commit. I've only fixed cases for down-arrow. I need to address up arrow, and there might also be changes for left/right arrows. Hmm, I'm going to try to follow the implementation of bring_cursor_of_cursor_node_in_view() in pensieve.love.

In the process of doing this I also noticed a bug with page-up/down. It already existed, but this approach has made it more obvious.

Created by Kartik K. Agaram on October 27, 2023

FWCILHZLHSMW2RQF4ZTJVABMHTD6IR4KPCHUEJFTQT2MXHV75XDQC

Dependencies

In channels

main

Change contents

File addition: 0035-pan_viewport_to_contain_cursor (----------)

[4.2]

function pan_viewport_to_contain_cursor(node)
	print('viewport', Viewport.y)
	local safety_margin = 2*node.editor.line_height
	print('safety margin', screen_top_y, 'dvpx')
	print('node', node.y)
	local cursor_y = y_of_schema1(node.editor, node.editor.cursor1)
	print('cursor', cursor_y, 'dvpx')
	if Viewport.y < node.y then
		-- node starts within Viewport
		print('node starts within viewport')
		local max_cursor_y = App.screen.height - scale(node.y - Viewport.y) - safety_margin
		if cursor_y > max_cursor_y then
			-- set Viewport.y so cursor_y == max_cursor_y
			-- equation: cursor_y == App.screen.height - (node.y - Viewport.y)*Viewport.zoom - safety_margin
			-- solve for Viewport.y
			Viewport.y = node.y - (App.screen.height - cursor_y - safety_margin)/Viewport.zoom
			print('adjusting Viewport to', Viewport.y)
		end
	else
		-- node extends above Viewport
		print('node extends above viewport')
		local screen_top_y = y_of_schema1(node.editor, node.editor.screen_top1)
		print('screen top', screen_top_y, 'dvpx')
		local min_screen_top_y = cursor_y + safety_margin - App.screen.height
		if screen_top_y < min_screen_top_y then
			screen_top_y = min_screen_top_y
			Viewport.y = node.y + screen_top_y/Viewport.zoom
			print('adjusting Viewport to', Viewport.y)
		end
	end
end

Replacement in 0030-update_editor_box at line 1 [5.26]

B:BD[5.26] → [6.32:97]

update_editor_box = function(node, skip_updating_screen_top_for)

[5.26]

[5.98]

update_editor_box = function(node, skip_updating)

Insertion in 0030-update_editor_box at line 3 [5.26]
[5.137]
[7.468]
```
	if node == skip_updating then return end
```

Deletion in 0030-update_editor_box at line 9 [5.26]

B:BD[8.213] → [3.32:134]

--? 	print('update', node.y, Viewport.y, 'spx', node.editor.screen_top1.line, node.editor.top, 'vpx')

Replacement in 0030-update_editor_box at line 10 [5.26]
B:BD[9.61] → [9.61:108]
B:BD[9.108] → [3.135:177]
∅:D[10.97] → [5.238:309]
∅:D[9.108] → [5.238:309]
∅:D[6.174] → [5.238:309]
∅:D[3.177] → [5.238:309]
B:BD[5.238] → [5.238:309]
B:BD[5.309] → [9.109:115]
```
		if node ~= skip_updating_screen_top_for then
--? 			print('modifying screen_top to 1')
			node.editor.screen_top1.line = 1
			node.editor.screen_top1.pos = 1
		end
```
[9.61]
[9.115]
```
		node.editor.screen_top1.line = 1
		node.editor.screen_top1.pos = 1
```

Replacement in 0030-update_editor_box at line 14 [5.26]

B:BD[9.152] → [3.178:232]

∅:D[3.232] → [9.152:199]

B:BD[9.152] → [9.152:199]

∅:D[9.199] → [6.214:312]

B:BD[6.214] → [6.214:312]

B:BD[6.312] → [3.233:608]

∅:D[6.312] → [5.309:315]

∅:D[3.608] → [5.309:315]

B:BD[5.309] → [5.309:315]

--? 		print('<=', node, skip_updating_screen_top_for)
		if node ~= skip_updating_screen_top_for then
			node.editor.screen_top1, node.editor.top = schema1_of_y(node.editor, scale(Viewport.y-node.y))
			print('modified screen_top to', node.editor.screen_top1.line, 'at', node.editor.top, 'vpx')
		else
			-- adjust editor to start rendering near top of viewport
--? 			print(Viewport.y)
			node.editor.top = Viewport.y%node.editor.line_height
			if node.editor.top > 0 then node.editor.top = node.editor.top - node.editor.line_height end
--? 			print('top', node.editor.top)
		end

[9.152]

[11.238]

		node.editor.screen_top1, node.editor.top = schema1_of_y(node.editor, scale(Viewport.y-node.y))

Replacement in 0028-A at line 1 [12.6019]
B:BD[12.6019] → [6.315:358]
```
A = function(skip_updating_screen_top_for)
```
[12.6019]
[13.1424]
```
A = function()
```

Replacement in 0028-A at line 12 [12.6019]

∅:D[14.2169] → [6.359:435]

∅:D[2.3061] → [6.359:435]

B:BD[7.536] → [6.359:435]

B:BD[6.435] → [2.3062:3141]

	compute_layout(Page, Page.x,Page.y, Surface, skip_updating_screen_top_for)
	compute_layout(Page2, Page2.x,Page2.y, Surface, skip_updating_screen_top_for)

[2.3061]

[13.1929]

	compute_layout(Page, Page.x,Page.y, Surface)
	compute_layout(Page2, Page2.x,Page2.y, Surface)

Replacement in 0028-A at line 15 [12.6019]
B:BD[13.1955] → [6.436:469]
```
	B(skip_updating_screen_top_for)
```
[13.1955]
[13.1960]
```
	B()
```

Replacement in 0023-on.keychord_press at line 20 [16.26]

∅:D[15.95] → [16.328:429]

B:BD[16.328] → [16.328:429]

		local old_top = {line=Cursor_node.editor.screen_top1.line, pos=Cursor_node.editor.screen_top1.pos}

[15.95]

[16.429]

		print('cursor before', Cursor_node.editor.cursor1.line, Cursor_node.editor.cursor1.pos)

Replacement in 0023-on.keychord_press at line 22 [16.26]

B:BD[16.483] → [3.616:693]

∅:D[3.693] → [16.483:541]

B:BD[16.483] → [16.483:541]

B:BD[16.541] → [3.694:837]

∅:D[3.837] → [17.295:406]

B:BD[16.541] → [17.295:406]

B:BD[17.406] → [3.838:884]

∅:D[17.406] → [18.39:722]

∅:D[3.884] → [18.39:722]

B:BD[16.638] → [18.39:722]

∅:D[19.188] → [6.475:528]

∅:D[18.722] → [6.475:528]

∅:D[14.2395] → [6.475:528]

B:BD[16.638] → [6.475:528]

∅:D[14.2484] → [6.528:538]

B:BD[6.528] → [6.528:538]

∅:D[6.538] → [16.638:644]

B:BD[16.638] → [16.638:644]

--? 		print('edit', old_top.line, '=>', Cursor_node.editor.screen_top1.line)
		if not eq(Cursor_node.editor.screen_top1, old_top) then
--? 			print('modifying Viewport', Viewport.y, 'based on', Cursor_node.y, Cursor_node.editor.screen_top1.line, Cursor_node.editor.line_height)
			Viewport.y = Cursor_node.y + y_of_schema1(Cursor_node.editor, Cursor_node.editor.screen_top1)/Viewport.zoom
--? 			print('modified Viewport', Viewport.y)
			-- Most of the time, we update the screen_top of nodes from Viewport.y.
			-- But here we went the other way.
			-- It's very important to avoid creating a recurrence, to avoid running
			-- both sides of this feedback loop in a single frame. These apps are
			-- not very numerically precise (e.g. we force text lines to start at
			-- integer pixels regardless of zoom, because that keeps text crisp),
			-- and the computations of Viewport.y and node.top will almost certainly
			-- not converge. The resulting bugs are extremely difficult to chase
			-- down.
			-- The optional skip_updating_screen_top_for arg ensures we don't run
			-- the other side of the feedback loop.
			A(--[[skip updating screen_top for]] Cursor_node)
			return
		end

[16.483]

[6.539]

		print('cursor after', Cursor_node.editor.cursor1.line, Cursor_node.editor.cursor1.pos)
		pan_viewport_to_contain_cursor(Cursor_node)

Replacement in 0021-compute_layout at line 1 [20.4307]

B:BD[20.4307] → [6.629:713]

compute_layout = function(node, x,y, nodes_to_render, skip_updating_screen_top_for)

[20.4307]

[20.4398]

compute_layout = function(node, x,y, nodes_to_render)

Replacement in 0021-compute_layout at line 34 [20.4307]
B:BD[20.5191] → [6.714:771]
```
			update_editor_box(node, skip_updating_screen_top_for)
```
[20.5191]
[20.5254]
```
			update_editor_box(node)
```

Replacement in 0021-compute_layout at line 62 [20.4307]

B:BD[20.6029] → [14.2613:2705]

			subx,suby = compute_layout(child, x,suby, nodes_to_render, skip_updating_screen_top_for)

[20.6029]

[20.6091]

			subx,suby = compute_layout(child, x,suby, nodes_to_render)

Replacement in 0021-compute_layout at line 90 [20.4307]

B:BD[20.6717] → [14.2706:2798]

			subx,suby = compute_layout(child, subx,y, nodes_to_render, skip_updating_screen_top_for)

[20.6717]

[20.6779]

			subx,suby = compute_layout(child, subx,y, nodes_to_render)

Replacement in 0019-B at line 1 [21.6168]
B:BD[21.6168] → [6.774:817]
```
B = function(skip_updating_screen_top_for)
```
[21.6168]
[13.4517]
```
B = function()
```

Replacement in 0019-B at line 19 [21.6168]

B:BD[13.5063] → [6.818:875]

				update_editor_box(obj, skip_updating_screen_top_for)

[13.5063]

[13.5090]

				update_editor_box(obj)