xwayland: implement forced scaling

Author: ammen99

metadata/workarounds.xml

@@ -105,5 +105,10 @@
 			<min>0</min>
 			<max>500</max>
 		</option>
+		<option name="force_xwayland_scaling" type="bool">
+			<_short>Force Xwayland DPI scaling</_short>
+			<_long>Disables the default blurry scaling for Xwayland and forces client-side scaling for Xwayland windows dependent on the DPI settings.</_long>
+			<default>false</default>
+		</option>
 	</plugin>
 </wayfire>

src/api/wayfire/unstable/wlr-surface-node.hpp

@@ -19,6 +19,7 @@ struct surface_state_t
     wlr_texture *texture; // The texture of the wlr_client_buffer
 
     wf::region_t accumulated_damage;
+    wf::region_t opaque_region;
     wf::dimensions_t size = {0, 0};
     std::optional<wlr_fbox> src_viewport;
     wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL;
@@ -69,7 +70,7 @@ class wlr_surface_node_t : public node_t, public zero_copy_texturable_node_t
     std::optional<wf::texture_t> to_texture() const override;
 
     wlr_surface *get_surface() const;
-    void apply_state(surface_state_t&& state);
+    virtual void apply_state(surface_state_t&& state);
     void apply_current_surface_state();
     void send_frame_done(bool delay_until_vblank);
 
@@ -92,6 +93,8 @@ class wlr_surface_node_t : public node_t, public zero_copy_texturable_node_t
     wf::wl_listener_wrapper on_surface_commit;
 
     const bool autocommit;
+
+  protected:
     surface_state_t current_state;
 };
 }

src/api/wayfire/unstable/xwl-toplevel-base.hpp

@@ -10,11 +10,17 @@
 
 #include <wayfire/nonstd/wlroots-full.hpp>
 #include <wayfire/view.hpp>
