refactor(ui): ponytail pass on dictation overlay

Drop the hand-drawn mic glyph, simplify the Cairo clear/pulse path,
reuse ConfigManager get_bool/set, tighten tray overlay helpers, and
delete string-grep structural tests that proved nothing.

Author: jatinkrmalik

src/vocalinux/ui/config_manager.py

@@ -373,13 +373,11 @@ def set_sound_effects_enabled(self, enabled: bool):
 
     def is_overlay_enabled(self) -> bool:
         """Check if the floating dictation overlay is enabled (default True)."""
-        return bool(self.config.get("ui", {}).get("show_overlay", True))
+        return self.get_bool("ui", "show_overlay", True)
 
     def set_overlay_enabled(self, enabled: bool):
         """Enable or disable the floating dictation overlay."""
-        if "ui" not in self.config:
-            self.config["ui"] = {}
-        self.config["ui"]["show_overlay"] = bool(enabled)
+        self.set("ui", "show_overlay", bool(enabled))
 
     def _update_dict_recursive(self, target: dict, source: dict):
         """

src/vocalinux/ui/dictation_overlay.py

@@ -118,7 +118,7 @@ def __init__(self, enabled: bool = True):
         self._anim_id: Optional[int] = None
         self._phase = 0.0
         self._gtk_ready = False
-        self._layer_shell = None
+        self._use_layer_shell = False
 
         try:
             self._init_gtk_window()
@@ -137,7 +137,6 @@ def _init_gtk_window(self) -> None:
         from gi.repository import Gdk, GLib, Gtk  # noqa: F401
 
         self._GLib = GLib
-        self._Gtk = Gtk
         self._Gdk = Gdk
 
         # TOPLEVEL (undecorated) positions more reliably than POPUP on Wayland
@@ -155,7 +154,6 @@ def _init_gtk_window(self) -> None:
         window.set_type_hint(Gdk.WindowTypeHint.NOTIFICATION)
         window.set_default_size(_OVERLAY_SIZE, _OVERLAY_SIZE)
         window.set_app_paintable(True)
-        window.set_events(0)  # no input events needed
 
         # RGBA visual for true transparency when the compositor supports it.
         screen = window.get_screen()
@@ -164,25 +162,20 @@ def _init_gtk_window(self) -> None:
             window.set_visual(visual)
 
         # Soft Wayland layer-shell (optional — never required).
-        self._layer_shell = _try_import_layer_shell()
-        self._use_layer_shell = False
-        if self._layer_shell is not None:
+        layer_shell = _try_import_layer_shell()
+        if layer_shell is not None:
             try:
-                if self._layer_shell.is_supported():
-                    self._layer_shell.init_for_window(window)
-                    self._layer_shell.set_layer(window, self._layer_shell.Layer.OVERLAY)
-                    self._layer_shell.set_anchor(window, self._layer_shell.Edge.BOTTOM, True)
-                    self._layer_shell.set_margin(
-                        window, self._layer_shell.Edge.BOTTOM, _BOTTOM_MARGIN
-                    )
-                    self._layer_shell.set_exclusive_zone(window, 0)
+                if layer_shell.is_supported():
+                    layer_shell.init_for_window(window)
+                    layer_shell.set_layer(window, layer_shell.Layer.OVERLAY)
+                    layer_shell.set_anchor(window, layer_shell.Edge.BOTTOM, True)
+                    layer_shell.set_margin(window, layer_shell.Edge.BOTTOM, _BOTTOM_MARGIN)
+                    layer_shell.set_exclusive_zone(window, 0)
                     # Do not grab keyboard — passive visual only.
-                    if hasattr(self._layer_shell, "set_keyboard_mode"):
-                        self._layer_shell.set_keyboard_mode(
-                            window, self._layer_shell.KeyboardMode.NONE
-                        )
-                    elif hasattr(self._layer_shell, "set_keyboard_interactivity"):
-                        self._layer_shell.set_keyboard_interactivity(window, False)
+                    if hasattr(layer_shell, "set_keyboard_mode"):
+                        layer_shell.set_keyboard_mode(window, layer_shell.KeyboardMode.NONE)
+                    elif hasattr(layer_shell, "set_keyboard_interactivity"):
+                        layer_shell.set_keyboard_interactivity(window, False)
                     self._use_layer_shell = True
                     logger.info("Dictation overlay using GtkLayerShell")
             except Exception as e:
@@ -313,12 +306,9 @@ def _on_draw(self, widget, cr) -> bool:
         width = widget.get_allocated_width()
         height = widget.get_allocated_height()
         cx, cy = width / 2.0, height / 2.0
-        base_r, base_g, base_b = _COLORS.get(mode, _COLORS[MODE_LISTENING])
+        base_r, base_g, base_b = _COLORS[mode]
 
-        # Clear to fully transparent.
-        cr.set_operator(cr.get_operator())  # keep default
-        cr.set_source_rgba(0, 0, 0, 0)
-        cr.set_operator(1)  # CAIRO_OPERATOR_SOURCE / CLEAR-like full clear
+        # Clear to fully transparent (SOURCE then OVER for compositors with alpha).
         try:
             import cairo as _cairo
 
@@ -327,67 +317,40 @@ def _on_draw(self, widget, cr) -> bool:
             cr.paint()
             cr.set_operator(_cairo.OPERATOR_OVER)
         except Exception:
+            cr.set_source_rgba(0, 0, 0, 0)
             cr.paint()
 
-        # Pulse 0..1 → soft scale/alpha modulation.
-        pulse = 0.5 + 0.5 * math.sin(self._phase * 2.0 * math.pi)
-        # Processing uses a slower, subtler pulse.
+        # Pulse 0..1 → soft scale/alpha modulation (quieter while processing).
         if mode == MODE_PROCESSING:
             pulse = 0.55 + 0.25 * math.sin(self._phase * 2.0 * math.pi)
+            alpha_scale = 0.75
+            core_a = 0.8
+        else:
+            pulse = 0.5 + 0.5 * math.sin(self._phase * 2.0 * math.pi)
+            alpha_scale = 1.0
+            core_a = 0.95
 
         # Outer glow rings.
-        for radius_scale, alpha_scale in ((0.95, 0.12), (0.72, 0.22), (0.52, 0.35)):
+        for radius_scale, ring_a in ((0.95, 0.12), (0.72, 0.22), (0.52, 0.35)):
             radius = (width * 0.42) * radius_scale * (0.92 + 0.08 * pulse)
-            alpha = alpha_scale * (0.55 + 0.45 * pulse)
-            if mode == MODE_PROCESSING:
-                alpha *= 0.75
+            alpha = ring_a * (0.55 + 0.45 * pulse) * alpha_scale
             cr.set_source_rgba(base_r, base_g, base_b, alpha)
             cr.arc(cx, cy, radius, 0, 2 * math.pi)
             cr.fill()
 
-        # Expanding ripple ring (listening only — stronger “hot mic” cue).
+        # Expanding ripple (listening only).
         if mode == MODE_LISTENING:
-            ripple_t = self._phase
-            ripple_r = (width * 0.28) + ripple_t * (width * 0.28)
-            ripple_a = max(0.0, 0.45 * (1.0 - ripple_t))
+            ripple_r = (width * 0.28) + self._phase * (width * 0.28)
+            ripple_a = max(0.0, 0.45 * (1.0 - self._phase))
             cr.set_source_rgba(base_r, base_g, base_b, ripple_a)
             cr.set_line_width(2.0)
             cr.arc(cx, cy, ripple_r, 0, 2 * math.pi)
             cr.stroke()
 
-        # Solid core circle.
+        # Solid core.
         core_r = width * 0.16 * (0.95 + 0.05 * pulse)
-        cr.set_source_rgba(base_r, base_g, base_b, 0.95 if mode == MODE_LISTENING else 0.8)
+        cr.set_source_rgba(base_r, base_g, base_b, core_a)
         cr.arc(cx, cy, core_r, 0, 2 * math.pi)
         cr.fill()
 
-        # Simple mic glyph (stem + capsule) in white for readability.
-        cr.set_source_rgba(1, 1, 1, 0.95)
-        mic_w = width * 0.06
-        mic_h = height * 0.10
-        # Capsule body
-        cr.save()
-        cr.translate(cx, cy - height * 0.02)
-        cr.scale(1.0, 1.15)
-        cr.arc(0, -mic_h * 0.15, mic_w, math.pi, 0)
-        cr.arc(0, mic_h * 0.15, mic_w, 0, math.pi)
-        cr.close_path()
-        cr.fill()
-        cr.restore()
-        # Stem
-        cr.set_line_width(max(1.5, width * 0.02))
-        cr.set_line_cap(1)  # round
-        try:
-            import cairo as _cairo
-
-            cr.set_line_cap(_cairo.LINE_CAP_ROUND)
-        except Exception:
-            pass
-        cr.move_to(cx, cy + height * 0.06)
-        cr.line_to(cx, cy + height * 0.14)
-        cr.stroke()
-        # Base arc under mic
-        cr.arc(cx, cy + height * 0.04, width * 0.09, 0.15 * math.pi, 0.85 * math.pi)
-        cr.stroke()
-
         return False

src/vocalinux/ui/settings_dialog.py

@@ -1328,7 +1328,6 @@ def _on_show_overlay_toggled(self, widget, state):
             return False
 
         enabled = bool(state)
-        logger.info(f"Dictation overlay toggled: {enabled}")
         self.config_manager.set_overlay_enabled(enabled)
         self.config_manager.save_settings()
         if self.overlay_enabled_callback is not None:

src/vocalinux/ui/tray_indicator.py

@@ -445,24 +445,20 @@ def _update_ui(self, state: RecognitionState):
 
     def _update_overlay(self, state: RecognitionState):
         """Show/hide the floating dictation overlay for the given state."""
-        if not hasattr(self, "overlay") or self.overlay is None:
+        if getattr(self, "overlay", None) is None:
             return
         # Re-read config so Settings toggles apply without restart.
         self.overlay.set_enabled(self.config_manager.is_overlay_enabled())
         self.overlay.on_recognition_state(state)
 
     def set_overlay_enabled(self, enabled: bool) -> None:
-        """
-        Live-update overlay enabled state (called from Settings).
-
-        Args:
-            enabled: Whether the floating overlay should be shown when listening.
-        """
+        """Live-update overlay enabled state (called from Settings)."""
         self.config_manager.set_overlay_enabled(enabled)
-        if hasattr(self, "overlay") and self.overlay is not None:
-            self.overlay.set_enabled(enabled)
-            # Re-apply current recognition state so hide/show is immediate.
-            self.overlay.on_recognition_state(self.speech_engine.state)
+        if getattr(self, "overlay", None) is None:
+            return
+        self.overlay.set_enabled(enabled)
+        # Re-apply current recognition state so hide/show is immediate.
+        self.overlay.on_recognition_state(self.speech_engine.state)
 
     def _set_menu_item_enabled(self, label: str, enabled: bool):
         """
