aboutsummaryrefslogtreecommitdiff
path: root/rootston
diff options
context:
space:
mode:
Diffstat (limited to 'rootston')
-rw-r--r--rootston/cursor.c7
-rw-r--r--rootston/desktop.c178
-rw-r--r--rootston/meson.build2
-rw-r--r--rootston/output.c673
-rw-r--r--rootston/seat.c99
-rw-r--r--rootston/wl_shell.c92
-rw-r--r--rootston/xdg_shell_v6.c103
-rw-r--r--rootston/xwayland.c61
8 files changed, 994 insertions, 221 deletions
diff --git a/rootston/cursor.c b/rootston/cursor.c
index 87391e29..ab32a5de 100644
--- a/rootston/cursor.c
+++ b/rootston/cursor.c
@@ -138,6 +138,11 @@ static void roots_cursor_update_position(struct roots_cursor *cursor,
} else {
wlr_seat_pointer_clear_focus(seat->seat);
}
+
+ struct roots_drag_icon *drag_icon;
+ wl_list_for_each(drag_icon, &seat->drag_icons, link) {
+ roots_drag_icon_update_position(drag_icon);
+ }
break;
case ROOTS_CURSOR_MOVE:
view = roots_seat_get_focus(seat);
@@ -198,7 +203,7 @@ static void roots_cursor_update_position(struct roots_cursor *cursor,
float angle = atan2(vx*uy - vy*ux, vx*ux + vy*uy);
int steps = 12;
angle = round(angle/M_PI*steps) / (steps/M_PI);
- view->rotation = cursor->view_rotation + angle;
+ view_rotate(view, cursor->view_rotation + angle);
}
break;
}
diff --git a/rootston/desktop.c b/rootston/desktop.c
index 435e9426..91661c05 100644
--- a/rootston/desktop.c
+++ b/rootston/desktop.c
@@ -24,12 +24,8 @@
void view_get_box(const struct roots_view *view, struct wlr_box *box) {
box->x = view->x;
box->y = view->y;
- if (view->get_size) {
- view->get_size(view, box);
- } else {
- box->width = view->wlr_surface->current->width;
- box->height = view->wlr_surface->current->height;
- }
+ box->width = view->width;
+ box->height = view->height;
}
void view_get_deco_box(const struct roots_view *view, struct wlr_box *box) {
@@ -111,8 +107,7 @@ void view_move(struct roots_view *view, double x, double y) {
if (view->move) {
view->move(view, x, y);
} else {
- view->x = x;
- view->y = y;
+ view_update_position(view, x, y);
}
view_update_output(view, &before);
}
@@ -195,7 +190,7 @@ void view_maximize(struct roots_view *view, bool maximized) {
view_move_resize(view, output_box->x, output_box->y, output_box->width,
output_box->height);
- view->rotation = 0;
+ view_rotate(view, 0);
}
if (view->maximized && !maximized) {
@@ -203,7 +198,7 @@ void view_maximize(struct roots_view *view, bool maximized) {
view_move_resize(view, view->saved.x, view->saved.y, view->saved.width,
view->saved.height);
- view->rotation = view->saved.rotation;
+ view_rotate(view, view->saved.rotation);
}
}
@@ -244,22 +239,34 @@ void view_set_fullscreen(struct roots_view *view, bool fullscreen,
wlr_output_layout_get_box(view->desktop->layout, output);
view_move_resize(view, output_box->x, output_box->y, output_box->width,
output_box->height);
- view->rotation = 0;
+ view_rotate(view, 0);
roots_output->fullscreen_view = view;
view->fullscreen_output = roots_output;
+ output_damage_whole(roots_output);
}
if (was_fullscreen && !fullscreen) {
view_move_resize(view, view->saved.x, view->saved.y, view->saved.width,
view->saved.height);
- view->rotation = view->saved.rotation;
+ view_rotate(view, view->saved.rotation);
+ output_damage_whole(view->fullscreen_output);
view->fullscreen_output->fullscreen_view = NULL;
view->fullscreen_output = NULL;
}
}
+void view_rotate(struct roots_view *view, float rotation) {
+ if (view->rotation == rotation) {
+ return;
+ }
+
+ view_damage_whole(view);
+ view->rotation = rotation;
+ view_damage_whole(view);
+}
+
void view_close(struct roots_view *view) {
if (view->close) {
view->close(view);
@@ -305,19 +312,116 @@ bool view_center(struct roots_view *view) {
return true;
}
-void view_destroy(struct roots_view *view) {
+void view_child_finish(struct roots_view_child *child) {
+ if (child == NULL) {
+ return;
+ }
+ view_damage_whole(child->view);
+ wl_list_remove(&child->link);
+ wl_list_remove(&child->commit.link);
+ wl_list_remove(&child->new_subsurface.link);
+}
+
+static void view_child_handle_commit(struct wl_listener *listener,
+ void *data) {
+ struct roots_view_child *child = wl_container_of(listener, child, commit);
+ view_apply_damage(child->view);
+}
+
+static void view_child_handle_new_subsurface(struct wl_listener *listener,
+ void *data) {
+ struct roots_view_child *child =
+ wl_container_of(listener, child, new_subsurface);
+ struct wlr_subsurface *wlr_subsurface = data;
+ subsurface_create(child->view, wlr_subsurface);
+}
+
+void view_child_init(struct roots_view_child *child, struct roots_view *view,
+ struct wlr_surface *wlr_surface) {
+ assert(child->destroy);
+ child->view = view;
+ child->wlr_surface = wlr_surface;
+ child->commit.notify = view_child_handle_commit;
+ wl_signal_add(&wlr_surface->events.commit, &child->commit);
+ child->new_subsurface.notify = view_child_handle_new_subsurface;
+ wl_signal_add(&wlr_surface->events.new_subsurface, &child->new_subsurface);
+ wl_list_insert(&view->children, &child->link);
+}
+
+static void subsurface_destroy(struct roots_view_child *child) {
+ assert(child->destroy == subsurface_destroy);
+ struct roots_subsurface *subsurface = (struct roots_subsurface *)child;
+ if (subsurface == NULL) {
+ return;
+ }
+ wl_list_remove(&subsurface->destroy.link);
+ view_child_finish(&subsurface->view_child);
+ free(subsurface);
+}
+
+static void subsurface_handle_destroy(struct wl_listener *listener,
+ void *data) {
+ struct roots_subsurface *subsurface =
+ wl_container_of(listener, subsurface, destroy);
+ subsurface_destroy((struct roots_view_child *)subsurface);
+}
+
+struct roots_subsurface *subsurface_create(struct roots_view *view,
+ struct wlr_subsurface *wlr_subsurface) {
+ struct roots_subsurface *subsurface =
+ calloc(1, sizeof(struct roots_subsurface));
+ if (subsurface == NULL) {
+ return NULL;
+ }
+ subsurface->wlr_subsurface = wlr_subsurface;
+ subsurface->view_child.destroy = subsurface_destroy;
+ view_child_init(&subsurface->view_child, view, wlr_subsurface->surface);
+ subsurface->destroy.notify = subsurface_handle_destroy;
+ wl_signal_add(&wlr_subsurface->events.destroy, &subsurface->destroy);
+ return subsurface;
+}
+
+void view_finish(struct roots_view *view) {
+ view_damage_whole(view);
wl_signal_emit(&view->events.destroy, view);
+ wl_list_remove(&view->new_subsurface.link);
+
+ struct roots_view_child *child, *tmp;
+ wl_list_for_each_safe(child, tmp, &view->children, link) {
+ child->destroy(child);
+ }
+
if (view->fullscreen_output) {
view->fullscreen_output->fullscreen_view = NULL;
}
+}
- free(view);
+static void view_handle_new_subsurface(struct wl_listener *listener,
+ void *data) {
+ struct roots_view *view = wl_container_of(listener, view, new_subsurface);
+ struct wlr_subsurface *wlr_subsurface = data;
+ subsurface_create(view, wlr_subsurface);
}
void view_init(struct roots_view *view, struct roots_desktop *desktop) {
+ assert(view->wlr_surface);
+
view->desktop = desktop;
wl_signal_init(&view->events.destroy);
+ wl_list_init(&view->children);
+
+ struct wlr_subsurface *subsurface;
+ wl_list_for_each(subsurface, &view->wlr_surface->subsurface_list,
+ parent_link) {
+ subsurface_create(view, subsurface);
+ }
+
+ view->new_subsurface.notify = view_handle_new_subsurface;
+ wl_signal_add(&view->wlr_surface->events.new_subsurface,
+ &view->new_subsurface);
+
+ view_damage_whole(view);
}
void view_setup(struct roots_view *view) {
@@ -332,6 +436,42 @@ void view_setup(struct roots_view *view) {
view_update_output(view, NULL);
}
+void view_apply_damage(struct roots_view *view) {
+ struct roots_output *output;
+ wl_list_for_each(output, &view->desktop->outputs, link) {
+ output_damage_from_view(output, view);
+ }
+}
+
+void view_damage_whole(struct roots_view *view) {
+ struct roots_output *output;
+ wl_list_for_each(output, &view->desktop->outputs, link) {
+ output_damage_whole_view(output, view);
+ }
+}
+
+void view_update_position(struct roots_view *view, double x, double y) {
+ if (view->x == x && view->y == y) {
+ return;
+ }
+
+ view_damage_whole(view);
+ view->x = x;
+ view->y = y;
+ view_damage_whole(view);
+}
+
+void view_update_size(struct roots_view *view, uint32_t width, uint32_t height) {
+ if (view->width == width && view->height == height) {
+ return;
+ }
+
+ view_damage_whole(view);
+ view->width = width;
+ view->height = height;
+ view_damage_whole(view);
+}
+
static bool view_at(struct roots_view *view, double lx, double ly,
struct wlr_surface **surface, double *sx, double *sy) {
if (view->type == ROOTS_WL_SHELL_VIEW &&
@@ -569,11 +709,11 @@ void desktop_destroy(struct roots_desktop *desktop) {
}
struct roots_output *desktop_output_from_wlr_output(
- struct roots_desktop *desktop, struct wlr_output *output) {
- struct roots_output *roots_output;
- wl_list_for_each(roots_output, &desktop->outputs, link) {
- if (roots_output->wlr_output == output) {
- return roots_output;
+ struct roots_desktop *desktop, struct wlr_output *wlr_output) {
+ struct roots_output *output;
+ wl_list_for_each(output, &desktop->outputs, link) {
+ if (output->wlr_output == wlr_output) {
+ return output;
}
}
return NULL;
diff --git a/rootston/meson.build b/rootston/meson.build
index 36b6241a..973f93a4 100644
--- a/rootston/meson.build
+++ b/rootston/meson.build
@@ -15,5 +15,5 @@ if get_option('enable_xwayland')
sources += ['xwayland.c']
endif
executable(
- 'rootston', sources, dependencies: [wlroots, wlr_protos]
+ 'rootston', sources, dependencies: [wlroots, wlr_protos, pixman]
)
diff --git a/rootston/output.c b/rootston/output.c
index 1fb848b9..0e0c6114 100644
--- a/rootston/output.c
+++ b/rootston/output.c
@@ -2,17 +2,21 @@
#include <time.h>
#include <stdlib.h>
#include <stdbool.h>
-#include <GLES2/gl2.h>
+#include <assert.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_compositor.h>
#include <wlr/types/wlr_wl_shell.h>
#include <wlr/types/wlr_xdg_shell_v6.h>
#include <wlr/render/matrix.h>
#include <wlr/util/log.h>
+#include <wlr/util/region.h>
#include "rootston/server.h"
-#include "rootston/desktop.h"
+#include "rootston/output.h"
#include "rootston/config.h"
+typedef void (*surface_iterator_func_t)(struct wlr_surface *surface,
+ double lx, double ly, float rotation, void *data);
+
/**
* Rotate a child's position relative to a parent. The parent size is (pw, ph),
* the child position is (*sx, *sy) and its size is (sw, sh).
@@ -31,66 +35,33 @@ static void rotate_child_position(double *sx, double *sy, double sw, double sh,
}
}
-static void render_surface(struct wlr_surface *surface,
- struct roots_desktop *desktop, struct wlr_output *wlr_output,
- struct timespec *when, double lx, double ly, float rotation) {
- if (!wlr_surface_has_buffer(surface)) {
- return;
- }
-
- int width = surface->current->width;
- int height = surface->current->height;
- int render_width = width * wlr_output->scale;
- int render_height = height * wlr_output->scale;
- double ox = lx, oy = ly;
- wlr_output_layout_output_coords(desktop->layout, wlr_output, &ox, &oy);
- ox *= wlr_output->scale;
- oy *= wlr_output->scale;
-
- struct wlr_box render_box = {
- .x = lx, .y = ly,
- .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];
- 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);
-
- wlr_surface_send_frame_done(surface, when);
- }
+static void surface_for_each_surface(struct wlr_surface *surface, double lx,
+ double ly, float rotation, surface_iterator_func_t iterator,
+ void *user_data) {
+ iterator(surface, lx, ly, rotation, user_data);
struct wlr_subsurface *subsurface;
wl_list_for_each(subsurface, &surface->subsurface_list, parent_link) {
struct wlr_surface_state *state = subsurface->surface->current;
double sx = state->subsurface_position.x;
double sy = state->subsurface_position.y;
- double sw = state->buffer_width / state->scale;
- double sh = state->buffer_height / state->scale;
- rotate_child_position(&sx, &sy, sw, sh, width, height, rotation);
+ rotate_child_position(&sx, &sy, state->width, state->height,
+ surface->current->width, surface->current->height, rotation);
- render_surface(subsurface->surface, desktop, wlr_output, when,
- lx + sx,
- ly + sy,
- rotation);
+ surface_for_each_surface(subsurface->surface, lx + sx, ly + sy,
+ rotation, iterator, user_data);
}
}
-static void render_xdg_v6_popups(struct wlr_xdg_surface_v6 *surface,
- struct roots_desktop *desktop, struct wlr_output *wlr_output,
- struct timespec *when, double base_x, double base_y, float rotation) {
+static void xdg_surface_v6_for_each_surface(struct wlr_xdg_surface_v6 *surface,
+ double base_x, double base_y, float rotation,
+ surface_iterator_func_t iterator, void *user_data) {
double width = surface->surface->current->width;
double height = surface->surface->current->height;
- struct wlr_xdg_surface_v6 *popup;
- wl_list_for_each(popup, &surface->popups, popup_link) {
+ struct wlr_xdg_popup_v6 *popup_state;
+ wl_list_for_each(popup_state, &surface->popups, link) {
+ struct wlr_xdg_surface_v6 *popup = popup_state->base;
if (!popup->configured) {
continue;
}
@@ -103,20 +74,20 @@ static void render_xdg_v6_popups(struct wlr_xdg_surface_v6 *surface,
rotate_child_position(&popup_sx, &popup_sy, popup_width, popup_height,
width, height, rotation);
- render_surface(popup->surface, desktop, wlr_output, when,
- base_x + popup_sx, base_y + popup_sy, rotation);
- render_xdg_v6_popups(popup, desktop, wlr_output, when,
- base_x + popup_sx, base_y + popup_sy, rotation);
+ surface_for_each_surface(popup->surface, base_x + popup_sx,
+ base_y + popup_sy, rotation, iterator, user_data);
+ xdg_surface_v6_for_each_surface(popup, base_x + popup_sx,
+ base_y + popup_sy, rotation, iterator, user_data);
}
}
-static void render_wl_shell_surface(struct wlr_wl_shell_surface *surface,
- struct roots_desktop *desktop, struct wlr_output *wlr_output,
- struct timespec *when, double lx, double ly, float rotation,
- bool is_child) {
+static void wl_shell_surface_for_each_surface(
+ struct wlr_wl_shell_surface *surface, double lx, double ly,
+ float rotation, bool is_child, surface_iterator_func_t iterator,
+ void *user_data) {
if (is_child || surface->state != WLR_WL_SHELL_SURFACE_STATE_POPUP) {
- render_surface(surface->surface, desktop, wlr_output, when,
- lx, ly, rotation);
+ surface_for_each_surface(surface->surface, lx, ly, rotation, iterator,
+ user_data);
double width = surface->surface->current->width;
double height = surface->surface->current->height;
@@ -131,32 +102,160 @@ static void render_wl_shell_surface(struct wlr_wl_shell_surface *surface,
rotate_child_position(&popup_x, &popup_y, popup_width, popup_height,
width, height, rotation);
- render_wl_shell_surface(popup, desktop, wlr_output, when,
- lx + popup_x, ly + popup_y, rotation, true);
+ wl_shell_surface_for_each_surface(popup, lx + popup_x, ly + popup_y,
+ rotation, true, iterator, user_data);
}
}
}
+static void view_for_each_surface(struct roots_view *view,
+ surface_iterator_func_t iterator, void *user_data) {
+ switch (view->type) {
+ case ROOTS_XDG_SHELL_V6_VIEW:
+ surface_for_each_surface(view->wlr_surface, view->x, view->y,
+ view->rotation, iterator, user_data);
+ xdg_surface_v6_for_each_surface(view->xdg_surface_v6, view->x, view->y,
+ view->rotation, iterator, user_data);
+ break;
+ case ROOTS_WL_SHELL_VIEW:
+ wl_shell_surface_for_each_surface(view->wl_shell_surface, view->x,
+ view->y, view->rotation, false, iterator, user_data);
+ break;
+#ifdef WLR_HAS_XWAYLAND
+ case ROOTS_XWAYLAND_VIEW:
+ if (view->wlr_surface != NULL) {
+ surface_for_each_surface(view->wlr_surface, view->x, view->y,
+ view->rotation, iterator, user_data);
+ }
+ break;
+#endif
+ }
+}
+
#ifdef WLR_HAS_XWAYLAND
-static void render_xwayland_children(struct wlr_xwayland_surface *surface,
- struct roots_desktop *desktop, struct wlr_output *wlr_output,
- struct timespec *when) {
+static void xwayland_children_for_each_surface(
+ struct wlr_xwayland_surface *surface,
+ surface_iterator_func_t iterator, void *user_data) {
struct wlr_xwayland_surface *child;
wl_list_for_each(child, &surface->children, parent_link) {
if (child->surface != NULL && child->added) {
- render_surface(child->surface, desktop, wlr_output, when,
- child->x, child->y, 0);
+ surface_for_each_surface(child->surface, child->x, child->y, 0,
+ iterator, user_data);
}
- render_xwayland_children(child, desktop, wlr_output, when);
+ xwayland_children_for_each_surface(child, iterator, user_data);
}
}
#endif
-static void render_decorations(struct roots_view *view,
- struct roots_desktop *desktop, struct wlr_output *output) {
- if (!view->decorated) {
+
+struct render_data {
+ struct roots_output *output;
+ struct timespec *when;
+ pixman_region32_t *damage;
+};
+
+/**
+ * Checks whether a surface at (lx, ly) intersects an output. Sets `box` to the
+ * surface box in the output, in output-local coordinates.
+ */
+static bool surface_intersect_output(struct wlr_surface *surface,
+ struct wlr_output_layout *output_layout, struct wlr_output *wlr_output,
+ double lx, double ly, float rotation, struct wlr_box *box) {
+ double ox = lx, oy = ly;
+ wlr_output_layout_output_coords(output_layout, wlr_output, &ox, &oy);
+ box->x = ox * wlr_output->scale;
+ box->y = oy * wlr_output->scale;
+ box->width = surface->current->width * wlr_output->scale;
+ box->height = surface->current->height * wlr_output->scale;
+
+ struct wlr_box layout_box = {
+ .x = lx, .y = ly,
+ .width = surface->current->width, .height = surface->current->height,
+ };
+ wlr_box_rotated_bounds(&layout_box, -rotation, &layout_box);
+ return wlr_output_layout_intersects(output_layout, wlr_output, &layout_box);
+}
+
+static void scissor_output(struct roots_output *output, pixman_box32_t *rect) {
+ struct wlr_output *wlr_output = output->wlr_output;
+ struct wlr_renderer *renderer = wlr_backend_get_renderer(wlr_output->backend);
+ assert(renderer);
+
+ struct wlr_box box = {
+ .x = rect->x1,
+ .y = rect->y1,
+ .width = rect->x2 - rect->x1,
+ .height = rect->y2 - rect->y1,
+ };
+
+ int ow, oh;
+ wlr_output_transformed_resolution(output->wlr_output, &ow, &oh);
+
+ // Scissor is in renderer coordinates, ie. upside down
+ enum wl_output_transform transform = wlr_output_transform_compose(
+ wlr_output_transform_invert(wlr_output->transform),
+ WL_OUTPUT_TRANSFORM_FLIPPED_180);
+ wlr_box_transform(&box, transform, ow, oh, &box);
+
+ wlr_renderer_scissor(renderer, &box);
+}
+
+static void render_surface(struct wlr_surface *surface, double lx, double ly,
+ float rotation, void *_data) {
+ struct render_data *data = _data;
+ struct roots_output *output = data->output;
+ struct timespec *when = data->when;
+ struct wlr_renderer *renderer =
+ wlr_backend_get_renderer(output->wlr_output->backend);
+ assert(renderer);
+
+ if (!wlr_surface_has_buffer(surface)) {
+ return;
+ }
+
+ struct wlr_box box;
+ bool intersects = surface_intersect_output(surface, output->desktop->layout,
+ output->wlr_output, lx, ly, rotation, &box);
+ if (!intersects) {
return;
}
+
+ struct wlr_box rotated;
+ wlr_box_rotated_bounds(&box, -rotation, &rotated);
+
+ pixman_region32_t damage;
+ pixman_region32_init(&damage);
+ pixman_region32_union_rect(&damage, &damage, rotated.x, rotated.y,
+ rotated.width, rotated.height);
+ pixman_region32_intersect(&damage, &damage, data->damage);
+ bool damaged = pixman_region32_not_empty(&damage);
+ if (!damaged) {
+ goto damage_finish;
+ }
+
+ float matrix[16];
+ 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 = pixman_region32_rectangles(&damage, &nrects);
+ for (int i = 0; i < nrects; ++i) {
+ scissor_output(output, &rects[i]);
+ wlr_render_with_matrix(renderer, surface->texture, &matrix);
+ }
+
+ wlr_surface_send_frame_done(surface, when);
+
+damage_finish:
+ pixman_region32_fini(&damage);
+}
+
+static void get_decoration_box(struct roots_view *view,
+ struct roots_output *output, struct wlr_box *box) {
+ 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;
@@ -164,49 +263,70 @@ static void render_decorations(struct roots_view *view,
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,
- };
+ double x = sx + view->x;
+ double y = sy + view->y;
- 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);
+ wlr_output_layout_output_coords(output->desktop->layout, wlr_output, &x, &y);
+
+ box->x = x * wlr_output->scale;
+ box->y = y * wlr_output->scale;
+ box->width = deco_box.width * wlr_output->scale;
+ box->height = deco_box.height * wlr_output->scale;
}
-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);
+static void render_decorations(struct roots_view *view,
+ struct render_data *data) {
+ if (!view->decorated || view->wlr_surface == NULL) {
+ return;
+ }
- switch (view->type) {
- case ROOTS_XDG_SHELL_V6_VIEW:
- render_surface(view->wlr_surface, desktop, wlr_output, when,
- view->x, view->y, view->rotation);
- render_xdg_v6_popups(view->xdg_surface_v6, desktop, wlr_output,
- when, view->x, view->y, view->rotation);
- break;
- case ROOTS_WL_SHELL_VIEW:
- render_wl_shell_surface(view->wl_shell_surface, desktop, wlr_output,
- when, view->x, view->y, view->rotation, false);
- break;
-#ifdef WLR_HAS_XWAYLAND
- case ROOTS_XWAYLAND_VIEW:
- render_surface(view->wlr_surface, desktop, wlr_output, when,
- view->x, view->y, view->rotation);
- break;
-#endif
+ struct roots_output *output = data->output;
+ struct wlr_renderer *renderer =
+ wlr_backend_get_renderer(output->wlr_output->backend);
+ assert(renderer);
+
+ struct wlr_box box;
+ get_decoration_box(view, output, &box);
+
+ struct wlr_box rotated;
+ wlr_box_rotated_bounds(&box, -view->rotation, &rotated);
+
+ pixman_region32_t damage;
+ pixman_region32_init(&damage);
+ pixman_region32_union_rect(&damage, &damage, rotated.x, rotated.y,
+ rotated.width, rotated.height);
+ pixman_region32_intersect(&damage, &damage, data->damage);
+ bool damaged = pixman_region32_not_empty(&damage);
+ if (!damaged) {
+ goto damage_finish;
+ }
+
+ float matrix[16];
+ wlr_matrix_project_box(&matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL,
+ view->rotation, &output->wlr_output->transform_matrix);
+ float color[] = { 0.2, 0.2, 0.2, 1 };
+
+ int nrects;
+ pixman_box32_t *rects =
+ pixman_region32_rectangles(&damage, &nrects);
+ for (int i = 0; i < nrects; ++i) {
+ scissor_output(output, &rects[i]);
+ wlr_render_colored_quad(renderer, &color, &matrix);
+ }
+
+damage_finish:
+ pixman_region32_fini(&damage);
+}
+
+static void render_view(struct roots_view *view, struct render_data *data) {
+ // Do not render views fullscreened on other outputs
+ if (view->fullscreen_output != NULL &&
+ view->fullscreen_output != data->output) {
+ return;
}
+
+ render_decorations(view, data);
+ view_for_each_surface(view, render_surface, data);
}
static bool has_standalone_surface(struct roots_view *view) {
@@ -227,11 +347,12 @@ static bool has_standalone_surface(struct roots_view *view) {
return true;
}
-static void output_frame_notify(struct wl_listener *listener, void *data) {
- struct wlr_output *wlr_output = data;
- struct roots_output *output = wl_container_of(listener, output, frame);
+static void render_output(struct roots_output *output) {
+ struct wlr_output *wlr_output = output->wlr_output;
struct roots_desktop *desktop = output->desktop;
struct roots_server *server = desktop->server;
+ struct wlr_renderer *renderer = wlr_backend_get_renderer(wlr_output->backend);
+ assert(renderer);
if (!wlr_output->enabled) {
return;
@@ -240,9 +361,9 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
- wlr_output_make_current(wlr_output);
- wlr_renderer_begin(server->renderer, wlr_output);
+ float clear_color[] = {0.25f, 0.25f, 0.25f, 1.0f};
+ // Check if we can delegate the fullscreen surface to the output
if (output->fullscreen_view != NULL) {
struct roots_view *view = output->fullscreen_view;
@@ -261,65 +382,292 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
wlr_output_set_fullscreen_surface(wlr_output, view->wlr_surface);
} else {
wlr_output_set_fullscreen_surface(wlr_output, NULL);
+ }
+
+ // Fullscreen views are rendered on a black background
+ clear_color[0] = clear_color[1] = clear_color[2] = 0;
+ } else {
+ wlr_output_set_fullscreen_surface(wlr_output, NULL);
+ }
+
+ int buffer_age = -1;
+ if (!wlr_output_make_current(wlr_output, &buffer_age)) {
+ return;
+ }
+
+ int width, height;
+ wlr_output_transformed_resolution(output->wlr_output, &width, &height);
- glClearColor(0, 0, 0, 0);
- glClear(GL_COLOR_BUFFER_BIT);
+ // Check if we can use damage tracking
+ pixman_region32_t damage;
+ pixman_region32_init(&damage);
+ if (buffer_age <= 0 || buffer_age - 1 > ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN) {
+ // Buffer new or too old, damage the whole output
+ pixman_region32_union_rect(&damage, &damage, 0, 0, width, height);
+ } else {
+ pixman_region32_copy(&damage, &output->damage);
- render_view(view, desktop, wlr_output, &now);
+ // Accumulate damage from old buffers
+ size_t idx = output->previous_damage_idx;
+ for (int i = 0; i < buffer_age - 1; ++i) {
+ int j = (idx + i) % ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN;
+ pixman_region32_union(&damage, &damage, &output->previous_damage[j]);
+ }
+ }
+ pixman_region32_intersect_rect(&damage, &damage, 0, 0, width, height);
- // During normal rendering the xwayland window tree isn't traversed
- // because all windows are rendered. Here we only want to render
- // the fullscreen window's children so we have to traverse the tree.
+ if (!pixman_region32_not_empty(&damage) && !wlr_output->needs_swap) {
+ // Output doesn't need swap and isn't damaged, skip rendering completely
+ goto damage_finish;
+ }
+
+ struct render_data data = {
+ .output = output,
+ .when = &now,
+ .damage = &damage,
+ };
+
+ wlr_renderer_begin(renderer, wlr_output);
+
+ if (!pixman_region32_not_empty(&damage)) {
+ // Output isn't damaged but needs buffer swap
+ goto renderer_end;
+ }
+
+ int nrects;
+ pixman_box32_t *rects = pixman_region32_rectangles(&damage, &nrects);
+ for (int i = 0; i < nrects; ++i) {
+ scissor_output(output, &rects[i]);
+ wlr_renderer_clear(renderer, &clear_color);
+ }
+
+ // If a view is fullscreen on this output, render it
+ if (output->fullscreen_view != NULL) {
+ struct roots_view *view = output->fullscreen_view;
+
+ if (wlr_output->fullscreen_surface == view->wlr_surface) {
+ // The output will render the fullscreen view
+ goto renderer_end;
+ }
+
+ view_for_each_surface(view, render_surface, &data);
+
+ // During normal rendering the xwayland window tree isn't traversed
+ // because all windows are rendered. Here we only want to render
+ // the fullscreen window's children so we have to traverse the tree.
#ifdef WLR_HAS_XWAYLAND
- if (view->type == ROOTS_XWAYLAND_VIEW) {
- render_xwayland_children(view->xwayland_surface, desktop,
- wlr_output, &now);
- }
-#endif
+ if (view->type == ROOTS_XWAYLAND_VIEW) {
+ xwayland_children_for_each_surface(view->xwayland_surface,
+ render_surface, &data);
}
- wlr_renderer_end(server->renderer);
- wlr_output_swap_buffers(wlr_output);
- output->last_frame = desktop->last_frame = now;
- return;
- } else {
- wlr_output_set_fullscreen_surface(wlr_output, NULL);
+#endif
+
+ goto renderer_end;
}
+ // Render all views
struct roots_view *view;
wl_list_for_each_reverse(view, &desktop->views, link) {
- render_view(view, desktop, wlr_output, &now);
+ render_view(view, &data);
}
- struct wlr_drag_icon *drag_icon = NULL;
+ // Render drag icons
+ struct roots_drag_icon *drag_icon = NULL;
struct roots_seat *seat = NULL;
wl_list_for_each(seat, &server->input->seats, link) {
- wl_list_for_each(drag_icon, &seat->seat->drag_icons, link) {
- if (!drag_icon->mapped) {
+ wl_list_for_each(drag_icon, &seat->drag_icons, link) {
+ if (!drag_icon->wlr_drag_icon->mapped) {
continue;
}
- struct wlr_surface *icon = drag_icon->surface;
- struct wlr_cursor *cursor = seat->cursor->cursor;
- double icon_x = 0, icon_y = 0;
- if (drag_icon->is_pointer) {
- icon_x = cursor->x + drag_icon->sx;
- icon_y = cursor->y + drag_icon->sy;
- render_surface(icon, desktop, wlr_output, &now, icon_x, icon_y, 0);
- } else {
- struct wlr_touch_point *point =
- wlr_seat_touch_get_point(seat->seat, drag_icon->touch_id);
- if (point) {
- icon_x = seat->touch_x + drag_icon->sx;
- icon_y = seat->touch_y + drag_icon->sy;
- render_surface(icon, desktop, wlr_output, &now, icon_x, icon_y, 0);
- }
+ render_surface(drag_icon->wlr_drag_icon->surface,
+ drag_icon->x, drag_icon->y, 0, &data);
+ }
+ }
+
+renderer_end:
+ wlr_renderer_scissor(renderer, NULL);
+ wlr_renderer_end(renderer);
+ if (!wlr_output_swap_buffers(wlr_output, &now, &damage)) {
+ goto damage_finish;
+ }
+ // same as decrementing, but works on unsigned integers
+ output->previous_damage_idx += ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN - 1;
+ output->previous_damage_idx %= ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN;
+ pixman_region32_copy(&output->previous_damage[output->previous_damage_idx],
+ &output->damage);
+ pixman_region32_clear(&output->damage);
+ output->last_frame = desktop->last_frame = now;
+
+damage_finish:
+ pixman_region32_fini(&damage);
+}
+
+static void output_handle_frame(struct wl_listener *listener, void *data) {
+ struct roots_output *output = wl_container_of(listener, output, frame);
+ render_output(output);
+}
+
+void output_damage_whole(struct roots_output *output) {
+ int width, height;
+ wlr_output_transformed_resolution(output->wlr_output, &width, &height);
+
+ pixman_region32_union_rect(&output->damage, &output->damage, 0, 0,
+ width, height);
+
+ wlr_output_schedule_frame(output->wlr_output);
+}
+
+static bool view_accept_damage(struct roots_output *output,
+ struct roots_view *view) {
+ if (output->fullscreen_view == NULL) {
+ return true;
+ }
+ if (output->fullscreen_view == view) {
+ return true;
+ }
+#ifdef WLR_HAS_XWAYLAND
+ if (output->fullscreen_view->type == ROOTS_XWAYLAND_VIEW &&
+ view->type == ROOTS_XWAYLAND_VIEW) {
+ // Special case: accept damage from children
+ struct wlr_xwayland_surface *xsurface = view->xwayland_surface;
+ while (xsurface != NULL) {
+ if (output->fullscreen_view->xwayland_surface == xsurface) {
+ return true;
}
+ xsurface = xsurface->parent;
}
}
+#endif
+ return false;
+}
+
+static void damage_whole_surface(struct wlr_surface *surface,
+ double lx, double ly, float rotation, void *data) {
+ struct roots_output *output = data;
+
+ if (!wlr_surface_has_buffer(surface)) {
+ return;
+ }
- wlr_renderer_end(server->renderer);
- wlr_output_swap_buffers(wlr_output);
+ int ow, oh;
+ wlr_output_transformed_resolution(output->wlr_output, &ow, &oh);
- output->last_frame = desktop->last_frame = now;
+ struct wlr_box box;
+ bool intersects = surface_intersect_output(surface, output->desktop->layout,
+ output->wlr_output, lx, ly, rotation, &box);
+ if (!intersects) {
+ return;
+ }
+
+ wlr_box_rotated_bounds(&box, -rotation, &box);
+
+ pixman_region32_union_rect(&output->damage, &output->damage,
+ box.x, box.y, box.width, box.height);
+
+ wlr_output_schedule_frame(output->wlr_output);
+}
+
+static void damage_whole_decoration(struct roots_view *view,
+ struct roots_output *output) {
+ if (!view->decorated || view->wlr_surface == NULL) {
+ return;
+ }
+
+ struct wlr_box box;
+ get_decoration_box(view, output, &box);
+
+ wlr_box_rotated_bounds(&box, -view->rotation, &box);
+
+ pixman_region32_union_rect(&output->damage, &output->damage,
+ box.x, box.y, box.width, box.height);
+}
+
+void output_damage_whole_view(struct roots_output *output,
+ struct roots_view *view) {
+ if (!view_accept_damage(output, view)) {
+ return;
+ }
+
+ damage_whole_decoration(view, output);
+ view_for_each_surface(view, damage_whole_surface, output);
+}
+
+void output_damage_whole_drag_icon(struct roots_output *output,
+ struct roots_drag_icon *icon) {
+ surface_for_each_surface(icon->wlr_drag_icon->surface, icon->x, icon->y, 0,
+ damage_whole_surface, output);
+}
+
+static void damage_from_surface(struct wlr_surface *surface,
+ double lx, double ly, float rotation, void *data) {
+ struct roots_output *output = data;
+ struct wlr_output *wlr_output = output->wlr_output;
+
+ if (!wlr_surface_has_buffer(surface)) {
+ return;
+ }
+
+ int ow, oh;
+ wlr_output_transformed_resolution(wlr_output, &ow, &oh);
+
+ struct wlr_box box;
+ surface_intersect_output(surface, output->desktop->layout,
+ wlr_output, lx, ly, rotation, &box);
+
+ if (rotation == 0) {
+ pixman_region32_t damage;
+ pixman_region32_init(&damage);
+ pixman_region32_copy(&damage, &surface->current->surface_damage);
+ wlr_region_scale(&damage, &damage, wlr_output->scale);
+ if (ceil(wlr_output->scale) > surface->current->scale) {
+ // When scaling up a surface, it'll become blurry so we need to
+ // expand the damage region
+ wlr_region_expand(&damage, &damage,
+ ceil(wlr_output->scale) - surface->current->scale);
+ }
+ pixman_region32_translate(&damage, box.x, box.y);
+ pixman_region32_union(&output->damage, &output->damage, &damage);
+ pixman_region32_fini(&damage);
+ } else {
+ pixman_box32_t *extents =
+ pixman_region32_extents(&surface->current->surface_damage);
+ struct wlr_box damage_box = {
+ .x = box.x + extents->x1 * wlr_output->scale,
+ .y = box.y + extents->y1 * wlr_output->scale,
+ .width = (extents->x2 - extents->x1) * wlr_output->scale,
+ .height = (extents->y2 - extents->y1) * wlr_output->scale,
+ };
+ wlr_box_rotated_bounds(&damage_box, -rotation, &damage_box);
+ pixman_region32_union_rect(&output->damage, &output->damage,
+ damage_box.x, damage_box.y, damage_box.width, damage_box.height);
+ }
+
+ pixman_region32_intersect_rect(&output->damage, &output->damage, 0, 0,
+ ow, oh);
+
+ wlr_output_schedule_frame(wlr_output);
+}
+
+void output_damage_from_view(struct roots_output *output,
+ struct roots_view *view) {
+ if (!view_accept_damage(output, view)) {
+ return;
+ }
+
+ view_for_each_surface(view, damage_from_surface, output);
+}
+
+static void output_handle_mode(struct wl_listener *listener, void *data) {
+ struct roots_output *output = wl_container_of(listener, output, mode);
+ output_damage_whole(output);
+}
+
+static void output_handle_needs_swap(struct wl_listener *listener, void *data) {
+ struct roots_output *output =
+ wl_container_of(listener, output, needs_swap);
+ pixman_region32_union(&output->damage, &output->damage,
+ &output->wlr_output->damage);
+ wlr_output_schedule_frame(output->wlr_output);
}
static void set_mode(struct wlr_output *output,
@@ -372,9 +720,18 @@ void output_add_notify(struct wl_listener *listener, void *data) {
clock_gettime(CLOCK_MONOTONIC, &output->last_frame);
output->desktop = desktop;
output->wlr_output = wlr_output;
- output->frame.notify = output_frame_notify;
- wl_signal_add(&wlr_output->events.frame, &output->frame);
wl_list_insert(&desktop->outputs, &output->link);
+ pixman_region32_init(&output->damage);
+ for (size_t i = 0; i < ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN; ++i) {
+ pixman_region32_init(&output->previous_damage[i]);
+ }
+
+ output->frame.notify = output_handle_frame;
+ wl_signal_add(&wlr_output->events.frame, &output->frame);
+ output->mode.notify = output_handle_mode;
+ wl_signal_add(&wlr_output->events.mode, &output->mode);
+ output->needs_swap.notify = output_handle_needs_swap;
+ wl_signal_add(&wlr_output->events.needs_swap, &output->needs_swap);
struct roots_output_config *output_config =
roots_config_get_output(config, wlr_output);
@@ -399,6 +756,8 @@ void output_add_notify(struct wl_listener *listener, void *data) {
roots_seat_configure_cursor(seat);
roots_seat_configure_xcursor(seat);
}
+
+ output_damage_whole(output);
}
void output_remove_notify(struct wl_listener *listener, void *data) {
@@ -423,7 +782,13 @@ void output_remove_notify(struct wl_listener *listener, void *data) {
//example_config_configure_cursor(sample->config, sample->cursor,
// sample->compositor);
+ pixman_region32_fini(&output->damage);
+ for (size_t i = 0; i < ROOTS_OUTPUT_PREVIOUS_DAMAGE_LEN; ++i) {
+ pixman_region32_fini(&output->previous_damage[i]);
+ }
wl_list_remove(&output->link);
wl_list_remove(&output->frame.link);
+ wl_list_remove(&output->mode.link);
+ wl_list_remove(&output->needs_swap.link);
free(output);
}
diff --git a/rootston/seat.c b/rootston/seat.c
index edb98095..45e42d7d 100644
--- a/rootston/seat.c
+++ b/rootston/seat.c
@@ -241,19 +241,97 @@ static void roots_seat_init_cursor(struct roots_seat *seat) {
seat->cursor->tool_tip.notify = handle_tool_tip;
wl_signal_add(&seat->seat->events.request_set_cursor,
- &seat->cursor->request_set_cursor);
+ &seat->cursor->request_set_cursor);
seat->cursor->request_set_cursor.notify = handle_request_set_cursor;
}
+static void roots_drag_icon_handle_surface_commit(struct wl_listener *listener,
+ void *data) {
+ struct roots_drag_icon *icon =
+ wl_container_of(listener, icon, surface_commit);
+ roots_drag_icon_damage_whole(icon);
+}
+
+static void roots_drag_icon_handle_map(struct wl_listener *listener,
+ void *data) {
+ struct roots_drag_icon *icon =
+ wl_container_of(listener, icon, map);
+ roots_drag_icon_damage_whole(icon);
+}
+
+static void roots_drag_icon_handle_destroy(struct wl_listener *listener,
+ void *data) {
+ struct roots_drag_icon *icon =
+ wl_container_of(listener, icon, destroy);
+ roots_drag_icon_damage_whole(icon);
+
+ wl_list_remove(&icon->link);
+ wl_list_remove(&icon->surface_commit.link);
+ wl_list_remove(&icon->map.link);
+ wl_list_remove(&icon->destroy.link);
+ free(icon);
+}
+
+static void roots_seat_handle_new_drag_icon(struct wl_listener *listener,
+ void *data) {
+ struct roots_seat *seat = wl_container_of(listener, seat, new_drag_icon);
+ struct wlr_drag_icon *wlr_drag_icon = data;
+
+ struct roots_drag_icon *icon = calloc(1, sizeof(struct roots_drag_icon));
+ if (icon == NULL) {
+ return;
+ }
+ icon->seat = seat;
+ icon->wlr_drag_icon = wlr_drag_icon;
+
+ icon->surface_commit.notify = roots_drag_icon_handle_surface_commit;
+ wl_signal_add(&wlr_drag_icon->surface->events.commit, &icon->surface_commit);
+ icon->map.notify = roots_drag_icon_handle_map;
+ wl_signal_add(&wlr_drag_icon->events.map, &icon->map);
+ icon->destroy.notify = roots_drag_icon_handle_destroy;
+ wl_signal_add(&wlr_drag_icon->events.destroy, &icon->destroy);
+
+ wl_list_insert(&seat->drag_icons, &icon->link);
+}
+
+void roots_drag_icon_update_position(struct roots_drag_icon *icon) {
+ roots_drag_icon_damage_whole(icon);
+
+ struct wlr_drag_icon *wlr_icon = icon->wlr_drag_icon;
+ struct roots_seat *seat = icon->seat;
+ struct wlr_cursor *cursor = seat->cursor->cursor;
+ if (wlr_icon->is_pointer) {
+ icon->x = cursor->x + wlr_icon->sx;
+ icon->y = cursor->y + wlr_icon->sy;
+ } else {
+ struct wlr_touch_point *point =
+ wlr_seat_touch_get_point(seat->seat, wlr_icon->touch_id);
+ if (point == NULL) {
+ return;
+ }
+ icon->x = seat->touch_x + wlr_icon->sx;
+ icon->y = seat->touch_y + wlr_icon->sy;
+ }
+
+ roots_drag_icon_damage_whole(icon);
+}
+
+void roots_drag_icon_damage_whole(struct roots_drag_icon *icon) {
+ struct roots_output *output;
+ wl_list_for_each(output, &icon->seat->input->server->desktop->outputs,
+ link) {
+ output_damage_whole_drag_icon(output, icon);
+ }
+}
+
static void seat_view_destroy(struct roots_seat_view *seat_view);
-static void roots_seat_handle_seat_destroy(struct wl_listener *listener,
+static void roots_seat_handle_destroy(struct wl_listener *listener,
void *data) {
- struct roots_seat *seat =
- wl_container_of(listener, seat, seat_destroy);
+ struct roots_seat *seat = wl_container_of(listener, seat, destroy);
// TODO: probably more to be freed here
- wl_list_remove(&seat->seat_destroy.link);
+ wl_list_remove(&seat->destroy.link);
struct roots_seat_view *view, *nview;
wl_list_for_each_safe(view, nview, &seat->views, link) {
@@ -262,7 +340,7 @@ static void roots_seat_handle_seat_destroy(struct wl_listener *listener,
}
void roots_seat_destroy(struct roots_seat *seat) {
- roots_seat_handle_seat_destroy(&seat->seat_destroy, seat->seat);
+ roots_seat_handle_destroy(&seat->destroy, seat->seat);
wlr_seat_destroy(seat->seat);
}
@@ -277,6 +355,7 @@ struct roots_seat *roots_seat_create(struct roots_input *input, char *name) {
wl_list_init(&seat->touch);
wl_list_init(&seat->tablet_tools);
wl_list_init(&seat->views);
+ wl_list_init(&seat->drag_icons);
seat->input = input;
@@ -295,8 +374,10 @@ struct roots_seat *roots_seat_create(struct roots_input *input, char *name) {
wl_list_insert(&input->seats, &seat->link);
- seat->seat_destroy.notify = roots_seat_handle_seat_destroy;
- wl_signal_add(&seat->seat->events.destroy, &seat->seat_destroy);
+ seat->new_drag_icon.notify = roots_seat_handle_new_drag_icon;
+ wl_signal_add(&seat->seat->events.new_drag_icon, &seat->new_drag_icon);
+ seat->destroy.notify = roots_seat_handle_destroy;
+ wl_signal_add(&seat->seat->events.destroy, &seat->destroy);
return seat;
}
@@ -683,6 +764,8 @@ void roots_seat_set_focus(struct roots_seat *seat, struct roots_view *view) {
wl_list_remove(&seat_view->link);
wl_list_insert(&seat->views, &seat_view->link);
+ view_damage_whole(view);
+
struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat->seat);
if (keyboard != NULL) {
wlr_seat_keyboard_notify_enter(seat->seat, view->wlr_surface,
diff --git a/rootston/wl_shell.c b/rootston/wl_shell.c
index 65067920..267e2cf5 100644
--- a/rootston/wl_shell.c
+++ b/rootston/wl_shell.c
@@ -10,6 +10,61 @@
#include "rootston/server.h"
#include "rootston/input.h"
+static void popup_destroy(struct roots_view_child *child) {
+ assert(child->destroy == popup_destroy);
+ struct roots_wl_shell_popup *popup = (struct roots_wl_shell_popup *)child;
+ if (popup == NULL) {
+ return;
+ }
+ wl_list_remove(&popup->destroy.link);
+ wl_list_remove(&popup->set_state.link);
+ wl_list_remove(&popup->new_popup.link);
+ view_child_finish(&popup->view_child);
+ free(popup);
+}
+
+static void popup_handle_destroy(struct wl_listener *listener, void *data) {
+ struct roots_wl_shell_popup *popup =
+ wl_container_of(listener, popup, destroy);
+ popup_destroy((struct roots_view_child *)popup);
+}
+
+static void popup_handle_set_state(struct wl_listener *listener, void *data) {
+ struct roots_wl_shell_popup *popup =
+ wl_container_of(listener, popup, set_state);
+ popup_destroy((struct roots_view_child *)popup);
+}
+
+static struct roots_wl_shell_popup *popup_create(struct roots_view *view,
+ struct wlr_wl_shell_surface *wlr_wl_shell_surface);
+
+static void popup_handle_new_popup(struct wl_listener *listener, void *data) {
+ struct roots_wl_shell_popup *popup =
+ wl_container_of(listener, popup, new_popup);
+ struct wlr_wl_shell_surface *wlr_wl_shell_surface = data;
+ popup_create(popup->view_child.view, wlr_wl_shell_surface);
+}
+
+static struct roots_wl_shell_popup *popup_create(struct roots_view *view,
+ struct wlr_wl_shell_surface *wlr_wl_shell_surface) {
+ struct roots_wl_shell_popup *popup =
+ calloc(1, sizeof(struct roots_wl_shell_popup));
+ if (popup == NULL) {
+ return NULL;
+ }
+ popup->wlr_wl_shell_surface = wlr_wl_shell_surface;
+ popup->view_child.destroy = popup_destroy;
+ view_child_init(&popup->view_child, view, wlr_wl_shell_surface->surface);
+ popup->destroy.notify = popup_handle_destroy;
+ wl_signal_add(&wlr_wl_shell_surface->events.destroy, &popup->destroy);
+ popup->set_state.notify = popup_handle_set_state;
+ wl_signal_add(&wlr_wl_shell_surface->events.set_state, &popup->set_state);
+ popup->new_popup.notify = popup_handle_new_popup;
+ wl_signal_add(&wlr_wl_shell_surface->events.new_popup, &popup->new_popup);
+ return popup;
+}
+
+
static void resize(struct roots_view *view, uint32_t width, uint32_t height) {
assert(view->type == ROOTS_WL_SHELL_VIEW);
struct wlr_wl_shell_surface *surf = view->wl_shell_surface;
@@ -88,19 +143,32 @@ static void handle_surface_commit(struct wl_listener *listener, void *data) {
struct roots_view *view = roots_surface->view;
struct wlr_surface *wlr_surface = view->wlr_surface;
+ view_apply_damage(view);
+
int width = wlr_surface->current->width;
int height = wlr_surface->current->height;
+ view_update_size(view, width, height);
+ double x = view->x;
+ double y = view->y;
if (view->pending_move_resize.update_x) {
- view->x = view->pending_move_resize.x +
- view->pending_move_resize.width - width;
+ x = view->pending_move_resize.x + view->pending_move_resize.width -
+ width;
view->pending_move_resize.update_x = false;
}
if (view->pending_move_resize.update_y) {
- view->y = view->pending_move_resize.y +
- view->pending_move_resize.height - height;
+ y = view->pending_move_resize.y + view->pending_move_resize.height -
+ height;
view->pending_move_resize.update_y = false;
}
+ view_update_position(view, x, y);
+}
+
+static void handle_new_popup(struct wl_listener *listener, void *data) {
+ struct roots_wl_shell_surface *roots_surface =
+ wl_container_of(listener, roots_surface, new_popup);
+ struct wlr_wl_shell_surface *wlr_wl_shell_surface = data;
+ popup_create(roots_surface->view, wlr_wl_shell_surface);
}
static void handle_destroy(struct wl_listener *listener, void *data) {
@@ -114,16 +182,22 @@ static void handle_destroy(struct wl_listener *listener, void *data) {
wl_list_remove(&roots_surface->set_state.link);
wl_list_remove(&roots_surface->surface_commit.link);
wl_list_remove(&roots_surface->view->link);
- view_destroy(roots_surface->view);
+ view_finish(roots_surface->view);
+ free(roots_surface->view);
free(roots_surface);
}
void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
struct roots_desktop *desktop =
wl_container_of(listener, desktop, wl_shell_surface);
-
struct wlr_wl_shell_surface *surface = data;
- wlr_log(L_DEBUG, "new shell surface: title=%s, class=%s",
+
+ if (surface->state == WLR_WL_SHELL_SURFACE_STATE_POPUP) {
+ wlr_log(L_DEBUG, "new wl shell popup");
+ return;
+ }
+
+ wlr_log(L_DEBUG, "new wl shell surface: title=%s, class=%s",
surface->title, surface->class);
wlr_wl_shell_surface_ping(surface);
@@ -134,6 +208,8 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
}
roots_surface->destroy.notify = handle_destroy;
wl_signal_add(&surface->events.destroy, &roots_surface->destroy);
+ roots_surface->new_popup.notify = handle_new_popup;
+ wl_signal_add(&surface->events.new_popup, &roots_surface->new_popup);
roots_surface->request_move.notify = handle_request_move;
wl_signal_add(&surface->events.request_move, &roots_surface->request_move);
roots_surface->request_resize.notify = handle_request_resize;
@@ -157,6 +233,8 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
return;
}
view->type = ROOTS_WL_SHELL_VIEW;
+ view->width = surface->surface->current->width;
+ view->height = surface->surface->current->height;
view->wl_shell_surface = surface;
view->roots_wl_shell_surface = roots_surface;
diff --git a/rootston/xdg_shell_v6.c b/rootston/xdg_shell_v6.c
index 884d0d05..9bd6f76a 100644
--- a/rootston/xdg_shell_v6.c
+++ b/rootston/xdg_shell_v6.c
@@ -10,6 +10,52 @@
#include "rootston/server.h"
#include "rootston/input.h"
+static void popup_destroy(struct roots_view_child *child) {
+ assert(child->destroy == popup_destroy);
+ struct roots_xdg_popup_v6 *popup = (struct roots_xdg_popup_v6 *)child;
+ if (popup == NULL) {
+ return;
+ }
+ wl_list_remove(&popup->destroy.link);
+ wl_list_remove(&popup->new_popup.link);
+ view_child_finish(&popup->view_child);
+ free(popup);
+}
+
+static void popup_handle_destroy(struct wl_listener *listener, void *data) {
+ struct roots_xdg_popup_v6 *popup =
+ wl_container_of(listener, popup, destroy);
+ popup_destroy((struct roots_view_child *)popup);
+}
+
+static struct roots_xdg_popup_v6 *popup_create(struct roots_view *view,
+ struct wlr_xdg_popup_v6 *wlr_popup);
+
+static void popup_handle_new_popup(struct wl_listener *listener, void *data) {
+ struct roots_xdg_popup_v6 *popup =
+ wl_container_of(listener, popup, new_popup);
+ struct wlr_xdg_popup_v6 *wlr_popup = data;
+ popup_create(popup->view_child.view, wlr_popup);
+}
+
+static struct roots_xdg_popup_v6 *popup_create(struct roots_view *view,
+ struct wlr_xdg_popup_v6 *wlr_popup) {
+ struct roots_xdg_popup_v6 *popup =
+ calloc(1, sizeof(struct roots_xdg_popup_v6));
+ if (popup == NULL) {
+ return NULL;
+ }
+ popup->wlr_popup = wlr_popup;
+ popup->view_child.destroy = popup_destroy;
+ view_child_init(&popup->view_child, view, wlr_popup->base->surface);
+ popup->destroy.notify = popup_handle_destroy;
+ wl_signal_add(&wlr_popup->base->events.destroy, &popup->destroy);
+ popup->new_popup.notify = popup_handle_new_popup;
+ wl_signal_add(&wlr_popup->base->events.new_popup, &popup->new_popup);
+ return popup;
+}
+
+
static void get_size(const struct roots_view *view, struct wlr_box *box) {
assert(view->type == ROOTS_XDG_SHELL_V6_VIEW);
struct wlr_xdg_surface_v6 *surface = view->xdg_surface_v6;
@@ -102,8 +148,7 @@ static void move_resize(struct roots_view *view, double x, double y,
if (serial > 0) {
roots_surface->pending_move_resize_configure_serial = serial;
} else if (roots_surface->pending_move_resize_configure_serial == 0) {
- view->x = x;
- view->y = y;
+ view_update_position(view, x, y);
}
}
@@ -192,26 +237,32 @@ static void handle_request_fullscreen(struct wl_listener *listener,
view_set_fullscreen(view, e->fullscreen, e->output);
}
-static void handle_commit(struct wl_listener *listener, void *data) {
+static void handle_surface_commit(struct wl_listener *listener, void *data) {
struct roots_xdg_surface_v6 *roots_surface =
- wl_container_of(listener, roots_surface, commit);
+ wl_container_of(listener, roots_surface, surface_commit);
struct roots_view *view = roots_surface->view;
struct wlr_xdg_surface_v6 *surface = view->xdg_surface_v6;
+ view_apply_damage(view);
+
+ struct wlr_box size;
+ get_size(view, &size);
+ view_update_size(view, size.width, size.height);
+
uint32_t pending_serial =
roots_surface->pending_move_resize_configure_serial;
if (pending_serial > 0 && pending_serial >= surface->configure_serial) {
- struct wlr_box size;
- get_size(view, &size);
-
+ double x = view->x;
+ double y = view->y;
if (view->pending_move_resize.update_x) {
- view->x = view->pending_move_resize.x +
- view->pending_move_resize.width - size.width;
+ x = view->pending_move_resize.x + view->pending_move_resize.width -
+ size.width;
}
if (view->pending_move_resize.update_y) {
- view->y = view->pending_move_resize.y +
- view->pending_move_resize.height - size.height;
+ y = view->pending_move_resize.y + view->pending_move_resize.height -
+ size.height;
}
+ view_update_position(view, x, y);
if (pending_serial == surface->configure_serial) {
roots_surface->pending_move_resize_configure_serial = 0;
@@ -219,15 +270,26 @@ static void handle_commit(struct wl_listener *listener, void *data) {
}
}
+static void handle_new_popup(struct wl_listener *listener, void *data) {
+ struct roots_xdg_surface_v6 *roots_xdg_surface =
+ wl_container_of(listener, roots_xdg_surface, new_popup);
+ struct wlr_xdg_popup_v6 *wlr_popup = data;
+ popup_create(roots_xdg_surface->view, wlr_popup);
+}
+
static void handle_destroy(struct wl_listener *listener, void *data) {
struct roots_xdg_surface_v6 *roots_xdg_surface =
wl_container_of(listener, roots_xdg_surface, destroy);
- wl_list_remove(&roots_xdg_surface->commit.link);
+ wl_list_remove(&roots_xdg_surface->surface_commit.link);
wl_list_remove(&roots_xdg_surface->destroy.link);
+ wl_list_remove(&roots_xdg_surface->new_popup.link);
wl_list_remove(&roots_xdg_surface->request_move.link);
wl_list_remove(&roots_xdg_surface->request_resize.link);
+ wl_list_remove(&roots_xdg_surface->request_maximize.link);
+ wl_list_remove(&roots_xdg_surface->request_fullscreen.link);
wl_list_remove(&roots_xdg_surface->view->link);
- view_destroy(roots_xdg_surface->view);
+ view_finish(roots_xdg_surface->view);
+ free(roots_xdg_surface->view);
free(roots_xdg_surface);
}
@@ -252,8 +314,9 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
if (!roots_surface) {
return;
}
- roots_surface->commit.notify = handle_commit;
- wl_signal_add(&surface->surface->events.commit, &roots_surface->commit);
+ roots_surface->surface_commit.notify = handle_surface_commit;
+ wl_signal_add(&surface->surface->events.commit,
+ &roots_surface->surface_commit);
roots_surface->destroy.notify = handle_destroy;
wl_signal_add(&surface->events.destroy, &roots_surface->destroy);
roots_surface->request_move.notify = handle_request_move;
@@ -267,6 +330,8 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
roots_surface->request_fullscreen.notify = handle_request_fullscreen;
wl_signal_add(&surface->events.request_fullscreen,
&roots_surface->request_fullscreen);
+ roots_surface->new_popup.notify = handle_new_popup;
+ wl_signal_add(&surface->events.new_popup, &roots_surface->new_popup);
struct roots_view *view = calloc(1, sizeof(struct roots_view));
if (!view) {
@@ -274,10 +339,10 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
return;
}
view->type = ROOTS_XDG_SHELL_V6_VIEW;
+
view->xdg_surface_v6 = surface;
view->roots_xdg_surface_v6 = roots_surface;
view->wlr_surface = surface->surface;
- view->get_size = get_size;
view->activate = activate;
view->resize = resize;
view->move_resize = move_resize;
@@ -285,6 +350,12 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
view->set_fullscreen = set_fullscreen;
view->close = close;
roots_surface->view = view;
+
+ struct wlr_box box;
+ get_size(view, &box);
+ view->width = box.width;
+ view->height = box.height;
+
view_init(view, desktop);
wl_list_insert(&desktop->views, &view->link);
diff --git a/rootston/xwayland.c b/rootston/xwayland.c
index 69c44add..36be9793 100644
--- a/rootston/xwayland.c
+++ b/rootston/xwayland.c
@@ -18,8 +18,7 @@ static void activate(struct roots_view *view, bool active) {
static void move(struct roots_view *view, double x, double y) {
assert(view->type == ROOTS_XWAYLAND_VIEW);
struct wlr_xwayland_surface *xwayland_surface = view->xwayland_surface;
- view->x = x;
- view->y = y;
+ view_update_position(view, x, y);
wlr_xwayland_surface_configure(xwayland_surface, x, y,
xwayland_surface->width, xwayland_surface->height);
}
@@ -122,7 +121,8 @@ static void handle_destroy(struct wl_listener *listener, void *data) {
if (xwayland_surface->mapped) {
wl_list_remove(&roots_surface->view->link);
}
- view_destroy(roots_surface->view);
+ view_finish(roots_surface->view);
+ free(roots_surface->view);
free(roots_surface);
}
@@ -133,8 +133,7 @@ static void handle_request_configure(struct wl_listener *listener, void *data) {
roots_surface->view->xwayland_surface;
struct wlr_xwayland_surface_configure_event *event = data;
- roots_surface->view->x = (double)event->x;
- roots_surface->view->y = (double)event->y;
+ view_update_position(roots_surface->view, event->x, event->y);
wlr_xwayland_surface_configure(xwayland_surface, event->x, event->y,
event->width, event->height);
@@ -206,19 +205,25 @@ static void handle_surface_commit(struct wl_listener *listener, void *data) {
struct roots_view *view = roots_surface->view;
struct wlr_surface *wlr_surface = view->wlr_surface;
+ view_apply_damage(view);
+
int width = wlr_surface->current->width;
int height = wlr_surface->current->height;
+ view_update_size(view, width, height);
+ double x = view->x;
+ double y = view->y;
if (view->pending_move_resize.update_x) {
- view->x = view->pending_move_resize.x +
- view->pending_move_resize.width - width;
+ x = view->pending_move_resize.x + view->pending_move_resize.width -
+ width;
view->pending_move_resize.update_x = false;
}
if (view->pending_move_resize.update_y) {
- view->y = view->pending_move_resize.y +
- view->pending_move_resize.height - height;
+ y = view->pending_move_resize.y + view->pending_move_resize.height -
+ height;
view->pending_move_resize.update_y = false;
}
+ view_update_position(view, x, y);
}
static void handle_map_notify(struct wl_listener *listener, void *data) {
@@ -229,24 +234,48 @@ static void handle_map_notify(struct wl_listener *listener, void *data) {
struct roots_desktop *desktop = view->desktop;
view->wlr_surface = xsurface->surface;
- view->x = (double)xsurface->x;
- view->y = (double)xsurface->y;
+ view->x = xsurface->x;
+ view->y = xsurface->y;
+ view->width = xsurface->surface->current->width;
+ view->height = xsurface->surface->current->height;
+ wl_list_insert(&desktop->views, &view->link);
+
+ struct wlr_subsurface *subsurface;
+ wl_list_for_each(subsurface, &view->wlr_surface->subsurface_list,
+ parent_link) {
+ subsurface_create(view, subsurface);
+ }
+
+ view_damage_whole(view);
roots_surface->surface_commit.notify = handle_surface_commit;
wl_signal_add(&xsurface->surface->events.commit,
&roots_surface->surface_commit);
-
- wl_list_insert(&desktop->views, &view->link);
}
static void handle_unmap_notify(struct wl_listener *listener, void *data) {
struct roots_xwayland_surface *roots_surface =
wl_container_of(listener, roots_surface, unmap_notify);
- roots_surface->view->wlr_surface = NULL;
+ struct roots_view *view = roots_surface->view;
wl_list_remove(&roots_surface->surface_commit.link);
- wl_list_remove(&roots_surface->view->link);
+ view_damage_whole(view);
+
+ struct roots_view_child *child, *tmp;
+ wl_list_for_each_safe(child, tmp, &view->children, link) {
+ child->destroy(child);
+ }
+
+ if (view->fullscreen_output != NULL) {
+ output_damage_whole(view->fullscreen_output);
+ view->fullscreen_output->fullscreen_view = NULL;
+ view->fullscreen_output = NULL;
+ }
+
+ view->wlr_surface = NULL;
+ view->width = view->height = 0;
+ wl_list_remove(&view->link);
}
void handle_xwayland_surface(struct wl_listener *listener, void *data) {
@@ -296,6 +325,8 @@ 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->width = surface->surface->current->width;
+ view->height = surface->surface->current->height;
view->xwayland_surface = surface;
view->roots_xwayland_surface = roots_surface;
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-25 17:22:43 +0000