trcc-linux 1.2.7__tar.gz → 1.2.8__tar.gz

{trcc_linux-1.2.7 → trcc_linux-1.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 1.2.7
+Version: 1.2.8
 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.7 → trcc_linux-1.2.8}/pyproject.toml

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

{trcc_linux-1.2.7 → trcc_linux-1.2.8}/src/trcc/__version__.py

@@ -1,6 +1,6 @@
 """TRCC Linux version information."""
 
-__version__ = "1.2.7"
+__version__ = "1.2.8"
 __version_info__ = tuple(int(x) for x in __version__.split("."))
 
 # Version history:
@@ -29,3 +29,5 @@ __version_info__ = tuple(int(x) for x in __version__.split("."))
 #         theme setup, tab switches, directory verification
 # 1.2.7 - Strip all theme data from wheel (download on first run only), fix
 #         _has_actual_themes to require PNGs (ignore leftover .dc files)
+# 1.2.8 - KISS refactor: consolidate 5 duplicate settings handlers into
+#         _update_selected(), remove dead code (set_format_options, LED stubs)

{trcc_linux-1.2.7 → trcc_linux-1.2.8}/src/trcc/core/models.py

@@ -979,27 +979,8 @@ class LEDModel:
         return colors
 
     # -- Effect algorithms (ported from FormLED.cs) --
-    # Each algorithm has a _for variant that accepts parameters so it can be
-    # used by both single-zone (global state) and multi-zone (per-zone state).
-    # Legacy names delegate to _for variants for backward compatibility.
-
-    def _tick_static(self) -> List[Tuple[int, int, int]]:
-        return [self.state.color] * self.state.segment_count
-
-    def _tick_breathing(self) -> List[Tuple[int, int, int]]:
-        return self._tick_breathing_for(self.state.color, self.state.segment_count)
-
-    def _tick_colorful(self) -> List[Tuple[int, int, int]]:
-        return self._tick_colorful_for(self.state.segment_count)
-
-    def _tick_rainbow(self) -> List[Tuple[int, int, int]]:
-        return self._tick_rainbow_for(self.state.segment_count)
-
-    def _tick_temp_linked(self) -> List[Tuple[int, int, int]]:
-        return self._tick_temp_linked_for(self.state.segment_count)
-
-    def _tick_load_linked(self) -> List[Tuple[int, int, int]]:
-        return self._tick_load_linked_for(self.state.segment_count)
+    # Each algorithm accepts parameters so it can be used by both
+    # single-zone (global state) and multi-zone (per-zone state).
 
     def _tick_breathing_for(self, color: Tuple[int, int, int],
                             seg_count: int) -> List[Tuple[int, int, int]]:

{trcc_linux-1.2.7 → trcc_linux-1.2.8}/src/trcc/overlay_renderer.py

@@ -120,19 +120,6 @@ class OverlayRenderer:
 
         return disp_size / cfg_size
 
