Merge remote-tracking branch 'upstream/master' into output-damage

include/rootston/cursor.h

@@ -27,6 +27,8 @@ struct roots_cursor {
 	float view_rotation;
 	uint32_t resize_edges;
 
+	struct roots_seat_view *pointer_view;
+
 	struct wl_listener motion;
 	struct wl_listener motion_absolute;
 	struct wl_listener button;

include/rootston/seat.h

@@ -31,6 +31,11 @@ struct roots_seat {
 struct roots_seat_view {
 	struct roots_seat *seat;
 	struct roots_view *view;
+
+	bool has_button_grab;
+	double grab_sx;
+	double grab_sy;
+
 	struct wl_list link; // roots_seat::views
 
 	struct wl_listener view_destroy;
@@ -97,4 +102,7 @@ void roots_seat_begin_resize(struct roots_seat *seat, struct roots_view *view,
 
 void roots_seat_begin_rotate(struct roots_seat *seat, struct roots_view *view);
 
+struct roots_seat_view *roots_seat_view_from_view( struct roots_seat *seat,
+		struct roots_view *view);
+
 #endif

include/rootston/view.h

@@ -64,6 +64,10 @@ struct roots_view {
 	double x, y;
 	float rotation;
 
+	bool decorated;
+	int border_width;
+	int titlebar_height;
+
 	bool maximized;
 	struct roots_output *fullscreen_output;
 	struct {
@@ -165,6 +169,19 @@ bool view_center(struct roots_view *view);
 void view_setup(struct roots_view *view);
 void view_teardown(struct roots_view *view);
 
+void view_get_deco_box(const struct roots_view *view, struct wlr_box *box);
+
+enum roots_deco_part {
+	ROOTS_DECO_PART_NONE = 0,
+	ROOTS_DECO_PART_TOP_BORDER = (1 << 0),
+	ROOTS_DECO_PART_BOTTOM_BORDER = (1 << 1),
+	ROOTS_DECO_PART_LEFT_BORDER = (1 << 2),
+	ROOTS_DECO_PART_RIGHT_BORDER = (1 << 3),
+	ROOTS_DECO_PART_TITLEBAR = (1 << 4),
+};
+
+enum roots_deco_part view_get_deco_part(struct roots_view *view, double sx, double sy);
+
 void view_child_init(struct roots_view_child *child, struct roots_view *view,
 	struct wlr_surface *wlr_surface);
 void view_child_finish(struct roots_view_child *child);

include/wlr/render/matrix.h

@@ -2,6 +2,7 @@
 #define WLR_RENDER_MATRIX_H
 
 #include <stdint.h>
+#include <wlr/types/wlr_box.h>
 
 void wlr_matrix_identity(float (*output)[16]);
 void wlr_matrix_translate(float (*output)[16], float x, float y, float z);
@@ -14,5 +15,8 @@ void wlr_matrix_transform(float mat[static 16],
 		enum wl_output_transform transform);
 void wlr_matrix_texture(float mat[static 16], int32_t width, int32_t height,
 		enum wl_output_transform transform);
+void wlr_matrix_project_box(float (*mat)[16], struct wlr_box *box,
+		enum wl_output_transform transform, float rotation, float
+		(*projection)[16]);
 
 #endif

include/wlr/types/wlr_output.h

@@ -93,6 +93,8 @@ struct wlr_output {
 struct wlr_surface;
 
 void wlr_output_enable(struct wlr_output *output, bool enable);
+void wlr_output_create_global(struct wlr_output *output);
+void wlr_output_destroy_global(struct wlr_output *output);
 bool wlr_output_set_mode(struct wlr_output *output,
 	struct wlr_output_mode *mode);
 bool wlr_output_set_custom_mode(struct wlr_output *output, int32_t width,

render/gles2/renderer.c

@@ -188,7 +188,7 @@ static bool wlr_gles2_render_texture(struct wlr_renderer *wlr_renderer,
 static void wlr_gles2_render_quad(struct wlr_renderer *wlr_renderer,
 		const float (*color)[4], const float (*matrix)[16]) {
 	GL_CALL(glUseProgram(shaders.quad));
-	GL_CALL(glUniformMatrix4fv(0, 1, GL_TRUE, *matrix));
+	GL_CALL(glUniformMatrix4fv(0, 1, GL_FALSE, *matrix));
 	GL_CALL(glUniform4f(1, (*color)[0], (*color)[1], (*color)[2], (*color)[3]));
 	draw_quad();
 }

render/matrix.c

@@ -1,6 +1,8 @@
 #include <string.h>
 #include <math.h>
 #include <wayland-server-protocol.h>
+#include <wlr/types/wlr_box.h>
+#include <wlr/types/wlr_output.h>
 #include <wlr/render/matrix.h>
 
 /* Obtains the index for the given row/column */
@@ -158,3 +160,51 @@ void wlr_matrix_texture(float mat[static 16], int32_t width, int32_t height,
 	mat[10] = 1.0f;
 	mat[15] = 1.0f;
 }
+
+void wlr_matrix_project_box(float (*mat)[16], struct wlr_box *box,
+		enum wl_output_transform transform, float rotation,
+		float (*projection)[16]) {
+	int x = box->x;
+	int y = box->y;
+	int width = box->width;
+	int height = box->height;
+
+	wlr_matrix_translate(mat, x, y, 0);
+
+	if (rotation != 0) {
+		float translate_center[16];
+		wlr_matrix_translate(&translate_center, width/2, height/2, 0);
+
+		float rotate[16];
+		wlr_matrix_rotate(&rotate, rotation);
+
+		float translate_origin[16];
+		wlr_matrix_translate(&translate_origin, -width/2, -height/2, 0);
+
+		wlr_matrix_mul(mat, &translate_center, mat);
+		wlr_matrix_mul(mat, &rotate, mat);
+		wlr_matrix_mul(mat, &translate_origin, mat);
+	}
+
+	float scale[16];
+	wlr_matrix_scale(&scale, width, height, 1);
+
+	wlr_matrix_mul(mat, &scale, mat);
+
+	if (transform != WL_OUTPUT_TRANSFORM_NORMAL) {
+		float surface_translate_center[16];
+		wlr_matrix_translate(&surface_translate_center, 0.5, 0.5, 0);
+
+		float surface_transform[16];
+		wlr_matrix_transform(surface_transform, transform);
+
+		float surface_translate_origin[16];
+		wlr_matrix_translate(&surface_translate_origin, -0.5, -0.5, 0);
+
+		wlr_matrix_mul(mat, &surface_translate_center, mat);
+		wlr_matrix_mul(mat, &surface_transform, mat);
+		wlr_matrix_mul(mat, &surface_translate_origin, mat);
+	}
+
+	wlr_matrix_mul(projection, mat, mat);
+}

rootston/cursor.c

@@ -30,19 +30,93 @@ void roots_cursor_destroy(struct roots_cursor *cursor) {
 	// TODO
 }
 
+static void seat_view_deco_motion(struct roots_seat_view *view, double deco_sx, double deco_sy) {
+	struct roots_cursor *cursor = view->seat->cursor;
+
+	double sx = deco_sx;
+	double sy = deco_sy;
+	if (view->has_button_grab) {
+		sx = view->grab_sx;
+		sy = view->grab_sy;
+	}
+
+	enum roots_deco_part parts = view_get_deco_part(view->view, sx, sy);
+
+	bool is_titlebar = (parts & ROOTS_DECO_PART_TITLEBAR);
+	uint32_t edges = 0;
+	if (parts & ROOTS_DECO_PART_LEFT_BORDER) {
+		edges |= WLR_EDGE_LEFT;
+	} else if (parts & ROOTS_DECO_PART_RIGHT_BORDER) {
+		edges |= WLR_EDGE_RIGHT;
+	} else if (parts & ROOTS_DECO_PART_BOTTOM_BORDER) {
+		edges |= WLR_EDGE_BOTTOM;
+	} else if (parts & ROOTS_DECO_PART_TOP_BORDER) {
+		edges |= WLR_EDGE_TOP;
+	}
+
+	if (view->has_button_grab) {
+		if (is_titlebar) {
+			roots_seat_begin_move(view->seat, view->view);
+		} else if (edges) {
+			roots_seat_begin_resize(view->seat, view->view, edges);
+		}
+		view->has_button_grab = false;
+	} else {
+		if (is_titlebar) {
+			wlr_xcursor_manager_set_cursor_image(cursor->xcursor_manager,
+				cursor->default_xcursor, cursor->cursor);
+		} else if (edges) {
+			const char *resize_name = wlr_xcursor_get_resize_name(edges);
+			wlr_xcursor_manager_set_cursor_image(cursor->xcursor_manager,
+				resize_name, cursor->cursor);
+		}
+	}
+}
+
+static void seat_view_deco_leave(struct roots_seat_view *view) {
+	struct roots_cursor *cursor = view->seat->cursor;
+	wlr_xcursor_manager_set_cursor_image(cursor->xcursor_manager,
+		cursor->default_xcursor, cursor->cursor);
+	view->has_button_grab = false;
+}
+
+static void seat_view_deco_button(struct roots_seat_view *view, double sx,
+		double sy, uint32_t button, uint32_t state) {
+	if (button == BTN_LEFT && state == WLR_BUTTON_PRESSED) {
+		view->has_button_grab = true;
+		view->grab_sx = sx;
+		view->grab_sy = sy;
+	} else {
+		view->has_button_grab = false;
+	}
+
+	enum roots_deco_part parts = view_get_deco_part(view->view, sx, sy);
+	if (state == WLR_BUTTON_RELEASED && (parts & ROOTS_DECO_PART_TITLEBAR)) {
+		struct roots_cursor *cursor = view->seat->cursor;
+		wlr_xcursor_manager_set_cursor_image(cursor->xcursor_manager,
+				cursor->default_xcursor, cursor->cursor);
+	}
+}
+
 static void roots_cursor_update_position(struct roots_cursor *cursor,
 		uint32_t time) {
 	struct roots_desktop *desktop = cursor->seat->input->server->desktop;
 	struct roots_seat *seat = cursor->seat;
 	struct roots_view *view;
-	struct wlr_surface *surface;
+	struct wlr_surface *surface = NULL;
 	double sx, sy;
 	switch (cursor->mode) {
 	case ROOTS_CURSOR_PASSTHROUGH:
 		view = desktop_view_at(desktop, cursor->cursor->x, cursor->cursor->y,
 			&surface, &sx, &sy);
-		bool set_compositor_cursor = !view && cursor->cursor_client;
+		struct roots_seat_view *seat_view =
-		if (view) {
+			roots_seat_view_from_view(seat, view);
+		if (cursor->pointer_view && (surface || seat_view != cursor->pointer_view)) {
+			seat_view_deco_leave(cursor->pointer_view);
+			cursor->pointer_view = NULL;
+		}
+		bool set_compositor_cursor = !view && !surface && cursor->cursor_client;
+		if (view && surface) {
 			struct wl_client *view_client =
 				wl_resource_get_client(view->wlr_surface->resource);
 			set_compositor_cursor = view_client != cursor->cursor_client;
@@ -52,7 +126,13 @@ static void roots_cursor_update_position(struct roots_cursor *cursor,
 				cursor->default_xcursor, cursor->cursor);
 			cursor->cursor_client = NULL;
 		}
-		if (view) {
+		if (view && !surface) {
+			if (seat_view) {
+				cursor->pointer_view = seat_view;
+				seat_view_deco_motion(seat_view, sx, sy);
+			}
+		} if (view && surface) {
+			// motion over a view surface
 			wlr_seat_pointer_notify_enter(seat->seat, surface, sx, sy);
 			wlr_seat_pointer_notify_motion(seat->seat, time, sx, sy);
 		} else {
@@ -131,7 +211,7 @@ static void roots_cursor_press_button(struct roots_cursor *cursor,
 	struct roots_desktop *desktop = seat->input->server->desktop;
 	bool is_touch = device->type == WLR_INPUT_DEVICE_TOUCH;
 
-	struct wlr_surface *surface;
+	struct wlr_surface *surface = NULL;
 	double sx, sy;
 	struct roots_view *view =
 		desktop_view_at(desktop, lx, ly, &surface, &sx, &sy);
@@ -166,6 +246,13 @@ static void roots_cursor_press_button(struct roots_cursor *cursor,
 		}
 		return;
 	}
+
+	if (view && !surface) {
+		if (cursor->pointer_view) {
+			seat_view_deco_button(cursor->pointer_view, sx, sy, button, state);
+		}
+	}
+
 	if (state == WLR_BUTTON_RELEASED &&
 			cursor->mode != ROOTS_CURSOR_PASSTHROUGH) {
 		cursor->mode = ROOTS_CURSOR_PASSTHROUGH;
@@ -174,9 +261,11 @@ static void roots_cursor_press_button(struct roots_cursor *cursor,
 		}
 	}
 
+	if (view && surface) {
 		if (!is_touch) {
 			wlr_seat_pointer_notify_button(seat->seat, time, button, state);
 		}
+	}
 
 	switch (state) {
 	case WLR_BUTTON_RELEASED:

rootston/desktop.c

@@ -19,6 +19,7 @@
 #include "rootston/server.h"
 #include "rootston/seat.h"
 #include "rootston/xcursor.h"
+#include "rootston/view.h"
 
 void view_get_box(const struct roots_view *view, struct wlr_box *box) {
 	box->x = view->x;
@@ -31,6 +32,55 @@ void view_get_box(const struct roots_view *view, struct wlr_box *box) {
 	}
 }
 
+void view_get_deco_box(const struct roots_view *view, struct wlr_box *box) {
+	view_get_box(view, box);
+	if (!view->decorated) {
+		return;
+	}
+
+	box->x -= view->border_width;
+	box->y -= (view->border_width + view->titlebar_height);
+	box->width += view->border_width * 2;
+	box->height += (view->border_width * 2 + view->titlebar_height);
+}
+
+enum roots_deco_part view_get_deco_part(struct roots_view *view, double sx, double sy) {
+	if (!view->decorated) {
+		return ROOTS_DECO_PART_NONE;
+	}
+
+	int sw = view->wlr_surface->current->width;
+	int sh = view->wlr_surface->current->height;
+	int bw = view->border_width;
+	int titlebar_h = view->titlebar_height;
+
+	if (sx > 0 && sx < sw && sy < 0 && sy > -view->titlebar_height) {
+		return ROOTS_DECO_PART_TITLEBAR;
+	}
+
+	enum roots_deco_part parts = 0;
+	if (sy >= -(titlebar_h + bw) &&
+			sy <= sh + bw) {
+		if (sx < 0 && sx > -bw) {
+			parts |= ROOTS_DECO_PART_LEFT_BORDER;
+		} else if (sx > sw && sx < sw + bw) {
+			parts |= ROOTS_DECO_PART_RIGHT_BORDER;
+		}
+	}
+
+	if (sx >= -bw && sx <= sw + bw) {
+		if (sy > sh && sy <= sh + bw) {
+			parts |= ROOTS_DECO_PART_BOTTOM_BORDER;
+		} else if (sy >= -(titlebar_h + bw) && sy < 0) {
+			parts |= ROOTS_DECO_PART_TOP_BORDER;
+		}
+	}
+
+	// TODO corners
+
+	return parts;
+}
+
 static void view_update_output(const struct roots_view *view,
 		const struct wlr_box *before) {
 	struct roots_desktop *desktop = view->desktop;
@@ -468,6 +518,13 @@ static bool view_at(struct roots_view *view, double lx, double ly,
 		return true;
 	}
 
+	if (view_get_deco_part(view, view_sx, view_sy)) {
+		*sx = view_sx;
+		*sy = view_sy;
+		*surface = NULL;
+		return true;
+	}
+
 	if (wlr_box_contains_point(&box, view_sx, view_sy) &&
 			pixman_region32_contains_point(&view->wlr_surface->current->input,
 				view_sx, view_sy, NULL)) {

rootston/output.c

@@ -198,49 +198,11 @@ static void render_surface(struct wlr_surface *surface, double lx, double ly,
 		goto surface_damage_finish;
 	}
 
-	float transform[16];
-	wlr_matrix_translate(&transform, box.x, box.y, 0);
-
-	if (rotation != 0) {
-		float translate_center[16];
-		wlr_matrix_translate(&translate_center, box.width/2, box.height/2, 0);
-
-		float rotate[16];
-		wlr_matrix_rotate(&rotate, rotation);
-
-		float translate_origin[16];
-		wlr_matrix_translate(&translate_origin, -box.width/2, -box.height/2, 0);
-
-		wlr_matrix_mul(&transform, &translate_center, &transform);
-		wlr_matrix_mul(&transform, &rotate, &transform);
-		wlr_matrix_mul(&transform, &translate_origin, &transform);
-	}
-
-	float scale[16];
-	wlr_matrix_scale(&scale, box.width, box.height, 1);
-
-	wlr_matrix_mul(&transform, &scale, &transform);
-
-	if (surface->current->transform != WL_OUTPUT_TRANSFORM_NORMAL) {
-		float surface_translate_center[16];
-		wlr_matrix_translate(&surface_translate_center, 0.5, 0.5, 0);
-
-		float surface_transform[16];
-		wlr_matrix_transform(surface_transform,
-			wlr_output_transform_invert(surface->current->transform));
-
-		float surface_translate_origin[16];
-		wlr_matrix_translate(&surface_translate_origin, -0.5, -0.5, 0);
-
-		wlr_matrix_mul(&transform, &surface_translate_center,
-			&transform);
-		wlr_matrix_mul(&transform, &surface_transform, &transform);
-		wlr_matrix_mul(&transform, &surface_translate_origin,
-			&transform);
-	}
-
 	float matrix[16];
-	wlr_matrix_mul(&output->wlr_output->transform_matrix, &transform, &matrix);
+	enum wl_output_transform transform =
+		wlr_output_transform_invert(surface->current->transform);
+	wlr_matrix_project_box(&matrix, &box, transform, rotation,
+		&output->wlr_output->transform_matrix);
 
 	int nrects;
 	pixman_box32_t *rects =
@@ -263,6 +225,46 @@ surface_damage_finish:
 	pixman_region32_fini(&surface_damage);
 }
 
+static void render_decorations(struct roots_view *view,
+		struct render_data *data) {
+	if (!view->decorated) {
+		return;
+	}
+
+	struct roots_output *output = data->output;
+	struct wlr_output *wlr_output = output->wlr_output;
+
+	struct wlr_box deco_box;
+	view_get_deco_box(view, &deco_box);
+	double sx = deco_box.x - view->x;
+	double sy = deco_box.y - view->y;
+	rotate_child_position(&sx, &sy, deco_box.width, deco_box.height,
+		view->wlr_surface->current->width,
+		view->wlr_surface->current->height, view->rotation);
+	double x = sx + view->x;
+	double y = sy + view->y;
+
+	wlr_output_layout_output_coords(output->desktop->layout, wlr_output, &x, &y);
+
+	struct wlr_box box = {
+		.x = x * wlr_output->scale,
+		.y = y * wlr_output->scale,
+		.width = deco_box.width * wlr_output->scale,
+		.height = deco_box.height * wlr_output->scale,
+	};
+
+	float matrix[16];
+	wlr_matrix_project_box(&matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL,
+		view->rotation, &wlr_output->transform_matrix);
+	float color[4] = { 0.2, 0.2, 0.2, 1 };
+	wlr_render_colored_quad(output->desktop->server->renderer, &color, &matrix);
+}
+
+static void render_view(struct roots_view *view, struct render_data *data) {
+	render_decorations(view, data);
+	view_for_each_surface(view, render_surface, data);
+}
+
 static bool has_standalone_surface(struct roots_view *view) {
 	if (!wl_list_empty(&view->wlr_surface->subsurface_list)) {
 		return false;
@@ -402,7 +404,7 @@ static void render_output(struct roots_output *output) {
 	// Render all views
 	struct roots_view *view;
 	wl_list_for_each_reverse(view, &desktop->views, link) {
-		view_for_each_surface(view, render_surface, &data);
+		render_view(view, &data);
 	}
 
 	// Render drag icons

rootston/seat.c

@@ -597,6 +597,10 @@ static void seat_view_destroy(struct roots_seat_view *seat_view) {
 		seat->cursor->mode = ROOTS_CURSOR_PASSTHROUGH;
 	}
 
+	if (seat_view == seat->cursor->pointer_view) {
+		seat->cursor->pointer_view = NULL;
+	}
+
 	wl_list_remove(&seat_view->view_destroy.link);
 	wl_list_remove(&seat_view->link);
 	free(seat_view);
@@ -625,7 +629,7 @@ static struct roots_seat_view *seat_add_view(struct roots_seat *seat,
 	seat_view->seat = seat;
 	seat_view->view = view;
 
-	wl_list_insert(&seat->views, &seat_view->link);
+	wl_list_insert(seat->views.prev, &seat_view->link);
 
 	seat_view->view_destroy.notify = seat_view_handle_destroy;
 	wl_signal_add(&view->events.destroy, &seat_view->view_destroy);
@@ -633,6 +637,31 @@ static struct roots_seat_view *seat_add_view(struct roots_seat *seat,
 	return seat_view;
 }
 
+struct roots_seat_view *roots_seat_view_from_view(
+		struct roots_seat *seat, struct roots_view *view) {
+	if (view == NULL) {
+		return NULL;
+	}
+
+	bool found = false;
+	struct roots_seat_view *seat_view = NULL;
+	wl_list_for_each(seat_view, &seat->views, link) {
+		if (seat_view->view == view) {
+			found = true;
+			break;
+		}
+	}
+	if (!found) {
+		seat_view = seat_add_view(seat, view);
+		if (seat_view == NULL) {
+			wlr_log(L_ERROR, "Allocation failed");
+			return NULL;
+		}
+	}
+
+	return seat_view;
+}
+
 void roots_seat_set_focus(struct roots_seat *seat, struct roots_view *view) {
 	// Make sure the view will be rendered on top of others, even if it's
 	// already focused in this seat
@@ -650,24 +679,13 @@ void roots_seat_set_focus(struct roots_seat *seat, struct roots_view *view) {
 			view->xwayland_surface->override_redirect) {
 		return;
 	}
-
 	struct roots_seat_view *seat_view = NULL;
 	if (view != NULL) {
-		bool found = false;
+		seat_view = roots_seat_view_from_view(seat, view);
-		wl_list_for_each(seat_view, &seat->views, link) {
-			if (seat_view->view == view) {
-				found = true;
-				break;
-			}
-		}
-		if (!found) {
-			seat_view = seat_add_view(seat, view);
 		if (seat_view == NULL) {
-				wlr_log(L_ERROR, "Allocation failed");
 			return;
 		}
 	}
-	}
 
 	seat->has_focus = false;
 

rootston/xwayland.c

@@ -314,6 +314,7 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
 	view->type = ROOTS_XWAYLAND_VIEW;
 	view->x = (double)surface->x;
 	view->y = (double)surface->y;
+
 	view->xwayland_surface = surface;
 	view->roots_xwayland_surface = roots_surface;
 	view->wlr_surface = surface->surface;
@@ -329,6 +330,12 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
 	wl_list_insert(&desktop->views, &view->link);
 
 	if (!surface->override_redirect) {
+		if (surface->decorations == WLR_XWAYLAND_SURFACE_DECORATIONS_ALL) {
+			view->decorated = true;
+			view->border_width = 4;
+			view->titlebar_height = 12;
+		}
+
 		view_setup(view);
 	}
 }

types/wlr_cursor.c

@@ -510,7 +510,7 @@ void wlr_cursor_detach_input_device(struct wlr_cursor *cur,
 
 static void handle_layout_destroy(struct wl_listener *listener, void *data) {
 	struct wlr_cursor_state *state =
-		wl_container_of(listener, state, layout_change);
+		wl_container_of(listener, state, layout_destroy);
 	wlr_cursor_detach_output_layout(state->cursor);
 }
 

types/wlr_output.c

@@ -113,7 +113,7 @@ static void wl_output_bind(struct wl_client *wl_client, void *data,
 	wl_output_send_to_resource(wl_resource);
 }
 
-static void wlr_output_create_global(struct wlr_output *output) {
+void wlr_output_create_global(struct wlr_output *output) {
 	if (output->wl_global != NULL) {
 		return;
 	}
@@ -122,7 +122,7 @@ static void wlr_output_create_global(struct wlr_output *output) {
 	output->wl_global = wl_global;
 }
 
-static void wlr_output_destroy_global(struct wlr_output *output) {
+void wlr_output_destroy_global(struct wlr_output *output) {
 	if (output->wl_global == NULL) {
 		return;
 	}
@@ -140,13 +140,6 @@ void wlr_output_update_enabled(struct wlr_output *output, bool enabled) {
 	}
 
 	output->enabled = enabled;
-
-	if (enabled) {
-		wlr_output_create_global(output);
-	} else {
-		wlr_output_destroy_global(output);
-	}
-
 	wl_signal_emit(&output->events.enable, output);
 }
 

types/wlr_output_layout.c

@@ -203,6 +203,7 @@ void wlr_output_layout_add(struct wlr_output_layout *layout,
 	l_output->y = y;
 	l_output->state->auto_configured = false;
 	wlr_output_layout_reconfigure(layout);
+	wlr_output_create_global(output);
 	wl_signal_emit(&layout->events.add, l_output);
 }
 
@@ -289,6 +290,7 @@ void wlr_output_layout_remove(struct wlr_output_layout *layout,
 		wlr_output_layout_output_destroy(l_output);
 		wlr_output_layout_reconfigure(layout);
 	}
+	wlr_output_destroy_global(output);
 }
 
 void wlr_output_layout_output_coords(struct wlr_output_layout *layout,
@@ -394,6 +396,7 @@ void wlr_output_layout_add_auto(struct wlr_output_layout *layout,
 
 	l_output->state->auto_configured = true;
 	wlr_output_layout_reconfigure(layout);
+	wlr_output_create_global(output);
 	wl_signal_emit(&layout->events.add, l_output);
 }