trcc-linux 1.2.9__tar.gz → 1.2.11__tar.gz

{trcc_linux-1.2.9 → trcc_linux-1.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 1.2.9
+Version: 1.2.11
 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

{trcc_linux-1.2.9 → trcc_linux-1.2.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "1.2.9"
+version = "1.2.11"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"

{trcc_linux-1.2.9 → trcc_linux-1.2.11}/src/trcc/__version__.py

@@ -1,6 +1,6 @@
 """TRCC Linux version information."""
 
-__version__ = "1.2.9"
+__version__ = "1.2.11"
 __version_info__ = tuple(int(x) for x in __version__.split("."))
 
 # Version history:
@@ -33,3 +33,6 @@ __version_info__ = tuple(int(x) for x in __version__.split("."))
 #         _update_selected(), remove dead code (set_format_options, LED stubs)
 # 1.2.9 - Fix HID handshake protocol (retry, timeout, endpoint auto-detect,
 #         relaxed validation), OOP refactor (DcConfig, conf.py, dataclasses)
+# 1.2.10 - Fix first-launch preview bug (paths not re-resolved after download)
+# 1.2.11 - Fix LCD send pipeline: overlay/mask/crop/video changes now update LCD,
+#          extracted _load_and_play_video() DRY helper, send_current_image applies overlay

{trcc_linux-1.2.9 → trcc_linux-1.2.11}/src/trcc/core/controllers.py

@@ -572,8 +572,9 @@ class LCDDeviceController:
         """Extract, locate, and wire theme/web/mask directories for a resolution."""
         ensure_all_data(width, height)
 
-        # Re-resolve paths after extraction (settings caches stale paths)
-        settings.set_resolution(width, height, persist=False)
+        # Force re-resolve paths after extraction — settings singleton
+        # resolved at import time (before data existed on disk).
+        settings._resolve_paths()
         td = settings.theme_dir
         web_dir = settings.web_dir
         masks_dir = settings.masks_dir
@@ -729,16 +730,8 @@ class LCDDeviceController:
             if bg_ref:
                 bg_ref_path = Path(bg_ref)
                 if bg_ref_path.exists():
-                    if bg_ref_path.suffix in ('.mp4', '.avi', '.mkv', '.webm'):
-                        self.video.load(bg_ref_path)
-                        first_frame = self.video.model.get_frame(0)
-                        if first_frame:
-                            self.current_image = first_frame
-                            self._update_preview(first_frame)
-                        self.video.play()
-                    elif bg_ref_path.suffix == '.zt':
-                        self.video.load(bg_ref_path)
-                        self.video.play()
+                    if bg_ref_path.suffix in ('.mp4', '.avi', '.mkv', '.webm', '.zt'):
+                        self._load_and_play_video(bg_ref_path)
                     else:
                         self._load_static_image(bg_ref_path)
 
@@ -757,24 +750,19 @@ class LCDDeviceController:
         if anim_file:
             anim_path = self.working_dir / anim_file
             if anim_path.exists():
-                self.video.load(anim_path)
-                self.video.play()
+                self._load_and_play_video(anim_path)
             elif theme.is_animated and theme.animation_path:
-                self.video.load(theme.animation_path)
-                self.video.play()
+                self._load_and_play_video(theme.animation_path)
         elif theme.is_animated and theme.animation_path:
             wd_copy = self.working_dir / Path(theme.animation_path).name
             load_path = wd_copy if wd_copy.exists() else theme.animation_path
-            self.video.load(load_path)
-            self.video.play()
+            self._load_and_play_video(load_path)
         elif wd.zt.exists():
-            self.video.load(wd.zt)
-            self.video.play()
+            self._load_and_play_video(wd.zt)
         elif wd.bg.exists():
             mp4_files = list(self.working_dir.glob('*.mp4'))
             if mp4_files:
-                self.video.load(mp4_files[0])
-                self.video.play()
+                self._load_and_play_video(mp4_files[0])
             else:
                 self._load_static_image(wd.bg)
         elif theme.is_mask_only:
@@ -806,13 +794,7 @@ class LCDDeviceController:
                 if not dest.exists():
                     shutil.copy2(str(video_path), str(dest))
 
-            self.video.load(theme.animation_path)
-            # Show first frame immediately so preview updates before timer fires
-            first_frame = self.video.model.get_frame(0)
-            if first_frame:
-                self.current_image = first_frame
-                self._update_preview(first_frame)
-            self.video.play()
+            self._load_and_play_video(theme.animation_path)
             self._update_status(f"Cloud Theme: {theme.name}")
 
     def apply_mask(self, mask_dir: Path):
@@ -848,10 +830,21 @@ class LCDDeviceController:
         if not self.current_image:
             self._create_mask_background(None)
 
-        # Render and update preview (don't stop video — it renders on next tick)
-        self.render_overlay_and_preview()
+        # Render and update preview + LCD (don't stop video — it renders on next tick)
+        img = self.render_overlay_and_preview()
+        if img and self.auto_send and not self.video.is_playing():
+            self._send_frame_to_lcd(img)
         self._update_status(f"Mask: {mask_dir.name}")
 
+    def _load_and_play_video(self, path: Path | str):
+        """Load video, show first frame on preview+LCD, and start playback."""
+        self.video.load(path)
+        first_frame = self.video.model.get_frame(0)
+        if first_frame:
+            self.current_image = first_frame
+            self._render_and_send()
+        self.video.play()
+
     def _load_static_image(self, path: Path):
         """Load a static image file."""
         try:
@@ -1101,9 +1094,12 @@ class LCDDeviceController:
     # =========================================================================
 
     def send_current_image(self):
-        """Send current image to LCD."""
+        """Send current image (with overlay if enabled) to LCD."""
         if self.current_image:
-            self._send_frame_to_lcd(self.current_image)
+            image = self.current_image
+            if self.overlay.is_enabled():
+                image = self.overlay.render(image)
+            self._send_frame_to_lcd(image)
             self._update_status("Sent to LCD")
 
     def _apply_rotation(self, image: Any) -> Any:
@@ -1234,7 +1230,7 @@ class LCDDeviceController:
             image = self.overlay.render(image)
         self._update_preview(image)
         if self.auto_send:
-            self._send_frame_to_lcd(self.current_image)
+            self._send_frame_to_lcd(image)
 
     def render_overlay_and_preview(self):
         """Re-render overlay on current_image and update preview.

{trcc_linux-1.2.9 → trcc_linux-1.2.11}/src/trcc/qt_components/qt_app_mvc.py

@@ -1061,11 +1061,13 @@ class TRCCMainWindowMVC(QMainWindow):
             self.uc_preview.set_status(f"Mask: {mask_info.name}")
 
     def _on_overlay_changed(self, element_data: dict):
-        """Forward overlay change to controller for live preview."""
+        """Forward overlay change to controller for live preview + LCD."""
         if not element_data:
             return
         self.controller.overlay.set_config(element_data)
-        self.controller.render_overlay_and_preview()
+        img = self.controller.render_overlay_and_preview()
+        if img and self.controller.auto_send and not self.controller.video.is_playing():
+            self.controller._send_frame_to_lcd(img)
 
         # Save overlay config per-device
         if self._active_device_key:
@@ -1082,7 +1084,9 @@ class TRCCMainWindowMVC(QMainWindow):
             self.controller.video.stop()
             self._screencast_timer.stop()
             self._screencast_active = False
-            self.controller.render_overlay_and_preview()
+            img = self.controller.render_overlay_and_preview()
+            if img and self.controller.auto_send:
+                self.controller._send_frame_to_lcd(img)
         self.uc_preview.set_status(f"Background: {'On' if enabled else 'Off'}")
 
     def _on_screencast_toggle(self, enabled: bool):
@@ -1143,7 +1147,9 @@ class TRCCMainWindowMVC(QMainWindow):
     def _on_mask_display_toggle(self, enabled):
         """Toggle mask visibility on preview/LCD (Windows SetDrawMengBan)."""
         self.controller.overlay.set_mask_visible(enabled)
-        self.controller.render_overlay_and_preview()
+        img = self.controller.render_overlay_and_preview()
+        if img and self.controller.auto_send:
+            self.controller._send_frame_to_lcd(img)
         self.uc_preview.set_status(f"Mask: {'On' if enabled else 'Off'}")
 
     def _switch_to_mask_tab(self):
@@ -1153,7 +1159,9 @@ class TRCCMainWindowMVC(QMainWindow):
     def _on_mask_reset(self):
         """Clear mask from preview (Windows buttonYDMB_Click / cmd 99)."""
         self.controller.overlay.set_theme_mask(None)
-        self.controller.render_overlay_and_preview()
+        img = self.controller.render_overlay_and_preview()
+        if img and self.controller.auto_send:
+            self.controller._send_frame_to_lcd(img)
         self.uc_preview.set_status("Mask cleared")
 
     def _on_video_display_toggle(self, enabled):
@@ -1309,10 +1317,10 @@ class TRCCMainWindowMVC(QMainWindow):
             result.save(str(bg_path))
             # Set as overlay background so mask/overlays render on top
             self.controller.overlay.set_background(result)
-            # Re-render with overlays
+            # Re-render with overlays and send to LCD
             preview = self.controller.render_overlay_and_preview()
-            if preview:
-                self.controller._update_preview(preview)
+            if preview and self.controller.auto_send:
+                self.controller._send_frame_to_lcd(preview)
             self.uc_preview.set_status("Image cropped and saved")
         else:
             self.uc_preview.set_status("Image crop cancelled")

{trcc_linux-1.2.9 → trcc_linux-1.2.11}/tests/test_controllers.py

@@ -1182,11 +1182,23 @@ class TestFormCZTVVideoAndSend(unittest.TestCase):
         statuses = []
         self.ctrl.on_status_update = lambda s: statuses.append(s)
 
-        with patch.object(self.ctrl, '_send_frame_to_lcd'):
+        with patch.object(self.ctrl, '_send_frame_to_lcd') as mock_send:
             self.ctrl.send_current_image()
+            mock_send.assert_called_once_with(self.ctrl.current_image)
 
         self.assertIn('Sent to LCD', statuses)
 
+    def test_send_current_image_with_overlay(self):
+        """send_current_image applies overlay before sending."""
+        self.ctrl.current_image = _make_test_image()
+        self.ctrl.overlay.enable(True)
+        rendered = _make_test_image(color=(0, 255, 0))
+
+        with patch.object(self.ctrl.overlay, 'render', return_value=rendered), \
+             patch.object(self.ctrl, '_send_frame_to_lcd') as mock_send:
+            self.ctrl.send_current_image()
+            mock_send.assert_called_once_with(rendered)
+
     def test_send_frame_to_lcd_no_device(self):
         """_send_frame_to_lcd is a no-op without selected device."""
         self.ctrl.devices.model.selected_device = None
@@ -1387,26 +1399,29 @@ class TestFormCZTVCallbacksAndHelpers(unittest.TestCase):
         self.ctrl._render_and_send()  # Should not raise
 
     def test_render_and_send_with_overlay(self):
-        """_render_and_send applies overlay when enabled."""
+        """_render_and_send sends overlay-rendered image to both preview and LCD."""
         self.ctrl.current_image = _make_test_image()
         self.ctrl.overlay.enable(True)
+        self.ctrl.auto_send = True
         rendered = _make_test_image(color=(0, 255, 0))
 
         with patch.object(self.ctrl.overlay, 'render', return_value=rendered), \
              patch.object(self.ctrl, '_update_preview') as mock_preview, \
-             patch.object(self.ctrl, '_send_frame_to_lcd'):
+             patch.object(self.ctrl, '_send_frame_to_lcd') as mock_send:
             self.ctrl._render_and_send()
             mock_preview.assert_called_once_with(rendered)
+            mock_send.assert_called_once_with(rendered)
 
     def test_render_and_send_auto_send(self):
-        """_render_and_send sends to LCD when auto_send is True."""
-        self.ctrl.current_image = _make_test_image()
+        """_render_and_send sends current image to LCD when auto_send is True."""
+        img = _make_test_image()
+        self.ctrl.current_image = img
         self.ctrl.auto_send = True
 
         with patch.object(self.ctrl, '_update_preview'), \
              patch.object(self.ctrl, '_send_frame_to_lcd') as mock_send:
             self.ctrl._render_and_send()
-            mock_send.assert_called_once()
+            mock_send.assert_called_once_with(img)
 
     def test_render_and_send_no_auto_send(self):
         """_render_and_send skips LCD send when auto_send is False."""