-    def set_format_options(self, time_format=0, date_format=0, temp_unit=0):
-        """
-        Set time, date, and temperature format options.
-
-        Args:
-            time_format: 0=HH:mm (24h), 1=hh:mm AM/PM (12h), 2=HH:mm
-            date_format: 0=yyyy/MM/dd, 1=yyyy/MM/dd, 2=dd/MM/yyyy, 3=MM/dd, 4=dd/MM
-            temp_unit: 0=Celsius (°C), 1=Fahrenheit (°F)
-        """
-        self.time_format = time_format
-        self.date_format = date_format
-        self.temp_unit = temp_unit
-
     def set_temp_unit(self, unit: int):
         """
         Set temperature unit (Windows UCXiTongXianShiTable button0 toggle).

{trcc_linux-1.2.7 → trcc_linux-1.2.8}/src/trcc/qt_components/uc_theme_setting.py

@@ -1436,52 +1436,37 @@ class UCThemeSetting(BasePanel):
         config = self.overlay_grid.to_overlay_config()
         self.invoke_delegate(self.CMD_OVERLAY_CHANGED, config)
 
-    def _on_color_changed(self, r, g, b):
-        """Color picker changed — update selected element."""
+    def _update_selected(self, require_mode: int | None = None, **fields):
+        """Update selected overlay element config fields and propagate.
+
+        Single entry point for all element property changes (color, position,
+        font, format, text). Guards on require_mode when the update only
+        applies to a specific element type.
+        """
         idx = self.overlay_grid.get_selected_index()
         cfg = self.overlay_grid.get_selected_config()
-        if cfg is not None:
-            cfg['color'] = f'#{r:02x}{g:02x}{b:02x}'
-            self.overlay_grid.update_element(idx, cfg)
-            self._on_elements_changed()
+        if cfg is None:
+            return
+        if require_mode is not None and cfg.get('mode') != require_mode:
+            return
+        cfg.update(fields)
+        self.overlay_grid.update_element(idx, cfg)
+        self._on_elements_changed()
+
+    def _on_color_changed(self, r, g, b):
+        self._update_selected(color=f'#{r:02x}{g:02x}{b:02x}')
 
     def _on_position_changed(self, x, y):
-        """Position changed — update selected element."""
-        idx = self.overlay_grid.get_selected_index()
-        cfg = self.overlay_grid.get_selected_config()
-        if cfg is not None:
-            cfg['x'] = x
-            cfg['y'] = y
-            self.overlay_grid.update_element(idx, cfg)
-            self._on_elements_changed()
+        self._update_selected(x=x, y=y)
 
     def _on_font_changed(self, font_name, font_size):
-        """Font picker changed — update selected element (Windows mode=4)."""
-        idx = self.overlay_grid.get_selected_index()
-        cfg = self.overlay_grid.get_selected_config()
-        if cfg is not None:
-            cfg['font_name'] = font_name
-            cfg['font_size'] = font_size
-            self.overlay_grid.update_element(idx, cfg)
-            self._on_elements_changed()
+        self._update_selected(font_name=font_name, font_size=font_size)
 
     def _on_format_changed(self, mode, mode_sub):
-        """Data table format combo changed."""
-        idx = self.overlay_grid.get_selected_index()
-        cfg = self.overlay_grid.get_selected_config()
-        if cfg is not None and cfg.get('mode') == mode:
-            cfg['mode_sub'] = mode_sub
-            self.overlay_grid.update_element(idx, cfg)
-            self._on_elements_changed()
+        self._update_selected(require_mode=mode, mode_sub=mode_sub)
 
     def _on_text_changed(self, text):
-        """Custom text changed."""
-        idx = self.overlay_grid.get_selected_index()
-        cfg = self.overlay_grid.get_selected_config()
-        if cfg is not None and cfg.get('mode') == MODE_CUSTOM:
-            cfg['text'] = text
-            self.overlay_grid.update_element(idx, cfg)
-            self._on_elements_changed()
+        self._update_selected(require_mode=MODE_CUSTOM, text=text)
 
     # --- Display mode panels ---
 

{trcc_linux-1.2.7 → trcc_linux-1.2.8}/tests/hid_testing/test_led_controller.py

@@ -463,11 +463,13 @@ class TestTickStatic:
 
     def test_all_segments_same_color(self, led_model):
         led_model.set_color(100, 200, 50)
-        colors = led_model._tick_static()
+        colors = led_model._tick_single_mode(
+            LEDMode.STATIC, led_model.state.color, led_model.state.segment_count)
         assert all(c == (100, 200, 50) for c in colors)
 
     def test_segment_count_matches(self, led_model):
-        colors = led_model._tick_static()
+        colors = led_model._tick_single_mode(
+            LEDMode.STATIC, led_model.state.color, led_model.state.segment_count)
         assert len(colors) == led_model.state.segment_count
 
 
@@ -481,19 +483,19 @@ class TestTickBreathing:
     def test_advances_timer(self, led_model):
         led_model.state.mode = LEDMode.BREATHING
         led_model.state.rgb_timer = 0
-        led_model._tick_breathing()
+        led_model._tick_breathing_for(led_model.state.color, led_model.state.segment_count)
         assert led_model.state.rgb_timer == 1
 
     def test_timer_wraps_at_66(self, led_model):
         led_model.state.rgb_timer = 65
-        led_model._tick_breathing()
+        led_model._tick_breathing_for(led_model.state.color, led_model.state.segment_count)
         assert led_model.state.rgb_timer == 0
 
     def test_at_zero_brightness_is_20_percent_base(self, led_model):
         """At timer=0, factor=0 so anim is 0; output = 20% of color."""
         led_model.set_color(255, 0, 0)
         led_model.state.rgb_timer = 0
-        colors = led_model._tick_breathing()
+        colors = led_model._tick_breathing_for(led_model.state.color, led_model.state.segment_count)
         r, g, b = colors[0]
         # int(255 * 0 * 0.8 + 255 * 0.2) = int(51.0) = 51
         assert r == 51
@@ -502,7 +504,7 @@ class TestTickBreathing:
         """At timer=33 (half), factor= (66-1-33)/33 ≈ 0.9697 → near full."""
         led_model.set_color(255, 0, 0)
         led_model.state.rgb_timer = 32  # factor = 32/33 ≈ 0.97
-        colors = led_model._tick_breathing()
+        colors = led_model._tick_breathing_for(led_model.state.color, led_model.state.segment_count)
         r, g, b = colors[0]
         # 80% animated + 20% base → near 255
         assert r > 200
@@ -511,7 +513,7 @@ class TestTickBreathing:
         """All segments get the same breathing color."""
         led_model.set_color(100, 100, 100)
         led_model.state.rgb_timer = 10
-        colors = led_model._tick_breathing()
+        colors = led_model._tick_breathing_for(led_model.state.color, led_model.state.segment_count)
         assert len(set(colors)) == 1  # All identical
 
 
@@ -524,24 +526,24 @@ class TestTickColorful:
 
     def test_advances_timer(self, led_model):
         led_model.state.rgb_timer = 0
-        led_model._tick_colorful()
+        led_model._tick_colorful_for(led_model.state.segment_count)
         assert led_model.state.rgb_timer == 1
 
     def test_timer_wraps_at_168(self, led_model):
         led_model.state.rgb_timer = 167
-        led_model._tick_colorful()
+        led_model._tick_colorful_for(led_model.state.segment_count)
         assert led_model.state.rgb_timer == 0
 
     def test_phase_0_starts_red(self, led_model):
         """Phase 0 offset 0 → (255, 0, 0) = pure red."""
         led_model.state.rgb_timer = 0
-        colors = led_model._tick_colorful()
+        colors = led_model._tick_colorful_for(led_model.state.segment_count)
         assert colors[0] == (255, 0, 0)
 
     def test_phase_1_yellow_to_green(self, led_model):
         """Phase 1 offset 0 → (255, 255, 0) → R starts decreasing."""
         led_model.state.rgb_timer = 28  # Phase 1 start
-        colors = led_model._tick_colorful()
+        colors = led_model._tick_colorful_for(led_model.state.segment_count)
         r, g, b = colors[0]
         assert g == 255
         assert b == 0
@@ -549,7 +551,7 @@ class TestTickColorful:
     def test_phase_2_green_to_cyan(self, led_model):
         """Phase 2 starts at timer=56."""
         led_model.state.rgb_timer = 56
-        colors = led_model._tick_colorful()
+        colors = led_model._tick_colorful_for(led_model.state.segment_count)
         r, g, b = colors[0]
         assert r == 0
         assert g == 255
@@ -558,13 +560,13 @@ class TestTickColorful:
         """After 168 ticks, we're back at phase 0 offset 0."""
         led_model.state.rgb_timer = 0
         for _ in range(168):