+#include <wayfire/util.hpp>
 #include <wayfire/unstable/wlr-surface-node.hpp>
 
 namespace wf
 {
 #if WF_HAS_XWAYLAND
+namespace xw
+{
+class xwayland_surface_node_t;
+}
+
 /**
  * A base class for views which base on a wlr_xwayland surface.
  * Contains the implementation of view_interface_t functions used in them.
@@ -50,7 +56,7 @@ class xwayland_view_base_t : public virtual wf::view_interface_t
     void handle_title_changed(std::string new_title);
 
     wf::wl_listener_wrapper on_destroy, on_set_title, on_set_app_id, on_ping_timeout;
-    std::shared_ptr<wf::scene::wlr_surface_node_t> main_surface;
+    std::shared_ptr<wf::xw::xwayland_surface_node_t> main_surface;
 };
 #endif
 }

src/core/xdg-output-management.cpp

@@ -11,6 +11,7 @@
 #include <wayfire/geometry.hpp>
 #include <wlr/types/wlr_output.h>
 #include <wayfire/signal-provider.hpp>
+#include "view/view-impl.hpp"
 #include "wayfire/debug.hpp"
 #include "xdg-output-unstable-v1-protocol.h"
 
@@ -62,6 +63,11 @@ class xdg_output_v1_resource
         }
     }
 
+    bool is_xwayland() const
+    {
+        return wl_resource_get_client(xdg_output) == wf::xwayland_get_client();
+    }
+
     bool resend_details(wf::geometry_t geometry)
     {
         if (last_sent_geometry == geometry)
@@ -117,12 +123,14 @@ void xdg_output_manager_v1::update_outputs()
         return config.count(output) && (config[output].source & OUTPUT_IMAGE_SOURCE_SELF);
     };
 
-    const auto& update_output = [&] (wlr_output *output, wf::geometry_t geometry)
+    const auto& update_output = [&] (wlr_output *output, wf::geometry_t geometry,
+                                     wf::geometry_t xwayland_geometry)
     {
         bool changed = false;
         for (auto& resource : output_resources[output])
         {
-            changed |= resource->resend_details(geometry);
+            wf::geometry_t to_send = resource->is_xwayland() ? xwayland_geometry : geometry;
+            changed |= resource->resend_details(to_send);
         }
 
         if (changed)
@@ -131,6 +139,9 @@ void xdg_output_manager_v1::update_outputs()
         }
     };
 
+    static wf::option_wrapper_t<bool> force_xwayland_scaling{"workarounds/force_xwayland_scaling"};
+
+    int xwayland_location_x = 0;
     auto it = output_resources.begin();
     while (it != output_resources.end())
     {
@@ -139,8 +150,22 @@ void xdg_output_manager_v1::update_outputs()
             it = output_resources.erase(it);
         } else
         {
-            auto geometry = ol->find_output(it->first)->get_layout_geometry();
-            update_output(it->first, geometry);
+            auto wo = ol->find_output(it->first);
+            auto geometry = wo->get_layout_geometry();
+            if (force_xwayland_scaling)
+            {
+                int width, height;
+                wlr_output_transformed_resolution(it->first, &width, &height);
+                wf::geometry_t xwayland_geometry = {xwayland_location_x, 0, width, height};
+                update_output(it->first, geometry, xwayland_geometry);
+                xwayland_location_x += width;
+                wo->get_data_safe<wf::xdg_output_xwayland_geometry>()->geometry = xwayland_geometry;
+            } else
+            {
+                update_output(it->first, geometry, geometry);
+                wo->get_data_safe<wf::xdg_output_xwayland_geometry>()->geometry = geometry;
+            }
+
             ++it;
         }
     }

src/core/xdg-output-management.hpp

@@ -3,12 +3,18 @@
 #include <memory>
 #include <map>
 #include <vector>
+#include "wayfire/object.hpp"
 #include "xdg-output-unstable-v1-protocol.h"
 #include <wayfire/output-layout.hpp>
 
 namespace wf
 {
 class xdg_output_v1_resource;
+class xdg_output_xwayland_geometry : public wf::custom_data_t
+{
+  public:
+    std::optional<wf::geometry_t> geometry;
+};
 
 class xdg_output_manager_v1
 {

src/meson.build

@@ -51,6 +51,7 @@ wayfire_sources = ['geometry.cpp',
                    'view/xwayland/xwayland-view-base.cpp',
                    'view/xwayland/xwayland-toplevel.cpp',
                    'view/xwayland/xwayland-helpers.cpp',
+                   'view/xwayland/xwayland-surface.cpp',
                    'view/layer-shell/layer-shell.cpp',
                    'view/layer-shell/layer-shell-node.cpp',
                    'view/view-3d.cpp',

src/view/view-impl.hpp

@@ -76,6 +76,7 @@ void xwayland_update_default_cursor();
 /* Ensure that the given surface is on top of the Xwayland stack order. */
 void xwayland_bring_to_front(wlr_surface *surface);
 int xwayland_get_pid();
+wl_client *xwayland_get_client();
 
 void init_desktop_apis();
 void fini_desktop_apis();

src/view/wlr-surface-node.cpp

@@ -1,5 +1,4 @@
 #include "wayfire/unstable/wlr-surface-node.hpp"
-#include "pixman.h"
 #include "wayfire/geometry.hpp"
 #include "wayfire/render-manager.hpp"
 #include "wayfire/scene-render.hpp"
@@ -32,6 +31,7 @@ wf::scene::surface_state_t& wf::scene::surface_state_t::operator =(surface_state
     current_buffer = other.current_buffer;
     texture = other.texture;
     accumulated_damage = other.accumulated_damage;
+    opaque_region = other.opaque_region;
     seq  = other.seq;
     size = other.size;
     src_viewport = other.src_viewport;
@@ -40,6 +40,7 @@ wf::scene::surface_state_t& wf::scene::surface_state_t::operator =(surface_state
     other.current_buffer = NULL;
     other.texture = NULL;
     other.accumulated_damage.clear();
+    other.opaque_region.clear();
     other.src_viewport.reset();
     other.seq.reset();
     return *this;
@@ -86,6 +87,7 @@ void wf::scene::surface_state_t::merge_state(wlr_surface *surface)
     wf::region_t current_damage;
     wlr_surface_get_effective_damage(surface, current_damage.to_pixman());
     this->accumulated_damage |= current_damage;
+    this->opaque_region = wf::region_t{&surface->current.opaque};
 }
 
 wf::scene::surface_state_t::~surface_state_t()
@@ -312,8 +314,7 @@ class wf::scene::wlr_surface_node_t::wlr_surface_render_instance_t : public rend
 
             if (self->surface)
             {
-                pixman_region32_subtract(damage.to_pixman(), damage.to_pixman(),
-                    &self->surface->opaque_region);
+                damage ^= self->current_state.opaque_region;
             }
         }
     }
