Refactor monitor handling

Refactored all the monitor code and standardised the data structures for rects, replacing the previous tuple-based approach.

Author: huntfx

mousetracks2/components/app_detection.py

@@ -11,6 +11,7 @@
 from ..applications import AppList, LOCAL_PATH
 from ..constants import DEFAULT_PROFILE_NAME, TRACKING_IGNORE
 from ..exceptions import ExitRequest
+from ..utils import RectList
 from ..utils.system import Window
 
 
@@ -25,7 +26,7 @@ def __post_init__(self) -> None:
         self._previous_app: tuple[str, str] | None = None
         self._previous_pos: tuple[int, int] | None = None
         self._previous_res: tuple[int, int] | None = None
-        self._previous_rects: list[tuple[int, int, int, int]] = []
+        self._previous_rects = RectList()
         self._fallback_title = ''
         self._fallback_pid = 0
 
@@ -114,7 +115,7 @@ def check_running_app(self) -> None:
         current_app_name = self.applist.match(exe, title)
         if current_app_name is None or current_app_name == TRACKING_IGNORE:
             current_app = None
-            rects = []
+            rects = RectList()
         else:
             current_app = current_app_name, exe
             rects = window.rects

mousetracks2/components/ipc.py

@@ -9,6 +9,8 @@
 
 from ..config import ProfileConfig
 from ..enums import BlendMode, Channel
+from ..utils import RectList
+from ..utils.monitor import MonitorData
 
 
 class Target:
@@ -197,8 +199,7 @@ class MonitorsChanged(Message):
     """Send the location of each monitor when the setup changes."""
 
     target: int = field(default=Target.GUI | Target.Processing, init=False)
-    physical_data: list[tuple[int, int, int, int]]
-    logical_data: list[tuple[int, int, int, int]]
+    data: MonitorData
 
 
 @dataclass
@@ -267,7 +268,7 @@ class TrackedApplicationDetected(Message):
     target: int = field(default=Target.Tracking, init=False)
     name: str
     process_id: int | None
-    rects: list[tuple[int, int, int, int]] = field(default_factory=list)
+    rects: RectList = field(default_factory=RectList)
 
 
 @dataclass
@@ -281,7 +282,7 @@ class CurrentProfileChanged(Message):
     target: int = field(default=Target.Processing | Target.GUI, init=False)
     name: str
     process_id: int | None
-    rects: list[tuple[int, int, int, int]] = field(default_factory=list)
+    rects: RectList = field(default_factory=RectList)
 
 
 @dataclass

mousetracks2/components/processing.py

@@ -17,10 +17,10 @@
 from ..export import Export
 from ..file import ArrayResolutionMap, MovementMaps, TrackingProfile, TrackingProfileLoader, get_filename
 from ..legacy import keyboard
-from ..utils import keycodes, get_cursor_pos
-from ..utils.math import calculate_line, calculate_distance, calculate_pixel_offset, logical_to_physical
+from ..utils import keycodes, RectList, get_cursor_pos
+from ..utils.math import calculate_line, calculate_distance
+from ..utils.monitor import MonitorData
 from ..utils.network import Interfaces
-from ..utils.system import monitor_locations
 from ..constants import DEFAULT_PROFILE_NAME, UPDATES_PER_SECOND, DOUBLE_CLICK_MS, DOUBLE_CLICK_TOL, RADIAL_ARRAY_SIZE, DEBUG
 from ..render import render, EmptyRenderError, LayerBlend
 
@@ -46,7 +46,7 @@ def position(self) -> tuple[int, int]:
 @dataclass
 class Application:
     name: str
-    rects: list[tuple[int, int, int, int]] = field(default_factory=list)
+    rects: RectList = field(default_factory=RectList)
 
 
 class Processing(Component):
@@ -55,13 +55,13 @@ def __post_init__(self) -> None:
         self._timestamp = -1
 
         self.previous_mouse_click: PreviousMouseClick | None = None
-        self.monitor_data = (monitor_locations(True), monitor_locations(False))
+        self.monitor_data = MonitorData()
         self.previous_monitor = None
 
         # Load in the default profile
         self.all_profiles = TrackingProfileLoader()
-        self._current_application = Application('', [])
-        self.current_application = Application(DEFAULT_PROFILE_NAME, [])
+        self._current_application = Application('', RectList())
+        self.current_application = Application(DEFAULT_PROFILE_NAME, RectList())
 
     @property
     def timestamp(self) -> int:
@@ -162,31 +162,12 @@ def profile_age_days(self) -> int:
 
     def _monitor_offset(self, pixel: tuple[int, int]) -> tuple[tuple[int, int], tuple[int, int]] | None:
         """Detect which monitor the pixel is on."""
