0024-display-Allow-fractional-scaling-to-be-enabled.patch

From: Robert Ancell <robert.ancell@canonical.com>
Date: Sun, 15 Mar 2020 09:07:51 +0100
Subject: [PATCH 24/26] display: Allow fractional scaling to be enabled

---
 panels/display/cc-display-config-dbus.c |  16 +++
 panels/display/cc-display-config.c      | 237 ++++++++++++++++++++++++++++++++
 panels/display/cc-display-config.h      |   5 +
 panels/display/cc-display-settings.c    |  28 +++-
 panels/display/cc-display-settings.ui   |  16 +++
 5 files changed, 301 insertions(+), 1 deletion(-)

diff --git a/panels/display/cc-display-config-dbus.c b/panels/display/cc-display-config-dbus.c
index fc050a3..7eda67a 100644
--- a/panels/display/cc-display-config-dbus.c
+++ b/panels/display/cc-display-config-dbus.c
@@ -887,6 +887,7 @@ struct _CcDisplayConfigDBus
   gboolean supports_changing_layout_mode;
   gboolean global_scale_required;
   CcDisplayLayoutMode layout_mode;
+  gint legacy_ui_scale;
 
   GList *monitors;
   CcDisplayMonitorDBus *primary;
@@ -1059,6 +1060,9 @@ cc_display_config_dbus_equal (CcDisplayConfig *pself,
   g_return_val_if_fail (pself, FALSE);
   g_return_val_if_fail (pother, FALSE);
 
+  if (self->layout_mode != other->layout_mode)
+    return FALSE;
+
   cc_display_config_dbus_ensure_non_offset_coords (self);
   cc_display_config_dbus_ensure_non_offset_coords (other);
 
@@ -1215,6 +1219,13 @@ cc_display_config_dbus_layout_use_ui_scale (CcDisplayConfig *pself)
   return self->layout_mode == CC_DISPLAY_LAYOUT_MODE_GLOBAL_UI_LOGICAL;
 }
 
