Fix scroll_cursor_into_view to work correctly with keyboard arrows.

- Renamed `offset_x_state` and `offset_y_state` to `scroll_x` and `scroll_y`, improving naming clarity and alignment with functionality.
- Updated all references across multiple modules (`view_state.v`, `xtra_window.v`, `view_scrollbar.v`, etc.) to use the new variable names.
- Refined `scroll_cursor_into_view` logic in `view_text.v` for better readability and scroll offset calculations.
- Adjusted stats output in `stats.v` to reflect renamed variables.
- Miscellaneous improvements to comments and parameter consistency for scroll handling methods.

Author: mike-ward

layout.v

@@ -568,12 +568,12 @@ fn layout_adjust_scroll_offsets(mut layout Layout, mut w Window) {
 	id_scroll := layout.shape.id_scroll
 	if id_scroll > 0 {
 		max_offset_x := f32_min(0, layout.shape.width - layout.shape.padding.width() - content_width(layout))
-		offset_x := w.view_state.offset_x_state[id_scroll]
-		w.view_state.offset_x_state[id_scroll] = f32_clamp(offset_x, max_offset_x, 0)
+		offset_x := w.view_state.scroll_x[id_scroll]
+		w.view_state.scroll_x[id_scroll] = f32_clamp(offset_x, max_offset_x, 0)
 
 		max_offset_y := f32_min(0, layout.shape.height - layout.shape.padding.height() - content_height(layout))
-		offset_y := w.view_state.offset_y_state[id_scroll]
-		w.view_state.offset_y_state[id_scroll] = f32_clamp(offset_y, max_offset_y, 0)
+		offset_y := w.view_state.scroll_y[id_scroll]
+		w.view_state.scroll_y[id_scroll] = f32_clamp(offset_y, max_offset_y, 0)
 	}
 	for mut child in layout.children {
 		layout_adjust_scroll_offsets(mut child, mut w)
@@ -599,8 +599,8 @@ fn layout_positions(mut layout Layout, offset_x f32, offset_y f32, w &Window) {
 	mut y := layout.shape.y + padding.top
 
 	if layout.shape.id_scroll > 0 {
-		x += w.view_state.offset_x_state[layout.shape.id_scroll]
-		y += w.view_state.offset_y_state[layout.shape.id_scroll]
+		x += w.view_state.scroll_x[layout.shape.id_scroll]
+		y += w.view_state.scroll_y[layout.shape.id_scroll]
 	}
 
 	// Eventually start/end will be culture dependent

stats.v

@@ -123,8 +123,8 @@ fn (vs ViewState) view_state_stats() string {
 	tx << 'View State'
 	tx << stat_sub_div
 	tx << 'input_state length       ${cm(usize(vs.input_state.len)):8}'
-	tx << 'offset_x_state length    ${cm(usize(vs.offset_x_state.len)):8}'
-	tx << 'offset_y_state length    ${cm(usize(vs.offset_y_state.len)):8}'
+	tx << 'scroll_x length          ${cm(usize(vs.scroll_x.len)):8}'
+	tx << 'scroll_y length          ${cm(usize(vs.scroll_y.len)):8}'
 	tx << 'text_widths length       ${cm(usize(vs.text_widths.len)):8}'
 	tx << 'menu_state length        ${cm(usize(vs.menu_state.len)):8}'
 	tx << 'image_map length         ${cm(usize(vs.image_map.len)):8}'

view_scrollbar.v

@@ -181,14 +181,14 @@ fn (cfg &ScrollbarCfg) mouse_move(layout &Layout, mut e Event, mut w Window) {
 				if e.mouse_x >= (ly.shape.x - extend)
 					&& e.mouse_x <= (ly.shape.x + ly.shape.width + extend) {
 					offset := offset_mouse_change_x(ly, e.mouse_dx, cfg.id_track, w)
-					w.view_state.offset_x_state[cfg.id_track] = offset
+					w.view_state.scroll_x[cfg.id_track] = offset
 				}
 			}
 			else {
 				if e.mouse_y >= (ly.shape.y - extend)
 					&& e.mouse_y <= (ly.shape.y + ly.shape.height + extend) {
 					offset := offset_mouse_change_y(ly, e.mouse_dy, cfg.id_track, w)
-					w.view_state.offset_y_state[cfg.id_track] = offset
+					w.view_state.scroll_y[cfg.id_track] = offset
 				}
 			}
 		}
@@ -219,7 +219,7 @@ fn (cfg &ScrollbarCfg) amend_layout(mut layout Layout, mut w Window) {
 			thumb_width := f32_clamp(t_width, min_thumb_size, layout.shape.width)
 
 			available_width := layout.shape.width - thumb_width
-			scroll_offset := -w.view_state.offset_x_state[cfg.id_track]
+			scroll_offset := -w.view_state.scroll_x[cfg.id_track]
 			offset := if available_width == 0 {
 				0
 			} else {
@@ -247,7 +247,7 @@ fn (cfg &ScrollbarCfg) amend_layout(mut layout Layout, mut w Window) {
 			thumb_height := f32_clamp(t_height, min_thumb_size, layout.shape.height)
 
 			available_height := layout.shape.height - thumb_height
-			scroll_offset := -w.view_state.offset_y_state[cfg.id_track]
+			scroll_offset := -w.view_state.scroll_y[cfg.id_track]
 			offset := if available_height == 0 {
 				0
 			} else {
@@ -307,7 +307,7 @@ fn find_layout_by_id_scroll(layout &Layout, id_scroll u32) ?Layout {
 fn offset_mouse_change_x(layout &Layout, mouse_x f32, id_scroll u32, w &Window) f32 {
 	total_width := content_width(layout)
 	shape_width := layout.shape.width - layout.shape.padding.width()
-	old_offset := w.view_state.offset_x_state[id_scroll]
+	old_offset := w.view_state.scroll_x[id_scroll]
 	new_offset := mouse_x * (total_width / shape_width)
 	offset := old_offset - new_offset
 	return f32_min(0, f32_max(offset, shape_width - total_width))
@@ -327,7 +327,7 @@ fn offset_mouse_change_x(layout &Layout, mouse_x f32, id_scroll u32, w &Window)
 fn offset_mouse_change_y(layout &Layout, mouse_y f32, id_scroll u32, w &Window) f32 {
 	total_height := content_height(layout)
 	shape_height := layout.shape.height - layout.shape.padding.height()
-	old_offset := w.view_state.offset_y_state[id_scroll]
+	old_offset := w.view_state.scroll_y[id_scroll]
 	new_offset := mouse_y * (total_height / shape_height)
 	offset := old_offset - new_offset
 	return f32_min(0, f32_max(offset, shape_height - total_height))
@@ -352,7 +352,7 @@ fn offset_from_mouse_x(layout &Layout, mouse_x f32, id_scroll u32, mut w Window)
 		if percent >= 0.97 {
 			percent = 1
 		}
-		w.view_state.offset_x_state[id_scroll] = -percent * (total_width - sb.shape.width)
+		w.view_state.scroll_x[id_scroll] = -percent * (total_width - sb.shape.width)
 	}
 }
 
@@ -375,7 +375,7 @@ fn offset_from_mouse_y(layout &Layout, mouse_y f32, id_scroll u32, mut w Window)
 		if percent >= 0.97 {
 			percent = 1
 		}
-		w.view_state.offset_y_state[id_scroll] = -percent * (total_height - sb.shape.height)
+		w.view_state.scroll_y[id_scroll] = -percent * (total_height - sb.shape.height)
 	}
 }
 
@@ -393,8 +393,8 @@ fn scroll_horizontal(layout &Layout, delta f32, mut w Window) bool {
 	if v_id > 0 {
 		// scrollable region does not including padding
 		max_offset := f32_min(0, layout.shape.width - layout.shape.padding.width() - content_width(layout))
-		offset_x := w.view_state.offset_x_state[v_id] + delta * gui_theme.scroll_multiplier
-		w.view_state.offset_x_state[v_id] = f32_clamp(offset_x, max_offset, 0)
+		offset_x := w.view_state.scroll_x[v_id] + delta * gui_theme.scroll_multiplier
+		w.view_state.scroll_x[v_id] = f32_clamp(offset_x, max_offset, 0)
 		return true
 	}
 	return false
@@ -414,8 +414,8 @@ fn scroll_vertical(layout &Layout, delta f32, mut w Window) bool {
 	if v_id > 0 {
 		// scrollable region does not including padding
 		max_offset := f32_min(0, layout.shape.height - layout.shape.padding.height() - content_height(layout))
-		offset_y := w.view_state.offset_y_state[v_id] + delta * gui_theme.scroll_multiplier
-		w.view_state.offset_y_state[v_id] = f32_clamp(offset_y, max_offset, 0)
+		offset_y := w.view_state.scroll_y[v_id] + delta * gui_theme.scroll_multiplier
+		w.view_state.scroll_y[v_id] = f32_clamp(offset_y, max_offset, 0)
 		return true
 	}
 	return false

view_state.v

@@ -8,8 +8,8 @@ struct ViewState {
 mut:
 	input_state            map[u32]InputState         // [id_focus] -> InputState
 	input_date_state       map[string]bool            // [id] -> visible
-	offset_x_state         map[u32]f32                // [id_scroll] -> offset x
-	offset_y_state         map[u32]f32                // [id_scroll] -> offset y
+	scroll_x               map[u32]f32                // [id_scroll] -> scroll offset x
+	scroll_y               map[u32]f32                // [id_scroll] -> scroll offset y
 	text_widths            map[u32]f32                // [text + hash(text_style)] -> text width
 	mouse_cursor           sapp.MouseCursor           // arrow, finger, ibeam, etc.
 	menu_state             map[u32]string             // [id_menubar] -> id of menu
@@ -28,8 +28,8 @@ fn (mut vs ViewState) clear(mut w Window) {
 	unsafe {
 		vs.input_state.free()
 		vs.input_date_state.free()
-		vs.offset_x_state.free()
-		vs.offset_y_state.free()
+		vs.scroll_x.free()
+		vs.scroll_y.free()
 		vs.text_widths.free()
 		vs.menu_state.free()
 		vs.image_map.free()

view_text.v

@@ -96,7 +96,7 @@ pub:
 	placeholder_active bool
 }
 
-// text is a general purpose text renderer. Use it for labels or larger
+// text is a general purpose text view. Use it for labels or larger
 // blocks of multiline text. Giving it an id_focus allows mark and copy
 // operations. See [TextCfg](#TextCfg)
 pub fn text(cfg TextView) View {
@@ -202,7 +202,13 @@ fn (tv &TextView) mouse_move_locked(layout &Layout, mut e Event, mut w Window) {
 // scroll container. It calculates the line position of the cursor and
 // adjusts the scroll offset if the cursor is outside the current visible
 // area.
-fn scroll_cursor_into_view(cursor_pos int, layout &Layout, e &Event, mut w Window) {
+fn scroll_cursor_into_view(cursor_pos int, layout &Layout, _ &Event, mut w Window) {
+	// Find the scroll container and calculate height. (need to start at the root layout)
+	scroll_container := w.layout.find_layout(fn [layout] (ly Layout) bool {
+		return ly.shape.id_scroll == layout.shape.id_scroll_container
+	}) or { return }
+	scroll_view_height := scroll_container.shape.height - scroll_container.shape.padding.height()
+
 	// Find the index of the line where the cursor is located.
 	mut line_idx := 0
 	mut total_len := 0
@@ -217,29 +223,22 @@ fn scroll_cursor_into_view(cursor_pos int, layout &Layout, e &Event, mut w Windo
 	// Calculate the y offset of the cursor line.
 	// Since scroll offsets are often negative (content moves up), use -lh.
 	lh := line_height(layout.shape)
-	cursor_offset_y := line_idx * -lh
-
-	// Find the scroll container. (need to start at the root layout)
-	scroll_container := w.layout.find_layout(fn [layout] (ly Layout) bool {
-		return ly.shape.id_scroll == layout.shape.id_scroll_container
-	}) or { return }
-
-	// Calculate the visible height of the scroll container
-	scroll_container_height := scroll_container.shape.height - scroll_container.shape.padding.height()
+	cursor_y := line_idx * -lh
+	cursor_h_y := cursor_y + scroll_view_height - lh
 
-	// Determine the bottom boundary relative to the cursor
-	scroll_offset_yb := cursor_offset_y + scroll_container_height
+	// Calculate scroll offsets for current visible region
+	current_scroll_y := w.view_state.scroll_y[layout.shape.id_scroll_container]
+	current_scroll_h_y := current_scroll_y - scroll_view_height
 
 	// Determine if we need to scroll:
-	// 1. If cursor is above the current view and trying to go up (mouse_dy < 0)
-	// 2. If cursor is below the current view and trying to go down (mouse_dy > 0)
-	current_scroll_offset_y := w.view_state.offset_y_state[layout.shape.id_scroll_container]
-	new_scroll_offset := match true {
-		cursor_offset_y > current_scroll_offset_y && e.mouse_dy < 0 { cursor_offset_y }
-		scroll_offset_yb < current_scroll_offset_y && e.mouse_dy > 0 { scroll_offset_yb }
-		else { return }
+	// 1. If cursor is above the current view
+	// 2. If cursor is below the current view
+	new_scroll_y := match true {
+		cursor_y > current_scroll_y { cursor_y }
+		cursor_y <= current_scroll_h_y { cursor_h_y }
+		else { current_scroll_y }
 	}
-	w.scroll_vertical_to(layout.shape.id_scroll_container, new_scroll_offset)
+	w.scroll_vertical_to(layout.shape.id_scroll_container, new_scroll_y)
 }
 
 fn view_text_mouse_up(layout &Layout, mut e Event, mut w Window) {

window.v

@@ -169,6 +169,7 @@ fn event_fn(ev &gg.Event, mut w Window) {
 	// An Event is processed until an event handler sets the event.is_handled`
 	// member to true.
 	w.lock()
+
 	// layout is not modified else where at this point in the life cycle.
 	// Locks in V do not nest, which is why unlock() is called immediately after
 	// acquiring the layout. This allows event handlers to lock the window to
@@ -260,6 +261,8 @@ pub fn (mut window Window) update_window() {
 		gui_stats.update_max_renderers(usize(window.renderers.len))
 	}
 
+	// Technically, clearing views and layouts should not be needed,
+	// but it appears to help the GC in some instances.
 	clear_views(mut view)
 	clear_layouts(mut old_layout)
 	window.ui.refresh_ui()

xtra_window.v

@@ -182,25 +182,25 @@ fn (mut window Window) update_window_size() {
 // scroll_horizontal_by scrolls the given scrollable by delta.
 // Use update_window() if not called from event handler
 pub fn (mut window Window) scroll_horizontal_by(id_scroll u32, delta f32) {
-	window.view_state.offset_x_state[id_scroll] += delta
+	window.view_state.scroll_x[id_scroll] += delta
 }
 
 // scroll_horizontal_to scrolls the given scrollable to the offset. offset is negative.
 // Use update_window() if not called from event handler
 pub fn (mut window Window) scroll_horizontal_to(id_scroll u32, offset f32) {
-	window.view_state.offset_x_state[id_scroll] = offset
+	window.view_state.scroll_x[id_scroll] = offset
 }
 
 // scroll_vertical_by scrolls the given scrollable by delta.
 // Use update_window() if not called from event handler
 pub fn (mut window Window) scroll_vertical_by(id_scroll u32, delta f32) {
-	window.view_state.offset_y_state[id_scroll] += delta
+	window.view_state.scroll_y[id_scroll] += delta
 }
 
 // scroll_vertical_to scrolls the given scrollable to the offset. offset is negative.
 // Use update_window() if not called from event handler
 pub fn (mut window Window) scroll_vertical_to(id_scroll u32, offset f32) {
-	window.view_state.offset_y_state[id_scroll] = offset
+	window.view_state.scroll_y[id_scroll] = offset
 }
 
 // set_id_focus sets the window's focus id.