1 files changed, 145 insertions, 66 deletions

diff --git a/sway/desktop/render.c b/sway/desktop/render.c
index bd85282c..ed9ad490 100644
--- a/sway/desktop/render.c
+++ b/sway/desktop/render.c
@@ -7,13 +7,12 @@
 #include <wayland-server-core.h>
 #include <wlr/render/gles2.h>
 #include <wlr/render/wlr_renderer.h>
-#include <wlr/types/wlr_box.h>
 #include <wlr/types/wlr_buffer.h>
 #include <wlr/types/wlr_matrix.h>
 #include <wlr/types/wlr_output_damage.h>
 #include <wlr/types/wlr_output_layout.h>
 #include <wlr/types/wlr_output.h>
-#include <wlr/types/wlr_surface.h>
+#include <wlr/types/wlr_compositor.h>
 #include <wlr/util/region.h>
 #include "log.h"
 #include "config.h"
@@ -32,6 +31,7 @@
 struct render_data {
         pixman_region32_t *damage;
         float alpha;
+        struct wlr_box *clip_box;
 };
 
 /**
@@ -52,7 +52,7 @@ static int scale_length(int length, int offset, float scale) {
 
 static void scissor_output(struct wlr_output *wlr_output,
                 pixman_box32_t *rect) {
-        struct wlr_renderer *renderer = wlr_backend_get_renderer(wlr_output->backend);
+        struct wlr_renderer *renderer = wlr_output->renderer;
         assert(renderer);
 
         struct wlr_box box = {
@@ -100,13 +100,9 @@ static void render_texture(struct wlr_output *wlr_output,
                 pixman_region32_t *output_damage, struct wlr_texture *texture,
                 const struct wlr_fbox *src_box, const struct wlr_box *dst_box,
                 const float matrix[static 9], float alpha) {
-        struct wlr_renderer *renderer =
-                wlr_backend_get_renderer(wlr_output->backend);
+        struct wlr_renderer *renderer = wlr_output->renderer;
         struct sway_output *output = wlr_output->data;
 
-        struct wlr_gles2_texture_attribs attribs;
-        wlr_gles2_texture_get_attribs(texture, &attribs);
-
         pixman_region32_t damage;
         pixman_region32_init(&damage);
         pixman_region32_union_rect(&damage, &damage, dst_box->x, dst_box->y,
@@ -133,9 +129,9 @@ damage_finish:
         pixman_region32_fini(&damage);
 }
 
-static void render_surface_iterator(struct sway_output *output, struct sway_view *view,
-                struct wlr_surface *surface, struct wlr_box *_box, float rotation,
-                void *_data) {
+static void render_surface_iterator(struct sway_output *output,
+                struct sway_view *view, struct wlr_surface *surface,
+                struct wlr_box *_box, void *_data) {
         struct render_data *data = _data;
         struct wlr_output *wlr_output = output->wlr_output;
         pixman_region32_t *output_damage = data->damage;
@@ -149,15 +145,23 @@ static void render_surface_iterator(struct sway_output *output, struct sway_view
         struct wlr_fbox src_box;
         wlr_surface_get_buffer_source_box(surface, &src_box);
 
-        struct wlr_box dst_box = *_box;
-        scale_box(&dst_box, wlr_output->scale);
+        struct wlr_box proj_box = *_box;
+        scale_box(&proj_box, wlr_output->scale);
 
         float matrix[9];
         enum wl_output_transform transform =
                 wlr_output_transform_invert(surface->current.transform);
-        wlr_matrix_project_box(matrix, &dst_box, transform, rotation,
+        wlr_matrix_project_box(matrix, &proj_box, transform, 0.0,
                 wlr_output->transform_matrix);
 
+        struct wlr_box dst_box = *_box;
+        struct wlr_box *clip_box = data->clip_box;
+        if (clip_box != NULL) {
+                dst_box.width = fmin(dst_box.width, clip_box->width);
+                dst_box.height = fmin(dst_box.height, clip_box->height);
+        }
+        scale_box(&dst_box, wlr_output->scale);
+
         render_texture(wlr_output, output_damage, texture,
                 &src_box, &dst_box, matrix, alpha);
 
@@ -213,8 +217,7 @@ void render_rect(struct sway_output *output,
                 pixman_region32_t *output_damage, const struct wlr_box *_box,
                 float color[static 4]) {
         struct wlr_output *wlr_output = output->wlr_output;
-        struct wlr_renderer *renderer =
-                wlr_backend_get_renderer(wlr_output->backend);
+        struct wlr_renderer *renderer = wlr_output->renderer;
 
         struct wlr_box box;
         memcpy(&box, _box, sizeof(struct wlr_box));
@@ -256,6 +259,14 @@ static void render_view_toplevels(struct sway_view *view,
                 .damage = damage,
                 .alpha = alpha,
         };
+        struct wlr_box clip_box;
+        if (!container_is_current_floating(view->container)) {
+                // As we pass the geometry offsets to the surface iterator, we will
+                // need to account for the offsets in the clip dimensions.
+                clip_box.width = view->container->current.content_width + view->geometry.x;
+                clip_box.height = view->container->current.content_height + view->geometry.y;
+                data.clip_box = &clip_box;
+        }
         // Render all toplevels without descending into popups
         double ox = view->container->surface_x -
                 output->lx - view->geometry.x;
@@ -282,17 +293,18 @@ static void render_saved_view(struct sway_view *view,
         if (wl_list_empty(&view->saved_buffers)) {
                 return;
         }
+
+        bool floating = container_is_current_floating(view->container);
+
         struct sway_saved_buffer *saved_buf;
         wl_list_for_each(saved_buf, &view->saved_buffers, link) {
                 if (!saved_buf->buffer->texture) {
                         continue;
                 }
 
-                struct wlr_box box = {
-                        .x = view->container->surface_x - output->lx -
-                                view->saved_geometry.x + saved_buf->x,
-                        .y = view->container->surface_y - output->ly -
-                                view->saved_geometry.y + saved_buf->y,
+                struct wlr_box proj_box = {
+                        .x = saved_buf->x - view->saved_geometry.x - output->lx,
+                        .y = saved_buf->y - view->saved_geometry.y - output->ly,
                         .width = saved_buf->width,
                         .height = saved_buf->height,
                 };
@@ -303,20 +315,31 @@ static void render_saved_view(struct sway_view *view,
                 };
 
                 struct wlr_box intersection;
-                bool intersects = wlr_box_intersection(&intersection, &output_box, &box);
+                bool intersects = wlr_box_intersection(&intersection, &output_box, &proj_box);
                 if (!intersects) {
                         continue;
                 }
 
-                scale_box(&box, wlr_output->scale);
+                struct wlr_box dst_box = proj_box;
+                scale_box(&proj_box, wlr_output->scale);
 
                 float matrix[9];
                 enum wl_output_transform transform = wlr_output_transform_invert(saved_buf->transform);
-                wlr_matrix_project_box(matrix, &box, transform, 0,
+                wlr_matrix_project_box(matrix, &proj_box, transform, 0,
                         wlr_output->transform_matrix);
 
+                if (!floating) {
+                        dst_box.width = fmin(dst_box.width,
+                                        view->container->current.content_width -
+                                        (saved_buf->x - view->container->current.content_x) + view->saved_geometry.x);
+                        dst_box.height = fmin(dst_box.height,
+                                        view->container->current.content_height -
+                                        (saved_buf->y - view->container->current.content_y) + view->saved_geometry.y);
+                }
+                scale_box(&dst_box, wlr_output->scale);
+
                 render_texture(wlr_output, damage, saved_buf->buffer->texture,
-                        &saved_buf->source_box, &box, matrix, alpha);
+                        &saved_buf->source_box, &dst_box, matrix, alpha);
         }
 
         // FIXME: we should set the surface that this saved buffer originates from
@@ -348,8 +371,8 @@ static void render_view(struct sway_output *output, pixman_region32_t *damage,
         if (state->border_left) {
                 memcpy(&color, colors->child_border, sizeof(float) * 4);
                 premultiply_alpha(color, con->alpha);
-                box.x = state->x;
-                box.y = state->content_y;
+                box.x = floor(state->x);
+                box.y = floor(state->content_y);
                 box.width = state->border_thickness;
                 box.height = state->content_height;
                 scale_box(&box, output_scale);
@@ -361,14 +384,14 @@ static void render_view(struct sway_output *output, pixman_region32_t *damage,
                 container_current_parent_layout(con);
 
         if (state->border_right) {
-                if (!container_is_floating(con) && siblings->length == 1 && layout == L_HORIZ) {
+                if (!container_is_current_floating(con) && siblings->length == 1 && layout == L_HORIZ) {
                         memcpy(&color, colors->indicator, sizeof(float) * 4);
                 } else {
                         memcpy(&color, colors->child_border, sizeof(float) * 4);
                 }
                 premultiply_alpha(color, con->alpha);
-                box.x = state->content_x + state->content_width;
-                box.y = state->content_y;
+                box.x = floor(state->content_x + state->content_width);
+                box.y = floor(state->content_y);
                 box.width = state->border_thickness;
                 box.height = state->content_height;
                 scale_box(&box, output_scale);
@@ -376,14 +399,14 @@ static void render_view(struct sway_output *output, pixman_region32_t *damage,
         }
 
         if (state->border_bottom) {
-                if (!container_is_floating(con) && siblings->length == 1 && layout == L_VERT) {
+                if (!container_is_current_floating(con) && siblings->length == 1 && layout == L_VERT) {
                         memcpy(&color, colors->indicator, sizeof(float) * 4);
                 } else {
                         memcpy(&color, colors->child_border, sizeof(float) * 4);
                 }
                 premultiply_alpha(color, con->alpha);
-                box.x = state->x;
-                box.y = state->content_y + state->content_height;
+                box.x = floor(state->x);
+                box.y = floor(state->content_y + state->content_height);
                 box.width = state->width;
                 box.height = state->border_thickness;
                 scale_box(&box, output_scale);
@@ -464,9 +487,10 @@ static void render_titlebar(struct sway_output *output,
         int ob_marks_x = 0; // output-buffer-local
         int ob_marks_width = 0; // output-buffer-local
         if (config->show_marks && marks_texture) {
-                struct wlr_box texture_box;
-                wlr_texture_get_size(marks_texture,
-                        &texture_box.width, &texture_box.height);
+                struct wlr_box texture_box = {
+                        .width = marks_texture->width,
+                        .height = marks_texture->height,
+                };
                 ob_marks_width = texture_box.width;
 
                 // The marks texture might be shorter than the config->font_height, in
@@ -517,15 +541,23 @@ static void render_titlebar(struct sway_output *output,
         int ob_title_x = 0;  // output-buffer-local
         int ob_title_width = 0; // output-buffer-local
         if (title_texture) {
-                struct wlr_box texture_box;
-                wlr_texture_get_size(title_texture,
-                        &texture_box.width, &texture_box.height);
+                struct wlr_box texture_box = {
+                        .width = title_texture->width,
+                        .height = title_texture->height,
+                };
+
+                // The effective output may be NULL when con is not on any output.
+                // This can happen because we render all children of containers,
+                // even those that are out of the bounds of any output.
+                struct sway_output *effective = container_get_effective_output(con);
+                float title_scale = effective ? effective->wlr_output->scale : output_scale;
+                texture_box.width = texture_box.width * output_scale / title_scale;
+                texture_box.height = texture_box.height * output_scale / title_scale;
                 ob_title_width = texture_box.width;
 
                 // The title texture might be shorter than the config->font_height,
                 // in which case we need to pad it above and below.
-                int ob_padding_above = round((config->font_baseline -
-                                        con->title_baseline + titlebar_v_padding -
+                int ob_padding_above = round((titlebar_v_padding -
                                         titlebar_border_thickness) * output_scale);
                 int ob_padding_below = ob_bg_height - ob_padding_above -
                         texture_box.height;
@@ -660,8 +692,8 @@ static void render_top_border(struct sway_output *output,
         // Child border - top edge
         memcpy(&color, colors->child_border, sizeof(float) * 4);
         premultiply_alpha(color, con->alpha);
-        box.x = state->x;
-        box.y = state->y;
+        box.x = floor(state->x);
+        box.y = floor(state->y);
         box.width = state->width;
         box.height = state->border_thickness;
         scale_box(&box, output_scale);
@@ -716,8 +748,8 @@ static void render_containers_linear(struct sway_output *output,
                         }
 
                         if (state->border == B_NORMAL) {
-                                render_titlebar(output, damage, child, state->x,
-                                                state->y, state->width, colors,
+                                render_titlebar(output, damage, child, floor(state->x),
+                                                floor(state->y), state->width, colors,
                                                 title_texture, marks_texture);
                         } else if (state->border == B_PIXEL) {
                                 render_top_border(output, damage, child, colors);
@@ -730,6 +762,14 @@ static void render_containers_linear(struct sway_output *output,
         }
 }
 
+static bool container_is_focused(struct sway_container *con, void *data) {
+        return con->current.focused;
+}
+
+static bool container_has_focused_child(struct sway_container *con) {
+        return container_find_child(con, container_is_focused, NULL);
+}
+
 /**
  * Render a container's children using the L_TABBED layout.
  */