+static gint
+cc_display_config_dbus_get_legacy_ui_scale (CcDisplayConfig *pself)
+{
+  CcDisplayConfigDBus *self = CC_DISPLAY_CONFIG_DBUS (pself);
+  return self->legacy_ui_scale;
+}
+
 static gboolean
 is_scaled_mode_allowed (CcDisplayConfigDBus *self,
                         CcDisplayMode       *pmode,
@@ -1469,6 +1480,10 @@ cc_display_config_dbus_constructed (GObject *object)
         {
           g_variant_get (v, "b", &self->global_scale_required);
         }
+      else if (g_str_equal (s, "legacy-ui-scaling-factor"))
+        {
+          g_variant_get (v, "i", &self->legacy_ui_scale);
+        }
       else if (g_str_equal (s, "layout-mode"))
         {
           guint32 u = 0;
@@ -1565,6 +1580,7 @@ cc_display_config_dbus_class_init (CcDisplayConfigDBusClass *klass)
   parent_class->is_scaled_mode_valid = cc_display_config_dbus_is_scaled_mode_valid;
   parent_class->set_minimum_size = cc_display_config_dbus_set_minimum_size;
   parent_class->layout_use_ui_scale = cc_display_config_dbus_layout_use_ui_scale;
+  parent_class->get_legacy_ui_scale = cc_display_config_dbus_get_legacy_ui_scale;
 
   pspec = g_param_spec_variant ("state",
                                 "GVariant",
diff --git a/panels/display/cc-display-config.c b/panels/display/cc-display-config.c
index 552a1a6..2ff5a06 100644
--- a/panels/display/cc-display-config.c
+++ b/panels/display/cc-display-config.c
@@ -17,10 +17,23 @@
  *
  */
 
+#define MUTTER_SCHEMA                     "org.gnome.mutter"
+#define MUTTER_EXPERIMENTAL_FEATURES_KEY  "experimental-features"
+#define MUTTER_FEATURE_FRACTIONAL_SCALING_X11 "x11-randr-fractional-scaling"
+#define MUTTER_FEATURE_FRACTIONAL_SCALING_WAYLAND "scale-monitor-framebuffer"
+
+#include <gdk/gdk.h>
 #include <gio/gio.h>
 #include <math.h>
 #include "cc-display-config.h"
 
+#ifdef GDK_WINDOWING_WAYLAND
+#include <gdk/gdkwayland.h>
+#endif
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#endif
+
 static const double known_diagonals[] = {
   12.1,
   13.3,
@@ -419,6 +432,10 @@ cc_display_monitor_set_ui_info (CcDisplayMonitor *self, gint ui_number, gchar *u
 
 struct _CcDisplayConfigPrivate {
   GList *ui_sorted_monitors;
+
+  GSettings *mutter_settings;
+  gboolean fractional_scaling;
+  gboolean fractional_scaling_pending_disable;
 };
 typedef struct _CcDisplayConfigPrivate CcDisplayConfigPrivate;
 
@@ -426,12 +443,80 @@ G_DEFINE_TYPE_WITH_PRIVATE (CcDisplayConfig,
                             cc_display_config,
                             G_TYPE_OBJECT)
 
+static const char *
+get_fractional_scaling_key (void)
+{
+  GdkDisplay *display;
+
+  display = gdk_display_get_default ();
+
+#if defined(GDK_WINDOWING_X11)
+  if (GDK_IS_X11_DISPLAY (display))
+    return MUTTER_FEATURE_FRACTIONAL_SCALING_X11;
+#endif /* GDK_WINDOWING_X11 */
+#if defined(GDK_WINDOWING_WAYLAND)
+  if (GDK_IS_WAYLAND_DISPLAY (display))
+    return MUTTER_FEATURE_FRACTIONAL_SCALING_WAYLAND;
+#endif /* GDK_WINDOWING_WAYLAND */
+  g_return_val_if_reached (NULL);
+}
+
+static gboolean
+get_fractional_scaling_active (CcDisplayConfig *self)
+{
+  CcDisplayConfigPrivate *priv = cc_display_config_get_instance_private (self);
+  g_auto(GStrv) features = NULL;
+  const char *key = get_fractional_scaling_key ();
+
+  g_return_val_if_fail (key, FALSE);
+
+  features = g_settings_get_strv (priv->mutter_settings, MUTTER_EXPERIMENTAL_FEATURES_KEY);
+  return g_strv_contains ((const gchar **) features, key);
+}
+
+static void
+set_fractional_scaling_active (CcDisplayConfig *self,
+                               gboolean         enable)
+{
+  CcDisplayConfigPrivate *priv = cc_display_config_get_instance_private (self);
+  g_auto(GStrv) existing_features = NULL;
+  gboolean have_fractional_scaling = FALSE;
+  g_autoptr(GVariantBuilder) builder = NULL;
+  const char *key = get_fractional_scaling_key ();
+
+  /* Add or remove the fractional scaling feature from mutter */
+  existing_features = g_settings_get_strv (priv->mutter_settings,
+                                           MUTTER_EXPERIMENTAL_FEATURES_KEY);
+  builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
+  for (int i = 0; existing_features[i] != NULL; i++)
+    {
+      if (g_strcmp0 (existing_features[i], key) == 0)
+        {
+          if (enable)
+            have_fractional_scaling = TRUE;
+          else
+            continue;
+        }
+
+      g_variant_builder_add (builder, "s", existing_features[i]);
+    }
+  if (enable && !have_fractional_scaling && key)
+    g_variant_builder_add (builder, "s", key);
+
+  g_settings_set_value (priv->mutter_settings, MUTTER_EXPERIMENTAL_FEATURES_KEY,
+                        g_variant_builder_end (builder));
+}
+
 static void
 cc_display_config_init (CcDisplayConfig *self)
 {
   CcDisplayConfigPrivate *priv = cc_display_config_get_instance_private (self);
 
   priv->ui_sorted_monitors = NULL;
+
+  /* No need to connect to the setting, as we'll get notified by mutter */
+  priv->mutter_settings = g_settings_new (MUTTER_SCHEMA);
+  priv->fractional_scaling = get_fractional_scaling_active (self);
 }
 
 static void
@@ -472,6 +557,7 @@ cc_display_config_finalize (GObject *object)
   CcDisplayConfigPrivate *priv = cc_display_config_get_instance_private (self);
 
   g_list_free (priv->ui_sorted_monitors);
+  g_clear_object (&priv->mutter_settings);
 
   G_OBJECT_CLASS (cc_display_config_parent_class)->finalize (object);
 }
@@ -557,9 +643,16 @@ gboolean
 cc_display_config_equal (CcDisplayConfig *self,
                          CcDisplayConfig *other)
 {
+  CcDisplayConfigPrivate *spriv = cc_display_config_get_instance_private (self);
+  CcDisplayConfigPrivate *opriv = cc_display_config_get_instance_private (other);
+
   g_return_val_if_fail (CC_IS_DISPLAY_CONFIG (self), FALSE);
   g_return_val_if_fail (CC_IS_DISPLAY_CONFIG (other), FALSE);
 
+  if (spriv->fractional_scaling_pending_disable !=
+      opriv->fractional_scaling_pending_disable)
+    return FALSE;
+
   return CC_DISPLAY_CONFIG_GET_CLASS (self)->equal (self, other);
 }
 
@@ -567,6 +660,8 @@ gboolean
 cc_display_config_apply (CcDisplayConfig *self,
                          GError **error)
 {
+  CcDisplayConfigPrivate *priv = cc_display_config_get_instance_private (self);
+
   if (!CC_IS_DISPLAY_CONFIG (self))
     {
       g_warning ("Cannot apply invalid configuration");
@@ -577,6 +672,12 @@ cc_display_config_apply (CcDisplayConfig *self,
       return FALSE;
     }
 
+  if (priv->fractional_scaling_pending_disable)
+    {
+      set_fractional_scaling_active (self, FALSE);
+      priv->fractional_scaling_pending_disable = FALSE;
+    }
+
   return CC_DISPLAY_CONFIG_GET_CLASS (self)->apply (self, error);
 }
 
@@ -618,13 +719,31 @@ cc_display_config_set_minimum_size (CcDisplayConfig *self,
   CC_DISPLAY_CONFIG_GET_CLASS (self)->set_minimum_size (self, width, height);
 }
 
+gint
+cc_display_config_get_legacy_ui_scale (CcDisplayConfig *self)
+{
+  return CC_DISPLAY_CONFIG_GET_CLASS (self)->get_legacy_ui_scale (self);
+}
+
+static gboolean
+scale_value_is_fractional (double scale)
+{
+  return (int) scale != scale;
+}
+
 gboolean
 cc_display_config_is_scaled_mode_valid (CcDisplayConfig *self,
                                         CcDisplayMode   *mode,
                                         double           scale)
 {
+  CcDisplayConfigPrivate *priv = cc_display_config_get_instance_private (self);
+
   g_return_val_if_fail (CC_IS_DISPLAY_CONFIG (self), FALSE);
   g_return_val_if_fail (CC_IS_DISPLAY_MODE (mode), FALSE);
+
+  if (priv->fractional_scaling_pending_disable && scale_value_is_fractional (scale))
+    return FALSE;
+
   return CC_DISPLAY_CONFIG_GET_CLASS (self)->is_scaled_mode_valid (self, mode, scale);
 }
 
@@ -653,3 +772,121 @@ cc_display_config_get_maximum_scaling (CcDisplayConfig *self)
 
   return max_scale;
 }
+
+static gboolean
+set_monitors_scaling_to_preferred_integers (CcDisplayConfig *self)
+{
+  GList *l;
+  gboolean any_changed = FALSE;
+
+  for (l = cc_display_config_get_monitors (self); l; l = l->next)
+    {
+      CcDisplayMonitor *monitor = l->data;
+      gdouble monitor_scale = cc_display_monitor_get_scale (monitor);
+
+      if (scale_value_is_fractional (monitor_scale))
+        {
+          CcDisplayMode *preferred_mode;
+          double preferred_scale;
+          double *saved_scale;
+
+          preferred_mode = cc_display_monitor_get_preferred_mode (monitor);
+          preferred_scale = cc_display_mode_get_preferred_scale (preferred_mode);
+          cc_display_monitor_set_scale (monitor, preferred_scale);
+          any_changed = TRUE;
+
+          saved_scale = g_new (double, 1);
+          *saved_scale = monitor_scale;
+          g_object_set_data_full (G_OBJECT (monitor),
+                                  "previous-fractional-scale",
+                                  saved_scale, g_free);
+        }
+      else
+        {
+          g_signal_emit_by_name (monitor, "scale");
+        }
+    }
+
+  return any_changed;
+}
+
+static void
+reset_monitors_scaling_to_selected_values (CcDisplayConfig *self)
+{
+  GList *l;
+
+  for (l = cc_display_config_get_monitors (self); l; l = l->next)
+    {
+      CcDisplayMonitor *monitor = l->data;
+      gdouble *saved_scale;
+
+      saved_scale = g_object_get_data (G_OBJECT (monitor),
+                                       "previous-fractional-scale");
+
+      if (saved_scale)
+        {
+          cc_display_monitor_set_scale (monitor, *saved_scale);
+          g_object_set_data (G_OBJECT (monitor), "previous-fractional-scale", NULL);
+        }
+      else
+        {
+          g_signal_emit_by_name (monitor, "scale");
+        }
+    }
+}
+
+void
+cc_display_config_set_fractional_scaling (CcDisplayConfig *self,
+                                          gboolean         enabled)
+{
+  CcDisplayConfigPrivate *priv = cc_display_config_get_instance_private (self);
+
+  if (priv->fractional_scaling == enabled)
+    return;
+
+  priv->fractional_scaling = enabled;
+
+  if (priv->fractional_scaling)
+    {
+      if (priv->fractional_scaling_pending_disable)
+        {
+          priv->fractional_scaling_pending_disable = FALSE;
+          reset_monitors_scaling_to_selected_values (self);
+        }
+
+      if (!get_fractional_scaling_active (self))
+        set_fractional_scaling_active (self, enabled);
+    }
+  else
+    {
+      priv->fractional_scaling_pending_disable = TRUE;
+
+      if (!set_monitors_scaling_to_preferred_integers (self))
+        {
+          gboolean disable_now = FALSE;
+
+          if (cc_display_config_layout_use_ui_scale (self))
+            {
+              disable_now =
+                G_APPROX_VALUE (cc_display_config_get_legacy_ui_scale (self),
+                                cc_display_config_get_maximum_scaling (self),
+                                DBL_EPSILON);
+            }
+
+          if (disable_now)
+            {
+              priv->fractional_scaling_pending_disable = FALSE;
+              reset_monitors_scaling_to_selected_values (self);
+              set_fractional_scaling_active (self, enabled);
+            }
+        }
+    }
+}
+
+gboolean
+cc_display_config_get_fractional_scaling (CcDisplayConfig *self)
+{
+  CcDisplayConfigPrivate *priv = cc_display_config_get_instance_private (self);
+
+  return priv->fractional_scaling;
+}
diff --git a/panels/display/cc-display-config.h b/panels/display/cc-display-config.h
index 1361f16..4a1548e 100644
--- a/panels/display/cc-display-config.h
+++ b/panels/display/cc-display-config.h
@@ -161,6 +161,7 @@ struct _CcDisplayConfigClass
                                     CcDisplayMode    *mode,
                                     double            scale);
   gboolean (*layout_use_ui_scale) (CcDisplayConfig  *self);
+  gint     (*get_legacy_ui_scale) (CcDisplayConfig  *self);
 };
 
 
@@ -188,8 +189,12 @@ gboolean          cc_display_config_is_scaled_mode_valid    (CcDisplayConfig
                                                              CcDisplayMode      *mode,
                                                              double              scale);
 gboolean          cc_display_config_layout_use_ui_scale     (CcDisplayConfig    *self);
+gint              cc_display_config_get_legacy_ui_scale     (CcDisplayConfig    *self);
 
 double            cc_display_config_get_maximum_scaling     (CcDisplayConfig    *self);
+void              cc_display_config_set_fractional_scaling  (CcDisplayConfig    *self,
+                                                             gboolean            enabled);
+gboolean          cc_display_config_get_fractional_scaling  (CcDisplayConfig    *self);
 
 const char*       cc_display_monitor_get_display_name       (CcDisplayMonitor   *monitor);
 gboolean          cc_display_monitor_is_active              (CcDisplayMonitor   *monitor);
diff --git a/panels/display/cc-display-settings.c b/panels/display/cc-display-settings.c
index d793fcc..947335a 100644
--- a/panels/display/cc-display-settings.c
+++ b/panels/display/cc-display-settings.c
@@ -49,6 +49,8 @@ struct _CcDisplaySettings
   GtkWidget        *resolution_row;
   GtkWidget        *scale_bbox;
   GtkWidget        *scale_row;
+  GtkWidget        *scale_fractional_row;
+  GtkWidget        *scale_fractional_switch;
   GtkWidget        *underscanning_row;
   GtkWidget        *underscanning_switch;
 };
@@ -71,7 +73,6 @@ static void on_scale_btn_active_changed_cb (GtkWidget         *widget,
                                             GParamSpec        *pspec,
                                             CcDisplaySettings *self);
 
-
 static gboolean
 should_show_rotation (CcDisplaySettings *self)
 {
@@ -242,6 +243,7 @@ cc_display_settings_rebuild_ui (CcDisplaySettings *self)
       gtk_widget_set_visible (self->refresh_rate_row, FALSE);
       gtk_widget_set_visible (self->resolution_row, FALSE);
       gtk_widget_set_visible (self->scale_row, FALSE);
+      gtk_widget_set_visible (self->scale_fractional_row, FALSE);
       gtk_widget_set_visible (self->underscanning_row, FALSE);
 
       return G_SOURCE_REMOVE;
@@ -429,6 +431,10 @@ cc_display_settings_rebuild_ui (CcDisplaySettings *self)
 
   gtk_widget_set_visible (self->scale_row, buttons > 1);
 
+  gtk_widget_set_visible (self->scale_fractional_row, TRUE);
+  gtk_switch_set_active (GTK_SWITCH (self->scale_fractional_switch),
+                         cc_display_config_get_fractional_scaling (self->config));
+
   gtk_widget_set_visible (self->underscanning_row,
                           cc_display_monitor_supports_underscanning (self->selected_output) &&
                           !cc_display_config_is_cloning (self->config));
@@ -671,6 +677,8 @@ cc_display_settings_class_init (CcDisplaySettingsClass *klass)
   gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, resolution_row);
   gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, scale_bbox);
   gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, scale_row);
