trcc-linux 9.2.9__tar.gz → 9.3.0__tar.gz

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.2.9
+Version: 9.3.0
 Summary: Linux implementation of Thermalright LCD Control Center
 Project-URL: Homepage, https://github.com/Lexonight1/thermalright-trcc-linux
 Project-URL: Documentation, https://github.com/Lexonight1/thermalright-trcc-linux#readme
@@ -31,6 +31,7 @@ Requires-Dist: psutil>=5.9.0
 Requires-Dist: pyside6>=6.5.0
 Requires-Dist: python-multipart>=0.0.6
 Requires-Dist: pyusb>=1.2.0
+Requires-Dist: sounddevice>=0.4.6
 Requires-Dist: typer>=0.9.0
 Requires-Dist: tzdata>=2024.1; sys_platform == 'win32'
 Requires-Dist: uvicorn[standard]>=0.20

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.2.9"
+version = "9.3.0"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -40,6 +40,7 @@ dependencies = [
     "uvicorn[standard]>=0.20",
     "python-multipart>=0.0.6",
     "prompt_toolkit>=3.0.0",
+    "sounddevice>=0.4.6",
     "wmi>=1.5.1; sys_platform == 'win32'",
 ]
 

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/__main__.py

@@ -19,7 +19,7 @@ _log_path = _log_dir / 'trcc.log'
 
 logging.basicConfig(
     level=logging.DEBUG,
-    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s',
+    format='%(asctime)s [%(levelname)s] %(name)s.%(funcName)s: %(message)s',
     datefmt='%Y-%m-%d %H:%M:%S',
     handlers=[
         logging.handlers.RotatingFileHandler(

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/__version__.py

@@ -1,4 +1,4 @@
 """TRCC Linux version information. History in doc/CHANGELOG.md."""
 
-__version__ = "9.2.9"
+__version__ = "9.3.0"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/adapters/infra/dc_writer.py

@@ -597,12 +597,4 @@ def read_carousel(filepath: str) -> Optional[CarouselConfig]:
         return None
 
 
-# ── Backward-compat aliases ──────────────────────────────────────────────
-
-write_dc_file = write
-write_tr_export = write_tr
-overlay_config_to_theme = overlay_to_theme
 _metric_to_hardware_ids = lambda metric: METRIC_TO_IDS.get(metric, (0, 0))  # noqa: E731
-write_config_json = write_json
-write_carousel_config = write_carousel
-read_carousel_config = read_carousel

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/adapters/infra/media_player.py

@@ -268,9 +268,3 @@ def is_animated_gif(path: str | os.PathLike) -> bool:
         pass
     return False
 
-
-# Backward-compat aliases
-VideoPlayer = VideoDecoder
-ThemeZtPlayer = ThemeZtDecoder
-GIFAnimator = VideoDecoder
-GIFThemeLoader = VideoDecoder

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/adapters/system/linux/setup.py

@@ -45,11 +45,22 @@ def _real_user_home() -> Path:
     return Path.home()
 
 
+# Map CLI subcommands to direct function calls — bypasses trcc.cli (typer)
+# entirely, avoiding Python 3.14 crash (TypeError: type 'Choice' is not
+# subscriptable).  See #87.
+_SUDO_DISPATCH: dict[str, str] = {
+    "setup-udev": "from trcc.adapters.system.linux.setup import setup_udev; exit(setup_udev())",
+    "setup-selinux": "from trcc.adapters.system.linux.setup import setup_selinux; exit(setup_selinux())",
+    "setup-polkit": "from trcc.adapters.system.linux.setup import setup_polkit; exit(setup_polkit())",
+}
+
+
 def sudo_reexec(subcommand: str) -> int:
-    """Re-exec `trcc <subcommand>` as root via sudo with correct PYTHONPATH.
+    """Re-exec a setup function as root via sudo with correct PYTHONPATH.
 
-    sudo strips user site-packages (~/.local/lib), so we include both
-    the trcc package root and all site-packages where dependencies live.
+    Calls the setup function directly via ``python -c`` instead of going
+    through ``trcc.cli`` — avoids importing typer under sudo, which crashes
+    on Python 3.14 (#87).
     """
     paths: list[str] = []
     paths.extend(site.getsitepackages())
@@ -57,10 +68,19 @@ def sudo_reexec(subcommand: str) -> int:
     trcc_pkg = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
     paths.append(trcc_pkg)
     pythonpath = os.pathsep.join(paths)
-    cmd = [
-        "sudo", "env", f"PYTHONPATH={pythonpath}",
-        sys.executable, "-m", "trcc.cli", subcommand,
-    ]
+
+    snippet = _SUDO_DISPATCH.get(subcommand)
+    if snippet:
+        cmd = [
+            "sudo", "env", f"PYTHONPATH={pythonpath}",
+            sys.executable, "-c", snippet,
+        ]
+    else:
+        cmd = [
+            "sudo", "env", f"PYTHONPATH={pythonpath}",
+            sys.executable, "-m", "trcc.cli", subcommand,
+        ]
+
     print("Root required — requesting sudo...")
     result = subprocess.run(cmd)
     if result.returncode != 0:
@@ -143,6 +163,13 @@ def setup_udev(dry_run: bool = False) -> int:
                 f'{attr}{{idProduct}}=="{pid:04x}", '
                 f'MODE="0666"'
             )
+        # Disable USB autosuspend — prevents kernel from resetting idle LCD devices
+        rule_parts.append(
+            f'ACTION=="add", SUBSYSTEM=="usb", '
+            f'ATTR{{idVendor}}=="{vid:04x}", '
+            f'ATTR{{idProduct}}=="{pid:04x}", '
+            f'ATTR{{power/autosuspend}}="-1"'
+        )
         rules_lines.append('\n'.join(rule_parts))
 
     rules_content = "\n\n".join(rules_lines) + "\n"

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/cli/__init__.py

@@ -907,7 +907,7 @@ def _cmd_hid_debug(
     )] = False,
 ) -> int:
     """HID handshake diagnostic (hex dump for bug reports)."""
-    return _diag.hid_debug(test_frame=test_frame)
+    return _diag.device_debug(test_frame=test_frame)
 
 
 @app.command("led-debug")
@@ -917,7 +917,7 @@ def _cmd_led_debug(
     )] = False,
 ) -> int:
     """Diagnose LED device (handshake, PM byte)."""
-    return _diag.led_debug(test_colors=test_colors)
+    return _diag.led_debug_interactive(test_colors=test_colors)
 
 
 @app.command("report")
@@ -1245,8 +1245,8 @@ play_video = _display.play_video
 reset_device = _display.reset
 resume = _display.resume
 show_info = _system.show_info
-hid_debug = _diag.hid_debug
-led_debug = _diag.led_debug
+hid_debug = _diag.device_debug
+led_debug = _diag.led_debug_interactive
 setup_udev = _system.setup_udev
 install_desktop = _system.install_desktop
 uninstall = _system.uninstall

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/cli/_diag.py

@@ -11,11 +11,7 @@ from trcc.adapters.infra.diagnostics import (
     led_debug_interactive,
 )
 
-# Legacy aliases for existing CLI callers
-hid_debug = device_debug
-led_debug = led_debug_interactive
-
 __all__ = [
     "_hex_dump", "_hid_debug_lcd", "_hid_debug_led",
-    "device_debug", "hid_debug", "led_debug", "led_debug_interactive",
+    "device_debug", "led_debug_interactive",
 ]

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/cli/_system.py

@@ -138,8 +138,6 @@ def setup_winusb() -> int:
     return TrccApp.get().setup_winusb()
 
 
-# _detect_install_method moved to core/platform.py as detect_install_method()
-_detect_install_method = detect_install_method
 
 
 def _is_externally_managed() -> bool:
@@ -221,7 +219,7 @@ def uninstall(*, yes: bool = False):
 
     # Detect install method and uninstall the package accordingly
     install_info = Settings.get_install_info()
-    method = install_info.get('method', _detect_install_method())
+    method = install_info.get('method', detect_install_method())
 
     if method in ('pacman', 'dnf', 'apt'):
         pkg_cmds = {

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/conf.py

@@ -332,6 +332,18 @@ class Settings:
         config['selected_device'] = device_path
         save_config(config)
 
+    @staticmethod
+    def get_last_device() -> int:
+        """Get index of last GUI-active device. Defaults to 0."""
+        return load_config().get('last_device', 0)
+
+    @staticmethod
+    def save_last_device(index: int) -> None:
+        """Persist index of last GUI-active device."""
+        config = load_config()
+        config['last_device'] = index
+        save_config(config)
+
     # Cache vid_pid per index so save_device_setting can store it automatically
     _vid_pid_cache: dict[str, str] = {}
 

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/core/lcd_device.py

@@ -89,16 +89,13 @@ class LCDDevice(Device):
             self._display_svc.overlay._invalidate_cache()
         return {"success": True, "message": f"Mask position: ({x}, {y})"}
 
-    def render_and_send(self, skip_if_video: bool = False) -> dict:
+    def render_and_send(self) -> dict:
         """Render the overlay and send to device if auto_send is on.
 
         Returns {'image': rendered_image} so callers can update their preview.
-        skip_if_video suppresses the send (not the render) during video playback.
         """
         if not self._display_svc:
             return {"success": False, "image": None}
-        if skip_if_video and self.playing:
-            return {"success": False, "image": None, "message": "Video playing"}
         image = self._display_svc.render_overlay()
         if image and self.auto_send and self.connected:
             self.send(image)
@@ -727,7 +724,10 @@ class LCDDevice(Device):
 
     def load(self, path: Any) -> dict:
         """Load video/GIF for playback."""
+        self._display_svc._cache = None
         success = self._display_svc.media.load(Path(path))
+        if success:
+            self._display_svc._convert_media_frames()
         if success:
             return {
                 "success": True,
@@ -758,27 +758,35 @@ class LCDDevice(Device):
         return {"success": True, "message": f"Seek: {percent:.0%}"}
 
     def tick(self) -> Any:
-        """Core metrics loop hook: render + send overlay frame if metrics changed.
+        """Core metrics loop hook: render overlay + send frame to device.
 
         Called by TrccApp metrics loop from a background thread.
         Video playback is driven exclusively by the GUI animation timer
         (video_tick()) — this method does NOT advance video frames.
 
+        SCSI devices need continuous frame refreshes to maintain their
+        display.  Re-render only when metrics change, but always resend
+        the current frame.  The encoding cache in DeviceService skips
+        re-encoding when the image hasn't changed.
+
         Returns:
-            Rendered image if a new frame was produced, None otherwise.
-            Callers (TrccApp) emit FRAME_RENDERED so GUI adapters can update
-            their preview without re-rendering.
+            Rendered image if a NEW frame was produced, None if we resent
+            the cached frame.  Callers (TrccApp) emit FRAME_RENDERED only
+            for new frames so GUI adapters skip redundant preview updates.
         """
         if not self._display_svc or self._display_svc.is_video_playing():
             return None
+        new_frame = None
         if self._display_svc.overlay.enabled and self._display_svc.overlay.would_change(
             self._display_svc.overlay.metrics
         ):
-            image = self._display_svc.render_overlay()
-            if image:
-                self.send(image)
-                return image
-        return None
+            new_frame = self._display_svc.render_overlay()
+            if new_frame:
+                self._last_overlay_frame = new_frame
+        image = new_frame or getattr(self, '_last_overlay_frame', None) or self._display_svc.current_image
+        if image:
+            self.send(image)
+        return new_frame
 
     def video_tick(self) -> dict | None:
         """Animation timer hook: advance one video frame, return frame data.

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/core/models.py

@@ -402,6 +402,7 @@ class DeviceInfo:
     protocol: str = "scsi"  # "scsi" or "hid"
     device_type: int = 1  # 1=SCSI, 2=HID Type 2 ("H"), 3=HID Type 3 ("ALi")
     implementation: str = "generic"  # e.g. "thermalright_lcd_v1", "hid_type2", "hid_led"
+    button_image: str = "A1CZTV"    # Sidebar image prefix (resolved from detection or handshake PM+SUB)
     led_style_id: Optional[int] = None  # LED style from probe (avoids name-based lookup)
     led_style_sub: int = 0              # LED style sub-variant (C# nowLedStyleSub)
 
@@ -1857,7 +1858,8 @@ DEVICE_BUTTON_IMAGE: dict[int, dict[Optional[int], str]] = {
     5:   {None: 'A1Mjolnir VISION'},
     6:   {1: 'FROZEN_WARFRAME_Ultra', 2: 'A1FROZEN VISION V2'},
     7:   {1: 'A1Stream Vision', 2: 'A1Mjolnir VISION PRO'},
-    9:   {None: 'A1LC2JD'},
+    9:   {0: 'A1LC2JD', 1: 'A1LC2JD', 2: 'A1LC2JD', 3: 'A1LC2JD',
+          4: 'A1LC2JD', None: 'A1LF19'},
     10:  {5: 'A1LF16', 6: 'A1LF18', 7: 'A1LD6', None: 'A1LC3'},
     11:  {6: 'A1LD8', None: 'A1LF19'},
     12:  {None: 'A1LF167'},
@@ -1870,6 +1872,7 @@ DEVICE_BUTTON_IMAGE: dict[int, dict[Optional[int], str]] = {
     32:  {0: 'A1ELITE VISION', 1: 'A1FROZEN WARFRAME PRO',
           None: 'A1ELITE VISION'},
     36:  {None: 'A1AS120 VISION'},
+    49:  {None: 'A1FROZEN WARFRAME'},
     50:  {None: 'A1FROZEN WARFRAME'},
     51:  {None: 'A1FROZEN WARFRAME'},
     52:  {None: 'A1BA120 VISION'},
@@ -1880,8 +1883,8 @@ DEVICE_BUTTON_IMAGE: dict[int, dict[Optional[int], str]] = {
           3: 'A1LM30'},
     64:  {0: 'A1FROZEN WARFRAME PRO', 1: 'A1LM22', 2: 'A1LM27',
           3: 'A1LM30'},
-    65:  {0: 'A1ELITE VISION', 1: 'A1LF14', 3: 'A1LD7', 4: 'A1LD10',
-          5: 'A1LD7'},
+    65:  {0: 'A1ELITE VISION', 1: 'A1LF14', 2: 'A1LF14', 3: 'A1LD7',
+          4: 'A1LD10', 5: 'A1LD7'},
     66:  {0: 'A1ELITE VISION', 1: 'A1LF14', 2: 'A1LF14',
           3: 'A1LD7', 4: 'A1LD7'},
     68:  {None: 'A1LM24'},
@@ -1891,15 +1894,8 @@ DEVICE_BUTTON_IMAGE: dict[int, dict[Optional[int], str]] = {
     101: {0: 'A1ELITE VISION', 1: 'A1LF14', None: 'A1ELITE VISION'},
     128: {None: 'A1LM24'},
     129: {None: 'A1GRAND VISION'},
-    # -- SCSI devices (VID → {PID: image}) --
-    0x87CD: {0x70DB: 'A1CZTV', None: 'A1CZTV'},
-    0x87AD: {0x70DB: 'A1GRAND VISION', None: 'A1GRAND VISION'},
-    0x0402: {0x3922: 'A1FROZEN WARFRAME', None: 'A1FROZEN WARFRAME'},
-    0x0416: {0x5406: 'A1CZTV', None: 'A1CZTV'},
 }
 
-# Backward-compat alias
-PM_TO_BUTTON_IMAGE = DEVICE_BUTTON_IMAGE
 
 
 def get_button_image(key: int, sub: int = 0) -> Optional[str]:

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/gui/lcd_handler.py

@@ -119,14 +119,7 @@ class LCDHandler(BaseHandler):
         Settings.save_device_setting(self._device_key, 'w', w)
         Settings.save_device_setting(self._device_key, 'h', h)
 
-        # Switch global resolution so theme/web/mask dirs resolve correctly
-        _conf.settings.set_resolution(w, h)
-
-        # Update GUI widgets to reflect the device resolution.
-        self._w['preview'].set_resolution(w, h)
-        self._w['image_cut'].set_resolution(w, h)
-        self._w['video_cut'].set_resolution(w, h)
-        self._w['theme_setting'].set_resolution(w, h)
+        self._switch_resolution(w, h)
 
         # Always refresh — first run downloads themes after widget init
         auto_loaded = self._update_theme_directories()
@@ -164,6 +157,38 @@ class LCDHandler(BaseHandler):
             elif overlay_enabled:
                 self._render_and_send()
 
+    def _switch_resolution(self, w: int, h: int) -> None:
+        """Switch active resolution and update all resolution-aware widgets."""
+        _conf.settings.set_resolution(w, h)
+        self._w['preview'].set_resolution(w, h)
+        self._w['image_cut'].set_resolution(w, h)
+        self._w['video_cut'].set_resolution(w, h)
+        self._w['theme_setting'].set_resolution(w, h)
+
+    def reactivate(self, w: int, h: int) -> None:
+        """Refresh shared widgets when switching back to this device."""
+        self._switch_resolution(w, h)
+        self._update_theme_directories()
+
+        # Preview image — device's current image is ground truth
+        image = self._lcd.current_image
+        if image:
+            self._w['preview'].set_image(image)
+
+        # Overlay — reload from per-device config (defensive: missing = disabled)
+        if self._device_key:
+            cfg = Settings.get_device_config(self._device_key)
+            overlay_cfg = cfg.get('overlay', {})
+            overlay_config = overlay_cfg.get('config')
+            overlay_enabled = overlay_cfg.get('enabled', False)
+            if overlay_config:
+                self._w['theme_setting'].load_from_overlay_config(overlay_config)
+            self._w['theme_setting'].set_overlay_enabled(overlay_enabled)
+            if overlay_enabled and image:
+                self._render_and_send()
+        else:
+            self._w['theme_setting'].set_overlay_enabled(False)
+
     def _restore_brightness(self, cfg: dict) -> None:
         self._brightness_level = cfg.get('brightness_level', DEFAULT_BRIGHTNESS_LEVEL)
         log.info("Restoring brightness: %d%%", self._brightness_level)
@@ -581,9 +606,14 @@ class LCDHandler(BaseHandler):
 
     # ── Rendering ──────────────────────────────────────────────────
 
-    def _render_and_send(self, skip_if_video: bool = False) -> None:
-        """Render overlay + send to LCD, update preview."""
-        result = self._lcd.render_and_send(skip_if_video)
+    def _render_and_send(self) -> None:
+        """Render overlay + send to LCD, update preview.
+
+        Skipped when video/screencast is active — those own the device.
+        """
+        if self._lcd.playing:
+            return
+        result = self._lcd.render_and_send()
         image = result.get('image')
         if image:
             self._w['preview'].set_image(image)

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/gui/trcc_app.py

@@ -32,7 +32,7 @@ from PySide6.QtWidgets import (
 import trcc.conf as _conf
 from trcc.conf import Settings
 
-from ..adapters.infra.dc_writer import read_carousel_config
+from ..adapters.infra.dc_writer import read_carousel
 from ..core.app import AppEvent
 from ..core.lcd_device import LCDDevice
 from ..core.led_device import LEDDevice
@@ -338,13 +338,20 @@ class TRCCApp(QMainWindow):
 
         self._refresh_sidebar()
 
-        # Auto-select first LCD, then first LED
-        first = next(
-            (p for p, h in self._handlers.items() if isinstance(h, LCDHandler)),
-            next(iter(self._handlers), None),
+        # Restore last active device, fall back to first LCD
+        last_idx = Settings.get_last_device()
+        target = next(
+            (p for p, h in self._handlers.items()
+             if h.device_info and h.device_info.device_index == last_idx),
+            None,
         )
-        if first:
-            self._activate_device(first)
+        if not target:
+            target = next(
+                (p for p, h in self._handlers.items() if isinstance(h, LCDHandler)),
+                next(iter(self._handlers), None),
+            )
+        if target:
+            self._activate_device(target)
 
     def _add_handler(self, device: Any) -> None:
         """Create handler for one new device."""
@@ -381,6 +388,19 @@ class TRCCApp(QMainWindow):
                 if self._ipc_server and lcd_handler.display.device_service:
                     lcd_handler.display.device_service.on_frame_sent = self._ipc_server.capture_frame
 
+        # Resolve button image from handshake FBL/PM before sidebar builds.
+        # For SCSI: pm_byte=0, so fbl_code is used as PM (matches C# USBLCD.exe).
+        if info.fbl_code:
+            from ..core.models import get_button_image
+            pm = info.fbl_code
+            sub = 0
+            btn_img = get_button_image(pm, sub)
+            if btn_img:
+                product = btn_img.replace('A1', '', 1).replace('_', ' ')
+                info.button_image = btn_img
+                log.info("button image resolved at connect: %s -> %s (%s)",
+                          path, btn_img, product)
+
         self._refresh_sidebar()
 
     def _remove_handler(self, path: str) -> None:
@@ -411,11 +431,17 @@ class TRCCApp(QMainWindow):
 
     def _activate_device(self, path: str) -> None:
         """Switch panel stack to show the given device."""
+        if path == self._active_path:
+            return
         self._active_path = path
         handler = self._handlers.get(path)
         if handler is None:
             return
 
+        # Persist last active device so we restore it on next launch
+        if handler.device_info:
+            Settings.save_last_device(handler.device_info.device_index)
+
         if isinstance(handler, LCDHandler):
             if handler.display.connected:
                 info = handler.display.device_info
@@ -427,9 +453,7 @@ class TRCCApp(QMainWindow):
                         handler.apply_device_config(info, w, h)
                         self._update_ldd_icon()
                     else:
-                        # Re-activate: switch global resolution so theme dirs match
-                        _conf.settings.set_resolution(w, h)
-                        handler._update_theme_directories()
+                        handler.reactivate(w, h)
         elif isinstance(handler, LEDHandler):
             info = handler.device_info
             if info and not handler.active:
@@ -991,7 +1015,11 @@ class TRCCApp(QMainWindow):
             self.uc_activity_sidebar.setVisible(False)
 
     def _show_view(self, view: str) -> None:
-        log.debug("_show_view: %s", view)
+        active = getattr(self, '_active_path', None)
+        log.debug("view=%s active_path=%s", view, active)
+        if view != 'form':
+            log.debug("clearing active_path (was %s)", active)
+            self._active_path = ''  # allow re-selecting same device on return
         self.form_container.setVisible(view == 'form')
         self.uc_about.setVisible(view == 'about')
         self.uc_system_info.setVisible(view == 'sysinfo')
@@ -1134,11 +1162,15 @@ class TRCCApp(QMainWindow):
         if not resolution or resolution == (0, 0):
             self.uc_preview.set_status("Handshake failed — no resolution")
             return
-        log.info("Handshake OK: %s -> %s (FBL=%s)", device.path, resolution, fbl)
+        log.info("Handshake OK: %s -> %s (FBL=%s, PM=%s, SUB=%s)",
+                 device.path, resolution, fbl, pm, sub)
         device.resolution = resolution
         if fbl:
             device.fbl_code = fbl
-            self._resolve_device_identity(device, pm or fbl, sub)
+            effective_pm = pm or fbl
+            log.debug("resolving identity: effective_pm=%d sub=%d (raw pm=%d fbl=%d)",
+                       effective_pm, sub, pm, fbl)
+            self._resolve_device_identity(device, effective_pm, sub)
 
         handler = self._handlers.get(device.path)
         if isinstance(handler, LCDHandler):
@@ -1155,15 +1187,19 @@ class TRCCApp(QMainWindow):
     def _resolve_device_identity(self, device: DeviceInfo, pm: int, sub: int = 0) -> None:
         from ..core.models import get_button_image
         btn_img = get_button_image(pm, sub)
+        log.debug("pm=%d sub=%d -> btn_img=%s", pm, sub, btn_img)
         if not btn_img:
+            log.debug("no match for pm=%d sub=%d, keeping original button", pm, sub)
             return
         product = btn_img.replace('A1', '', 1).replace('_', ' ')
+        log.info("%s -> %s (%s)", device.path, btn_img, product)
         for dev in self.uc_device.devices:
             if dev.get('path') == device.path:
                 dev['button_image'] = btn_img
                 dev['product'] = product
                 dev['name'] = f"Thermalright {product}"
                 self.uc_device.update_device_button(dev)
+                log.debug("_resolve_device_identity: updated sidebar button for %s", device.path)
                 break
         active_key = Settings.device_config_key(device.device_index, device.vid, device.pid)
         Settings.save_device_setting(active_key, 'resolved_button_image', btn_img)
@@ -1694,7 +1730,7 @@ class TRCCApp(QMainWindow):
     # ── Carousel Config ─────────────────────────────────────────────
 
     def _load_carousel_config(self, theme_dir: Path) -> None:
-        config = read_carousel_config(str(theme_dir / 'Theme.dc'))
+        config = read_carousel(str(theme_dir / 'Theme.dc'))
         if config is None:
             return
         all_themes = self.uc_theme_local._all_themes

{trcc_linux-9.2.9 → trcc_linux-9.3.0}/src/trcc/gui/uc_device.py

@@ -85,26 +85,33 @@ def _get_device_images(device_info: dict) -> tuple[str | None, str | None]:
     # For HID devices, skip the generic A1CZTV default — show text name
     # until the handshake identifies the actual product.
     if protocol == 'hid' and button_image == 'A1CZTV':
+        log.debug("_get_device_images: HID default A1CZTV, showing text until handshake")
         return None, None
 
     # Try button_image field first (from DetectedDevice)
     if button_image:
         if Assets.exists(button_image):
+            log.debug("_get_device_images: found %s (exact)", button_image)
             return button_image, f"{button_image}a"
 
         spaced = button_image.replace('_', ' ')
         if Assets.exists(spaced):
+            log.debug("_get_device_images: found %s (spaced)", spaced)
             return spaced, f"{spaced}a"
 
         underscored = button_image.replace(' ', '_')
         if Assets.exists(underscored):
+            log.debug("_get_device_images: found %s (underscored)", underscored)
             return underscored, f"{underscored}a"
 
+        log.debug("_get_device_images: button_image=%r not found in assets", button_image)
+
     # Try model field
     model = device_info.get('model', '')
     if model in DEVICE_IMAGE_MAP:
         base = DEVICE_IMAGE_MAP[model]
         if Assets.exists(base):
+            log.debug("_get_device_images: found %s via model=%s", base, model)
             return base, f"{base}a"
 
     # Try name field as fallback
@@ -112,10 +119,12 @@ def _get_device_images(device_info: dict) -> tuple[str | None, str | None]:
     for model_key, img_base in DEVICE_IMAGE_MAP.items():
         if model_key.lower() in name.lower():
             if Assets.exists(img_base):
+                log.debug("_get_device_images: found %s via name match %s", img_base, model_key)
                 return img_base, f"{img_base}a"
 
     # Default to CZTV for non-HID devices
     if protocol != 'hid' and Assets.exists('A1CZTV'):
+        log.debug("_get_device_images: falling back to A1CZTV")
         return 'A1CZTV', 'A1CZTVa'
 
     return None, None
@@ -217,6 +226,9 @@ class UCDevice(BasePanel):
 
         for i, device in enumerate(devices):
             normal_name, active_name = _get_device_images(device)
+            fallback = device.get('name', 'Unknown')
+            log.debug("_build_device_buttons[%d]: image=%s fallback=%r",
+                       i, normal_name, fallback)
             x = Sizes.DEVICE_BTN_X
             y = i * Sizes.DEVICE_BTN_SPACING
             w = Sizes.DEVICE_BTN_W
@@ -226,7 +238,7 @@ class UCDevice(BasePanel):
                 self.device_area, x, y, w, h,
                 normal_name, active_name,
                 checkable=True,
-                fallback_text=device.get('name', 'Unknown')[:18],
+                fallback_text=fallback,
             )
             btn.device_info = device  # type: ignore[attr-defined]
             btn.clicked.connect(lambda _=False, d=device: self._on_device_clicked(d))
@@ -304,11 +316,14 @@ class UCDevice(BasePanel):
         Called from _on_handshake_done() when PM determines the actual product.
         Swaps the button icon from generic to product-specific.
         """
+        log.debug("update_device_button: button_image=%s name=%s",
+                   device_info.get('button_image'), device_info.get('name'))
         for btn in self.device_buttons:
             if getattr(btn, 'device_info', None) is not device_info:
                 continue
             normal_name, active_name = _get_device_images(device_info)
             if not normal_name:
+                log.debug("update_device_button: no image resolved, keeping current")
                 break
             normal_pix = Assets.load_pixmap(normal_name, btn.width(), btn.height())
             active_pix = (Assets.load_pixmap(active_name, btn.width(), btn.height())
@@ -321,6 +336,9 @@ class UCDevice(BasePanel):
                 btn.setIconSize(btn.size())
                 btn._img_refs = [normal_pix, active_pix]  # type: ignore[attr-defined]
                 btn.setText("")  # Clear text fallback
+                log.debug("update_device_button: icon set to %s", normal_name)
+            else:
+                log.warning("update_device_button: pixmap load failed for %s", normal_name)
             break
 
     def update_devices(self, devices: list[dict]) -> None: