feat: various improvements to the scroller layout

Author: dy-tea

examples/README.md

@@ -178,6 +178,22 @@ doorsctl config scroller_ignore_proportion_single true|false
 
 When true, proportion settings are ignored for single-window scroller desktops.
 
+```
+doorsctl config scroller_center_focused_column never|on_overflow|always
+```
+
+Controls how the focused column is positioned in the scroller viewport.
+
+- **never**: The column is left-aligned (view offset stays at 0).
+- **on_overflow** (default): Columns narrower than the viewport are left-aligned; columns wider than the viewport are centered so their middle is visible.
+- **always**: The focused column is always centered in the viewport.
+
+```
+doorsctl config scroller_always_center_single_column true|false
+```
+
+When true (default), the single column on a one-column desktop is centered regardless of `scroller_center_focused_column`. Only applies when the column is narrower than the viewport.
+
 ```
 doorsctl config scroller_structs <n>
 ```
@@ -893,6 +909,8 @@ doorsctl config enable_animations [true|false]
 doorsctl config edge_scroller_pointer_focus [true|false]
 doorsctl config scroller_default_proportion [<value>]
 doorsctl config scroller_proportion_preset [<values>]
+doorsctl config scroller_center_focused_column [never|on_overflow|always]
+doorsctl config scroller_always_center_single_column [true|false]
 doorsctl config animation_bezier [<name>]
 doorsctl config animation_duration [<ms>]
 doorsctl config animation <type> [bezier|duration|spring|enabled] [<value>]

include/scroller.h

@@ -3,6 +3,7 @@
 #include "types.h"
 
 #include <stdbool.h>
+#include <time.h>
 #include <wlr/util/box.h>
 
 struct output_t;
@@ -43,6 +44,14 @@ typedef struct scroller_state_t {
 	scroller_column_t *columns;
 	int column_count, capacity, active_column_idx;
 	double view_offset;
+	bool view_offset_dirty;
+	struct {
+		bool active;
+		double from;
+		double target;
+		struct timespec start;
+		uint64_t duration_ms;
+	} view_anim;
 	struct wlr_box working_area;
 } scroller_state_t;
 
@@ -65,6 +74,7 @@ bool scroller_consume_into_column(desktop_t *d);
 bool scroller_expel_from_column(desktop_t *d);
 
 bool scroller_is_tiled(const client_t *c);
+bool scroller_tick(struct output_t *output, struct timespec now);
 void scroller_apply_client_rules(client_t *c, float rule_proportion, float rule_proportion_single);
 
 void scroller_resize_width(client_t *client, float delta);
@@ -84,3 +94,12 @@ extern bool scroller_ignore_proportion_single;
 extern bool edge_scroller_pointer_focus;
 extern float *scroller_proportion_preset;
 extern int scroller_proportion_preset_count;
+
+enum scroller_center_mode {
+	SCROLLER_CENTER_NEVER = 0,
+	SCROLLER_CENTER_ON_OVERFLOW = 1,
+	SCROLLER_CENTER_ALWAYS = 2,
+};
+
+extern int scroller_center_focused_column;
+extern bool scroller_always_center_single_column;

src/ipc_cmd/config.c

