ui: inline single monitor settings

data/ui/pages/displays-page.blp

@@ -70,6 +70,294 @@ Tuner.Page displays_page {
     }
 
     Tuner.Group {
+        title: _("Display");
+        id: "single-display";
+
+        Tuner.Combo {
+            title: _("Resolution");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "mode";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "combined-mode"; group-feature: "single-monitor-display"; };
+            };
+            $TunerDisplaysMonitorChoiceLoader { field: "mode"; }
+        }
+
+        Tuner.Combo {
+            title: _("Resolution");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "resolution";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "separate-refresh"; group-feature: "single-monitor-display"; };
+            };
+            $TunerDisplaysMonitorChoiceLoader { field: "resolution"; }
+        }
+
+        Tuner.Expander {
+            title: _("Refresh Rate");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "refresh-visible";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "separate-refresh"; group-feature: "single-monitor-display"; };
+            };
+
+            Tuner.Combo {
+                title: _("Refresh Rate");
+                binding: $TunerDisplaysMonitorSettingBinding {
+                    field: "refresh";
+                    validator: $TunerDisplaysMonitorSettingValidator { feature: "fixed-refresh"; };
+                };
+                $TunerDisplaysMonitorChoiceLoader { field: "refresh"; }
+            }
+
+            Tuner.Switch {
+                title: _("Variable Refresh Rate");
+                binding: $TunerDisplaysMonitorSettingBinding {
+                    field: "variable-refresh";
+                    validator: $TunerDisplaysMonitorSettingValidator { feature: "variable-refresh"; };
+                };
+            }
+        }
+
+        Tuner.Combo {
+            title: _("Scale");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "scale-choice";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "scale-choice"; group-feature: "single-monitor-display"; };
+            };
+            $TunerDisplaysMonitorChoiceLoader { field: "scale"; }
+        }
+
+        Tuner.Spin {
+            title: _("Scale");
+            digits: 2;
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "scale-spin";
+                lower: 0.25;
+                upper: 8.0;
+                step: 0.05;
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "scale-spin"; group-feature: "single-monitor-display"; };
+            };
+        }
+
+        Tuner.Combo {
+            title: _("Rotation");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "transform";
+                validator: $TunerDisplaysMonitorSettingValidator { group-feature: "single-monitor-display"; };
+            };
+            $TunerDisplaysMonitorChoiceLoader { field: "transform"; }
+        }
+
+        Tuner.Combo {
+            title: _("Variable Refresh Rate");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "niri-vrr";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "adaptive-sync"; group-feature: "single-monitor-display"; };
+            };
+            $TunerDisplaysMonitorChoiceLoader { field: "niri-vrr"; }
+        }
+
+        Tuner.Switch {
+            title: _("Focus at startup");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "niri-focus";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "focus-at-startup"; group-feature: "single-monitor-display"; };
+            };
+        }
+
+        $TunerDisplaysBackdropColorWidget {
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "backdrop-color";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "backdrop-color"; group-feature: "single-monitor-display"; };
+            };
+        }
+
+        Tuner.Combo {
+            title: _("Hot corners");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "hot-corners";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "hot-corners"; group-feature: "single-monitor-display"; };
+            };
+            $TunerDisplaysMonitorChoiceLoader { field: "hot-corners"; }
+        }
+
+        Tuner.Switch {
+            title: _("Adjust for TV");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "underscanning";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "underscanning"; group-feature: "single-monitor-display"; };
+            };
+        }
+
+        Tuner.Switch {
+            title: _("HDR");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "hdr-toggle";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "hdr-toggle"; group-feature: "single-monitor-display"; };
+            };
+        }
+    }
+
+    Tuner.Group {
+        title: _("Hyprland");
+        id: "single-hyprland";
+
+        Tuner.Switch {
+            title: _("Use description");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "use-description";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "description-identifier"; group-feature: "single-monitor-hyprland"; };
+            };
+        }
+
+        Tuner.Combo {
+            title: _("Bit depth");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "bitdepth";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "bit-depth"; group-feature: "single-monitor-hyprland"; };
+            };
+            $TunerDisplaysMonitorChoiceLoader { field: "bitdepth"; }
+        }
+
+        Tuner.Combo {
+            title: _("VRR");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "hypr-vrr";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "vrr-modes"; group-feature: "single-monitor-hyprland"; };
+            };
+            $TunerDisplaysMonitorChoiceLoader { field: "hypr-vrr"; }
+        }
+
+        Tuner.Combo {
+            title: _("Color management");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "color-management";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "color-management"; group-feature: "single-monitor-hyprland"; };
+            };
+            $TunerDisplaysMonitorChoiceLoader { field: "color-management"; }
+        }
+
+        Tuner.Combo {
+            title: _("SDR EOTF");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "sdr-eotf";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "color-management"; group-feature: "single-monitor-hyprland"; };
+            };
+            $TunerDisplaysMonitorChoiceLoader { field: "sdr-eotf"; }
+        }
+
+        Tuner.Spin {
+            title: _("SDR brightness");
+            digits: 2;
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "sdr-brightness";
+                lower: 0.1;
+                upper: 4.0;
+                step: 0.05;
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "color-management"; group-feature: "single-monitor-hyprland"; };
+            };
+        }
+
+        Tuner.Spin {
+            title: _("SDR saturation");
+            digits: 2;
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "sdr-saturation";
+                lower: 0.1;
+                upper: 4.0;
+                step: 0.05;
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "color-management"; group-feature: "single-monitor-hyprland"; };
+            };
+        }
+    }
+
+    Tuner.Group {
+        title: _("HDR / EDID overrides");
+        id: "single-hdr";
+
+        Tuner.Combo {
+            title: _("Force wide color");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "force-wide-color";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "hdr-metadata"; group-feature: "single-monitor-hdr"; };
+            };
+            $TunerDisplaysMonitorChoiceLoader { field: "force-toggle"; }
+        }
+
+        Tuner.Combo {
+            title: _("Force HDR");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "force-hdr";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "hdr-metadata"; group-feature: "single-monitor-hdr"; };
+            };
+            $TunerDisplaysMonitorChoiceLoader { field: "force-toggle"; }
+        }
+
+        Tuner.Spin {
+            title: _("SDR min luminance");
+            digits: 2;
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "sdr-min-luminance";
+                lower: 0.0;
+                upper: 10.0;
+                step: 0.01;
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "hdr-metadata"; group-feature: "single-monitor-hdr"; };
+            };
+        }
+
+        Tuner.Spin {
+            title: _("SDR max luminance");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "sdr-max-luminance";
+                lower: 1;
+                upper: 1000;
+                step: 1;
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "hdr-metadata"; group-feature: "single-monitor-hdr"; };
+            };
+        }
+
+        Tuner.Spin {
+            title: _("Min luminance");
+            digits: 2;
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "min-luminance";
+                lower: -1;
+                upper: 10.0;
+                step: 0.01;
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "hdr-metadata"; group-feature: "single-monitor-hdr"; };
+            };
+        }
+
+        Tuner.Spin {
+            title: _("Max luminance");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "max-luminance";
+                lower: -1;
+                upper: 10000;
+                step: 1;
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "hdr-metadata"; group-feature: "single-monitor-hdr"; };
+            };
+        }
+
+        Tuner.Spin {
+            title: _("Max average luminance");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "max-avg-luminance";
+                lower: -1;
+                upper: 10000;
+                step: 1;
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "hdr-metadata"; group-feature: "single-monitor-hdr"; };
+            };
+        }
+
+        Tuner.Entry {
+            title: _("ICC profile");
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "icc";
+                validator: $TunerDisplaysMonitorSettingValidator { feature: "hdr-metadata"; group-feature: "single-monitor-hdr"; };
+            };
+        }
+    }
+
+    Tuner.Group {
         title: _("Virtual Displays");
         id: "virtual-outputs";
         show-empty: true;
@@ -90,17 +378,6 @@ Tuner.Page displays_page {
             };
         }
     }