@@ -761,6 +801,10 @@ static void render_containers_tabbed(struct sway_output *output,
                         colors = &config->border_colors.focused;
                         title_texture = child->title_focused;
                         marks_texture = child->marks_focused;
+                } else if (config->has_focused_tab_title && container_has_focused_child(child)) {
+                        colors = &config->border_colors.focused_tab_title;
+                        title_texture = child->title_focused_tab_title;
+                        marks_texture = child->marks_focused_tab_title;
                 } else if (child == parent->active_child) {
                         colors = &config->border_colors.focused_inactive;
                         title_texture = child->title_focused_inactive;
@@ -771,7 +815,7 @@ static void render_containers_tabbed(struct sway_output *output,
                         marks_texture = child->marks_unfocused;
                 }
 
-                int x = cstate->x + tab_width * i;
+                int x = floor(cstate->x + tab_width * i);
 
                 // Make last tab use the remaining width of the parent
                 if (i == parent->children->length - 1) {
@@ -826,7 +870,11 @@ static void render_containers_stacked(struct sway_output *output,
                         colors = &config->border_colors.focused;
                         title_texture = child->title_focused;
                         marks_texture = child->marks_focused;
-                } else if (child == parent->active_child) {
+                } else if (config->has_focused_tab_title && container_has_focused_child(child)) {
+                        colors = &config->border_colors.focused_tab_title;
+                        title_texture = child->title_focused_tab_title;
+                        marks_texture = child->marks_focused_tab_title;
+                 } else if (child == parent->active_child) {
                         colors = &config->border_colors.focused_inactive;
                         title_texture = child->title_focused_inactive;
                         marks_texture = child->marks_focused_inactive;
@@ -884,8 +932,8 @@ static void render_container(struct sway_output *output,
         struct parent_data data = {
                 .layout = con->current.layout,
                 .box = {
-                        .x = con->current.x,
-                        .y = con->current.y,
+                        .x = floor(con->current.x),
+                        .y = floor(con->current.y),
                         .width = con->current.width,
                         .height = con->current.height,
                 },
@@ -901,8 +949,8 @@ static void render_workspace(struct sway_output *output,
         struct parent_data data = {
                 .layout = ws->current.layout,
                 .box = {
-                        .x = ws->current.x,
-                        .y = ws->current.y,
+                        .x = floor(ws->current.x),
+                        .y = floor(ws->current.y),
                         .width = ws->current.width,
                         .height = ws->current.height,
                 },
@@ -936,8 +984,8 @@ static void render_floating_container(struct sway_output *soutput,
                 }
 
                 if (con->current.border == B_NORMAL) {
-                        render_titlebar(soutput, damage, con, con->current.x,
-                                        con->current.y, con->current.width, colors,
+                        render_titlebar(soutput, damage, con, floor(con->current.x),
+                                        floor(con->current.y), con->current.width, colors,
                                         title_texture, marks_texture);
                 } else if (con->current.border == B_PIXEL) {
                         render_top_border(soutput, damage, con, colors);
@@ -959,7 +1007,7 @@ static void render_floating(struct sway_output *soutput,
                         }
                         for (int k = 0; k < ws->current.floating->length; ++k) {
                                 struct sway_container *floater = ws->current.floating->items[k];
-                                if (floater->fullscreen_mode != FULLSCREEN_NONE) {
+                                if (floater->current.fullscreen_mode != FULLSCREEN_NONE) {
                                         continue;
                                 }
                                 render_floating_container(soutput, damage, floater);
@@ -979,13 +1027,7 @@ static void render_seatops(struct sway_output *output,
 void output_render(struct sway_output *output, struct timespec *when,
                 pixman_region32_t *damage) {
         struct wlr_output *wlr_output = output->wlr_output;
-
-        struct wlr_renderer *renderer =
-                wlr_backend_get_renderer(wlr_output->backend);
-        if (!sway_assert(renderer != NULL,
-                        "expected the output backend to have a renderer")) {
-                return;
-        }
+        struct wlr_renderer *renderer = output->server->renderer;
 
         struct sway_workspace *workspace = output->current.active_workspace;
         if (workspace == NULL) {
@@ -999,6 +1041,12 @@ void output_render(struct sway_output *output, struct timespec *when,
 
         wlr_renderer_begin(renderer, wlr_output->width, wlr_output->height);
 
+        if (debug.damage == DAMAGE_RERENDER) {
+                int width, height;
+                wlr_output_transformed_resolution(wlr_output, &width, &height);
+                pixman_region32_union_rect(damage, damage, 0, 0, width, height);
+        }
+
         if (!pixman_region32_not_empty(damage)) {
                 // Output isn't damaged but needs buffer swap
                 goto renderer_end;
@@ -1006,10 +1054,41 @@ void output_render(struct sway_output *output, struct timespec *when,
 
         if (debug.damage == DAMAGE_HIGHLIGHT) {
                 wlr_renderer_clear(renderer, (float[]){1, 1, 0, 1});
-        } else if (debug.damage == DAMAGE_RERENDER) {
-                int width, height;
-                wlr_output_transformed_resolution(wlr_output, &width, &height);
-                pixman_region32_union_rect(damage, damage, 0, 0, width, height);
+        }
+
+        if (server.session_lock.locked) {
+                float clear_color[] = {0.0f, 0.0f, 0.0f, 1.0f};
+                if (server.session_lock.lock == NULL) {
+                        // abandoned lock -> red BG
+                        clear_color[0] = 1.f;
+                }
+                int nrects;
+                pixman_box32_t *rects = pixman_region32_rectangles(damage, &nrects);
+                for (int i = 0; i < nrects; ++i) {
+                        scissor_output(wlr_output, &rects[i]);
+                        wlr_renderer_clear(renderer, clear_color);
+                }
+
+                if (server.session_lock.lock != NULL) {
+                        struct render_data data = {
+                                .damage = damage,
+                                .alpha = 1.0f,
+                        };
+
+                        struct wlr_session_lock_surface_v1 *lock_surface;
+                        wl_list_for_each(lock_surface, &server.session_lock.lock->surfaces, link) {
+                                if (lock_surface->output != wlr_output) {
+                                        continue;
+                                }
+                                if (!lock_surface->mapped) {
+                                        continue;
+                                }
+
+                                output_surface_for_each_surface(output, lock_surface->surface,
+                                        0.0, 0.0, render_surface_iterator, &data);
+                        }
+                }
+                goto renderer_end;
         }
 
         if (output_has_opaque_overlay_layer_surface(output)) {
@@ -1110,7 +1189,7 @@ renderer_end:
         wlr_region_transform(&frame_damage, &output->damage->current,
                 transform, width, height);
 
-        if (debug.damage == DAMAGE_HIGHLIGHT) {
+        if (debug.damage != DAMAGE_DEFAULT) {
                 pixman_region32_union_rect(&frame_damage, &frame_damage,
                         0, 0, wlr_output->width, wlr_output->height);
         }