-        physical_monitor_data, logical_monitor_data = self.monitor_data
-
-        monitor_data = physical_monitor_data
+        monitors = self.monitor_data.physical
         if self.current_application.rects:
-            monitor_data = self.current_application.rects
-
-        single_monitor = CLI.single_monitor if self.profile.config.multi_monitor is None else not self.profile.config.multi_monitor
-        if single_monitor:
-            x_min, y_min, x_max, y_max = monitor_data[0]
-            for x1, y1, x2, y2 in monitor_data[1:]:
-                x_min = min(x_min, x1)
-                y_min = min(y_min, y1)
-                x_max = max(x_max, x2)
-                y_max = max(y_max, y2)
-            result = calculate_pixel_offset(pixel[0], pixel[1], x_min, y_min, x_max, y_max)
-            if result is not None:
-                return result
-
-        else:
-            for x1, y1, x2, y2 in monitor_data:
-                result = calculate_pixel_offset(pixel[0], pixel[1], x1, y1, x2, y2)
-                if result is not None:
-                    return result
+            monitors = self.current_application.rects
 
-        return None
+        single_monitor = bool(CLI.single_monitor) if self.profile.config.multi_monitor is None else not self.profile.config.multi_monitor
+        return monitors.calculate_offset(pixel, combined=single_monitor)
 
     def _record_move(self, data: MovementMaps, position: tuple[int, int],
                      force_monitor: tuple[int, int] | None = None) -> float:
