Merge pull request #128 from acrisci/feature/layout-autoconfiguration

implement output layout auto configuration

examples/config.c

@@ -255,49 +255,14 @@ void example_config_destroy(struct example_config *config) {
 	free(config);
 }
 
-struct wlr_output_layout *configure_layout(struct example_config *config,
+struct output_config *example_config_get_output(struct example_config *config,
-		struct wl_list *outputs) {
+		struct wlr_output *output) {
-	struct wlr_output_layout *layout = wlr_output_layout_init();
+	struct output_config *o_config;
-	int max_x = INT_MIN;
+	wl_list_for_each(o_config, &config->outputs, link) {
-	int max_x_y = INT_MIN; // y value for the max_x output
+		if (strcmp(o_config->name, output->name) == 0) {
-
+			return o_config;
-	// first add all the configured outputs
-	struct output_state *output;
-	wl_list_for_each(output, outputs, link) {
-		struct output_config *conf;
-		wl_list_for_each(conf, &config->outputs, link) {
-			if (strcmp(conf->name, output->output->name) == 0) {
-				wlr_output_layout_add(layout, output->output,
-						conf->x, conf->y);
-				wlr_output_transform(output->output, conf->transform);
-				int width, height;
-				wlr_output_effective_resolution(output->output, &width,
-					&height);
-				if (conf->x + width > max_x) {
-					max_x = conf->x + width;
-					max_x_y = conf->y;
-				}
-				break;
-			}
 		}
 	}
 
-	if (max_x == INT_MIN) {
+	return NULL;
-		// couldn't find a configured output
-		max_x = 0;
-		max_x_y = 0;
-	}
-
-	// now add all the other configured outputs in a sensible position
-	wl_list_for_each(output, outputs, link) {
-		if (wlr_output_layout_get(layout, output->output)) {
-			continue;
-		}
-		wlr_output_layout_add(layout, output->output, max_x, max_x_y);
-		int width, height;
-		wlr_output_effective_resolution(output->output, &width, &height);
-		max_x += width;
-	}
-
-	return layout;
 }

examples/config.h

@@ -34,6 +34,11 @@ struct example_config *parse_args(int argc, char *argv[]);
 
 void example_config_destroy(struct example_config *config);
 
-struct wlr_output_layout *configure_layout(struct example_config *config,
+/**
-		struct wl_list *outputs);
+ * Get configuration for the output. If the output is not configured, returns
+ * NULL.
+ */
+struct output_config *example_config_get_output(struct example_config *config,
+		struct wlr_output *output);
+
 #endif

examples/output-layout.c

@@ -32,11 +32,70 @@ struct sample_state {
 	struct wlr_output_layout *layout;
 	float x_offs, y_offs;
 	float x_vel, y_vel;
-	struct wlr_output *main_output;
+	struct timespec ts_last;
-	struct wl_list outputs;
 };
 
-static void handle_output_frame(struct output_state *output, struct timespec *ts) {
+static void animate_cat(struct sample_state *sample,
+		struct wlr_output *output) {
+	struct timespec ts;
+	clock_gettime(CLOCK_MONOTONIC, &ts);
+	long ms = (ts.tv_sec - sample->ts_last.tv_sec) * 1000 +
+		(ts.tv_nsec - sample->ts_last.tv_nsec) / 1000000;
+	// how many seconds have passed since the last time we animated
+	float seconds = ms / 1000.0f;
+
+	if (seconds > 0.1f) {
+		// XXX when we switch vt, the rendering loop stops so try to detect
+		// that and pause when it happens.
+		seconds = 0.0f;
+	}
+
+	// check for collisions and bounce
+	bool ur_collision = !wlr_output_layout_output_at(sample->layout,
+			sample->x_offs + 128, sample->y_offs);
+	bool ul_collision = !wlr_output_layout_output_at(sample->layout,
+			sample->x_offs, sample->y_offs);
+	bool ll_collision = !wlr_output_layout_output_at(sample->layout,
+			sample->x_offs, sample->y_offs + 128);
+	bool lr_collision = !wlr_output_layout_output_at(sample->layout,
+			sample->x_offs + 128, sample->y_offs + 128);
+
+	if (ur_collision && ul_collision && ll_collision && lr_collision) {
+		// oops we went off the screen somehow
+		struct wlr_output_layout_output *l_output =
+			wlr_output_layout_get(sample->layout, output);
+		sample->x_offs = l_output->x + 20;
+		sample->y_offs = l_output->y + 20;
+	} else if (ur_collision && ul_collision) {
+		sample->y_vel = fabs(sample->y_vel);
+	} else if (lr_collision && ll_collision) {
+		sample->y_vel = -fabs(sample->y_vel);
+	} else if (ll_collision && ul_collision) {
+		sample->x_vel = fabs(sample->x_vel);
+	} else if (ur_collision && lr_collision) {
+		sample->x_vel = -fabs(sample->x_vel);
+	} else {
+		if (ur_collision || lr_collision) {
+			sample->x_vel = -fabs(sample->x_vel);
+		}
+		if (ul_collision || ll_collision) {
+			sample->x_vel = fabs(sample->x_vel);
+		}
+		if (ul_collision || ur_collision) {
+			sample->y_vel = fabs(sample->y_vel);
+		}
+		if (ll_collision || lr_collision) {
+			sample->y_vel = -fabs(sample->y_vel);
+		}
+	}
+
+	sample->x_offs += sample->x_vel * seconds;
+	sample->y_offs += sample->y_vel * seconds;
+	sample->ts_last = ts;
+}
+
+static void handle_output_frame(struct output_state *output,
+		struct timespec *ts) {
 	struct compositor_state *state = output->compositor;
 	struct sample_state *sample = state->data;
 	struct wlr_output *wlr_output = output->output;
@@ -44,105 +103,50 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
 	wlr_output_make_current(wlr_output);
 	wlr_renderer_begin(sample->renderer, wlr_output);
 
-	if (wlr_output_layout_intersects(sample->layout, output->output,
+	animate_cat(sample, output->output);
-				sample->x_offs, sample->y_offs,
+
-				sample->x_offs + 128, sample->y_offs + 128)) {
+	bool intersects = wlr_output_layout_intersects(sample->layout,
+		output->output, sample->x_offs, sample->y_offs,
+		sample->x_offs + 128, sample->y_offs + 128);
+
+	if (intersects) {
 		float matrix[16];
 
 		// transform global coordinates to local coordinates
 		double local_x = sample->x_offs;
 		double local_y = sample->y_offs;
-		wlr_output_layout_output_coords(sample->layout, output->output, &local_x,
+		wlr_output_layout_output_coords(sample->layout, output->output,
-				&local_y);
+			&local_x, &local_y);
 
 		wlr_texture_get_matrix(sample->cat_texture, &matrix,
 			&wlr_output->transform_matrix, local_x, local_y);
 		wlr_render_with_matrix(sample->renderer,
 			sample->cat_texture, &matrix);
+
 	}
 
 	wlr_renderer_end(sample->renderer);
 	wlr_output_swap_buffers(wlr_output);
+}
 
-	if (output->output == sample->main_output) {
+static void handle_output_add(struct output_state *ostate) {
-		long ms = (ts->tv_sec - output->last_frame.tv_sec) * 1000 +
+	struct sample_state *sample = ostate->compositor->data;
-			(ts->tv_nsec - output->last_frame.tv_nsec) / 1000000;
-		// how many seconds have passed since the last frame
-		float seconds = ms / 1000.0f;
 
-		if (seconds > 0.1f) {
+	struct output_config *o_config =
-			// XXX when we switch vt, the rendering loop stops so try to detect
+		example_config_get_output(sample->config, ostate->output);
-			// that and pause when it happens.
-			seconds = 0.0f;
-		}
 
-		// check for collisions and bounce
+	if (o_config) {
-		bool ur_collision = !wlr_output_layout_output_at(sample->layout,
+		wlr_output_transform(ostate->output, o_config->transform);
-				sample->x_offs + 128, sample->y_offs);
+		wlr_output_layout_add(sample->layout, ostate->output, o_config->x,
-		bool ul_collision = !wlr_output_layout_output_at(sample->layout,
+			o_config->y);
-				sample->x_offs, sample->y_offs);
+	} else {
-		bool ll_collision = !wlr_output_layout_output_at(sample->layout,
+		wlr_output_layout_add_auto(sample->layout, ostate->output);
-				sample->x_offs, sample->y_offs + 128);
-		bool lr_collision = !wlr_output_layout_output_at(sample->layout,
-				sample->x_offs + 128, sample->y_offs + 128);
-
-		if (ur_collision && ul_collision && ll_collision && lr_collision) {
-			// oops we went off the screen somehow
-			struct wlr_output_layout_output *main_l_output;
-			main_l_output = wlr_output_layout_get(sample->layout, sample->main_output);
-			sample->x_offs = main_l_output->x + 20;
-			sample->y_offs = main_l_output->y + 20;
-		} else if (ur_collision && ul_collision) {
-			sample->y_vel = fabs(sample->y_vel);
-		} else if (lr_collision && ll_collision) {
-			sample->y_vel = -fabs(sample->y_vel);
-		} else if (ll_collision && ul_collision) {
-			sample->x_vel = fabs(sample->x_vel);
-		} else if (ur_collision && lr_collision) {
-			sample->x_vel = -fabs(sample->x_vel);
-		} else {
-			if (ur_collision || lr_collision) {
-				sample->x_vel = -fabs(sample->x_vel);
-			}
-			if (ul_collision || ll_collision) {
-				sample->x_vel = fabs(sample->x_vel);
-			}
-			if (ul_collision || ur_collision) {
-				sample->y_vel = fabs(sample->y_vel);
-			}
-			if (ll_collision || lr_collision) {
-				sample->y_vel = -fabs(sample->y_vel);
-			}
-		}
-
-		sample->x_offs += sample->x_vel * seconds;
-		sample->y_offs += sample->y_vel * seconds;
 	}
 }
 
-static void set_main_output(struct sample_state *sample,
+static void handle_output_remove(struct output_state *ostate) {
-		struct wlr_output *output) {
+	struct sample_state *sample = ostate->compositor->data;
-	sample->main_output = output;
+	wlr_output_layout_remove(sample->layout, ostate->output);
-	struct wlr_output_layout_output *l_output;
-	l_output = wlr_output_layout_get(sample->layout, output);
-	sample->x_offs = l_output->x + 200;
-	sample->y_offs = l_output->y + 200;
-}
-
-static void handle_output_resolution(struct compositor_state *state, struct output_state *output) {
-	struct sample_state *sample = state->data;
-	wlr_output_layout_destroy(sample->layout);
-	sample->layout = configure_layout(sample->config, &sample->outputs);
-	set_main_output(sample, output->output);
-
-}
-
-static void handle_output_add(struct output_state *output) {
-	struct sample_state *sample = output->compositor->data;
-	wl_list_insert(&sample->outputs, &output->link);
-	wlr_output_layout_destroy(sample->layout);
-	sample->layout = configure_layout(sample->config, &sample->outputs);
-	set_main_output(sample, output->output);
 }
 
 static void update_velocities(struct compositor_state *state,
@@ -152,8 +156,8 @@ static void update_velocities(struct compositor_state *state,
 	sample->y_vel += y_diff;
 }
 
-static void handle_keyboard_key(struct keyboard_state *kbstate, uint32_t keycode,
+static void handle_keyboard_key(struct keyboard_state *kbstate,
-	 	xkb_keysym_t sym, enum wlr_key_state key_state) {
+		uint32_t keycode, xkb_keysym_t sym, enum wlr_key_state key_state) {
 	// NOTE: It may be better to simply refer to our key state during each frame
 	// and make this change in pixels/sec^2
 	// Also, key repeat
@@ -182,15 +186,15 @@ int main(int argc, char *argv[]) {
 	state.x_vel = 500;
 	state.y_vel = 500;
 	state.layout = wlr_output_layout_init();
+	clock_gettime(CLOCK_MONOTONIC, &state.ts_last);
 
-	wl_list_init(&state.outputs);
 	state.config = parse_args(argc, argv);
 
 	struct compositor_state compositor = { 0 };
 	compositor.data = &state;
 	compositor.output_add_cb = handle_output_add;
+	compositor.output_remove_cb = handle_output_remove;
 	compositor.output_frame_cb = handle_output_frame;
-	compositor.output_resolution_cb = handle_output_resolution;
 	compositor.keyboard_key_cb = handle_keyboard_key;
 	compositor_init(&compositor);
 

examples/pointer.c

@@ -132,11 +132,16 @@ static void handle_output_add(struct output_state *ostate) {
 	struct wlr_output *wlr_output = ostate->output;
 	struct wlr_xcursor_image *image = sample->xcursor->images[0];
 
-	// reset layout
+	struct output_config *o_config =
-	wlr_output_layout_destroy(sample->layout);
+		example_config_get_output(sample->config, ostate->output);
-	sample->layout =
+
-        configure_layout(sample->config, &ostate->compositor->outputs);
+	if (o_config) {
-	wlr_cursor_attach_output_layout(sample->cursor, sample->layout);
+		wlr_output_transform(ostate->output, o_config->transform);
+		wlr_output_layout_add(sample->layout, ostate->output, o_config->x,
+			o_config->y);
+	} else {
+		wlr_output_layout_add_auto(sample->layout, ostate->output);
+	}
 
 	// cursor configuration
 	char *mapped_output = sample->config->cursor.mapped_output;
@@ -158,11 +163,9 @@ static void handle_output_add(struct output_state *ostate) {
 }
 
 static void handle_output_remove(struct output_state *ostate) {
-		struct sample_state *sample = ostate->compositor->data;
+	struct sample_state *sample = ostate->compositor->data;
-	wlr_output_layout_destroy(sample->layout);
+
-	sample->layout =
+	wlr_output_layout_remove(sample->layout, ostate->output);
-        configure_layout(sample->config, &ostate->compositor->outputs);
-	wlr_cursor_attach_output_layout(sample->cursor, sample->layout);
 
 	configure_devices(sample);
 
@@ -172,15 +175,6 @@ static void handle_output_remove(struct output_state *ostate) {
 	}
 }
 
-static void handle_output_resolution(struct compositor_state *state,
-		struct output_state *ostate) {
-	struct sample_state *sample = ostate->compositor->data;
-	wlr_output_layout_destroy(sample->layout);
-	sample->layout =
-        configure_layout(sample->config, &ostate->compositor->outputs);
-	wlr_cursor_attach_output_layout(sample->cursor, sample->layout);
-}
-
 static void handle_input_add(struct compositor_state *state,
         struct wlr_input_device *device) {
 	struct sample_state *sample = state->data;
@@ -341,6 +335,8 @@ int main(int argc, char *argv[]) {
 
 	state.config = parse_args(argc, argv);
 	state.cursor = wlr_cursor_create();
+	state.layout = wlr_output_layout_init();
+	wlr_cursor_attach_output_layout(state.cursor, state.layout);
 	wlr_cursor_map_to_region(state.cursor, state.config->cursor.mapped_box);
 	wl_list_init(&state.devices);
 
@@ -380,7 +376,6 @@ int main(int argc, char *argv[]) {
 	compositor.data = &state;
 	compositor.output_add_cb = handle_output_add;
 	compositor.output_remove_cb = handle_output_remove;
-	compositor.output_resolution_cb = handle_output_resolution;
 	compositor.output_frame_cb = handle_output_frame;
 	compositor.input_add_cb = handle_input_add;
 	compositor.input_remove_cb = handle_input_remove;
@@ -407,4 +402,5 @@ int main(int argc, char *argv[]) {
 	wlr_xcursor_theme_destroy(theme);
 	example_config_destroy(state.config);
 	wlr_cursor_destroy(state.cursor);
+	wlr_output_layout_destroy(state.layout);
 }

include/wlr/types/wlr_output.h

@@ -37,6 +37,7 @@ struct wlr_output {
 	struct {
 		struct wl_signal frame;
 		struct wl_signal resolution;
+		struct wl_signal destroy;
 	} events;
 
 	struct {

include/wlr/types/wlr_output_layout.h

@@ -67,4 +67,15 @@ void wlr_output_layout_closest_point(struct wlr_output_layout *layout,
 struct wlr_box *wlr_output_layout_get_box(
 		struct wlr_output_layout *layout, struct wlr_output *reference);
 
+/**
+* Add an auto configured output to the layout. This will place the output in a
+* sensible location in the layout. The coordinates of the output in the layout
+* may adjust dynamically when the layout changes. If the output is already in
+* the layout, it will become auto configured. If the position of the output is
+* set such as with `wlr_output_layout_move()`, the output will become manually
+* configured.
+*/
+void wlr_output_layout_add_auto(struct wlr_output_layout *layout,
+		struct wlr_output *output);
+
 #endif

types/wlr_output.c

@@ -100,6 +100,7 @@ void wlr_output_init(struct wlr_output *output,
 	output->scale = 1;
 	wl_signal_init(&output->events.frame);
 	wl_signal_init(&output->events.resolution);
+	wl_signal_init(&output->events.destroy);
 }
 
 void wlr_output_enable(struct wlr_output *output, bool enable) {
@@ -176,6 +177,8 @@ void wlr_output_destroy(struct wlr_output *output) {
 		return;
 	}
 
+	wl_signal_emit(&output->events.destroy, output);
+
 	wlr_texture_destroy(output->cursor.texture);
 	wlr_renderer_destroy(output->cursor.renderer);
 

types/wlr_output_layout.c

@@ -12,7 +12,14 @@ struct wlr_output_layout_state {
 };
 
 struct wlr_output_layout_output_state {
+	struct wlr_output_layout *layout;
+	struct wlr_output_layout_output *l_output;
+
 	struct wlr_box *_box;
+	bool auto_configured;
+
+	struct wl_listener resolution;
+	struct wl_listener output_destroy;
 };
 
 struct wlr_output_layout *wlr_output_layout_init() {
@@ -26,6 +33,8 @@ struct wlr_output_layout *wlr_output_layout_init() {
 
 static void wlr_output_layout_output_destroy(
 		struct wlr_output_layout_output *l_output) {
+	wl_list_remove(&l_output->state->resolution.link);
+	wl_list_remove(&l_output->state->output_destroy.link);
 	wl_list_remove(&l_output->link);
 	free(l_output->state->_box);
 	free(l_output->state);
@@ -47,16 +56,105 @@ void wlr_output_layout_destroy(struct wlr_output_layout *layout) {
 	free(layout);
 }
 
-void wlr_output_layout_add(struct wlr_output_layout *layout,
+static struct wlr_box *wlr_output_layout_output_get_box(
-		struct wlr_output *output, int x, int y) {
+		struct wlr_output_layout_output *l_output) {
+	l_output->state->_box->x = l_output->x;
+	l_output->state->_box->y = l_output->y;
+	int width, height;
+	wlr_output_effective_resolution(l_output->output, &width, &height);
+	l_output->state->_box->width = width;
+	l_output->state->_box->height = height;
+	return l_output->state->_box;
+}
+
+/**
+ * This must be called whenever the layout changes to reconfigure the auto
+ * configured outputs.
+ *
+ * Auto configured outputs are placed to the right of the north east corner of
+ * the rightmost output in the layout in a horizontal line.
+ */
+static void wlr_output_layout_reconfigure(struct wlr_output_layout *layout) {
+	int max_x = INT_MIN;
+	int max_x_y = INT_MIN; // y value for the max_x output
+
+	// find the rightmost x coordinate occupied by a manually configured output
+	// in the layout
+	struct wlr_output_layout_output *l_output;
+	wl_list_for_each(l_output, &layout->outputs, link) {
+		if (l_output->state->auto_configured) {
+			continue;
+		}
+
+		struct wlr_box *box = wlr_output_layout_output_get_box(l_output);
+		if (box->x + box->width > max_x) {
+			max_x = box->x + box->width;
+			max_x_y = box->y;
+		}
+	}
+
+	if (max_x == INT_MIN) {
+		// there are no manually configured outputs
+		max_x = 0;
+		max_x_y = 0;
+	}
+
+	wl_list_for_each(l_output, &layout->outputs, link) {
+		if (!l_output->state->auto_configured) {
+			continue;
+		}
+		struct wlr_box *box = wlr_output_layout_output_get_box(l_output);
+		l_output->x = max_x;
+		l_output->y = max_x_y;
+		max_x += box->width;
+	}
+}
+
+static void handle_output_resolution(struct wl_listener *listener, void *data) {
+	struct wlr_output_layout_output_state *state =
+		wl_container_of(listener, state, resolution);
+	wlr_output_layout_reconfigure(state->layout);
+}
+
+static void handle_output_destroy(struct wl_listener *listener, void *data) {
+	struct wlr_output_layout_output_state *state =
+		wl_container_of(listener, state, output_destroy);
+	struct wlr_output_layout *layout = state->layout;
+	wlr_output_layout_output_destroy(state->l_output);
+	wlr_output_layout_reconfigure(layout);
+}
+
+static struct wlr_output_layout_output *wlr_output_layout_output_create(
+		struct wlr_output_layout *layout, struct wlr_output *output) {
 	struct wlr_output_layout_output *l_output;
 	l_output= calloc(1, sizeof(struct wlr_output_layout_output));
 	l_output->state = calloc(1, sizeof(struct wlr_output_layout_output_state));
+	l_output->state->l_output = l_output;
 	l_output->state->_box = calloc(1, sizeof(struct wlr_box));
+	l_output->state->layout = layout;
 	l_output->output = output;
+	wl_list_insert(&layout->outputs, &l_output->link);
+
+	wl_signal_add(&output->events.resolution, &l_output->state->resolution);
+	l_output->state->resolution.notify = handle_output_resolution;
+
+	wl_signal_add(&output->events.destroy, &l_output->state->output_destroy);
+	l_output->state->output_destroy.notify = handle_output_destroy;
+
+	return l_output;
+}
+
+void wlr_output_layout_add(struct wlr_output_layout *layout,
+		struct wlr_output *output, int x, int y) {
+	struct wlr_output_layout_output *l_output =
+		wlr_output_layout_get(layout, output);
+	if (!l_output) {
+		l_output = wlr_output_layout_output_create(layout, output);
+	}
 	l_output->x = x;
 	l_output->y = y;
-	wl_list_insert(&layout->outputs, &l_output->link);
+	l_output->state->auto_configured = false;
+	wlr_output_layout_reconfigure(layout);
 }
 
 struct wlr_output_layout_output *wlr_output_layout_get(
@@ -70,20 +168,13 @@ struct wlr_output_layout_output *wlr_output_layout_get(
 	return NULL;
 }
 
-static bool output_contains_point( struct wlr_output_layout_output *l_output,
-		int x, int y, int width, int height) {
-	return x >= l_output->x && x <= l_output->x + width &&
-		y >= l_output->y && y <= l_output->y + height;
-}
-
 bool wlr_output_layout_contains_point(struct wlr_output_layout *layout,
 		struct wlr_output *reference, int x, int y) {
 	if (reference) {
-		struct wlr_output_layout_output *layout_output =
+		struct wlr_output_layout_output *l_output =
 			wlr_output_layout_get(layout, reference);
-		int width, height;
+		struct wlr_box *box = wlr_output_layout_output_get_box(l_output);
-		wlr_output_effective_resolution(layout_output->output, &width, &height);
+		return wlr_box_contains_point(box, x, y);
-		return output_contains_point(layout_output, x, y, width, height);
 	} else {
 		return !!wlr_output_layout_output_at(layout, x, y);
 	}
@@ -93,17 +184,17 @@ bool wlr_output_layout_intersects(struct wlr_output_layout *layout,
 		struct wlr_output *reference, int x1, int y1, int x2, int y2) {
 	struct wlr_output_layout_output *l_output =
 		wlr_output_layout_get(layout, reference);
+
 	if (!l_output) {
 		return false;
 	}
-	int width, height;
-	wlr_output_effective_resolution(l_output->output, &width, &height);
 
-	// the output must contain one of the points
+	// the output box must contain one of the points
-	return output_contains_point(l_output, x1, y1, width, height) ||
+	struct wlr_box *box = wlr_output_layout_output_get_box(l_output);
-		output_contains_point(l_output, x2, y2, width, height) ||
+	return wlr_box_contains_point(box, x1, y1) ||
-		output_contains_point(l_output, x2, y1, width, height) ||
+		wlr_box_contains_point(box, x2, y2) ||
-		output_contains_point(l_output, y2, x1, width, height);
+		wlr_box_contains_point(box, x2, y1) ||
+		wlr_box_contains_point(box, y2, x1);
 }
 
 struct wlr_output *wlr_output_layout_output_at(struct wlr_output_layout *layout,
@@ -111,11 +202,8 @@ struct wlr_output *wlr_output_layout_output_at(struct wlr_output_layout *layout,
 	struct wlr_output_layout_output *l_output;
 	wl_list_for_each(l_output, &layout->outputs, link) {
 		if (l_output->output) {
-			int width, height;
+			struct wlr_box *box = wlr_output_layout_output_get_box(l_output);
-			wlr_output_effective_resolution(l_output->output, &width, &height);
+			if (wlr_box_contains_point(box, x, y)) {
-			bool has_x = x >= l_output->x && x <= l_output->x + width;
-			bool has_y = y >= l_output->y && y <= l_output->y + height;
-			if (has_x && has_y) {
 				return l_output->output;
 			}
 		}
@@ -130,6 +218,10 @@ void wlr_output_layout_move(struct wlr_output_layout *layout,
 	if (l_output) {
 		l_output->x = x;
 		l_output->y = y;
+		l_output->state->auto_configured = false;
+		wlr_output_layout_reconfigure(layout);
+	} else {
+		wlr_log(L_ERROR, "output not found in this layout: %s", output->name);
 	}
 }
 
@@ -139,6 +231,7 @@ void wlr_output_layout_remove(struct wlr_output_layout *layout,
 	l_output= wlr_output_layout_get(layout, output);
 	if (l_output) {
 		wlr_output_layout_output_destroy(l_output);
+		wlr_output_layout_reconfigure(layout);
 	}
 }
 
@@ -158,15 +251,6 @@ void wlr_output_layout_output_coords(struct wlr_output_layout *layout,
 	}
 }
 
-static struct wlr_box *wlr_output_layout_output_get_box(
-		struct wlr_output_layout_output *l_output) {
-		l_output->state->_box->x = l_output->x;
-		l_output->state->_box->y = l_output->y;
-		wlr_output_effective_resolution(l_output->output,
-			&l_output->state->_box->width, &l_output->state->_box->height);
-		return l_output->state->_box;
-}
-
 void wlr_output_layout_closest_point(struct wlr_output_layout *layout,
 		struct wlr_output *reference, double x, double y, double *dest_x,
 		double *dest_y) {
@@ -201,26 +285,31 @@ struct wlr_box *wlr_output_layout_get_box(
 	struct wlr_output_layout_output *l_output;
 	if (reference) {
 		// output extents
-		l_output= wlr_output_layout_get(layout, reference);
+		l_output = wlr_output_layout_get(layout, reference);
-		return wlr_output_layout_output_get_box(l_output);
+
+		if (l_output) {
+			return wlr_output_layout_output_get_box(l_output);
+		} else {
+			return NULL;
+		}
 	} else {
 		// layout extents
 		int min_x = INT_MAX, min_y = INT_MAX;
 		int max_x = INT_MIN, max_y = INT_MIN;
 		wl_list_for_each(l_output, &layout->outputs, link) {
-			int width, height;
+			struct wlr_box *box = wlr_output_layout_output_get_box(l_output);
-			wlr_output_effective_resolution(l_output->output, &width, &height);
+
-			if (l_output->x < min_x) {
+			if (box->x < min_x) {
-				min_x = l_output->x;
+				min_x = box->x;
 			}
-			if (l_output->y < min_y) {
+			if (box->y < min_y) {
-				min_y = l_output->y;
+				min_y = box->y;
 			}
-			if (l_output->x + width > max_x) {
+			if (box->x + box->width > max_x) {
-				max_x = l_output->x + width;
+				max_x = box->x + box->width;
 			}
-			if (l_output->y + height > max_y) {
+			if (box->y + box->height > max_y) {
-				max_y = l_output->y + height;
+				max_y = box->y + box->height;
 			}
 		}
 
@@ -234,3 +323,16 @@ struct wlr_box *wlr_output_layout_get_box(
 
 	// not reached
 }
+
+void wlr_output_layout_add_auto(struct wlr_output_layout *layout,
+		struct wlr_output *output) {
+	struct wlr_output_layout_output *l_output =
+		wlr_output_layout_get(layout, output);
+
+	if (!l_output) {
+		l_output = wlr_output_layout_output_create(layout, output);
+	}
+
+	l_output->state->auto_configured = true;
+	wlr_output_layout_reconfigure(layout);
+}