-            led_model._tick_colorful()
+            led_model._tick_colorful_for(led_model.state.segment_count)
         assert led_model.state.rgb_timer == 0
 
     def test_uniform_across_segments(self, led_model):
         """All segments get the same colorful color."""
         led_model.state.rgb_timer = 42
-        colors = led_model._tick_colorful()
+        colors = led_model._tick_colorful_for(led_model.state.segment_count)
         assert len(set(colors)) == 1
 
 
@@ -580,7 +582,7 @@ class TestTickRainbow:
         table = [(i, 0, 0) for i in range(768)]
         mock_table.return_value = table
         led_model.state.rgb_timer = 0
-        colors = led_model._tick_rainbow()
+        colors = led_model._tick_rainbow_for(led_model.state.segment_count)
         # Each segment gets a different offset
         assert len(colors) == led_model.state.segment_count
         mock_table.assert_called()
@@ -589,14 +591,14 @@ class TestTickRainbow:
     def test_advances_by_4(self, mock_table, led_model):
         mock_table.return_value = [(0, 0, 0)] * 768
         led_model.state.rgb_timer = 0
-        led_model._tick_rainbow()
+        led_model._tick_rainbow_for(led_model.state.segment_count)
         assert led_model.state.rgb_timer == 4
 
     @patch("trcc.led_device.get_rgb_table")
     def test_timer_wraps(self, mock_table, led_model):
         mock_table.return_value = [(0, 0, 0)] * 768
         led_model.state.rgb_timer = 764
