Enhance curve and output preset handling in D-Bus control and UI

Author: bhack

extensions/gnome-shell/mini-eq@bhack.github.io/extension.js

@@ -342,7 +342,9 @@ class MiniEqIndicator extends PanelMenu.Button {
             ? Boolean(unpackValue(state.analyzer_enabled))
             : true;
         const presetName = unpackValue(state.preset_name) || _('Current State');
+        const curveLabel = unpackValue(state.curve_label) || presetName;
         const outputPresetName = unpackValue(state.output_preset_name) || '';
+        const outputPresetLabel = unpackValue(state.output_preset_label) || outputPresetName;
         const capabilities = unpackValue(state.capabilities) || [];
         this._capabilities = new Set(Array.isArray(capabilities) ? capabilities : []);
         const canQuit = this._capabilities.has('quit');
@@ -367,9 +369,9 @@ class MiniEqIndicator extends PanelMenu.Button {
         this._routingItem.setSensitive(running);
         this._eqItem.setSensitive(running && routed);
         this._presetsItem.setSensitive(running);
-        this._presetsItem.label.text = running ? _('Preset: %s').format(presetName) : _('Presets');
+        this._presetsItem.label.text = running ? _('Curve: %s').format(curveLabel) : _('Presets');
         this._statusItem.label.text = this._statusText(running, routed, eqEnabled);
-        this._outputPresetItem.label.text = this._outputPresetText(running, outputPresetName);
+        this._outputPresetItem.label.text = this._outputPresetText(running, outputPresetLabel);
         this._quitItem.visible = running && canQuit;
     }
 

src/mini_eq/dbus_control.py

@@ -24,6 +24,19 @@
     "output-presets",
     "analyzer-levels",
 )