@@ -402,8 +403,7 @@ class wf::scene::wlr_surface_node_t::wlr_surface_render_instance_t : public rend
             output->connect(&on_frame_done);
             if (use_opaque_optimizations && self->surface)
             {
-                pixman_region32_subtract(visible.to_pixman(), visible.to_pixman(),
-                    &self->surface->opaque_region);
+                visible ^= self->current_state.opaque_region;
             }
         }
     }

src/view/xwayland.cpp

@@ -337,3 +337,14 @@ int wf::xwayland_get_pid()
     return -1;
 #endif
 }
+
+wl_client*wf::xwayland_get_client()
+{
+#if WF_HAS_XWAYLAND
+
+    return (xwayland_handle && xwayland_handle->server) ? xwayland_handle->server->client : NULL;
+#else
+
+    return nullptr;
+#endif
+}

src/view/xwayland/xwayland-helpers.cpp

@@ -1,4 +1,5 @@
 #include "xwayland-helpers.hpp"
+#include "core/xdg-output-management.hpp"
 
 #if WF_HAS_XWAYLAND
 
@@ -50,4 +51,58 @@ bool wf::xw::has_type(wlr_xwayland_surface *xw, xcb_atom_t type)
     return false;
 }
 
+wf::output_t*wf::xw::find_xwayland_surface_output(wlr_xwayland_surface *xw)
+{
+    auto& ol  = wf::get_core().output_layout;
+    double cx = xw->x + xw->width / 2.0;
+    double cy = xw->y + xw->height / 2.0;
+    wf::output_t *closest = ol->get_outputs().empty() ? nullptr : ol->get_outputs().front();
+    double closest_dist   = std::numeric_limits<double>::max();
+    for (auto & wo : ol->get_outputs())
+    {
+        auto data = wo->get_data_safe<wf::xdg_output_xwayland_geometry>();
+        if (!data->geometry.has_value())
+        {
+            continue;
+        }
+
+        double dx;
+        double dy;
+        wlr_box_closest_point(&data->geometry.value(), cx, cy, &dx, &dy);
+        const double dist = (dx - cx) * (dx - cx) + (dy - cy) * (dy - cy);
+        if (dist < closest_dist)
+        {
+            closest_dist = dist;
+            closest = wo;
+        }
+    }
+
+    return closest;
+}
+
+wf::geometry_t wf::xw::calculate_wayfire_geometry(wf::output_t *ref_output, wf::geometry_t geometry)
+{
+    if (!ref_output)
+    {
+        return geometry;
+    }
+
+    auto data = ref_output->get_data_safe<wf::xdg_output_xwayland_geometry>();
+    if (!data->geometry.has_value())
+    {
+        LOGW("Xwayland geometry not set for output ", ref_output->to_string(),
+            ", returning original geometry");
+        return geometry;
+    }
+
+    geometry = geometry - wf::origin(data->geometry.value());
+    static wf::option_wrapper_t<bool> force_xwayland_scaling{"workarounds/force_xwayland_scaling"};
+    if (force_xwayland_scaling)
+    {
+        geometry = geometry * (1.0 / ref_output->get_scale());
+    }
+
+    return geometry;
+}
+
 #endif