6 files changed, 148 insertions, 77 deletions

diff --git a/sway/desktop/launcher.c b/sway/desktop/launcher.c
index 00a7e38a..28043d19 100644
--- a/sway/desktop/launcher.c
+++ b/sway/desktop/launcher.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdlib.h>
 #include <string.h>
 #include <wlr/types/wlr_xdg_activation_v1.h>
@@ -67,6 +66,9 @@ void launcher_ctx_destroy(struct launcher_ctx *ctx) {
         }
         wl_list_remove(&ctx->node_destroy.link);
         wl_list_remove(&ctx->token_destroy.link);
+        if (ctx->seat) {
+                wl_list_remove(&ctx->seat_destroy.link);
+        }
         wl_list_remove(&ctx->link);
         wlr_xdg_activation_token_v1_destroy(ctx->token);
         free(ctx->fallback_name);
@@ -213,6 +215,8 @@ struct launcher_ctx *launcher_ctx_create(struct wlr_xdg_activation_token_v1 *tok
         ctx->fallback_name = strdup(fallback_name);
         ctx->token = token;
         ctx->node = node;
+        // Having surface set means that the focus check in wlroots has passed
+        ctx->had_focused_surface = token->surface != NULL;
 
         ctx->node_destroy.notify = ctx_handle_node_destroy;
         wl_signal_add(&ctx->node->events.destroy, &ctx->node_destroy);
@@ -227,6 +231,12 @@ struct launcher_ctx *launcher_ctx_create(struct wlr_xdg_activation_token_v1 *tok
         return ctx;
 }
 
+static void launch_ctx_handle_seat_destroy(struct wl_listener *listener, void *data) {
+        struct launcher_ctx *ctx = wl_container_of(listener, ctx, seat_destroy);
+        ctx->seat = NULL;
+        wl_list_remove(&ctx->seat_destroy.link);
+}
+
 // Creates a context with a new token for the internal launcher
 struct launcher_ctx *launcher_ctx_create_internal(void) {
         struct sway_seat *seat = input_manager_current_seat();
@@ -238,13 +248,15 @@ struct launcher_ctx *launcher_ctx_create_internal(void) {
 
         struct wlr_xdg_activation_token_v1 *token =
                 wlr_xdg_activation_token_v1_create(server.xdg_activation_v1);
-        token->seat = seat->wlr_seat;
 
         struct launcher_ctx *ctx = launcher_ctx_create(token, &ws->node);
         if (!ctx) {
                 wlr_xdg_activation_token_v1_destroy(token);
                 return NULL;
         }
+        ctx->seat = seat;
+        ctx->seat_destroy.notify = launch_ctx_handle_seat_destroy;
+        wl_signal_add(&seat->wlr_seat->events.destroy, &ctx->seat_destroy);
 
         return ctx;
 }
diff --git a/sway/desktop/layer_shell.c b/sway/desktop/layer_shell.c
index c71abce7..6221b7b9 100644
--- a/sway/desktop/layer_shell.c
+++ b/sway/desktop/layer_shell.c
@@ -2,9 +2,12 @@
 #include <stdlib.h>
 #include <string.h>
 #include <wayland-server-core.h>
+#include <wlr/types/wlr_fractional_scale_v1.h>
 #include <wlr/types/wlr_layer_shell_v1.h>
 #include <wlr/types/wlr_output.h>
+#include <wlr/types/wlr_scene.h>
 #include <wlr/types/wlr_subcompositor.h>
+#include <wlr/types/wlr_xdg_shell.h>
 #include "log.h"
 #include "sway/scene_descriptor.h"
 #include "sway/desktop/transaction.h"
@@ -16,7 +19,6 @@
 #include "sway/server.h"
 #include "sway/tree/arrange.h"
 #include "sway/tree/workspace.h"
-#include <wlr/types/wlr_scene.h>
 
 struct wlr_layer_surface_v1 *toplevel_layer_surface_from_surface(
                 struct wlr_surface *surface) {
@@ -85,6 +87,8 @@ void arrange_layers(struct sway_output *output) {
                 sway_log(SWAY_DEBUG, "Usable area changed, rearranging output");
                 output->usable_area = usable_area;
                 arrange_output(output);
+        } else {
+                arrange_popups(root->layers.popup);
         }
 }
 
@@ -120,10 +124,21 @@ static struct sway_layer_surface *sway_layer_surface_create(
                 return NULL;
         }
 
+        surface->desc.relative = &scene->tree->node;
+
+        if (!scene_descriptor_assign(&popups->node,
+                        SWAY_SCENE_DESC_POPUP, &surface->desc)) {
+                sway_log(SWAY_ERROR, "Failed to allocate a popup scene descriptor");
+                wlr_scene_node_destroy(&popups->node);
+                free(surface);
+                return NULL;
+        }
+
         surface->tree = scene->tree;
         surface->scene = scene;
         surface->layer_surface = scene->layer_surface;
         surface->popups = popups;
+        surface->layer_surface->data = surface;
 
         return surface;
 }
@@ -197,6 +212,8 @@ static void handle_node_destroy(struct wl_listener *listener, void *data) {
         wl_list_remove(&layer->node_destroy.link);
         wl_list_remove(&layer->output_destroy.link);
 
+        layer->layer_surface->data = NULL;
+
         free(layer);
 }
 
@@ -222,10 +239,6 @@ static void handle_surface_commit(struct wl_listener *listener, void *data) {
                 arrange_layers(surface->output);
                 transaction_commit_dirty();
         }
-
-        int lx, ly;
-        wlr_scene_node_coords(&surface->scene->tree->node, &lx, &ly);
-        wlr_scene_node_set_position(&surface->popups->node, lx, ly);
 }
 
 static void handle_map(struct wl_listener *listener, void *data) {
@@ -420,6 +433,12 @@ void handle_layer_shell_surface(struct wl_listener *listener, void *data) {
 
         surface->output = output;
 
+        // now that the surface's output is known, we can advertise its scale
+        wlr_fractional_scale_v1_notify_scale(surface->layer_surface->surface,
+                layer_surface->output->scale);
+        wlr_surface_set_preferred_buffer_scale(surface->layer_surface->surface,
+                ceil(layer_surface->output->scale));
+
         surface->surface_commit.notify = handle_surface_commit;
         wl_signal_add(&layer_surface->surface->events.commit,
                 &surface->surface_commit);
diff --git a/sway/desktop/output.c b/sway/desktop/output.c
index 9c4baafd..2722e556 100644
--- a/sway/desktop/output.c
+++ b/sway/desktop/output.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
 #include <stdlib.h>
 #include <strings.h>
@@ -12,6 +11,8 @@
 #include <wlr/types/wlr_gamma_control_v1.h>
 #include <wlr/types/wlr_matrix.h>
 #include <wlr/types/wlr_output_layout.h>
+#include <wlr/types/wlr_output_management_v1.h>
+#include <wlr/types/wlr_output_power_management_v1.h>
 #include <wlr/types/wlr_output.h>
 #include <wlr/types/wlr_presentation_time.h>
 #include <wlr/types/wlr_compositor.h>
@@ -182,7 +183,15 @@ static void send_frame_done_iterator(struct wlr_scene_buffer *buffer,
         }
 }
 
-static enum wlr_scale_filter_mode get_scale_filter(struct sway_output *output) {
+static enum wlr_scale_filter_mode get_scale_filter(struct sway_output *output,
+                struct wlr_scene_buffer *buffer) {
+        // if we are scaling down, we should always choose linear
+        if (buffer->dst_width > 0 && buffer->dst_height > 0 && (
+                        buffer->dst_width < buffer->buffer_width ||
+                        buffer->dst_height < buffer->buffer_height)) {
+                return WLR_SCALE_FILTER_BILINEAR;
+        }
+
         switch (output->scale_filter) {
         case SCALE_FILTER_LINEAR:
                 return WLR_SCALE_FILTER_BILINEAR;
@@ -211,7 +220,7 @@ static void output_configure_scene(struct sway_output *output,
                 // hack: don't call the scene setter because that will damage all outputs
                 // We don't want to damage outputs that aren't our current output that
                 // we're configuring
-                buffer->filter_mode = get_scale_filter(output);
+                buffer->filter_mode = get_scale_filter(output, buffer);
 
                 wlr_scene_buffer_set_opacity(buffer, opacity);
         } else if (node->type == WLR_SCENE_NODE_TREE) {
@@ -512,9 +521,7 @@ void handle_new_output(struct wl_listener *listener, void *data) {
                 sway_session_lock_add_output(server->session_lock.lock, output);
         }
 
-        struct output_config *oc = find_output_config(output);
-        apply_output_config(oc, output);
-        free_output_config(oc);
+        apply_all_output_configs();
 
         transaction_commit_dirty();
 
@@ -543,63 +550,89 @@ void handle_gamma_control_set_gamma(struct wl_listener *listener, void *data) {
         wlr_output_schedule_frame(output->wlr_output);
 }
 
+static struct output_config *output_config_for_config_head(
+                struct wlr_output_configuration_head_v1 *config_head,
+                struct sway_output *output) {
+        struct output_config *oc = new_output_config(output->wlr_output->name);
+        oc->enabled = config_head->state.enabled;
+        if (!oc->enabled) {
+                return oc;
+        }
+
+        if (config_head->state.mode != NULL) {
+                struct wlr_output_mode *mode = config_head->state.mode;
+                oc->width = mode->width;
+                oc->height = mode->height;
+                oc->refresh_rate = mode->refresh / 1000.f;
+        } else {
+                oc->width = config_head->state.custom_mode.width;
+                oc->height = config_head->state.custom_mode.height;
+                oc->refresh_rate =
+                        config_head->state.custom_mode.refresh / 1000.f;
+        }
+        oc->x = config_head->state.x;
+        oc->y = config_head->state.y;
+        oc->transform = config_head->state.transform;
+        oc->scale = config_head->state.scale;
+        oc->adaptive_sync = config_head->state.adaptive_sync_enabled;
+        return oc;
+}
+
 static void output_manager_apply(struct sway_server *server,
                 struct wlr_output_configuration_v1 *config, bool test_only) {
-        // TODO: perform atomic tests on the whole backend atomically
-
-        struct wlr_output_configuration_head_v1 *config_head;
-        // First disable outputs we need to disable
-        bool ok = true;
-        wl_list_for_each(config_head, &config->heads, link) {
-                struct wlr_output *wlr_output = config_head->state.output;
-                struct sway_output *output = wlr_output->data;
-                if (!output->enabled || config_head->state.enabled) {
+        size_t configs_len = wl_list_length(&root->all_outputs);
+        struct matched_output_config *configs = calloc(configs_len, sizeof(*configs));
+        if (!configs) {
+                return;
+        }
+
+        int config_idx = 0;
+        struct sway_output *sway_output;
+        wl_list_for_each(sway_output, &root->all_outputs, link) {
+                if (sway_output == root->fallback_output) {
+                        configs_len--;
                         continue;
                 }
-                struct output_config *oc = new_output_config(output->wlr_output->name);
-                oc->enabled = false;
 
-                if (test_only) {
-                        ok &= test_output_config(oc, output);
-                } else {
-                        oc = store_output_config(oc);
-                        ok &= apply_output_config(oc, output);
+                struct matched_output_config *cfg = &configs[config_idx++];
+                cfg->output = sway_output;
+
+                struct wlr_output_configuration_head_v1 *config_head;
+                wl_list_for_each(config_head, &config->heads, link) {
+                        if (config_head->state.output == sway_output->wlr_output) {
+                                cfg->config = output_config_for_config_head(config_head, sway_output);
+                                break;
+                        }
+                }
+                if (!cfg->config) {
+                        cfg->config = find_output_config(sway_output);
                 }
         }
 
-        // Then enable outputs that need to
-        wl_list_for_each(config_head, &config->heads, link) {
-                struct wlr_output *wlr_output = config_head->state.output;
-                struct sway_output *output = wlr_output->data;
-                if (!config_head->state.enabled) {
-                        continue;
-                }
-                struct output_config *oc = new_output_config(output->wlr_output->name);
-                oc->enabled = true;
-                if (config_head->state.mode != NULL) {
-                        struct wlr_output_mode *mode = config_head->state.mode;
-                        oc->width = mode->width;
-                        oc->height = mode->height;
-                        oc->refresh_rate = mode->refresh / 1000.f;
-                } else {
-                        oc->width = config_head->state.custom_mode.width;
-                        oc->height = config_head->state.custom_mode.height;
-                        oc->refresh_rate =
-                                config_head->state.custom_mode.refresh / 1000.f;
+        sort_output_configs_by_priority(configs, configs_len);
+        bool ok = apply_output_configs(configs, configs_len, test_only, false);
+        for (size_t idx = 0; idx < configs_len; idx++) {
+                struct matched_output_config *cfg = &configs[idx];
+
+                // Only store new configs for successful non-test commits. Old configs,
+                // test-only and failed commits just get freed.
+                bool store_config = false;
+                if (!test_only && ok) {
+                        struct wlr_output_configuration_head_v1 *config_head;
+                        wl_list_for_each(config_head, &config->heads, link) {
+                                if (config_head->state.output == cfg->output->wlr_output) {
+                                        store_config = true;
+                                        break;
+                                }
+                        }
                 }
-                oc->x = config_head->state.x;
-                oc->y = config_head->state.y;
-                oc->transform = config_head->state.transform;
-                oc->scale = config_head->state.scale;
-                oc->adaptive_sync = config_head->state.adaptive_sync_enabled;
-
-                if (test_only) {
-                        ok &= test_output_config(oc, output);
+                if (store_config) {
+                        store_output_config(cfg->config);
                 } else {
-                        oc = store_output_config(oc);
-                        ok &= apply_output_config(oc, output);
+                        free_output_config(cfg->config);
                 }
         }
+        free(configs);
 
         if (ok) {
                 wlr_output_configuration_v1_send_succeeded(config);
@@ -643,6 +676,6 @@ void handle_output_power_manager_set_mode(struct wl_listener *listener,
                 oc->power = 1;
                 break;
         }
-        oc = store_output_config(oc);
-        apply_output_config(oc, output);
+        store_output_config(oc);
+        apply_all_output_configs();
 }
diff --git a/sway/desktop/transaction.c b/sway/desktop/transaction.c
index acc3e3f9..042141ab 100644
--- a/sway/desktop/transaction.c
+++ b/sway/desktop/transaction.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
@@ -606,21 +605,15 @@ static void arrange_output(struct sway_output *output, int width, int height) {
         }
 }
 
-static void arrange_popup(struct wlr_scene_tree *popup) {
+void arrange_popups(struct wlr_scene_tree *popups) {
         struct wlr_scene_node *node;
-        wl_list_for_each(node, &popup->children, link) {
-                struct sway_xdg_popup *popup = scene_descriptor_try_get(node,
+        wl_list_for_each(node, &popups->children, link) {
+                struct sway_popup_desc *popup = scene_descriptor_try_get(node,
                         SWAY_SCENE_DESC_POPUP);
 
-                // the popup layer may have popups from layer_shell surfaces, in this
-                // case those don't have a scene descriptor, so lets skip those here.
-                if (popup) {
-                        struct wlr_scene_tree *tree = popup->view->content_tree;
-
-                        int lx, ly;
-                        wlr_scene_node_coords(&tree->node, &lx, &ly);
-                        wlr_scene_node_set_position(&popup->scene_tree->node, lx, ly);
-                }
+                int lx, ly;
+                wlr_scene_node_coords(popup->relative, &lx, &ly);
+                wlr_scene_node_set_position(node, lx, ly);
         }
 }
 
@@ -679,7 +672,7 @@ static void arrange_root(struct sway_root *root) {
                 }
         }
 
-        arrange_popup(root->layers.popup);
+        arrange_popups(root->layers.popup);
 }
 
 /**
diff --git a/sway/desktop/xdg_shell.c b/sway/desktop/xdg_shell.c
index 7cdd97c8..7c417891 100644
--- a/sway/desktop/xdg_shell.c
+++ b/sway/desktop/xdg_shell.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 199309L
 #include <float.h>
 #include <stdbool.h>
 #include <stdlib.h>
@@ -36,6 +35,7 @@ static void popup_handle_destroy(struct wl_listener *listener, void *data) {
         wl_list_remove(&popup->new_popup.link);
         wl_list_remove(&popup->destroy.link);
         wl_list_remove(&popup->surface_commit.link);
+        wl_list_remove(&popup->reposition.link);
         wlr_scene_node_destroy(&popup->scene_tree->node);
         free(popup);
 }
@@ -71,6 +71,11 @@ static void popup_handle_surface_commit(struct wl_listener *listener, void *data
         }
 }
 
+static void popup_handle_reposition(struct wl_listener *listener, void *data) {
+        struct sway_xdg_popup *popup = wl_container_of(listener, popup, reposition);
+        popup_unconstrain(popup);
+}
+
 static struct sway_xdg_popup *popup_create(struct wlr_xdg_popup *wlr_popup,
                 struct sway_view *view, struct wlr_scene_tree *parent) {
         struct wlr_xdg_surface *xdg_surface = wlr_popup->base;
@@ -97,8 +102,11 @@ static struct sway_xdg_popup *popup_create(struct wlr_xdg_popup *wlr_popup,
                 return NULL;
         }
 
+        popup->desc.relative = &view->content_tree->node;
+        popup->desc.view = view;
+
         if (!scene_descriptor_assign(&popup->scene_tree->node,
-                        SWAY_SCENE_DESC_POPUP, popup)) {
+                        SWAY_SCENE_DESC_POPUP, &popup->desc)) {
                 sway_log(SWAY_ERROR, "Failed to allocate a popup scene descriptor");
                 wlr_scene_node_destroy(&popup->scene_tree->node);
                 free(popup);
@@ -114,6 +122,8 @@ static struct sway_xdg_popup *popup_create(struct wlr_xdg_popup *wlr_popup,
         popup->surface_commit.notify = popup_handle_surface_commit;
         wl_signal_add(&xdg_surface->events.new_popup, &popup->new_popup);
         popup->new_popup.notify = popup_handle_new_popup;
+        wl_signal_add(&wlr_popup->events.reposition, &popup->reposition);
+        popup->reposition.notify = popup_handle_reposition;
         wl_signal_add(&wlr_popup->events.destroy, &popup->destroy);
         popup->destroy.notify = popup_handle_destroy;
 
@@ -279,6 +289,7 @@ static void handle_commit(struct wl_listener *listener, void *data) {
                 }
                 // XXX: https://github.com/swaywm/sway/issues/2176
                 wlr_xdg_surface_schedule_configure(xdg_surface);
+                // TODO: wlr_xdg_toplevel_set_bounds()
                 return;
         }
 
@@ -337,6 +348,7 @@ static void handle_set_app_id(struct wl_listener *listener, void *data) {
         struct sway_xdg_shell_view *xdg_shell_view =
                 wl_container_of(listener, xdg_shell_view, set_app_id);
         struct sway_view *view = &xdg_shell_view->view;
+        view_update_app_id(view);
         view_execute_criteria(view);
 }
 
@@ -563,4 +575,7 @@ void handle_xdg_shell_toplevel(struct wl_listener *listener, void *data) {
         wlr_scene_xdg_surface_create(xdg_shell_view->view.content_tree, xdg_toplevel->base);
 
         xdg_toplevel->base->data = xdg_shell_view;
+
+        wlr_xdg_toplevel_set_wm_capabilities(xdg_toplevel,
+                XDG_TOPLEVEL_WM_CAPABILITIES_FULLSCREEN);
 }
diff --git a/sway/desktop/xwayland.c b/sway/desktop/xwayland.c
index 9f3f4d5f..270cf08f 100644
--- a/sway/desktop/xwayland.c
+++ b/sway/desktop/xwayland.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 199309L
 #include <float.h>
 #include <stdbool.h>
 #include <stdlib.h>