+CURVE_STATUS_BY_PRESET_STATE = {
+    "preset": "preset",
+    "modified": "modified",
+    "neutral": "neutral",
+    "unsaved": "unsaved",
+}
+OUTPUT_PRESET_STATUS_LABELS = {
+    "applied": "Applied",
+    "different": "Different",
+    "linked": "Linked",
+    "missing": "Missing",
+    "modified": "Modified",
+}
 
 INTROSPECTION_XML = f"""
 <node>
@@ -117,6 +130,93 @@ def quit_fully(self) -> None: ...
     def get_dbus_connection(self) -> Gio.DBusConnection | None: ...
 
 
+def curve_status_from_preset_state(value: object) -> str:
+    return CURVE_STATUS_BY_PRESET_STATE.get(str(value or "").strip().casefold(), "unknown")
+
+
+def format_curve_label(name: str, status: str) -> str:
+    label = name.strip() or "Current State"
+    if status == "modified":
+        return f"{label} (modified)"
+    return label
+
+
+def window_curve_display_state(window: object | None) -> tuple[str, str, str]:
+    if window is None:
+        return "", "none", "Current State"
+
+    curve_name = ""
+    curve_status = "unknown"
+    panel_state_factory = getattr(window, "preset_panel_ui_state", None)
+    if callable(panel_state_factory):
+        try:
+            panel_state = panel_state_factory()
+            curve_name = str(getattr(panel_state, "current_curve_text", "") or "").strip()
+            curve_status = curve_status_from_preset_state(getattr(panel_state, "preset_state_text", ""))
+        except Exception:
+            curve_name = ""
+            curve_status = "unknown"
+
+    if not curve_name:
+        curve_name = str(getattr(window, "current_preset_name", "") or "").strip() or "Current State"
+    if curve_status == "unknown" and getattr(window, "current_preset_name", None):
+        curve_status = "preset"
+
+    return curve_name, curve_status, format_curve_label(curve_name, curve_status)
+
+
+def window_output_preset_link_name(window: object | None) -> str:
+    if window is None:
+        return ""
+
+    output_preset_link_name = getattr(window, "output_preset_link_name", None)
+    if not callable(output_preset_link_name):
+        return ""
+
+    try:
+        return str(output_preset_link_name() or "").strip()
+    except Exception:
+        return ""
+
+
+def window_preset_name_exists(window: object, preset_name: str) -> bool:
+    preset_name_exists = getattr(window, "preset_name_exists", None)
+    if not callable(preset_name_exists):
+        return True
+
+    try:
+        return bool(preset_name_exists(preset_name))
+    except Exception:
+        return True
+
+
+def window_output_preset_status(window: object | None, preset_name: str) -> str:
+    if window is None or not preset_name:
+        return "none"
+
+    if not window_preset_name_exists(window, preset_name):
+        return "missing"
+    if bool(getattr(window, "output_preset_auto_applied", False)):
+        return "applied"
+
+    current_preset_name = getattr(window, "current_preset_name", None)
+    if current_preset_name == preset_name:
+        return "modified"
+    if current_preset_name:
+        return "different"
+    return "linked"
+
+
+def format_output_preset_label(preset_name: str, status: str) -> str:
+    if not preset_name:
+        return ""
+
+    status_label = OUTPUT_PRESET_STATUS_LABELS.get(status)
+    if status_label is None:
+        return preset_name
+    return f"{status_label} - {preset_name}"
+
+
 class MiniEqDbusControl:
     def __init__(self, app: ApplicationProtocol) -> None:
         self.app = app
@@ -148,11 +248,10 @@ def unregister(self) -> None:
     def state(self) -> dict[str, GLib.Variant]:
         controller = self.app.controller
         window = self.app.window
-        output_preset_name = ""
-        if window is not None:
-            output_preset_link_name = getattr(window, "output_preset_link_name", None)
-            if output_preset_link_name is not None:
-                output_preset_name = output_preset_link_name() or ""
+        curve_name, curve_status, curve_label = window_curve_display_state(window)
+        output_preset_name = window_output_preset_link_name(window)
+        output_preset_status = window_output_preset_status(window, output_preset_name)
+        output_preset_label = format_output_preset_label(output_preset_name, output_preset_status)
 
         return {
             "api_version": GLib.Variant("u", API_VERSION),
@@ -164,8 +263,13 @@ def state(self) -> dict[str, GLib.Variant]:
             "preset_name": GLib.Variant(
                 "s", window.current_preset_name if window and window.current_preset_name else ""
             ),
+            "curve_name": GLib.Variant("s", curve_name),
+            "curve_status": GLib.Variant("s", curve_status),
+            "curve_label": GLib.Variant("s", curve_label),
             "output_sink": GLib.Variant("s", controller.output_sink if controller and controller.output_sink else ""),
             "output_preset_name": GLib.Variant("s", output_preset_name),
+            "output_preset_status": GLib.Variant("s", output_preset_status),
+            "output_preset_label": GLib.Variant("s", output_preset_label),
             "output_preset_auto_applied": GLib.Variant(
                 "b",
                 bool(window and getattr(window, "output_preset_auto_applied", False)),

src/mini_eq/window_graph.py

@@ -177,6 +177,9 @@ def on_curve_metadata_refresh_idle(self) -> bool:
 
         self.update_status_summary()
         self.update_preset_state()
+        notify_control_state_changed = getattr(self, "notify_control_state_changed", None)
+        if callable(notify_control_state_changed):
+            notify_control_state_changed()
         return False
 
     def schedule_band_engine_update(self, index: int) -> None:
@@ -461,7 +464,7 @@ def on_custom_band_mute_toggled(self, index: int, muted: bool) -> None:
         self.update_status_summary()
         self.invalidate_graph_response_cache()
         self.queue_response_draw()
-        self.update_preset_state()
+        self.schedule_curve_metadata_refresh()
 
     def on_custom_band_solo_toggled(self, index: int, soloed: bool) -> None:
         if self.updating_ui:
@@ -480,7 +483,7 @@ def on_custom_band_solo_toggled(self, index: int, soloed: bool) -> None:
         self.update_status_summary()
         self.invalidate_graph_response_cache()
         self.queue_response_draw()
-        self.update_preset_state()
+        self.schedule_curve_metadata_refresh()
 
     def on_selected_band_type_changed(self, combo: Gtk.DropDown, _param: object) -> None:
         if self.updating_ui:
@@ -505,7 +508,7 @@ def on_selected_band_type_changed(self, combo: Gtk.DropDown, _param: object) ->
         self.update_status_summary()
         self.invalidate_graph_response_cache()
         self.queue_response_draw()
-        self.update_preset_state()
+        self.schedule_curve_metadata_refresh()
 
     def on_selected_band_frequency_changed(self, spin: Gtk.SpinButton) -> None:
         if self.updating_ui:

tests/test_mini_eq_dbus_control.py

@@ -98,7 +98,11 @@ def __init__(self, controller: FakeController) -> None:
         self.route_switch = FakeSwitch(controller.routed)
         self.loaded_presets: list[str] = []
         self.update_count = 0
+        self.current_curve_text = "Flat"
+        self.preset_state_text = "Preset"
+        self.output_preset_link = "Headphones"
         self.output_preset_auto_applied = False
+        self.existing_presets = {"Flat", "Headphones"}
         self.visible = True
 
     def sync_control_switches_from_controller(self, *, route: bool = True, eq: bool = True) -> None:
@@ -148,10 +152,21 @@ def refresh_after_eq_state_changed(
 
     def load_library_preset(self, name: str) -> None:
         self.current_preset_name = name
+        self.current_curve_text = name
+        self.preset_state_text = "Preset"
         self.loaded_presets.append(name)
 
     def output_preset_link_name(self) -> str | None:
-        return "Headphones"
+        return self.output_preset_link
+
+    def preset_panel_ui_state(self) -> SimpleNamespace:
+        return SimpleNamespace(
+            current_curve_text=self.current_curve_text,
+            preset_state_text=self.preset_state_text,
+        )
+
+    def preset_name_exists(self, preset_name: str) -> bool:
+        return preset_name in self.existing_presets
 
     def present(self) -> None:
         pass
@@ -214,8 +229,13 @@ def test_dbus_control_state_contains_shell_summary() -> None:
         "eq_enabled": True,
         "routed": False,
         "preset_name": "Flat",
+        "curve_name": "Flat",
+        "curve_status": "preset",
+        "curve_label": "Flat",
         "output_sink": "alsa_output.test",
         "output_preset_name": "Headphones",
+        "output_preset_status": "different",
+        "output_preset_label": "Different - Headphones",
         "output_preset_auto_applied": False,
         "analyzer_enabled": False,
         "background_mode": True,
@@ -225,6 +245,46 @@ def test_dbus_control_state_contains_shell_summary() -> None:
     }
 
 
+def test_dbus_control_state_marks_modified_curve_for_shell() -> None:
+    control, _controller, window = make_control()
+    window.current_curve_text = "Flat"
+    window.preset_state_text = "Modified"
+
+    state = {key: value.unpack() for key, value in control.state().items()}
+
+    assert state["curve_name"] == "Flat"
+    assert state["curve_status"] == "modified"
+    assert state["curve_label"] == "Flat (modified)"
+
+
+@pytest.mark.parametrize(
+    ("current_preset_name", "auto_applied", "existing_presets", "status", "label"),
+    [
+        ("Headphones", True, {"Headphones"}, "applied", "Applied - Headphones"),
+        ("Headphones", False, {"Headphones"}, "modified", "Modified - Headphones"),
+        ("Flat", False, {"Flat", "Headphones"}, "different", "Different - Headphones"),
+        (None, False, {"Headphones"}, "linked", "Linked - Headphones"),
+        ("Flat", False, {"Flat"}, "missing", "Missing - Headphones"),
+    ],
+)
+def test_dbus_control_state_describes_output_preset_for_shell(
+    current_preset_name: str | None,
+    auto_applied: bool,
+    existing_presets: set[str],
+    status: str,
+    label: str,
+) -> None:
+    control, _controller, window = make_control()
+    window.current_preset_name = current_preset_name
+    window.output_preset_auto_applied = auto_applied
+    window.existing_presets = existing_presets
+
+    state = {key: value.unpack() for key, value in control.state().items()}
+
+    assert state["output_preset_status"] == status
+    assert state["output_preset_label"] == label
+
+
 def test_dbus_control_compacts_analyzer_levels_for_shell_signal() -> None:
     control, _controller, window = make_control()
     window.analyzer_enabled = True

tests/test_mini_eq_window_graph.py

@@ -289,3 +289,20 @@ def test_curve_metadata_refresh_updates_preset_state_with_pending_idle(monkeypat
 
     assert calls == ["preset-state"]
     assert test_window.curve_metadata_refresh_source_id == 42
+
+
+def test_curve_metadata_refresh_idle_notifies_control_clients() -> None:
+    calls: list[str] = []
+    test_window = SimpleNamespace(
+        curve_metadata_refresh_source_id=42,
+        ui_shutting_down=False,
+        update_status_summary=lambda: calls.append("status"),
+        update_preset_state=lambda: calls.append("preset-state"),
+        notify_control_state_changed=lambda: calls.append("control-state"),
+    )
+
+    keep_source = window_graph.MiniEqWindowGraphMixin.on_curve_metadata_refresh_idle(test_window)
+
+    assert keep_source is False
+    assert test_window.curve_metadata_refresh_source_id == 0
+    assert calls == ["status", "preset-state", "control-state"]

tools/gnome-shell-extension/fake_mini_eq_control.py

@@ -119,8 +119,13 @@ def state(self) -> dict[str, GLib.Variant]:
             "eq_enabled": GLib.Variant("b", self.eq_enabled),
             "routed": GLib.Variant("b", self.routed),
             "preset_name": GLib.Variant("s", self.preset_name),
+            "curve_name": GLib.Variant("s", self.preset_name),
+            "curve_status": GLib.Variant("s", "preset"),
+            "curve_label": GLib.Variant("s", self.preset_name),
             "output_sink": GLib.Variant("s", "Demo Output"),
             "output_preset_name": GLib.Variant("s", self.output_preset_name),
+            "output_preset_status": GLib.Variant("s", "applied"),
+            "output_preset_label": GLib.Variant("s", f"Applied - {self.output_preset_name}"),
             "output_preset_auto_applied": GLib.Variant("b", True),
             "analyzer_enabled": GLib.Variant("b", self.analyzer_enabled),
             "background_mode": GLib.Variant("b", True),