-        led_model._tick_rainbow()
+        led_model._tick_rainbow_for(led_model.state.segment_count)
         assert led_model.state.rgb_timer == 0  # (764 + 4) % 768 = 0
 
     @patch("trcc.led_device.get_rgb_table")
@@ -607,7 +609,7 @@ class TestTickRainbow:
         led_model.state.rgb_timer = 0
         led_model.state.segment_count = 4
         led_model.state.segment_on = [True] * 4
-        colors = led_model._tick_rainbow()
+        colors = led_model._tick_rainbow_for(led_model.state.segment_count)
         # With 4 segments, offsets should be 0, 192, 384, 576
         assert len(set(colors)) > 1  # Not all the same
 
@@ -624,7 +626,7 @@ class TestTickTempLinked:
         mock_cfv.return_value = (0, 255, 0)
         led_model.state.temp_source = "cpu"
         led_model._metrics = {"cpu_temp": 45}
-        led_model._tick_temp_linked()
+        led_model._tick_temp_linked_for(led_model.state.segment_count)
         mock_cfv.assert_called_once()
         # First positional arg is the temp value
         assert mock_cfv.call_args[0][0] == 45
@@ -634,21 +636,21 @@ class TestTickTempLinked:
         mock_cfv.return_value = (255, 0, 0)
         led_model.state.temp_source = "gpu"
         led_model._metrics = {"gpu_temp": 92}
-        led_model._tick_temp_linked()
+        led_model._tick_temp_linked_for(led_model.state.segment_count)
         assert mock_cfv.call_args[0][0] == 92
 
     @patch("trcc.led_device.color_for_value")
     def test_missing_metric_defaults_to_zero(self, mock_cfv, led_model):
         mock_cfv.return_value = (0, 255, 255)
         led_model._metrics = {}
-        led_model._tick_temp_linked()
+        led_model._tick_temp_linked_for(led_model.state.segment_count)
         assert mock_cfv.call_args[0][0] == 0
 
     @patch("trcc.led_device.color_for_value")
     def test_uniform_color(self, mock_cfv, led_model):
         mock_cfv.return_value = (0, 255, 0)
         led_model._metrics = {"cpu_temp": 40}
-        colors = led_model._tick_temp_linked()
+        colors = led_model._tick_temp_linked_for(led_model.state.segment_count)
         assert all(c == (0, 255, 0) for c in colors)
         assert len(colors) == led_model.state.segment_count
 