+  gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, scale_fractional_row);
+  gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, scale_fractional_switch);
   gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, underscanning_row);
   gtk_widget_class_bind_template_child (widget_class, CcDisplaySettings, underscanning_switch);
 
@@ -680,11 +688,29 @@ cc_display_settings_class_init (CcDisplaySettingsClass *klass)
   gtk_widget_class_bind_template_callback (widget_class, on_underscanning_switch_active_changed_cb);
 }
 
+static void
+on_scale_fractional_toggled (CcDisplaySettings *self)
+{
+  gboolean active;
+
+  active = gtk_switch_get_active (GTK_SWITCH (self->scale_fractional_switch));
+
+  if (self->config)
+    cc_display_config_set_fractional_scaling (self->config, active);
+
+  g_signal_emit_by_name (G_OBJECT (self), "updated", self->selected_output);
+}
+
 static void
 cc_display_settings_init (CcDisplaySettings *self)
 {
   gtk_widget_init_template (GTK_WIDGET (self));
 
+  g_signal_connect_object (self->scale_fractional_switch,
+                           "notify::active",
+                           G_CALLBACK (on_scale_fractional_toggled),
+                           self, G_CONNECT_SWAPPED);
+
   gtk_list_box_set_header_func (GTK_LIST_BOX (self),
                                 cc_list_box_update_header_func,
                                 NULL, NULL);
diff --git a/panels/display/cc-display-settings.ui b/panels/display/cc-display-settings.ui
index 50ef951..cf8ca0a 100644
--- a/panels/display/cc-display-settings.ui
+++ b/panels/display/cc-display-settings.ui
@@ -68,5 +68,21 @@
         </child>
       </object>
     </child>
+    <child>
+      <object class="HdyActionRow" id="scale_fractional_row">
+        <property name="width_request">100</property>
+        <property name="visible">True</property>
+        <property name="can_focus">True</property>
+        <property name="title" translatable="yes" context="display setting">Fractional Scaling</property>
+        <property name="subtitle" translatable="yes" context="display setting">May increase power usage, lower speed, or reduce display sharpness.</property>
+        <child type="action">
+          <object class="GtkSwitch" id="scale_fractional_switch">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="valign">center</property>
+          </object>
+        </child>
+      </object>
+    </child>
   </template>
 </interface>