@@ -209,11 +190,11 @@ def _record_move(self, data: MovementMaps, position: tuple[int, int],
         moving, and will always skip the first frame of movement.
         """
         # Convert logical to physical
-        old_position = logical_to_physical(position, self.monitor_data[1], self.monitor_data[0])
+        old_position = self.monitor_data.coordinate(position)
         if data.position is None:
             new_position = old_position
         else:
-            new_position = logical_to_physical(data.position, self.monitor_data[1], self.monitor_data[0])
+            new_position = self.monitor_data.coordinate(data.position)
 
         # If the ticks match then overwrite the old data
         if self.tick == data.tick:
@@ -711,7 +692,7 @@ def _process_message(self, message: ipc.Message) -> None:
 
             case ipc.MonitorsChanged():
                 print(f'[Processing] Monitors changed.')
-                self.monitor_data = message.physical_data, message.logical_data
+                self.monitor_data = message.data
 
             case ipc.ThumbstickMove():
                 if not self.profile.config.track_gamepad:

mousetracks2/components/tracking.py

@@ -19,8 +19,9 @@
 from ..constants import UPDATES_PER_SECOND, DEFAULT_PROFILE_NAME
 from ..exceptions import ExitRequest
 from ..utils import get_cursor_pos, keycodes
+from ..utils.monitor import MonitorData
 from ..utils.network import Interfaces
-from ..utils.system import monitor_locations, MonitorEventsListener
+from ..utils.system import MonitorEventsListener
 
 
 if XInput is None:
@@ -74,8 +75,7 @@ class DataState:
     mouse_inactive: bool = field(default=False)
     mouse_clicks: dict[int, tuple[int, int]] = field(default_factory=dict)
     mouse_position: tuple[int, int] | None = field(default_factory=get_cursor_pos)
-    monitors: tuple[list[tuple[int, int, int, int]], list[tuple[int, int, int, int]]] = field(
-        default_factory=lambda: (monitor_locations(True), monitor_locations(False)))
+    monitors: MonitorData = field(default_factory=MonitorData)
     gamepads_current: tuple[bool, bool, bool, bool] = field(default_factory=_getConnectedGamepads)
     gamepads_previous: tuple[bool, bool, bool, bool] = field(default_factory=_getConnectedGamepads)
     gamepad_force_recheck: bool = field(default=False)
@@ -267,7 +267,8 @@ def _check_monitor_data(self, pixel: tuple[int, int]) -> None:
         """Check if the monitor data is valid for the pixel.
         If not, recalculate it and update the other components.
         """
-        for x1, y1, x2, y2 in self.data.monitors[0]:
+        for monitor in self.data.monitors.logical:  # TODO: Test
+            x1, y1, x2, y2 = monitor.rect
             if x1 <= pixel[0] < x2 and y1 <= pixel[1] < y2:
                 break
         else:
@@ -278,10 +279,10 @@ def _refresh_monitor_data(self) -> None:
         """Check the monitor data is up to date.
         If not, then send a signal with the updated data.
         """
-        self.data.monitors, old_data = (monitor_locations(True), monitor_locations(False)), self.data.monitors
+        self.data.monitors, old_data = MonitorData(), self.data.monitors
         if old_data != self.data.monitors:
             print('[Tracking] Monitor change detected')
-            self.send_data(ipc.MonitorsChanged(*self.data.monitors))
+            self.send_data(ipc.MonitorsChanged(self.data.monitors))
 
     @contextmanager
     def _exception_handler(self) -> Iterator[None]:

mousetracks2/gui/main_window.py

@@ -31,9 +31,10 @@
 from ..file import PROFILE_DIR, get_profile_names, get_filename, sanitise_profile_name, TrackingProfile
 from ..legacy import colours
 from ..update import is_latest_version
-from ..utils import keycodes, get_cursor_pos
-from ..utils.math import calculate_line, calculate_distance, calculate_pixel_offset, logical_to_physical
-from ..utils.system import monitor_locations, get_autostart, set_autostart, remove_autostart
+from ..utils import keycodes, RectList, get_cursor_pos
+from ..utils.math import calculate_line, calculate_distance
+from ..utils.monitor import MonitorData
+from ..utils.system import get_autostart, set_autostart, remove_autostart
 
 if TYPE_CHECKING:
     from ..components.gui import GUI
@@ -59,7 +60,7 @@ class Profile:
     """Hold data related to the currently running profile."""
 
     name: str
-    rects: list[tuple[int, int, int, int]] = field(default_factory=list)
+    rects: RectList = field(default_factory=RectList)
     track_mouse: bool = True
     track_keyboard: bool = True
     track_gamepad: bool = True
@@ -311,7 +312,7 @@ def __init__(self, component: GUI) -> None:
         self.mouse_click_count = self.mouse_held_count = self.mouse_scroll_count = 0
         self.button_press_count = self.key_press_count = 0
         self.elapsed_time = self.active_time = self.inactive_time = 0
-        self.monitor_data = monitor_locations(True), monitor_locations(False)
+        self.monitor_data = MonitorData()
         self.render_type = ipc.RenderType.MouseMovement
         self.tick_current = 0
         self.last_render: tuple[ipc.RenderType, int] = (self.render_type, -1)
@@ -1227,31 +1228,12 @@ def toggle_auto_switch_profile(self, state: QtCore.Qt.CheckState) -> None:
 
     def _monitor_offset(self, pixel: tuple[int, int]) -> tuple[tuple[int, int], tuple[int, int]] | None:
         """Detect which monitor the pixel is on."""
-        physical_monitor_data, logical_monitor_data = self.monitor_data
-
-        monitor_data = physical_monitor_data
+        monitors = self.monitor_data.physical
         if self.current_profile.rects:
-            monitor_data = self.current_profile.rects
-
-        single_monitor = self.ui.single_monitor.isChecked() if self.ui.opts_monitor.isChecked() else CLI.single_monitor
-        if single_monitor:
-            x_min, y_min, x_max, y_max = monitor_data[0]
-            for x1, y1, x2, y2 in monitor_data[1:]:
-                x_min = min(x_min, x1)
-                y_min = min(y_min, y1)
-                x_max = max(x_max, x2)
-                y_max = max(y_max, y2)
-            result = calculate_pixel_offset(pixel[0], pixel[1], x_min, y_min, x_max, y_max)
-            if result is not None:
-                return result
-
-        else:
-            for x1, y1, x2, y2 in monitor_data:
-                result = calculate_pixel_offset(pixel[0], pixel[1], x1, y1, x2, y2)
-                if result is not None:
-                    return result
+            monitors = self.current_profile.rects
 
-        return None
+        single_monitor = self.ui.single_monitor.isChecked() if self.ui.opts_monitor.isChecked() else bool(CLI.single_monitor)
+        return monitors.calculate_offset(pixel, combined=single_monitor)
 
     def start_rendering_timer(self) -> None:
         """Start the timer to display rendering text.
@@ -1603,7 +1585,7 @@ def _process_message(self, message: ipc.Message) -> None:
 
             # When monitors change, store the new data
             case ipc.MonitorsChanged():
-                self.monitor_data = message.physical_data, message.logical_data
+                self.monitor_data = message.data
 
             case ipc.Render():
                 if message.array.any():
@@ -2284,9 +2266,9 @@ def draw_pixmap_line(self, old_position: tuple[int, int] | None, new_position: t
 
         # Convert logical to physical
         if old_position is not None:
-            old_position = logical_to_physical(old_position, self.monitor_data[1], self.monitor_data[0])
+            old_position = self.monitor_data.coordinate(old_position)
         if new_position is not None:
-            new_position = logical_to_physical(new_position, self.monitor_data[1], self.monitor_data[0])
+            new_position = self.monitor_data.coordinate(new_position)
 
         unique_pixels = set()
         size = self.ui.thumbnail.pixmap_size()