| // Copyright 2021 The ChromiumOS Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "sommelier-window.h" // NOLINT(build/include_directory) |
| |
| #include <algorithm> |
| #include <climits> |
| #include <fstream> |
| #include <assert.h> |
| #include <cstdint> |
| #include <wayland-client-protocol.h> |
| |
| #include "sommelier.h" // NOLINT(build/include_directory) |
| #include "sommelier-logging.h" // NOLINT(build/include_directory) |
| #include "sommelier-tracing.h" // NOLINT(build/include_directory) |
| #include "sommelier-transform.h" // NOLINT(build/include_directory) |
| #include "viewporter-shim.h" // NOLINT(build/include_directory) |
| #include "xcb/xcb-shim.h" |
| |
| #include "aura-shell-client-protocol.h" // NOLINT(build/include_directory) |
| #include "viewporter-client-protocol.h" // NOLINT(build/include_directory) |
| #include "xdg-shell-client-protocol.h" // NOLINT(build/include_directory) |
| |
| #ifdef QUIRKS_SUPPORT |
| #include "quirks/sommelier-quirks.h" |
| #endif |
| |
| #define XID_APPLICATION_ID_FORMAT APPLICATION_ID_FORMAT_PREFIX ".xid.%d" |
| #define WM_CLIENT_LEADER_APPLICATION_ID_FORMAT \ |
| APPLICATION_ID_FORMAT_PREFIX ".wmclientleader.%d" |
| #define WM_CLASS_APPLICATION_ID_FORMAT \ |
| APPLICATION_ID_FORMAT_PREFIX ".wmclass.%s" |
| #define X11_PROPERTY_APPLICATION_ID_FORMAT \ |
| APPLICATION_ID_FORMAT_PREFIX ".xprop.%s" |
| sl_window::sl_window(struct sl_context* ctx, |
| xcb_window_t id, |
| int x, |
| int y, |
| int width, |
| int height, |
| int border_width) |
| : ctx(ctx), |
| id(id), |
| x(x), |
| y(y), |
| width(width), |
| height(height), |
| border_width(border_width) { |
| wl_list_insert(&ctx->unpaired_windows, &link); |
| pixman_region32_init(&shape_rectangles); |
| } |
| |
| sl_window::~sl_window() { |
| if (this == ctx->host_focus_window) { |
| ctx->host_focus_window = nullptr; |
| ctx->needs_set_input_focus = 1; |
| } |
| |
| free(name); |
| free(clazz); |
| free(startup_id); |
| wl_list_remove(&link); |
| pixman_region32_fini(&shape_rectangles); |
| } |
| |
| void sl_configure_window(struct sl_window* window) { |
| TRACE_EVENT("surface", "sl_configure_window", "id", window->id); |
| assert(!window->pending_config.serial); |
| |
| if (window->next_config.mask) { |
| int x = window->x; |
| int y = window->y; |
| int i = 0; |
| |
| xcb()->configure_window(window->ctx->connection, window->frame_id, |
| window->next_config.mask, |
| window->next_config.values); |
| |
| if (window->next_config.mask & XCB_CONFIG_WINDOW_X) { |
| x = window->next_config.values[i++]; |
| } |
| if (window->next_config.mask & XCB_CONFIG_WINDOW_Y) { |
| y = window->next_config.values[i++]; |
| } |
| if (window->next_config.mask & XCB_CONFIG_WINDOW_WIDTH) { |
| window->width = window->next_config.values[i++]; |
| } |
| if (window->next_config.mask & XCB_CONFIG_WINDOW_HEIGHT) { |
| window->height = window->next_config.values[i++]; |
| } |
| if (window->next_config.mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) { |
| window->border_width = window->next_config.values[i++]; |
| } |
| |
| // Set x/y to origin in case window gravity is not northwest as expected. |
| assert(window->managed); |
| |
| uint32_t values[5]; |
| // Populate values[0~3] with x,y,w,h |
| // x and y need to be 0. We are configuring the child window, not the frame |
| // window, and the child window should always have a zero offset from its |
| // frame (parent) window. See |
| // https://en.wikipedia.org/wiki/Re-parenting_window_manager |
| values[0] = 0; |
| values[1] = 0; |
| sl_window_get_width_height(window, &values[2], &values[3]); |
| |
| values[4] = window->border_width; |
| xcb()->configure_window( |
| window->ctx->connection, window->id, |
| XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | |
| XCB_CONFIG_WINDOW_HEIGHT | XCB_CONFIG_WINDOW_BORDER_WIDTH, |
| values); |
| |
| if (x != window->x || y != window->y) { |
| window->x = x; |
| window->y = y; |
| sl_send_configure_notify(window); |
| } |
| } |
| |
| if (window->managed) { |
| xcb()->change_property( |
| window->ctx->connection, XCB_PROP_MODE_REPLACE, window->id, |
| window->ctx->atoms[ATOM_NET_WM_STATE].value, XCB_ATOM_ATOM, 32, |
| window->next_config.states_length, window->next_config.states); |
| } |
| |
| window->pending_config = window->next_config; |
| window->next_config.serial = 0; |
| window->next_config.mask = 0; |
| window->next_config.states_length = 0; |
| } |
| |
| void sl_send_configure_notify(struct sl_window* window) { |
| // Send a "synthetic" ConfigureNotify event. |
| xcb_configure_notify_event_t event = {}; |
| event.response_type = XCB_CONFIGURE_NOTIFY; |
| event.pad0 = 0; |
| event.event = window->id; |
| event.window = window->id; |
| event.above_sibling = XCB_WINDOW_NONE; |
| |
| // Per ICCCM, synthetic ConfigureNotify events use root coordinates |
| // even if the window has been reparented. |
| uint32_t xywh[4]; |
| sl_window_get_x_y(window, &xywh[0], &xywh[1]); |
| sl_window_get_width_height(window, &xywh[2], &xywh[3]); |
| event.x = static_cast<int16_t>(xywh[0]); |
| event.y = static_cast<int16_t>(xywh[1]); |
| event.width = static_cast<uint16_t>(xywh[2]); |
| event.height = static_cast<uint16_t>(xywh[3]); |
| |
| event.border_width = static_cast<uint16_t>(window->border_width); |
| event.override_redirect = 0; |
| event.pad1 = 0; |
| |
| xcb()->send_event(window->ctx->connection, 0, window->id, |
| XCB_EVENT_MASK_STRUCTURE_NOTIFY, |
| reinterpret_cast<char*>(&event)); |
| } |
| |
| int sl_process_pending_configure_acks(struct sl_window* window, |
| struct sl_host_surface* host_surface) { |
| if (!window->pending_config.serial) { |
| return 0; |
| } |
| |
| #ifdef COMMIT_LOOP_FIX |
| // Do not commit/ack if there is nothing to change. |
| // |
| // TODO(b/181077580): we should never do this, but avoiding it requires a |
| // more systemic fix |
| if (!window->pending_config.mask && |
| window->pending_config.states_length == 0) { |
| return 0; |
| } |
| #endif |
| |
| if (window->managed && host_surface) { |
| if (window->viewport_override) { |
| // If viewport override is set, only check viewport size and completely |
| // ignore window size for containerized windows. |
| if (sl_window_is_containerized(window) && |
| (window->viewport_height != window->viewport_height_realized || |
| window->viewport_width != window->viewport_width_realized)) { |
| return 0; |
| } |
| } else { |
| uint32_t width = window->width + window->border_width * 2; |
| uint32_t height = window->height + window->border_width * 2; |
| // Early out if we expect contents to match window size at some point in |
| // the future. |
| if ((width != host_surface->contents_width || |
| height != host_surface->contents_height)) { |
| return 0; |
| } |
| } |
| } |
| |
| if (window->xdg_surface) { |
| xdg_surface_ack_configure(window->xdg_surface, |
| window->pending_config.serial); |
| } |
| window->pending_config.serial = 0; |
| |
| if (window->next_config.serial) { |
| sl_configure_window(window); |
| } |
| |
| return 1; |
| } |
| |
| void sl_commit(struct sl_window* window, struct sl_host_surface* host_surface) { |
| if (sl_process_pending_configure_acks(window, host_surface)) { |
| if (host_surface) { |
| wl_surface_commit(host_surface->proxy); |
| } |
| } |
| } |
| |
| static const struct xdg_popup_listener sl_internal_xdg_popup_listener = { |
| /*configure=*/DoNothing, /*done=*/DoNothing}; |
| |
| static void sl_internal_xdg_surface_configure(void* data, |
| struct xdg_surface* xdg_surface, |
| uint32_t serial) { |
| TRACE_EVENT("surface", "sl_internal_xdg_surface_configure"); |
| struct sl_window* window = |
| static_cast<sl_window*>(xdg_surface_get_user_data(xdg_surface)); |
| |
| window->next_config.serial = serial; |
| |
| if (window->configure_event_barrier) { |
| window->coalesced_next_config = window->next_config; |
| window->next_config.serial = 0; |
| } else if (!window->pending_config.serial) { |
| struct wl_resource* host_resource; |
| struct sl_host_surface* host_surface = nullptr; |
| |
| host_resource = |
| wl_client_get_object(window->ctx->client, window->host_surface_id); |
| if (host_resource) { |
| host_surface = static_cast<sl_host_surface*>( |
| wl_resource_get_user_data(host_resource)); |
| } |
| |
| sl_configure_window(window); |
| sl_commit(window, host_surface); |
| } |
| } |
| |
| static const struct xdg_surface_listener sl_internal_xdg_surface_listener = { |
| sl_internal_xdg_surface_configure}; |
| |
| static void sl_internal_xdg_surface_configure_barrier_done( |
| void* data, struct wl_callback* callback, uint32_t serial) { |
| struct sl_window* window = |
| static_cast<sl_window*>(wl_callback_get_user_data(callback)); |
| |
| window->configure_event_barrier = nullptr; |
| |
| if (window->coalesced_next_config.serial) { |
| window->next_config = window->coalesced_next_config; |
| window->coalesced_next_config.serial = 0; |
| sl_internal_xdg_surface_configure(data, window->xdg_surface, |
| window->next_config.serial); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // common toplevel code |
| |
| static const int32_t kUnspecifiedCoord = INT32_MIN; |
| |
| void sl_window_update_should_be_containerized_from_pid( |
| struct sl_window* window) { |
| bool quirk_enabled = false; |
| #ifdef QUIRKS_SUPPORT |
| quirk_enabled = window->ctx->quirks.IsEnabled( |
| window, quirks::FEATURE_CONTAINERIZE_WINDOWS); |
| #endif |
| if (!quirk_enabled || !window->pid) { |
| return; |
| } |
| |
| // If the binary name contains certain keywords, it is probably not actually a |
| // game. |
| char comm_file_path[50]; |
| snprintf(comm_file_path, sizeof(comm_file_path), "/proc/%d/comm", |
| window->pid); |
| std::ifstream proc_comm_file(comm_file_path); |
| if (proc_comm_file.is_open()) { |
| std::string process_name; |
| if (getline(proc_comm_file, process_name)) { |
| std::transform(process_name.begin(), process_name.end(), |
| process_name.begin(), tolower); |
| window->should_be_containerized_from_pid = |
| (process_name.find("launcher") == std::string::npos && |
| process_name.find("easyanticheat") == std::string::npos && |
| process_name.find("battleeye") == std::string::npos && |
| process_name.find("nprotect") == std::string::npos); |
| } |
| proc_comm_file.close(); |
| } |
| |
| // TODO(endlesspring): Consider other aspects of the process - memory |
| // usage, library usage, etc to determine. |
| } |
| |
| bool sl_window_is_containerized(struct sl_window* window) { |
| bool window_containerized = false; |
| #ifdef QUIRKS_SUPPORT |
| bool probably_game_window = |
| // Steam game ID property is set |
| window->steam_game_id && |
| // Window type is normal |
| window->type == |
| window->ctx->atoms[ATOM_NET_WM_WINDOW_TYPE_NORMAL].value && |
| // Based on the PID and derived information, the window is probably a game |
| // window. |
| window->should_be_containerized_from_pid && |
| // Window max dimensions are either not set or if set, bigger (in |
| // half-perimeter) than specified value. |
| ((window->max_width + window->max_height == 0) || |
| (window->max_width + window->max_height >= 400)); |
| if (window_containerized && !probably_game_window) { |
| LOG(VERBOSE) << window |
| << " is not a game window! max_width=" << window->max_width; |
| } |
| window_containerized = |
| probably_game_window && window->ctx->quirks.IsEnabled( |
| window, quirks::FEATURE_CONTAINERIZE_WINDOWS); |
| #endif |
| return window_containerized; |
| } |
| |
| void sl_window_reset_viewport(struct sl_window* window) { |
| LOG(VERBOSE) << window << " viewport override unset"; |
| window->viewport_width = -1; |
| window->viewport_height = -1; |
| window->viewport_override = false; |
| // Note that viewport destination is reset during surface_commit. |
| } |
| |
| // Handle a configure event on a toplevel object from the compositor. |
| // |
| // window: The window being configured. |
| // x: The configured X coordinate in host logical space, or kUnspecifiedCoord |
| // for toplevel objects that don't send positions. |
| // y: The configured Y coordinate in host logical space, or kUnspecifiedCoord |
| // for toplevel objects that don't send positions. |
| // width, height: Configured size in host logical space. |
| // states: Array of XDG_TOPLEVEL_STATE_* enum values. |
| void sl_internal_toplevel_configure(struct sl_window* window, |
| int32_t x, |
| int32_t y, |
| int32_t width, |
| int32_t height, |
| struct wl_array* states) { |
| if (!window->managed || |
| (window->ctx->ignore_stateless_toplevel_configure && states->size == 0)) { |
| // Ignore requests for non-managed windows. |
| // Ignore requests with no states if --ignore-stateless-toplevel-configure |
| // is set. |
| return; |
| } |
| |
| bool window_containerized = sl_window_is_containerized(window); |
| |
| if (window_containerized) { |
| // Process window states first, so that window position and size can be |
| // configured based on the states. If the window is not containerized, we |
| // process the states last. |
| sl_internal_toplevel_configure_state_containerized(window, states); |
| } |
| |
| if (width && height) { |
| int32_t width_in_pixels = width; |
| int32_t height_in_pixels = height; |
| |
| // We are receiving a request to resize a window (in logical dimensions) |
| // If the request is equal to the cached values we used to make adjustments |
| // do not recalculate the values |
| // However, if the request is not equal to the cached values, try |
| // and keep the buffer same size as what was previously set |
| // by the application. |
| struct sl_host_surface* paired_surface = window->paired_surface; |
| |
| if (paired_surface && paired_surface->has_own_scale) { |
| if (width != paired_surface->cached_logical_width || |
| height != paired_surface->cached_logical_height) { |
| sl_transform_try_window_scale(window->ctx, paired_surface, |
| window->width, window->height); |
| } |
| } |
| sl_transform_host_to_guest(window->ctx, window->paired_surface, |
| &width_in_pixels, &height_in_pixels); |
| |
| int config_idx = 0; |
| window->next_config.mask = 0; |
| // Refer to enum xcb_config_window_t for the order of configuration, |
| // position must be done before size. |
| sl_internal_toplevel_configure_position(window, x, y, width_in_pixels, |
| height_in_pixels, config_idx); |
| |
| // We don't need to resize windows using viewports that are windowed and |
| // resizble. |
| if (window_containerized) { |
| sl_internal_toplevel_configure_size_containerized( |
| window, x, y, width, height, width_in_pixels, height_in_pixels, |
| config_idx); |
| } else { |
| sl_internal_toplevel_configure_size(window, x, y, width, height, |
| width_in_pixels, height_in_pixels, |
| config_idx); |
| } |
| } |
| |
| if (!window_containerized) { |
| sl_internal_toplevel_configure_state(window, states); |
| } |
| } |
| |
| void sl_internal_toplevel_configure_size_containerized(struct sl_window* window, |
| int32_t x, |
| int32_t y, |
| int32_t host_width, |
| int32_t host_height, |
| int32_t width_in_pixels, |
| int32_t height_in_pixels, |
| int& mut_config_idx) { |
| // Check the game is windowed (with decorations, indicating that this is not |
| // borderless windowed), and has hinted that it can be resized to the size |
| // that Exo requested. Note that max size 0 means no limits. Note that min&max |
| // dimensions are strictly set by the X11 client only (and forwarded to Exo |
| // immediately). |
| bool windowed_and_resizable = |
| (!window->fullscreen && window->decorated) && |
| (window->max_width >= width_in_pixels || !window->max_width) && |
| window->min_width <= width_in_pixels && |
| (window->max_height >= height_in_pixels || !window->max_height) && |
| window->min_height <= height_in_pixels; |
| // Forward resizes to the client if requested size fits within the min&max |
| // dimensions. |
| if (windowed_and_resizable && !window->use_emulated_rects) { |
| // TODO(b/330639760): Consider unset aspect ratio every frame in |
| // surface_commit. |
| zaura_surface_set_aspect_ratio(window->aura_surface, -1, -1); |
| sl_window_reset_viewport(window); |
| window->next_config.mask |= XCB_CONFIG_WINDOW_WIDTH | |
| XCB_CONFIG_WINDOW_HEIGHT | |
| XCB_CONFIG_WINDOW_BORDER_WIDTH; |
| window->next_config.values[mut_config_idx++] = width_in_pixels; |
| window->next_config.values[mut_config_idx++] = height_in_pixels; |
| window->next_config.values[mut_config_idx++] = 0; |
| LOG(VERBOSE) << window << " size set to " << width_in_pixels << "x" |
| << height_in_pixels; |
| return; |
| } |
| |
| auto output = window->paired_surface->output.get(); |
| |
| // Set the window size to be either max or min window size, set by the X11 |
| // client. If width/height min and max are 0, set the window size to the size |
| // of the screen. If the window is fullscreen (by the client), ignore size |
| // hints and set it to the size of the screen. |
| // We are effectively maximizing the window as much as we can within the |
| // specified range, then down-scaling. This is to have consistent window |
| // rendering experience with the most-expected use-case (fullscreen game, |
| // user hits fullscreen toggle key). However, once we have better upscaling |
| // algorithm, we should consider minimizing the size (or average?) then |
| // upscaling in viewports instead. |
| int safe_window_width = |
| window->max_width ? window->max_width : window->min_width; |
| int safe_window_height = |
| window->max_height ? window->max_height : window->min_height; |
| if (window->use_emulated_rects) { |
| LOG(VERBOSE) << "using emulated rects " << window->emulated_width << "x" |
| << window->emulated_height; |
| // If screen size emulation is set by XWayland, set the window size to the |
| // emulated size and adjust the viewport size as Exo had requested it to be. |
| safe_window_width = window->emulated_width; |
| safe_window_height = window->emulated_height; |
| } else if (!safe_window_width || !safe_window_height || |
| window->max_width > output->width || |
| window->max_height > output->height || window->fullscreen) { |
| safe_window_width = output->width; |
| safe_window_height = output->height; |
| } |
| |
| window->next_config.mask |= XCB_CONFIG_WINDOW_WIDTH | |
| XCB_CONFIG_WINDOW_HEIGHT | |
| XCB_CONFIG_WINDOW_BORDER_WIDTH; |
| window->next_config.values[mut_config_idx++] = safe_window_width; |
| window->next_config.values[mut_config_idx++] = safe_window_height; |
| window->next_config.values[mut_config_idx++] = 0; |
| LOG(VERBOSE) << window << " size(safe) set to " << safe_window_width << "x" |
| << safe_window_height; |
| |
| if (window->use_emulated_rects && window->compositor_fullscreen) { |
| // Some games using emulated rects have xwayland send the wrong viewport |
| // destination, causing the game to render in a small box. This overrides |
| // that via quirk to set the destination to the size of the screen. |
| if (sl_window_should_fix_randr_emu(window)) { |
| window->viewport_override = true; |
| window->viewport_width = host_width; |
| window->viewport_height = host_height; |
| window->viewport_pointer_scale = |
| static_cast<float>(output->logical_width) / window->viewport_width; |
| return; |
| } |
| // If we are using emulated rects and the window is fullscreen in |
| // compositor, we only have to report the emulated size (done above). Aspect |
| // ratio changes are moot (since compositor fullscreen). We don't have to |
| // set viewport overrides since we can fully rely on viewport setup by |
| // Xwayland. |
| // If the window is windowed in compositor, then we have to do additional |
| // viewport operations to make the window fit into the size that compositor |
| // wants it to be, without disrupting the emulation. This has identical code |
| // path as non-emulated mode, except pointer movement scaling (see below). |
| sl_window_reset_viewport(window); |
| return; |
| } |
| |
| // Use viewport to resize surface as per Exo request if we are not using |
| // emulated rects, or window is not fullscreen in Exo (and using emulated |
| // rects). |
| window->viewport_override = true; |
| |
| int32_t safe_window_width_in_wl = safe_window_width; |
| int32_t safe_window_height_in_wl = safe_window_height; |
| sl_transform_guest_to_host(window->ctx, window->paired_surface, |
| &safe_window_width_in_wl, |
| &safe_window_height_in_wl); |
| // TODO(endlesspring): consider ignoring aspect ratio and filling the entire |
| // screen if Exo wants the window to be fullscreen. This wills require having |
| // pointer scale in x and y, instead of one. |
| // if (window->compositor_fullscreen) { |
| // window->viewport_width = output->logical_width; |
| // window->viewport_height = output->logical_height; |
| // window->viewport_pointer_scale = |
| // static_cast<float>(safe_window_width_in_wl) / window->viewport_width; |
| // return; |
| // } |
| |
| // TODO(b/330639760): Once aspect ratio is working correctly, we can entirely |
| // get rid of this ratio calculation, in theory. |
| // Adjust viewport while maintaining aspect ratio |
| float width_ratio = static_cast<float>(safe_window_width) / width_in_pixels; |
| float height_ratio = |
| static_cast<float>(safe_window_height) / height_in_pixels; |
| if (std::abs(width_ratio - height_ratio) < 0.005) { |
| window->viewport_width = host_width; |
| window->viewport_height = host_height; |
| // If Exo sets a size that is of a different aspect ratio we shrink |
| // the window to maintain aspect ratio. We do this by always shrinking |
| // the side that is now proportionally larger as if we expand the |
| // smaller side it might result in the window becoming larger than the |
| // allowed bounds of the screen. |
| } else if (width_ratio < height_ratio) { |
| window->viewport_width = |
| (static_cast<float>(safe_window_width) * host_height) / |
| safe_window_height; |
| window->viewport_height = host_height; |
| |
| } else if (width_ratio > height_ratio) { |
| window->viewport_height = |
| (static_cast<float>(safe_window_height) * host_width) / |
| safe_window_width; |
| window->viewport_width = host_width; |
| } |
| LOG(VERBOSE) << window << " viewport set to " << window->viewport_width << "x" |
| << window->viewport_height; |
| |
| // TODO(b/330639760): For some reason, set_aspect_ratio includes the title |
| // bar in the surface ratio. Figure out a way to mitigate this. |
| // Also consider setting aspect ratio every frame in surface_commit. |
| zaura_surface_set_aspect_ratio( |
| window->aura_surface, window->viewport_width, |
| window->viewport_height + (window->compositor_fullscreen ? 0 : 32)); |
| |
| if (window->use_emulated_rects) { |
| // Pointer scaling is being done in XWayland as well, assuming the viewport |
| // is the size of the screen. Map the movement from viewport to logical |
| // width of the screen (which XWayland is expecting). |
| window->viewport_pointer_scale = |
| static_cast<float>(output->logical_width) / window->viewport_width; |
| } else { |
| // Map movement from viewport to the window's space. |
| window->viewport_pointer_scale = |
| static_cast<float>(safe_window_width_in_wl) / window->viewport_width; |
| } |
| |
| if (window->xdg_toplevel) { |
| // Override X11 client-defined min and max size to a value relative to |
| // display screen size. |
| // When client client updates min/max, window->min/max_width/height values |
| // are updated, then xdg_toplevel calls are made (see |
| // sl_handle_property_notify for details). This results in Exo adjusting |
| // the window size appropriately, resulting in this snippet |
| // (part of toplevel_configure) to run and override the max/min again. This |
| // allows the X11 client to continue resize itself but also allow the user |
| // to resize the window at will within the constraints. |
| xdg_toplevel_set_max_size(window->xdg_toplevel, output->logical_width * 0.8, |
| output->logical_height * 0.8); |
| xdg_toplevel_set_min_size(window->xdg_toplevel, output->logical_width * 0.4, |
| output->logical_height * 0.4); |
| } |
| } |
| |
| void sl_internal_toplevel_configure_size(struct sl_window* window, |
| int32_t x, |
| int32_t y, |
| int32_t host_width, |
| int32_t host_height, |
| int32_t width_in_pixels, |
| int32_t height_in_pixels, |
| int& mut_config_idx) { |
| // For games with issues with incorrect viewport destination when using randr |
| // emulation, this will override the viewport destination with the screen size |
| // when in fullscreen mode. |
| if (window->use_emulated_rects && window->compositor_fullscreen && |
| sl_window_should_fix_randr_emu(window)) { |
| window->viewport_override = true; |
| window->viewport_width = host_width; |
| window->viewport_height = host_height; |
| window->viewport_pointer_scale = |
| static_cast<float>(window->width) / window->viewport_width; |
| // Workaround using viewport for when Exo sets sizes that are not |
| // within the bounds the client requested. |
| // TODO(b/316990641): Implement resizing via viewports if |
| // window->fullscreen==true but window->compositor_fullscreen==false. |
| // Only do this when --only-client-can-exit-fullscreen is set. |
| } else if (window->ctx->viewport_resize && |
| ((window->max_width != 0 && width_in_pixels > window->max_width) || |
| (window->min_width != 0 && width_in_pixels < window->min_width) || |
| (window->max_height != 0 && |
| height_in_pixels > window->max_height) || |
| (window->min_height != 0 && |
| height_in_pixels < window->min_height))) { |
| window->viewport_override = true; |
| float width_ratio = static_cast<float>(window->width) / width_in_pixels; |
| float height_ratio = static_cast<float>(window->height) / height_in_pixels; |
| if (std::abs(width_ratio - height_ratio) < 0.01) { |
| window->viewport_override = true; |
| window->viewport_width = host_width; |
| window->viewport_height = host_height; |
| // If Exo sets a size that is of a different aspect ratio we shrink |
| // the window to maintain aspect ratio. We do this by always shrinking |
| // the side that is now proportionally larger as if we expand the |
| // smaller side it might result in the window becoming larger than the |
| // allowed bounds of the screen. |
| } else if (width_ratio < height_ratio) { |
| window->viewport_width = |
| (static_cast<float>(window->width) * host_height) / window->height; |
| window->viewport_height = host_height; |
| |
| } else if (width_ratio > height_ratio) { |
| window->viewport_height = |
| (static_cast<float>(window->height) * host_width) / window->width; |
| window->viewport_width = host_width; |
| } |
| |
| int32_t window_width = window->width; |
| int32_t window_height = window->height; |
| sl_transform_guest_to_host(window->ctx, window->paired_surface, |
| &window_width, &window_height); |
| window->viewport_pointer_scale = |
| static_cast<float>(window_width) / window->viewport_width; |
| xdg_toplevel_set_min_size(window->xdg_toplevel, window->viewport_width, |
| window->viewport_height); |
| xdg_toplevel_set_max_size(window->xdg_toplevel, window->viewport_width, |
| window->viewport_height); |
| } else if (window->viewport_override) { |
| sl_window_reset_viewport(window); |
| wp_viewport_shim()->set_destination(window->paired_surface->viewport, |
| window->viewport_width, |
| window->viewport_height); |
| } |
| |
| window->next_config.mask |= XCB_CONFIG_WINDOW_WIDTH | |
| XCB_CONFIG_WINDOW_HEIGHT | |
| XCB_CONFIG_WINDOW_BORDER_WIDTH; |
| if (window->viewport_override) { |
| LOG(VERBOSE) << window << " viewport override, size set to " |
| << window->width << "x" << window->height; |
| window->next_config.values[mut_config_idx++] = window->width; |
| window->next_config.values[mut_config_idx++] = window->height; |
| window->next_config.values[mut_config_idx++] = 0; |
| } else if (window->use_emulated_rects) { |
| LOG(VERBOSE) << window << " emulated, size set to " |
| << window->emulated_width << "x" << window->emulated_height; |
| window->next_config.values[mut_config_idx++] = window->emulated_width; |
| window->next_config.values[mut_config_idx++] = window->emulated_height; |
| window->next_config.values[mut_config_idx++] = 0; |
| } else { |
| LOG(VERBOSE) << window << " size set to " << width_in_pixels << "x" |
| << height_in_pixels; |
| window->next_config.values[mut_config_idx++] = width_in_pixels; |
| window->next_config.values[mut_config_idx++] = height_in_pixels; |
| window->next_config.values[mut_config_idx++] = 0; |
| } |
| } |
| |
| void sl_internal_toplevel_configure_position(struct sl_window* window, |
| uint32_t x, |
| uint32_t y, |
| int32_t width_in_pixels, |
| int32_t height_in_pixels, |
| int& mut_config_idx) { |
| if (window->use_emulated_rects) { |
| // Ignore requests from the compositor and set the coordinates as emulation |
| // requested. |
| window->next_config.mask |= XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y; |
| window->next_config.values[mut_config_idx++] = window->emulated_x; |
| window->next_config.values[mut_config_idx++] = window->emulated_y; |
| LOG(VERBOSE) << window << " position set to emulated " << window->emulated_x |
| << "," << window->emulated_y; |
| |
| } else if (x != kUnspecifiedCoord && y != kUnspecifiedCoord) { |
| // Convert to virtual coordinates |
| int32_t guest_x = x; |
| int32_t guest_y = y; |
| |
| sl_transform_host_position_to_guest_position( |
| window->ctx, window->paired_surface, &guest_x, &guest_y); |
| |
| window->next_config.mask |= XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y; |
| window->next_config.values[mut_config_idx++] = guest_x; |
| window->next_config.values[mut_config_idx++] = guest_y; |
| LOG(VERBOSE) << window << " position set to specified " << guest_x << "," |
| << guest_y; |
| |
| } else if (!(window->size_flags & (US_POSITION | P_POSITION))) { |
| uint32_t new_x = 0; |
| uint32_t new_y = 0; |
| |
| const sl_host_output* output = |
| window->paired_surface ? window->paired_surface->output.get() : nullptr; |
| if (output) { |
| if (sl_window_is_containerized(window) && window->viewport_override && |
| window->fullscreen && !window->compositor_fullscreen) { |
| new_x = output->virt_x; |
| new_y = output->virt_y; |
| } else { |
| new_x = |
| output->virt_x + (output->virt_rotated_width - width_in_pixels) / 2; |
| new_y = (output->virt_rotated_height - height_in_pixels) / 2; |
| } |
| } else { |
| new_x = window->ctx->screen->width_in_pixels / 2 - width_in_pixels / 2; |
| new_y = window->ctx->screen->height_in_pixels / 2 - height_in_pixels / 2; |
| } |
| |
| window->next_config.mask |= XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y; |
| window->next_config.values[mut_config_idx++] = new_x; |
| window->next_config.values[mut_config_idx++] = new_y; |
| LOG(VERBOSE) << window << " position set to new " << new_x << "," << new_y; |
| } |
| } |
| |
| void sl_internal_toplevel_configure_set_activated(struct sl_window* window, |
| bool activated) { |
| if (activated != window->activated) { |
| if (activated != (window->ctx->host_focus_window == window)) { |
| window->ctx->host_focus_window = activated ? window : nullptr; |
| window->ctx->needs_set_input_focus = 1; |
| } |
| window->activated = activated; |
| } |
| } |
| |
| void sl_internal_toplevel_configure_state(struct sl_window* window, |
| struct wl_array* states) { |
| // States: https://wayland.app/protocols/xdg-shell#xdg_toplevel:enum:state |
| // Note that if there are no states specified, it is not-maximized, |
| // not-fullscreen, not-currently-being-resized and not-activated window. |
| bool activated = false; |
| window->allow_resize = 1; |
| window->compositor_fullscreen = 0; |
| |
| uint32_t* state; |
| int state_idx = 0; |
| |
| if (window->ctx->only_client_can_exit_fullscreen && window->fullscreen) { |
| // If the window has been set to full screen by the client, do not try to |
| // revert it back. Many games and applications fail to adapt to changes |
| // enforced by the WM (ie. the fullscreen state must be toggled via the |
| // game's UI). |
| window->next_config.states[state_idx++] = |
| window->ctx->atoms[ATOM_NET_WM_STATE_FULLSCREEN].value; |
| window->allow_resize = 0; |
| } |
| |
| sl_array_for_each(state, states) { |
| if (*state == XDG_TOPLEVEL_STATE_FULLSCREEN) { |
| if (state_idx == 0) { |
| // Only add fullscreen state if it was previously not added by |
| // --only-client-can-exit-fullscreen |
| window->next_config.states[state_idx++] = |
| window->ctx->atoms[ATOM_NET_WM_STATE_FULLSCREEN].value; |
| } |
| window->allow_resize = 0; |
| window->compositor_fullscreen = 1; |
| } |
| if (*state == XDG_TOPLEVEL_STATE_MAXIMIZED) { |
| bool force_x11_unmaximize = false; |
| #ifdef QUIRKS_SUPPORT |
| force_x11_unmaximize = window->ctx->quirks.IsEnabled( |
| window, quirks::FEATURE_FORCE_X11_UNMAXIMIZE); |
| #endif |
| window->allow_resize = 0; |
| if (!force_x11_unmaximize) { |
| window->next_config.states[state_idx++] = |
| window->ctx->atoms[ATOM_NET_WM_STATE_MAXIMIZED_VERT].value; |
| window->next_config.states[state_idx++] = |
| window->ctx->atoms[ATOM_NET_WM_STATE_MAXIMIZED_HORZ].value; |
| } |
| } |
| if (*state == XDG_TOPLEVEL_STATE_ACTIVATED) { |
| activated = true; |
| window->next_config.states[state_idx++] = |
| window->ctx->atoms[ATOM_NET_WM_STATE_FOCUSED].value; |
| } |
| if (*state == XDG_TOPLEVEL_STATE_RESIZING) { |
| window->allow_resize = 0; |
| } |
| } |
| |
| sl_internal_toplevel_configure_set_activated(window, activated); |
| |
| LOG(VERBOSE) << window << " state change, fullscreen=" << window->fullscreen |
| << " compositor_fullscreen=" << window->compositor_fullscreen; |
| // Override previous state definitions |
| window->next_config.states_length = state_idx; |
| } |
| |
| void sl_internal_toplevel_configure_state_containerized( |
| struct sl_window* window, struct wl_array* states) { |
| // States: https://wayland.app/protocols/xdg-shell#xdg_toplevel:enum:state |
| // Note that if there are no states specified, it is not-maximized, |
| // not-fullscreen, not-currently-being-resized and not-activated window. |
| bool activated = false; |
| window->allow_resize = 1; |
| window->compositor_fullscreen = 0; |
| |
| uint32_t* state; |
| int state_idx = 0; |
| |
| // Keep the fullscreen state if X11 client decided to be fullscreen. Ignore |
| // compositor's request. |
| if (window->fullscreen) { |
| window->allow_resize = 0; |
| window->next_config.states[state_idx++] = |
| window->ctx->atoms[ATOM_NET_WM_STATE_FULLSCREEN].value; |
| } |
| |
| // Ditto as above, but maximize state. |
| if (window->maximized) { |
| bool force_x11_unmaximize = false; |
| #ifdef QUIRKS_SUPPORT |
| force_x11_unmaximize = window->ctx->quirks.IsEnabled( |
| window, quirks::FEATURE_FORCE_X11_UNMAXIMIZE); |
| #endif |
| window->allow_resize = 0; |
| if (!force_x11_unmaximize) { |
| window->next_config.states[state_idx++] = |
| window->ctx->atoms[ATOM_NET_WM_STATE_MAXIMIZED_VERT].value; |
| window->next_config.states[state_idx++] = |
| window->ctx->atoms[ATOM_NET_WM_STATE_MAXIMIZED_HORZ].value; |
| } |
| } |
| |
| sl_array_for_each(state, states) { |
| // Note that we are ignoring maximized state for reasons specified above. We |
| // are not even taking note of what the compositor wants since we don't have |
| // to for window containerization. |
| if (*state == XDG_TOPLEVEL_STATE_FULLSCREEN) { |
| // Mark as compositor request to be fullscreen, so that other sizing |
| // operations can operate to fulfill Exo's request. |
| window->compositor_fullscreen = 1; |
| } |
| if (*state == XDG_TOPLEVEL_STATE_ACTIVATED) { |
| activated = true; |
| window->next_config.states[state_idx++] = |
| window->ctx->atoms[ATOM_NET_WM_STATE_FOCUSED].value; |
| } |
| if (*state == XDG_TOPLEVEL_STATE_RESIZING) { |
| window->allow_resize = 0; |
| } |
| } |
| |
| // Set focus appropriately. |
| sl_internal_toplevel_configure_set_activated(window, activated); |
| |
| if (!window->compositor_fullscreen) { |
| // Ignore the window decoration settings done by the X11 client, and show |
| // frame decorations if Exo treats the surface as non-fullscreen. |
| zaura_surface_set_frame(window->aura_surface, |
| ZAURA_SURFACE_FRAME_TYPE_NORMAL); |
| } |
| |
| LOG(VERBOSE) << window << " state change, fullscreen=" << window->fullscreen |
| << " compositor_fullscreen=" << window->compositor_fullscreen; |
| // Override previous state definitions |
| window->next_config.states_length = state_idx; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // xdg_toplevel event listeners |
| // |
| // https://crsrc.org/s/?q=f:sommelier/protocol/xdg-shell.xml%20name=\"xdg_toplevel |
| // |
| // In Exo, this is sent from |
| // https://crsrc.org/s/?q=f:exo%2Fwayland.*cc%20xdg_toplevel_send_configure |
| static void sl_internal_xdg_toplevel_configure( |
| void* unused_data, |
| struct xdg_toplevel* xdg_toplevel, |
| int32_t width, |
| int32_t height, |
| struct wl_array* states) { |
| TRACE_EVENT("other", "sl_internal_xdg_toplevel_configure"); |
| struct sl_window* window = |
| static_cast<sl_window*>(xdg_toplevel_get_user_data(xdg_toplevel)); |
| sl_internal_toplevel_configure(window, kUnspecifiedCoord, kUnspecifiedCoord, |
| width, height, states); |
| } |
| |
| // In Exo, this is sent from |
| // https://crsrc.org/s/?q=f:exo%2Fwayland.*cc%20xdg_toplevel_send_close |
| static void sl_internal_xdg_toplevel_close(void* data, |
| struct xdg_toplevel* xdg_toplevel) { |
| TRACE_EVENT("other", "sl_internal_xdg_toplevel_close"); |
| struct sl_window* window = |
| static_cast<sl_window*>(xdg_toplevel_get_user_data(xdg_toplevel)); |
| xcb_client_message_event_t event = {}; |
| event.response_type = XCB_CLIENT_MESSAGE; |
| event.format = 32; |
| event.window = window->id; |
| event.type = window->ctx->atoms[ATOM_WM_PROTOCOLS].value; |
| event.data.data32[0] = window->ctx->atoms[ATOM_WM_DELETE_WINDOW].value; |
| event.data.data32[1] = XCB_CURRENT_TIME; |
| |
| xcb_send_event(window->ctx->connection, 0, window->id, |
| XCB_EVENT_MASK_NO_EVENT, (const char*)&event); |
| } |
| |
| static const struct xdg_toplevel_listener sl_internal_xdg_toplevel_listener = { |
| sl_internal_xdg_toplevel_configure, sl_internal_xdg_toplevel_close}; |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // zaura_toplevel event listeners |
| // |
| // https://crsrc.org/s/?q=f:sommelier/protocol/aura-shell.xml%20name=\"zaura_toplevel |
| |
| // Sent from Exo here: |
| // https://crsrc.org/s/?q=f:exo%2Fwayland.*cc%20zaura_toplevel_send_configure |
| static void sl_internal_zaura_toplevel_configure( |
| void* unused_data, |
| struct zaura_toplevel* zaura_toplevel, |
| int32_t x, |
| int32_t y, |
| int32_t width, |
| int32_t height, |
| struct wl_array* states) { |
| TRACE_EVENT("other", "sl_internal_zaura_toplevel_configure"); |
| struct sl_window* window = |
| static_cast<sl_window*>(zaura_toplevel_get_user_data(zaura_toplevel)); |
| |
| // aura_toplevel.configure replaces xdg_toplevel.configure for surfaces on |
| // which zaura_toplevel_set_supports_screen_coordinates() has been called. |
| // So we shouldn't get duplicate events. |
| // |
| // TODO(cpelling): Handle aura-specific states. |
| sl_internal_toplevel_configure(window, x, y, width, height, states); |
| } |
| |
| // Sent from Exo here: |
| // https://crsrc.org/s/?q=f:exo%2Fwayland.*cc%20zaura_toplevel_send_origin_change |
| static void sl_internal_zaura_toplevel_origin_change( |
| void* data, struct zaura_toplevel* zaura_toplevel, int32_t x, int32_t y) { |
| // aura_toplevel.origin_change is not part of the normal configuration |
| // lifecycle, and is not followed by xdg_surface.configure. So just apply |
| // this change immediately. |
| sl_window* window = |
| static_cast<sl_window*>(zaura_toplevel_get_user_data(zaura_toplevel)); |
| |
| if (window->configure_event_barrier) { |
| // TODO(cpelling): Coalesce origin_change events instead of dropping them. |
| return; |
| } |
| |
| int32_t guest_x = x; |
| int32_t guest_y = y; |
| sl_transform_host_position_to_guest_position( |
| window->ctx, window->paired_surface, &guest_x, &guest_y); |
| window->x = guest_x; |
| window->y = guest_y; |
| |
| uint32_t values[2]; |
| sl_window_get_x_y(window, &values[0], &values[1]); |
| xcb()->configure_window(window->ctx->connection, window->frame_id, |
| XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, values); |
| } |
| |
| static const struct zaura_toplevel_listener |
| sl_internal_zaura_toplevel_listener = { |
| sl_internal_zaura_toplevel_configure, |
| sl_internal_zaura_toplevel_origin_change}; |
| |
| static const struct wl_callback_listener configure_event_barrier_listener = { |
| sl_internal_xdg_surface_configure_barrier_done}; |
| |
| void sl_toplevel_send_window_bounds_to_host(struct sl_window* window) { |
| // Don't send window bounds if fullscreen/maximized/resizing, |
| // or if the feature is unsupported by the host or disabled by flag. |
| if (!window->allow_resize || !sl_window_is_client_positioned(window) || |
| !window->ctx->aura_shell || |
| window->ctx->aura_shell->version < |
| ZAURA_TOPLEVEL_SET_WINDOW_BOUNDS_SINCE_VERSION || |
| !window->aura_toplevel) { |
| return; |
| } |
| int32_t x = window->x; |
| int32_t y = window->y; |
| int32_t w = window->width; |
| int32_t h = window->height; |
| if (window->size_flags & P_MIN_SIZE) { |
| if (w < window->min_width) { |
| w = window->min_width; |
| } |
| if (h < window->min_height) { |
| h = window->min_height; |
| } |
| } |
| if (window->size_flags & P_MAX_SIZE) { |
| if (w > window->max_width) { |
| w = window->max_width; |
| } |
| if (h > window->max_height) { |
| h = window->max_height; |
| } |
| } |
| |
| sl_host_output* output = sl_transform_guest_position_to_host_position( |
| window->ctx, window->paired_surface, &x, &y); |
| sl_transform_guest_to_host(window->ctx, window->paired_surface, &w, &h); |
| |
| zaura_toplevel_set_window_bounds(window->aura_toplevel, x, y, w, h, |
| output->proxy); |
| |
| if (window->configure_event_barrier) { |
| wl_callback_destroy(window->configure_event_barrier); |
| } |
| window->configure_event_barrier = wl_display_sync(window->ctx->display); |
| wl_callback_add_listener(window->configure_event_barrier, |
| &configure_event_barrier_listener, window); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| void sl_update_application_id(struct sl_context* ctx, |
| struct sl_window* window) { |
| TRACE_EVENT("other", "sl_update_application_id"); |
| if (!window->aura_surface) { |
| return; |
| } |
| if (ctx->application_id) { |
| zaura_surface_set_application_id(window->aura_surface, ctx->application_id); |
| return; |
| } |
| // Don't set application id for X11 override redirect. This prevents |
| // aura shell from thinking that these are regular application windows |
| // that should appear in application lists. |
| if (!ctx->xwayland || window->managed) { |
| char* application_id_str; |
| if (!window->app_id_property.empty()) { |
| application_id_str = |
| sl_xasprintf(X11_PROPERTY_APPLICATION_ID_FORMAT, ctx->vm_id, |
| window->app_id_property.c_str()); |
| } else if (window->clazz) { |
| application_id_str = sl_xasprintf(WM_CLASS_APPLICATION_ID_FORMAT, |
| ctx->vm_id, window->clazz); |
| } else if (window->client_leader != XCB_WINDOW_NONE) { |
| application_id_str = sl_xasprintf(WM_CLIENT_LEADER_APPLICATION_ID_FORMAT, |
| ctx->vm_id, window->client_leader); |
| } else { |
| application_id_str = |
| sl_xasprintf(XID_APPLICATION_ID_FORMAT, ctx->vm_id, window->id); |
| } |
| |
| zaura_surface_set_application_id(window->aura_surface, application_id_str); |
| free(application_id_str); |
| } |
| } |
| |
| void sl_window_update(struct sl_window* window) { |
| TRACE_EVENT("surface", "sl_window_update", "id", window->id); |
| struct wl_resource* host_resource = nullptr; |
| struct sl_host_surface* host_surface; |
| struct sl_context* ctx = window->ctx; |
| struct sl_window* parent = nullptr; |
| |
| if (window->host_surface_id) { |
| host_resource = wl_client_get_object(ctx->client, window->host_surface_id); |
| if (host_resource && window->unpaired) { |
| wl_list_remove(&window->link); |
| wl_list_insert(&ctx->windows, &window->link); |
| window->unpaired = 0; |
| } |
| } else if (!window->unpaired) { |
| wl_list_remove(&window->link); |
| wl_list_insert(&ctx->unpaired_windows, &window->link); |
| window->unpaired = 1; |
| window->paired_surface->window = nullptr; |
| window->paired_surface = nullptr; |
| } |
| |
| if (!host_resource) { |
| if (window->aura_surface) { |
| zaura_surface_destroy(window->aura_surface); |
| window->aura_surface = nullptr; |
| } |
| if (window->xdg_toplevel) { |
| xdg_toplevel_destroy(window->xdg_toplevel); |
| window->xdg_toplevel = nullptr; |
| } |
| if (window->xdg_popup) { |
| xdg_popup_destroy(window->xdg_popup); |
| window->xdg_popup = nullptr; |
| } |
| if (window->xdg_surface) { |
| xdg_surface_destroy(window->xdg_surface); |
| window->xdg_surface = nullptr; |
| } |
| window->realized = 0; |
| return; |
| } |
| |
| host_surface = |
| static_cast<sl_host_surface*>(wl_resource_get_user_data(host_resource)); |
| assert(host_surface); |
| assert(!host_surface->has_role); |
| |
| if (!window->unpaired) { |
| window->paired_surface = host_surface; |
| host_surface->window = window; |
| sl_transform_try_window_scale(ctx, host_surface, window->width, |
| window->height); |
| } |
| |
| assert(ctx->xdg_shell); |
| assert(ctx->xdg_shell->internal); |
| |
| if (window->managed) { |
| if (window->transient_for != XCB_WINDOW_NONE) { |
| struct sl_window* sibling; |
| |
| wl_list_for_each(sibling, &ctx->windows, link) { |
| if (sibling->id == window->transient_for) { |
| if (sibling->xdg_toplevel) { |
| parent = sibling; |
| } |
| break; |
| } |
| } |
| } |
| } |
| |
| // If we have a transient parent, but could not find it in the list of |
| // realized windows, then pick the window that had the last event for the |
| // parent. We update this again when we gain focus, so if we picked the wrong |
| // one it can get corrected at that point (but it's also possible the parent |
| // will never be realized, which is why selecting one here is important). |
| if (!window->managed || |
| (!parent && window->transient_for != XCB_WINDOW_NONE)) { |
| struct sl_window* sibling; |
| uint32_t parent_last_event_serial = 0; |
| |
| wl_list_for_each(sibling, &ctx->windows, link) { |
| struct wl_resource* sibling_host_resource; |
| struct sl_host_surface* sibling_host_surface; |
| |
| if (!sibling->realized) { |
| continue; |
| } |
| |
| sibling_host_resource = |
| wl_client_get_object(ctx->client, sibling->host_surface_id); |
| if (!sibling_host_resource) { |
| continue; |
| } |
| |
| // Any parent will do but prefer last event window. |
| sibling_host_surface = static_cast<sl_host_surface*>( |
| wl_resource_get_user_data(sibling_host_resource)); |
| if (parent_last_event_serial > sibling_host_surface->last_event_serial) { |
| continue; |
| } |
| |
| // Do not use ourselves as the parent. |
| if (sibling->host_surface_id == window->host_surface_id) { |
| continue; |
| } |
| |
| parent = sibling; |
| parent_last_event_serial = sibling_host_surface->last_event_serial; |
| } |
| } |
| |
| if (!window->depth) { |
| xcb_get_geometry_reply_t* geometry_reply = xcb()->get_geometry_reply( |
| ctx->connection, xcb()->get_geometry(ctx->connection, window->id), |
| nullptr); |
| if (geometry_reply) { |
| window->depth = geometry_reply->depth; |
| free(geometry_reply); |
| } |
| } |
| |
| if (!window->xdg_surface) { |
| window->xdg_surface = xdg_wm_base_get_xdg_surface(ctx->xdg_shell->internal, |
| host_surface->proxy); |
| xdg_surface_add_listener(window->xdg_surface, |
| &sl_internal_xdg_surface_listener, window); |
| } |
| |
| if (ctx->aura_shell) { |
| uint32_t frame_color; |
| |
| if (!window->aura_surface) { |
| window->aura_surface = zaura_shell_get_aura_surface( |
| ctx->aura_shell->internal, host_surface->proxy); |
| } |
| |
| zaura_surface_set_frame(window->aura_surface, |
| window->decorated ? ZAURA_SURFACE_FRAME_TYPE_NORMAL |
| : window->depth == 32 |
| ? ZAURA_SURFACE_FRAME_TYPE_NONE |
| : ZAURA_SURFACE_FRAME_TYPE_SHADOW); |
| |
| frame_color = window->dark_frame ? ctx->dark_frame_color : ctx->frame_color; |
| zaura_surface_set_frame_colors(window->aura_surface, frame_color, |
| frame_color); |
| zaura_surface_set_startup_id(window->aura_surface, window->startup_id); |
| sl_update_application_id(ctx, window); |
| |
| if (ctx->aura_shell->version >= |
| ZAURA_SURFACE_SET_FULLSCREEN_MODE_SINCE_VERSION) { |
| zaura_surface_set_fullscreen_mode(window->aura_surface, |
| ctx->fullscreen_mode); |
| } |
| } |
| |
| // Always use top-level surface for X11 windows as we can't control when the |
| // window is closed. |
| if (ctx->xwayland || !parent) { |
| if (!window->xdg_toplevel) { |
| window->xdg_toplevel = xdg_surface_get_toplevel(window->xdg_surface); |
| xdg_toplevel_add_listener(window->xdg_toplevel, |
| &sl_internal_xdg_toplevel_listener, window); |
| } |
| |
| // Right now, aura_toplevel is only needed for windows positioned by the |
| // client (which is all windows if --enable-x11-move-windows is passed). |
| // Setting it up means we get x and y coordinates in configure |
| // events (aura_toplevel.configure replaces xdg_toplevel.configure), which |
| // changes how windows are positioned in the X server's coordinate space. If |
| // windows end up partially offscreen in that space, we get bugs like |
| // b/269053427. |
| // |
| // Bottom line: If --enable-x11-move-windows is enabled, apps are |
| // responsible for keeping themselves onscreen within X space. If not, |
| // Sommelier is; in which case it should ignore the host compositor's |
| // positioning decisions, since those are made without reference to X space. |
| // Sommelier could listen to aura_toplevel.configure and ignore the x and y |
| // coordinates, but for now the most conservative approach is to avoid using |
| // aura_toplevel entirely. This can be revisited later if we need |
| // aura_toplevel for anything else. |
| if (sl_window_is_client_positioned(window) && ctx->aura_shell && |
| window->xdg_toplevel && !window->aura_toplevel) { |
| window->aura_toplevel = zaura_shell_get_aura_toplevel_for_xdg_toplevel( |
| ctx->aura_shell->internal, window->xdg_toplevel); |
| zaura_toplevel_set_supports_screen_coordinates(window->aura_toplevel); |
| zaura_toplevel_add_listener(window->aura_toplevel, |
| &sl_internal_zaura_toplevel_listener, window); |
| } |
| |
| if (parent) { |
| xdg_toplevel_set_parent(window->xdg_toplevel, parent->xdg_toplevel); |
| } |
| if (window->name) { |
| xdg_toplevel_set_title(window->xdg_toplevel, window->name); |
| } |
| if (window->size_flags & P_MIN_SIZE) { |
| int32_t minw = window->min_width; |
| int32_t minh = window->min_height; |
| |
| sl_transform_guest_to_host(window->ctx, window->paired_surface, &minw, |
| &minh); |
| xdg_toplevel_set_min_size(window->xdg_toplevel, minw, minh); |
| } |
| if (window->size_flags & P_MAX_SIZE) { |
| int32_t maxw = window->max_width; |
| int32_t maxh = window->max_height; |
| |
| sl_transform_guest_to_host(window->ctx, window->paired_surface, &maxw, |
| &maxh); |
| xdg_toplevel_set_max_size(window->xdg_toplevel, maxw, maxh); |
| } |
| if (window->maximized) { |
| xdg_toplevel_set_maximized(window->xdg_toplevel); |
| } |
| if (window->fullscreen) { |
| xdg_toplevel_set_fullscreen(window->xdg_toplevel, nullptr); |
| } |
| } else if (!window->xdg_popup) { |
| struct xdg_positioner* positioner; |
| int32_t diffx = window->x - parent->x; |
| int32_t diffy = window->y - parent->y; |
| |
| positioner = xdg_wm_base_create_positioner(ctx->xdg_shell->internal); |
| assert(positioner); |
| |
| sl_transform_guest_to_host(window->ctx, window->paired_surface, &diffx, |
| &diffy); |
| xdg_positioner_set_anchor(positioner, XDG_POSITIONER_ANCHOR_TOP_LEFT); |
| xdg_positioner_set_gravity(positioner, XDG_POSITIONER_GRAVITY_BOTTOM_RIGHT); |
| xdg_positioner_set_anchor_rect(positioner, diffx, diffy, 1, 1); |
| |
| window->xdg_popup = xdg_surface_get_popup(window->xdg_surface, |
| parent->xdg_surface, positioner); |
| xdg_popup_add_listener(window->xdg_popup, &sl_internal_xdg_popup_listener, |
| window); |
| |
| xdg_positioner_destroy(positioner); |
| } |
| |
| if ((window->size_flags & (US_POSITION | P_POSITION)) && parent && |
| ctx->aura_shell) { |
| int32_t diffx = window->x - parent->x; |
| int32_t diffy = window->y - parent->y; |
| |
| sl_transform_guest_to_host(window->ctx, window->paired_surface, &diffx, |
| &diffy); |
| zaura_surface_set_parent(window->aura_surface, parent->aura_surface, diffx, |
| diffy); |
| } |
| |
| #ifdef COMMIT_LOOP_FIX |
| sl_commit(window, host_surface); |
| #else |
| wl_surface_commit(host_surface->proxy); |
| #endif |
| |
| if (host_surface->contents_width && host_surface->contents_height) { |
| window->realized = 1; |
| } |
| } |
| |
| #ifdef QUIRKS_SUPPORT |
| bool sl_window_should_log_quirk(struct sl_window* window, int feature_enum) { |
| return window->logged_quirks.insert(feature_enum).second; |
| } |
| |
| std::set<int> sl_window_logged_quirks(struct sl_window* window) { |
| return window->logged_quirks; |
| } |
| #endif |
| |
| bool sl_window_is_client_positioned(struct sl_window* window) { |
| #ifdef QUIRKS_SUPPORT |
| if (window->ctx->quirks.IsEnabled(window, quirks::FEATURE_X11_MOVE_WINDOWS)) { |
| return true; |
| } |
| #endif |
| return window->ctx->enable_x11_move_windows; |
| } |
| |
| bool sl_window_should_fix_randr_emu(struct sl_window* window) { |
| #ifdef QUIRKS_SUPPORT |
| if (window->ctx->quirks.IsEnabled(window, quirks::FEATURE_RANDR_EMU_FIX)) { |
| return true; |
| } |
| #endif |
| return false; |
| } |
| |
| void sl_window_get_x_y(struct sl_window* window, uint32_t* x, uint32_t* y) { |
| if (x != nullptr) { |
| *x = window->x; |
| } |
| if (y != nullptr) { |
| *y = window->y; |
| } |
| } |
| |
| void sl_window_get_width_height(struct sl_window* window, |
| uint32_t* w, |
| uint32_t* h) { |
| if (window->use_emulated_rects) { |
| if (w != nullptr) { |
| *w = window->emulated_width; |
| } |
| if (h != nullptr) { |
| *h = window->emulated_height; |
| } |
| } else { |
| if (w != nullptr) { |
| *w = window->width; |
| } |
| if (h != nullptr) { |
| *h = window->height; |
| } |
| } |
| } |
| |
| bool sl_window_get_output_virt_position(struct sl_window* window, |
| uint32_t& mut_x, |
| uint32_t& mut_y) { |
| for (auto output : window->ctx->host_outputs) { |
| if (window->x >= output->virt_x && |
| window->x < output->virt_x + output->virt_width && |
| window->y >= output->virt_y && |
| window->y < output->virt_y + output->virt_height) { |
| mut_x = output->virt_x; |
| mut_y = output->virt_y; |
| return true; |
| } |
| } |
| return false; |
| } |