-
-    Tuner.Group {
-        id: "single-monitor";
-
-        $TunerDisplaysSingleMonitorWidget single_monitor_widget {
-            binding: $TunerDisplaysDisplaysVisibilityBinding {
-                mode: "single-monitor";
-                validator: $TunerDisplaysDisplaysVisibilityValidator {};
-            };
-        }
-    }
 }
 
 Button refresh_button {

data/ui/pages/monitor-settings-content.blp

@@ -10,7 +10,15 @@ Tuner.Page monitor_settings_content_page {
     Tuner.Group {
         id: "preview";
 
-        $TunerDisplaysMonitorSettingsPreviewWidget {}
+        $TunerDisplaysMonitorSettingsPreviewWidget {
+            binding: $TunerDisplaysMonitorSettingBinding {
+                field: "preview";
+                validator: $TunerDisplaysMonitorSettingValidator {
+                    feature: "preview";
+                    group-feature: "preview";
+                };
+            };
+        }
     }
 
     Tuner.Group {

src/meson.build

@@ -29,7 +29,6 @@ sources = files(
     'ui/widgets/monitor-settings-preview-widget.vala',
     'ui/widgets/monitor-row.vala',
     'ui/widgets/primary-display-widget.vala',
-    'ui/widgets/single-monitor-widget.vala',
     'ui/widgets/status-widget.vala',
     'ui/widgets/virtual-outputs-widget.vala',
     'ui/pages/monitor-settings-content.vala',

src/plugin.vala

@@ -5,6 +5,11 @@ namespace TunerDisplays {
         private Tuner.Page monitor_page;
         private Gtk.Box monitor_page_content;
         private Gtk.Label monitor_page_title;
+        private MonitorSettingsContext? single_monitor_context;
+        private Adw.PreferencesGroup? single_display_group;
+        private Adw.PreferencesGroup? single_hyprland_group;
+        private Adw.PreferencesGroup? single_hdr_group;
+        private bool single_monitor_groups_ready;
 
         construct {
             Intl.bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
@@ -12,6 +17,9 @@ namespace TunerDisplays {
             load_css();
 
             DisplaysContext.controller = new DisplaysController();
+            DisplaysContext.controller.reload();
+            create_main_monitor_context();
+            DisplaysContext.controller.changed.connect(create_main_monitor_context);
 
             typeof(ConfigIncludeBinding).ensure();
             typeof(ConfigIncludeValidator).ensure();
@@ -27,7 +35,6 @@ namespace TunerDisplays {
             typeof(MirrorSettingsWidget).ensure();
             typeof(PrimaryDisplayWidget).ensure();
             typeof(MonitorListWidget).ensure();
-            typeof(SingleMonitorWidget).ensure();
             typeof(VirtualOutputsWidget).ensure();
             typeof(MonitorSettingBinding).ensure();
             typeof(MonitorSettingValidator).ensure();
@@ -72,7 +79,9 @@ namespace TunerDisplays {
             DisplaysContext.controller.monitor_settings_requested.connect(show_monitor_settings);
 
             add_page(page);
-            DisplaysContext.controller.reload();
+            Idle.add(() => {
+                return setup_single_monitor_groups();
+            });
         }
 
         private void load_css() {
@@ -104,6 +113,63 @@ namespace TunerDisplays {
             content.monitor_changed.connect(DisplaysContext.controller.refresh_from_monitors);
             return content;
         }
+
+        private void create_main_monitor_context() {
+            var controller = DisplaysContext.controller;
+            var monitor = controller.monitors.size > 0 ? controller.monitors[0] : new MonitorConfig();
+            single_monitor_context = new MonitorSettingsContext(monitor, controller.backend, controller.monitors, false);
+            MonitorSettingsState.current = single_monitor_context;
+            single_monitor_context.changed.connect(controller.refresh_from_monitors);
+        }
+
+        private bool setup_single_monitor_groups() {
+            if (single_monitor_groups_ready)
+                return false;
+
+            var panel_page = page.list as Tuner.PanelPage;
+            if (panel_page == null)
+                return true;
+
+            var content = panel_page.content;
+            if (content == null)
+                return true;
+
+            var panel_content = content as Tuner.PanelContent;
+            if (panel_content == null)
+                return true;
+
+            find_single_monitor_groups(panel_content);
+            single_monitor_groups_ready = true;
+            update_single_monitor_groups();
+            DisplaysContext.controller.changed.connect(update_single_monitor_groups);
+            return false;
+        }
+
+        private void find_single_monitor_groups(Tuner.PanelContent content) {
+            for (var child = content.get_groups_container().get_first_child(); child != null; child = child.get_next_sibling()) {
+                var group = child as Adw.PreferencesGroup;
+                if (group == null)
+                    continue;
+
+                if (group.title == _("Display"))
+                    single_display_group = group;
+                else if (group.title == _("Hyprland"))
+                    single_hyprland_group = group;
+                else if (group.title == _("HDR / EDID overrides"))
+                    single_hdr_group = group;
+            }
+        }
+
+        private void update_single_monitor_groups() {
+            var visible = DisplaysContext.controller.single_monitor_mode();
+
+            if (single_display_group != null)
+                single_display_group.visible = visible;
+            if (single_hyprland_group != null)
+                single_hyprland_group.visible = visible && monitor_feature_visible("hyprland");
+            if (single_hdr_group != null)
+                single_hdr_group.visible = visible && monitor_feature_visible("hdr");
+        }
     }
 }
 

src/ui/common/displays-visibility.vala

@@ -41,6 +41,10 @@ namespace TunerDisplays {
 
         public override void apply(Tuner.Binding binding, Gtk.Widget native_widget) {
             update(binding, native_widget);
+            Idle.add(() => {
+                update(binding, native_widget);
+                return false;
+            });
             DisplaysContext.controller.changed.connect(() => update(binding, native_widget));
         }
 

src/ui/settings/monitor-setting-validator.vala

@@ -6,7 +6,12 @@ namespace TunerDisplays {
 
         public override void apply(Tuner.Binding binding, Gtk.Widget native_widget) {
             update(native_widget);
+            Idle.add(() => {
+                update(native_widget);
+                return false;
+            });
             MonitorSettingsState.current.changed.connect(() => update(native_widget));
+            DisplaysContext.controller.changed.connect(() => update(native_widget));
         }
 
         private void update(Gtk.Widget widget) {
@@ -22,13 +27,20 @@ namespace TunerDisplays {
         var context = MonitorSettingsState.current;
         var backend = context.backend;
         var monitor = context.monitor;
-
         switch (feature) {
         case "":
         case "always":
             return true;
         case "enabled":
             return context.show_enabled;
+        case "preview":
+            return context.all_monitors.size > 1;
+        case "single-monitor-display":
+            return DisplaysContext.controller.single_monitor_mode();
+        case "single-monitor-hyprland":
+            return DisplaysContext.controller.single_monitor_mode() && monitor_feature_visible("hyprland");
+        case "single-monitor-hdr":
+            return DisplaysContext.controller.single_monitor_mode() && monitor_feature_visible("hdr");
         case "combined-mode":
             return !backend.uses_separate_refresh_rate_controls;
         case "separate-refresh":

src/ui/widgets/monitor-settings-preview-widget.vala

@@ -25,6 +25,8 @@ namespace TunerDisplays {
             context.changed.connect(() => layout.set_monitors(context.all_monitors));
 
             row.child = layout;
+            if (binding != null && binding.validator != null)
+                binding.validator.apply(binding, row);
             return row;
         }
     }

src/ui/widgets/single-monitor-widget.vala

-namespace TunerDisplays {
-
-    public class SingleMonitorWidget : Tuner.Widget {
-        private Gtk.Box box;
-        private MonitorSettingsContent? content;
-
-        public override Gtk.Widget? create() {
-            box = new Gtk.Box(Gtk.Orientation.VERTICAL, 0);
-            DisplaysContext.controller.changed.connect(rebuild);
-            rebuild();
-            if (binding != null && binding.validator != null)
-                binding.validator.apply(binding, box);
-            return box;
-        }
-
-        private void rebuild() {
-            var child = box.get_first_child();
-            while (child != null) {
-                var next = child.get_next_sibling();
-                box.remove(child);
-                child = next;
-            }
-            content = null;
-
-            var controller = DisplaysContext.controller;
-            if (!controller.single_monitor_mode()) {
-                box.visible = false;
-                return;
-            }
-
-            content = new MonitorSettingsContent(controller.monitors[0], controller.backend, controller.monitors, false);
-            content.monitor_changed.connect(controller.refresh_from_monitors);
-            box.append(content);
-            box.visible = true;
-        }
-    }
-}