Redesign theme; restructure ANC; add ANC to tray

- Refined monochrome theme: soft near-black surfaces and off-white text
  instead of harsh pure black/white, rounded shapes, styled menus, hover
  states; EQ curve recoloured to match.
- ANC tab restructured: top mode (Off / Transparency / Noise Cancelling)
  with a separate strength row (Adaptive / Low / Mid / High); a public
  apply() method drives both the UI and the device.
- Tray menu gains a Noise Cancelling submenu to set ANC directly.

https://claude.ai/code/session_014KrpftzUgVFGFXVUU3DUTT

Author: claude

src/nothing_ear/ui/anc_tab.py

@@ -1,8 +1,8 @@
 """ANC (Noise Cancelling) control tab.
 
-Each action opens a short-lived RFCOMM connection (connect, send, close). The
-blocking work runs on a background thread so the UI never freezes; results come
-back via Qt signals.
+Top level chooses Off / Transparency / Noise Cancelling; when noise cancelling
+is on, the strength row (Adaptive / Low / Mid / High) selects the level. Each
+action opens a short-lived RFCOMM connection on a background thread.
 """
 
 from __future__ import annotations
@@ -11,7 +11,8 @@
 
 from PySide6.QtCore import QObject, Signal
 from PySide6.QtWidgets import (
-    QGridLayout,
+    QFrame,
+    QHBoxLayout,
     QLabel,
     QPushButton,
     QVBoxLayout,
@@ -20,28 +21,25 @@
 
 from ..bluetooth.protocol import ANCMode, NothingController
 
-_MODES: list[tuple[str, ANCMode | None]] = [
-    ("Off", ANCMode.OFF),
-    ("Transparency", ANCMode.TRANSPARENCY),
+_LEVELS: list[tuple[str, ANCMode]] = [
+    ("Adaptive", ANCMode.ADAPTIVE),
     ("Low", ANCMode.LOW),
     ("Mid", ANCMode.MID),
     ("High", ANCMode.HIGH),
-    ("Adaptive", ANCMode.ADAPTIVE),
 ]
+_LEVEL_SET = {ANCMode.ADAPTIVE, ANCMode.LOW, ANCMode.MID, ANCMode.HIGH}
 
-_MODE_LABEL = {
+_LABELS = {
     ANCMode.OFF: "Off",
     ANCMode.TRANSPARENCY: "Transparency",
+    ANCMode.ADAPTIVE: "Adaptive",
     ANCMode.LOW: "Low",
     ANCMode.MID: "Mid",
     ANCMode.HIGH: "High",
-    ANCMode.ADAPTIVE: "Adaptive",
 }
 
 
 class _AncWorker(QObject):
-    """Runs RFCOMM ANC operations off the UI thread."""
-
     statusRead = Signal(object)
     actionDone = Signal(object)
     failed = Signal(str)
@@ -52,30 +50,24 @@ def __init__(self) -> None:
         self.channel = 15
 
     def query(self) -> None:
-        addr = self.address
-        if addr:
-            self._spawn(self._query, addr, self.channel)
+        if self.address:
+            threading.Thread(target=self._query, daemon=True).start()
 
     def set_mode(self, mode: ANCMode) -> None:
-        addr = self.address
-        if addr:
-            self._spawn(self._set, addr, self.channel, mode)
-
-    @staticmethod
-    def _spawn(fn, *args) -> None:
-        threading.Thread(target=fn, args=args, daemon=True).start()
+        if self.address:
+            threading.Thread(target=self._set, args=(mode,), daemon=True).start()
 
-    def _query(self, addr: str, channel: int) -> None:
+    def _query(self) -> None:
         try:
-            with NothingController(addr, channel=channel) as ctrl:
+            with NothingController(self.address, channel=self.channel) as ctrl:
                 mode = ctrl.query_anc()
             self.statusRead.emit(mode)
         except Exception as exc:
             self.failed.emit(str(exc))
 
-    def _set(self, addr: str, channel: int, mode: ANCMode) -> None:
+    def _set(self, mode: ANCMode) -> None:
         try:
-            with NothingController(addr, channel=channel) as ctrl:
+            with NothingController(self.address, channel=self.channel) as ctrl:
                 ctrl.set_anc(mode)
             self.actionDone.emit(mode)
         except Exception as exc:
@@ -88,56 +80,87 @@ def __init__(self, mock: bool = False) -> None:
         self._mock = mock
         self._address: str | None = None
         self._active: ANCMode | None = None
-        self._buttons: dict[ANCMode, QPushButton] = {}
+        self._level = ANCMode.HIGH
 
         self._worker = _AncWorker()
         self._worker.statusRead.connect(self._on_status)
-        self._worker.actionDone.connect(self._on_action_done)
+        self._worker.actionDone.connect(self._on_status)
         self._worker.failed.connect(self._on_failed)
 
         self._build()
 
     def _build(self) -> None:
-        v = QVBoxLayout(self)
-        v.setContentsMargins(0, 16, 0, 0)
-        v.setSpacing(12)
-
-        title = QLabel("Noise Cancelling")
-        title.setObjectName("deviceName")
-        v.addWidget(title)
+        root = QVBoxLayout(self)
+        root.setContentsMargins(0, 16, 0, 0)
+        root.setSpacing(14)
+
+        mode_card = QFrame()
+        mode_card.setObjectName("card")
+        mv = QVBoxLayout(mode_card)
+        mv.setContentsMargins(18, 18, 18, 18)
+        mv.setSpacing(12)
+
+        mtitle = QLabel("MODE")
+        mtitle.setObjectName("sectionTitle")
+        mv.addWidget(mtitle)
+
+        mode_row = QHBoxLayout()
+        mode_row.setSpacing(8)
+        self._off_btn = self._chip("Off", lambda: self.apply(ANCMode.OFF))
+        self._transparency_btn = self._chip(
+            "Transparency", lambda: self.apply(ANCMode.TRANSPARENCY)
+        )
+        self._anc_btn = self._chip("Noise Cancelling", self._enable_anc)
+        mode_row.addWidget(self._off_btn)
+        mode_row.addWidget(self._transparency_btn)
+        mode_row.addWidget(self._anc_btn)
+        mv.addLayout(mode_row)
+        root.addWidget(mode_card)
+
+        level_card = QFrame()
+        level_card.setObjectName("card")
+        lv = QVBoxLayout(level_card)
+        lv.setContentsMargins(18, 18, 18, 18)
+        lv.setSpacing(12)
+
+        ltitle = QLabel("STRENGTH")
+        ltitle.setObjectName("sectionTitle")
+        lv.addWidget(ltitle)
+
+        level_row = QHBoxLayout()
+        level_row.setSpacing(8)
+        self._level_buttons: dict[ANCMode, QPushButton] = {}
+        for label, mode in _LEVELS:
+            btn = self._chip(label, lambda _checked=False, m=mode: self.apply(m))
+            self._level_buttons[mode] = btn
+            level_row.addWidget(btn)
+        lv.addLayout(level_row)
+        root.addWidget(level_card)
 
         self._hint = QLabel("No connected Nothing device.")
         self._hint.setObjectName("deviceMeta")
         self._hint.setWordWrap(True)
-        v.addWidget(self._hint)
-
-        grid = QGridLayout()
-        grid.setSpacing(8)
-        for i, (label, mode) in enumerate(_MODES):
-            btn = QPushButton(label)
-            btn.setObjectName("secondary")
-            if mode is None:
-                btn.setEnabled(False)
-                btn.setToolTip("Command not reverse-engineered yet")
-            else:
-                btn.clicked.connect(lambda _checked=False, m=mode: self._choose(m))
-                self._buttons[mode] = btn
-            grid.addWidget(btn, i // 2, i % 2)
-        v.addLayout(grid)
-        v.addStretch(1)
+        root.addWidget(self._hint)
+        root.addStretch(1)
+
+        self._set_enabled(False)
 
-        self._set_buttons_enabled(False)
+    def _chip(self, label: str, on_click) -> QPushButton:
+        btn = QPushButton(label)
+        btn.setObjectName("chip")
+        btn.setCheckable(True)
+        btn.clicked.connect(lambda _checked=False: on_click())
+        return btn
 
     def set_device(self, address: str | None, channel: int = 15) -> None:
         changed = address != self._address
         self._address = address
         self._worker.address = address
         self._worker.channel = channel
-
-        self._set_buttons_enabled(address is not None)
+        self._set_enabled(address is not None)
         if address is None:
             self._active = None
-            self._highlight()
+            self._render()
             self._hint.setText("No connected Nothing device.")
         elif changed:
             if self._mock:
@@ -146,36 +169,43 @@ def set_device(self, address: str | None, channel: int = 15) -> None:
                 self._hint.setText("Reading current mode ...")
                 self._worker.query()
 
-    def _choose(self, mode: ANCMode) -> None:
+    def apply(self, mode: ANCMode) -> None:
+        if mode in _LEVEL_SET:
+            self._level = mode
+        self._active = mode
+        self._render()
         if self._mock:
-            self._on_action_done(mode)
+            self._hint.setText(f"Mock: {_LABELS[mode]}")
             return
-        self._hint.setText(f"Setting {_MODE_LABEL[mode]} ...")
+        self._hint.setText(f"Setting {_LABELS[mode]} ...")
         self._worker.set_mode(mode)
 
+    def _enable_anc(self) -> None:
+        self.apply(self._level)
+
     def _on_status(self, mode: object) -> None:
-        self._active = mode if isinstance(mode, ANCMode) else None
-        self._highlight()
-        if self._active is not None:
-            self._hint.setText(f"Current mode: {_MODE_LABEL[self._active]}")
+        if isinstance(mode, ANCMode):
+            self._active = mode
+            if mode in _LEVEL_SET:
+                self._level = mode
+            self._hint.setText(f"Current mode: {_LABELS[mode]}")
         else:
             self._hint.setText("Current mode unknown.")
-
-    def _on_action_done(self, mode: object) -> None:
-        self._active = mode if isinstance(mode, ANCMode) else None
-        self._highlight()
-        if self._active is not None:
-            self._hint.setText(f"Current mode: {_MODE_LABEL[self._active]}")
+        self._render()
 
     def _on_failed(self, message: str) -> None:
         self._hint.setText(f"Error: {message}")
 
-    def _set_buttons_enabled(self, enabled: bool) -> None:
-        for btn in self._buttons.values():
+    def _set_enabled(self, enabled: bool) -> None:
+        for btn in (self._off_btn, self._transparency_btn, self._anc_btn):
+            btn.setEnabled(enabled)
+        for btn in self._level_buttons.values():
             btn.setEnabled(enabled)
 
-    def _highlight(self) -> None:
-        for mode, btn in self._buttons.items():
-            btn.setObjectName("" if mode == self._active else "secondary")
-            btn.style().unpolish(btn)
-            btn.style().polish(btn)
+    def _render(self) -> None:
+        anc_on = self._active in _LEVEL_SET
+        self._off_btn.setChecked(self._active == ANCMode.OFF)
+        self._transparency_btn.setChecked(self._active == ANCMode.TRANSPARENCY)
+        self._anc_btn.setChecked(anc_on)
+        for mode, btn in self._level_buttons.items():
+            btn.setChecked(self._active == mode)

src/nothing_ear/ui/eq_curve.py

@@ -91,30 +91,30 @@ def _response(self, freq: float) -> float:
     def paintEvent(self, _event) -> None:
         p = QPainter(self)
         p.setRenderHint(QPainter.Antialiasing)
-        p.fillRect(self.rect(), QColor("#0b0b0b"))
+        p.fillRect(self.rect(), QColor("#141418"))
         r = self._rect()
 
         label_font = QFont()
         label_font.setPointSize(8)
         p.setFont(label_font)
 
-        p.setPen(QPen(QColor("#1d1d1d"), 1))
+        p.setPen(QPen(QColor("#232329"), 1))
         for freq in (100, 1000, 10000):
             x = self._x(freq, r)
             p.drawLine(int(x), int(r.top()), int(x), int(r.bottom()))
         for gain in (-6, 6):
             y = self._y(gain, r)
             p.drawLine(int(r.left()), int(y), int(r.right()), int(y))
 
-        p.setPen(QColor("#5a5a5a"))
+        p.setPen(QColor("#6a6a72"))
         for freq, text in ((100, "100"), (1000, "1k"), (10000, "10k")):
             x = self._x(freq, r)
             p.drawText(int(x) - 10, int(r.bottom()) + 16, text)
         for gain in (-12, 0, 12):
             y = self._y(gain, r)
             p.drawText(2, int(y) + 4, f"{gain:+d}")
 
-        p.setPen(QPen(QColor("#3a3a3a"), 1))
+        p.setPen(QPen(QColor("#34343c"), 1))
         y0 = self._y(0, r)
         p.drawLine(int(r.left()), int(y0), int(r.right()), int(y0))
 
@@ -128,16 +128,16 @@ def paintEvent(self, _event) -> None:
         fill.lineTo(r.right(), y0)
         fill.lineTo(r.left(), y0)
         fill.closeSubpath()
-        p.fillPath(fill, QColor(255, 255, 255, 14))
-        p.setPen(QPen(QColor("#ffffff"), 2))
+        p.fillPath(fill, QColor(236, 236, 238, 16))
+        p.setPen(QPen(QColor("#ececee"), 2))
         p.drawPath(path)
 
         for i, b in enumerate(self._bands):
             x = self._x(b.frequency, r)
             y = self._y(b.gain, r)
             selected = i == self._selected
-            p.setPen(QPen(QColor("#ffffff"), 2))
-            p.setBrush(QBrush(QColor("#ffffff") if selected else QColor("#0b0b0b")))
+            p.setPen(QPen(QColor("#fafafa"), 2))
+            p.setBrush(QBrush(QColor("#fafafa") if selected else QColor("#141418")))
             radius = 8 if selected else 5
             p.drawEllipse(QPointF(x, y), radius, radius)
 

src/nothing_ear/ui/main_window.py

@@ -26,6 +26,7 @@
 
 from .. import __version__
 from ..bluetooth import BtDevice
+from ..bluetooth.protocol import ANCMode
 from ..config import Settings
 from .anc_tab import AncTab
 from .eq_tab import EqTab
@@ -101,10 +102,25 @@ def _setup_tray(self) -> None:
         menu = QMenu()
         open_action = QAction("Open", self)
         open_action.triggered.connect(self._show_window)
-        quit_action = QAction("Quit", self)
-        quit_action.triggered.connect(self._quit)
         menu.addAction(open_action)
+
+        anc_menu = menu.addMenu("Noise Cancelling")
+        tray_modes = [
+            ("Off", ANCMode.OFF),
+            ("Transparency", ANCMode.TRANSPARENCY),
+            ("Adaptive", ANCMode.ADAPTIVE),
+            ("Low", ANCMode.LOW),
+            ("Mid", ANCMode.MID),
+            ("High", ANCMode.HIGH),
+        ]
+        for label, mode in tray_modes:
+            action = QAction(label, self)
+            action.triggered.connect(lambda _checked=False, m=mode: self._anc_tab.apply(m))
+            anc_menu.addAction(action)
+
         menu.addSeparator()
+        quit_action = QAction("Quit", self)
+        quit_action.triggered.connect(self._quit)
         menu.addAction(quit_action)
 
         tray.setContextMenu(menu)