Merge pull request #570 from acrisci/decorations

Decorations

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

@@ -28,6 +28,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;
@@ -84,4 +89,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

@@ -61,6 +61,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 {
@@ -126,4 +130,17 @@ 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);
+
 #endif

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

render/gles2/renderer.c

@@ -177,7 +177,7 @@ static bool wlr_gles2_render_texture(struct wlr_renderer *_renderer,
 static void wlr_gles2_render_quad(struct wlr_renderer *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,50 @@ 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;
+
+	float translate_center[16];
+	wlr_matrix_translate(&translate_center,
+			(int)x + width / 2, (int)y + 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);
+
+	float scale[16];
+	wlr_matrix_scale(&scale, width, height, 1);
+
+	wlr_matrix_mul(&translate_center, &rotate, mat);
+	wlr_matrix_mul(mat, &translate_origin, mat);
+	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,
+				wlr_output_transform_invert(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;
-		if (view) {
+		struct roots_seat_view *seat_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;
@@ -347,6 +397,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

@@ -52,47 +52,15 @@ static void render_surface(struct wlr_surface *surface,
 		.width = render_width, .height = render_height,
 	};
 	if (wlr_output_layout_intersects(desktop->layout, wlr_output, &render_box)) {
+		struct wlr_box project_box = {
+			.x = ox,
+			.y = oy,
+			.width = render_width,
+			.height = render_height,
+		};
 		float matrix[16];
-
-		float translate_center[16];
-		wlr_matrix_translate(&translate_center,
-			(int)ox + render_width / 2, (int)oy + render_height / 2, 0);
-
-		float rotate[16];
-		wlr_matrix_rotate(&rotate, rotation);
-
-		float translate_origin[16];
-		wlr_matrix_translate(&translate_origin, -render_width / 2,
-			-render_height / 2, 0);
-
-		float scale[16];
-		wlr_matrix_scale(&scale, render_width, render_height, 1);
-
-		float transform[16];
-		wlr_matrix_mul(&translate_center, &rotate, &transform);
-		wlr_matrix_mul(&transform, &translate_origin, &transform);
-		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);
-		}
-
-		wlr_matrix_mul(&wlr_output->transform_matrix, &transform, &matrix);
-
+		wlr_matrix_project_box(&matrix, &project_box, surface->current->transform,
+			rotation, &wlr_output->transform_matrix);
 		wlr_render_with_matrix(desktop->server->renderer, surface->texture,
 			&matrix);
 
@@ -182,8 +150,43 @@ static void render_xwayland_children(struct wlr_xwayland_surface *surface,
 	}
 }
 
+static void render_decorations(struct roots_view *view,
+		struct roots_desktop *desktop, struct wlr_output *output) {
+	if (!view->decorated) {
+		return;
+	}
+	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 ox = sx + view->x;
+	double oy = sy + view->y;
+
+	wlr_output_layout_output_coords(desktop->layout, output, &ox, &oy);
+	ox *= output->scale;
+	oy *= output->scale;
+
+	struct wlr_box project_box = {
+		.x = ox,
+		.y = oy,
+		.width = deco_box.width,
+		.height = deco_box.height,
+	};
+
+	float matrix[16];
+	wlr_matrix_project_box(&matrix, &project_box, WL_OUTPUT_TRANSFORM_NORMAL,
+		view->rotation, &output->transform_matrix);
+	float color[4] = { 0.2, 0.2, 0.2, 1 };
+	wlr_render_colored_quad(desktop->server->renderer, &color, &matrix);
+}
+
 static void render_view(struct roots_view *view, struct roots_desktop *desktop,
 		struct wlr_output *wlr_output, struct timespec *when) {
+	render_decorations(view, desktop, wlr_output);
+
 	switch (view->type) {
 	case ROOTS_XDG_SHELL_V6_VIEW:
 		render_surface(view->wlr_surface, desktop, wlr_output, when,

rootston/seat.c

@@ -573,6 +573,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);
@@ -601,7 +605,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);
@@ -609,6 +613,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
@@ -626,24 +655,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;
-		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);
+		seat_view = roots_seat_view_from_view(seat, view);
 		if (seat_view == NULL) {
-				wlr_log(L_ERROR, "Allocation failed");
 			return;
 		}
 	}
-	}
 
 	seat->has_focus = false;
 

rootston/xwayland.c

@@ -296,6 +296,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;
@@ -311,6 +312,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);
 	}
 }