@@ -665,7 +667,7 @@ class TestTickLoadLinked:
         mock_cfv.return_value = (255, 255, 0)
         led_model.state.load_source = "cpu"
         led_model._metrics = {"cpu_load": 60}
-        led_model._tick_load_linked()
+        led_model._tick_load_linked_for(led_model.state.segment_count)
         assert mock_cfv.call_args[0][0] == 60
 
     @patch("trcc.led_device.color_for_value")
@@ -673,14 +675,14 @@ class TestTickLoadLinked:
         mock_cfv.return_value = (255, 110, 0)
         led_model.state.load_source = "gpu"
         led_model._metrics = {"gpu_load": 85}
-        led_model._tick_load_linked()
+        led_model._tick_load_linked_for(led_model.state.segment_count)
         assert mock_cfv.call_args[0][0] == 85
 
     @patch("trcc.led_device.color_for_value")
     def test_missing_metric_defaults_to_zero(self, mock_cfv, led_model):
         mock_cfv.return_value = (0, 255, 255)
         led_model._metrics = {}
-        led_model._tick_load_linked()
+        led_model._tick_load_linked_for(led_model.state.segment_count)
         assert mock_cfv.call_args[0][0] == 0
 
 

{trcc_linux-1.2.7 → trcc_linux-1.2.8}/tests/test_overlay_renderer.py

@@ -77,21 +77,13 @@ class TestSetResolution(unittest.TestCase):
 class TestFormatOptions(unittest.TestCase):
     """Test format options methods."""
 
-    def test_set_format_options_all(self):
-        """Test setting all format options."""
+    def test_set_temp_unit_updates_attribute(self):
+        """Test setting temp unit via set_temp_unit."""
         renderer = OverlayRenderer()
-        renderer.set_format_options(time_format=1, date_format=2, temp_unit=1)
-        self.assertEqual(renderer.time_format, 1)
-        self.assertEqual(renderer.date_format, 2)
+        renderer.set_temp_unit(1)
         self.assertEqual(renderer.temp_unit, 1)
-
-    def test_set_format_options_partial(self):
-        """Test setting partial format options."""
-        renderer = OverlayRenderer()
-        renderer.set_format_options(time_format=1)
-        self.assertEqual(renderer.time_format, 1)
-        self.assertEqual(renderer.date_format, 0)  # Default
-        self.assertEqual(renderer.temp_unit, 0)    # Default
+        self.assertEqual(renderer.time_format, 0)  # Default unchanged
+        self.assertEqual(renderer.date_format, 0)  # Default unchanged
 
     def test_set_temp_unit(self):
         """Test set_temp_unit method."""
@@ -342,7 +334,9 @@ class TestRender(unittest.TestCase):
     def test_render_with_format_options(self):
         """Test rendering respects format options."""
         renderer = OverlayRenderer()
-        renderer.set_format_options(time_format=1, date_format=2, temp_unit=1)
+        renderer.time_format = 1
+        renderer.date_format = 2
+        renderer.temp_unit = 1
         renderer.set_config({
             'time': {
                 'x': 160, 'y': 160,
@@ -414,7 +408,9 @@ class TestClear(unittest.TestCase):
     def test_clear_preserves_format_options(self):
         """Test that clear preserves format options."""
         renderer = OverlayRenderer()
-        renderer.set_format_options(time_format=1, date_format=2, temp_unit=1)
+        renderer.time_format = 1
+        renderer.date_format = 2
+        renderer.temp_unit = 1
         renderer.clear()
         # Format options are NOT cleared
         self.assertEqual(renderer.time_format, 1)
@@ -462,8 +458,7 @@ class TestRenderIntegration(unittest.TestCase):
             }
         })
 
-        # Set format options
-        renderer.set_format_options(time_format=0, date_format=0, temp_unit=0)
+        # Format options default to 0, no need to set
 
         # Render with metrics
         metrics = {