@@ -297,6 +297,32 @@ void ipc_cmd_config(char **args, int num, int client_fd) {
 		ipc_handle_bool(args, num, client_fd, &scroller_prefer_overspread, IPC_FLAG_NONE);
 	} else if (streq("scroller_ignore_proportion_single", *args)) {
 		ipc_handle_bool(args, num, client_fd, &scroller_ignore_proportion_single, IPC_FLAG_NONE);
+	} else if (streq("scroller_center_focused_column", *args)) {
+		if (num >= 2) {
+			if (strcmp(args[1], "never") == 0)
+				scroller_center_focused_column = SCROLLER_CENTER_NEVER;
+			else if (strcmp(args[1], "on_overflow") == 0)
+				scroller_center_focused_column = SCROLLER_CENTER_ON_OVERFLOW;
+			else if (strcmp(args[1], "always") == 0)
+				scroller_center_focused_column = SCROLLER_CENTER_ALWAYS;
+			else {
+				send_failure(client_fd,
+					"scroller_center_focused_column: must be 'never', 'on_overflow', or 'always'\n");
+				return;
+			}
+			send_success(client_fd, "scroller_center_focused_column set\n");
+		} else {
+			const char *names[] = {
+				"never",
+				"on_overflow",
+				"always"
+			};
+			char buf[64];
+			snprintf(buf, sizeof(buf), "%s\n", names[scroller_center_focused_column]);
+			send_success(client_fd, buf);
+		}
+	} else if (streq("scroller_always_center_single_column", *args)) {
+		ipc_handle_bool(args, num, client_fd, &scroller_always_center_single_column, IPC_FLAG_NONE);
 	} else if (streq("scroller_structs", *args)) {
 		ipc_handle_int(args, num, client_fd, &scroller_structs, IPC_FLAG_NONE, 0, 1000000, NULL);
 	} else if (streq("focus_follows_pointer", *args) || streq("focus_follows_mouse", *args)) {

src/output.c

@@ -7,6 +7,7 @@
 #include "lock.h"
 #include "output.h"
 #include "output_config.h"
+#include "scroller.h"
 #include "server.h"
 #include "toplevel.h"
 #include "tree.h"
@@ -228,6 +229,10 @@ static void output_repaint(output_t *output) {
 	clock_gettime(CLOCK_MONOTONIC, &now);
 	bool animating = animation_update_output(output, now);
 
+	// tick scroller view offset animation
+	if (output->desk && output->desk->layout == LAYOUT_SCROLLER)
+		animating = scroller_tick(output, now) || animating;
+
 	// ensure blur nodes track animated window positions during workspace slide
 	if (animating)
 		animation_update_slide_blur(output);

src/scroller.c

@@ -1,3 +1,4 @@
+#include "animation.h"
 #include "output.h"
 #include "scroller.h"
 #include "toplevel.h"
@@ -19,6 +20,9 @@ bool edge_scroller_pointer_focus = true;
 float *scroller_proportion_preset = NULL;
 int scroller_proportion_preset_count = 0;
 
+int scroller_center_focused_column = SCROLLER_CENTER_ON_OVERFLOW;
+bool scroller_always_center_single_column = true;
+
 static int max_i(int a, int b) {
 	return a > b ? a : b;
 }
@@ -27,6 +31,9 @@ static double max_d(double a, double b) {
 	return a > b ? a : b;
 }
 
+static double compute_view_offset(scroller_state_t *s, struct wlr_box available);
+static void scroller_start_view_anim(scroller_state_t *s, double target_offset);
+
 static scroller_tile_t *tile_grow(scroller_column_t *col) {
 	if (col->tile_count >= col->capacity) {
 		int new_cap = col->capacity ? col->capacity * 2 : 4;
@@ -371,6 +378,12 @@ void scroller_arrange(struct output_t *m, desktop_t *d, struct wlr_box available
 	}
 	col_xs[s->column_count] = wx; // sentinel
 
+	// auto-compute view offset when active column changes
+	if (s->view_offset_dirty) {
+		scroller_start_view_anim(s, compute_view_offset(s, available));
+		s->view_offset_dirty = false;
+	}
+
 	// view position (camera in world space)
 	double active_col_x = col_xs[s->active_column_idx];
 	double view_pos = active_col_x + s->view_offset;
@@ -439,6 +452,91 @@ static void apply_active_focus(desktop_t *d) {
 	}
 }
 
+static double compute_view_offset(scroller_state_t *s, struct wlr_box available) {
+	scroller_column_t *col = &s->columns[s->active_column_idx];
+	double col_width = col->resolved_width;
+	double avail_width = (double)available.width;
+
+	if (scroller_always_center_single_column && s->column_count == 1 && col_width < avail_width)
+		return (col_width - avail_width) / 2.0;
+
+	switch (scroller_center_focused_column) {
+	case SCROLLER_CENTER_NEVER:
+		return 0.0;
+	case SCROLLER_CENTER_ALWAYS:
+		return (col_width - avail_width) / 2.0;
+	case SCROLLER_CENTER_ON_OVERFLOW:
+	default:
+		if (col_width > avail_width)
+			return (col_width - avail_width) / 2.0;
+		return 0.0;
+	}
+}
+
+static void scroller_apply_positions(output_t *m, scroller_state_t *s) {
+	desktop_t *d = m->desk;
+	int bw = (int)effective_border_width(d);
+
+	for (int i = 0; i < s->column_count; i++) {
+		scroller_column_t *col = &s->columns[i];
+		for (int j = 0; j < col->tile_count; j++) {
+			client_t *c = col->tiles[j].client;
+			if (!c || !c->toplevel || !c->toplevel->node)
+				continue;
+
+			struct wlr_scene_tree *st = client_get_scene_tree(c);
+			if (st)
+				wlr_scene_node_set_position(&st->node, c->tiled_rectangle.x, c->tiled_rectangle.y);
+
+			struct wlr_scene_tree *bt = client_border_tree(c);
+			if (bt)
+				wlr_scene_node_set_position(&bt->node, c->tiled_rectangle.x - bw, c->tiled_rectangle.y - bw);
+		}
+	}
+}
+
+static void scroller_start_view_anim(scroller_state_t *s, double target_offset) {
+	if (enable_animations) {
+		s->view_anim.active = true;
+		s->view_anim.from = s->view_offset;
+		s->view_anim.target = target_offset;
+		clock_gettime(CLOCK_MONOTONIC, &s->view_anim.start);
+		s->view_anim.duration_ms = animation_get_duration();
+	} else {
+		s->view_offset = target_offset;
+		s->view_offset_dirty = false;
+	}
+}
+
+bool scroller_tick(output_t *output, struct timespec now) {
+	if (!output || !output->desk || output->desk->layout != LAYOUT_SCROLLER)
+		return false;
+
+	scroller_state_t *s = output->desk->scroller_state;
+	if (!s || !s->view_anim.active)
+		return false;
+
+	long elapsed_ms = (now.tv_sec - s->view_anim.start.tv_sec) * 1000 + (now.tv_nsec -
+		s->view_anim.start.tv_nsec) / 1000000;
+
+	if (elapsed_ms >= (long)s->view_anim.duration_ms) {
+		s->view_offset = s->view_anim.target;
+		s->view_anim.active = false;
+		arrange(output, output->desk, true);
+		return false;
+	}
+
+	double t = (double)elapsed_ms / (double)s->view_anim.duration_ms;
+	// ease-out cubic (no pow to avoid -lm)
+	double eased = 1.0 - (1.0 - t) * (1.0 - t) * (1.0 - t);
+	s->view_offset = s->view_anim.from + (s->view_anim.target - s->view_anim.from) * eased;
+
+	arrange(output, output->desk, false);
+	scroller_apply_positions(output, s);
+
+	return true;
+}
+
 bool scroller_focus_next(desktop_t *d) {
 	scroller_state_t *s = d->scroller_state;
 	if (!s || s->column_count == 0)
@@ -450,7 +548,7 @@ bool scroller_focus_next(desktop_t *d) {
 	} else {
 		s->active_column_idx++;
 	}
-	s->view_offset = 0.0; // reset scroll for now
+	s->view_offset_dirty = true;
 	apply_active_focus(d);
 	return true;
 }
@@ -466,7 +564,7 @@ bool scroller_focus_prev(desktop_t *d) {
 	} else {
 		s->active_column_idx--;
 	}
-	s->view_offset = 0.0;
+	s->view_offset_dirty = true;
 	apply_active_focus(d);
 	return true;
 }
@@ -514,7 +612,7 @@ void scroller_center_window(desktop_t *d, client_t *client) {
 
 	s->active_column_idx = col_idx;
 	s->columns[col_idx].active_tile_idx = tile_idx;
-	s->view_offset = 0.0;
+	s->view_offset_dirty = true;
 	apply_active_focus(d);
 }