@@ -667,8 +663,7 @@ def _quit(self):
         # Stop the keyboard shortcut manager
         self.shortcut_manager.stop()
 
-        # Tear down floating overlay
-        if hasattr(self, "overlay") and self.overlay is not None:
+        if getattr(self, "overlay", None) is not None:
             self.overlay.destroy()
             self.overlay = None
 

tests/test_dictation_overlay.py

@@ -24,10 +24,7 @@
     DictationOverlayController,
 )
 
-# Source paths for structural checks (avoid importing modules that load GTK).
 _REPO_ROOT = Path(__file__).resolve().parents[1]
-_OVERLAY_SRC = _REPO_ROOT / "src" / "vocalinux" / "ui" / "dictation_overlay.py"
-_TRAY_SRC = _REPO_ROOT / "src" / "vocalinux" / "ui" / "tray_indicator.py"
 
 
 def _ensure_test_config_dir(path: str):
@@ -237,43 +234,6 @@ def test_gtk_init_failure_keeps_controller_usable(self):
         overlay.destroy()
 
 
-class TestOverlayWindowPassiveProperties(unittest.TestCase):
-    """
-    Structural checks against source files (no module import side effects).
-    """
-
-    def test_source_sets_non_focus_and_skip_taskbar(self):
-        source = _OVERLAY_SRC.read_text(encoding="utf-8")
-        self.assertIn("set_accept_focus(False)", source)
-        self.assertIn("set_skip_taskbar_hint(True)", source)
-        self.assertIn("set_keep_above(True)", source)
-        self.assertIn("set_skip_pager_hint(True)", source)
-        # Click-through so the overlay is passive.
-        self.assertIn("input_shape_combine_region", source)
-
-    def test_source_has_glow_or_pulse_animation(self):
-        source = _OVERLAY_SRC.read_text(encoding="utf-8")
-        self.assertIn("_on_draw", source)
-        self.assertIn("_on_anim_tick", source)
-        self.assertIn("timeout_add", source)
-        # Glow rings / pulse phase.
-        self.assertIn("pulse", source)
-        self.assertIn("sin", source)
-
-    def test_layer_shell_is_optional_soft_import(self):
-        source = _OVERLAY_SRC.read_text(encoding="utf-8")
-        self.assertIn("_try_import_layer_shell", source)
-        self.assertIn("GtkLayerShell", source)
-        # Soft failure path is present in the helper.
-        self.assertIn("except Exception", source)
-
-    def test_tray_wires_overlay_to_state_updates(self):
-        source = _TRAY_SRC.read_text(encoding="utf-8")
-        self.assertIn("DictationOverlay", source)
-        self.assertIn("_update_overlay", source)
-        self.assertIn("on_recognition_state", source)
-
-
 class TestOverlayWithMockedGtkWindow(unittest.TestCase):
     """
     Exercise DictationOverlay sync path when a mock window is attached,
@@ -516,11 +476,10 @@ def test_on_draw_listening_paints_rings_and_ripple(self):
         widget.get_allocated_width.return_value = 96
         widget.get_allocated_height.return_value = 96
         cr = MagicMock()
-        # Simulate cairo import failure for the clear path then success for line cap
         self.assertFalse(overlay._on_draw(widget, cr))
         self.assertTrue(cr.arc.called)
         self.assertTrue(cr.fill.called)
-        self.assertTrue(cr.stroke.called)
+        self.assertTrue(cr.stroke.called)  # ripple ring
 
     def test_on_draw_processing_uses_muted_pulse(self):
         overlay = _overlay_without_gtk(enabled=True)