9141916465

Committed 18 May 2024 06:39PM UTC coverage: 84.842% (-0.05%) from 84.888%

Build # 9141916465

Build Type

push

github

Committed by

dynobo

Commit Message

refactor(gui): set window fullscreen

- Move window flags and focus policy to init, where other window
  attributes are set.
- Move delay mechanism of move on wayland into method due to its close
  relation.

Run Details

554 of 747 branches covered (74.16%)

Branch coverage included in aggregate %.

4 of 14 new or added lines in 1 file covered. (28.57%)

1 existing line in 1 file now uncovered.

2558 of 2921 relevant lines covered (87.57%)

3.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.19

/normcap/gui/window.py

"""Normcap window.

Supposed to show a screenshot of the current desktop in full screen, on which the
user can draw a selection rectangle.

One instance (single-display) or multiple instances (multi-display) might be created.

On Linux's Wayland DE, where the compositor and not the application is supposed to
control the window's position, some platform specific workarounds are implemented to
nevertheless display potentially multiple windows in fullscreen on multiple displays.
"""

import logging
from dataclasses import dataclass
from typing import Callable, Optional, cast

from PySide6 import QtCore, QtGui, QtWidgets

from normcap.gui import dbus, system_info
from normcap.gui.models import CaptureMode, DesktopEnvironment, Rect, Screen
from normcap.gui.settings import Settings

logger = logging.getLogger(__name__)


@dataclass
class DebugInfo:
    screen: Optional[Screen] = None
    window: Optional[QtWidgets.QMainWindow] = None
    scale_factor: float = 1


class Communicate(QtCore.QObject):
    """Window's communication bus."""

    on_esc_key_pressed = QtCore.Signal()
    on_region_selected = QtCore.Signal(Rect)


class Window(QtWidgets.QMainWindow):
    """Provide fullscreen UI for interacting with NormCap."""

    def __init__(
        self,
        screen: Screen,
        settings: Settings,
        parent: Optional[QtWidgets.QWidget] = None,
    ) -> None:
        """Initialize window."""
        super().__init__(parent=parent)
        logger.debug("Create window for screen %s", screen.index)

        self.settings = settings
        self.screen_ = screen

        self.com = Communicate(parent=self)
        self.color: QtGui.QColor = QtGui.QColor(str(settings.value("color")))

        self.setWindowTitle(f"NormCap [{screen.index}]")
        self.setWindowIcon(QtGui.QIcon(":normcap"))
        self.setWindowFlags(
            QtGui.Qt.WindowType.FramelessWindowHint
            | QtGui.Qt.WindowType.CustomizeWindowHint
            | QtGui.Qt.WindowType.WindowStaysOnTopHint
        )
        self.setFocusPolicy(QtCore.Qt.FocusPolicy.StrongFocus)
        self.setAnimated(False)
        self.setEnabled(True)

        self.selection_rect: QtCore.QRect = QtCore.QRect()

        self._add_image_container()
        self._add_ui_container()

    def _get_scale_factor(self) -> float:
        """Calculate scale factor from image and screen dimensions."""
        if not self.screen_.screenshot:
            raise ValueError("Screenshot image is missing!")
        return self.screen_.screenshot.width() / self.width()

    def _add_image_container(self) -> None:
        """Add widget showing screenshot."""
        self.image_container = QtWidgets.QLabel()
        self.image_container.setScaledContents(True)
        self.setCentralWidget(self.image_container)

    def _add_ui_container(self) -> None:
        """Add widget for showing selection rectangle and settings button."""
        self.ui_container = UiContainerLabel(
            parent=self, color=self.color, capture_mode_func=self.get_capture_mode
        )

        if logger.getEffectiveLevel() is logging.DEBUG:
            self.ui_container.debug_info = DebugInfo(
                scale_factor=self._get_scale_factor(), screen=self.screen_, window=self
            )

        self.ui_container.color = self.color
        self.ui_container.setGeometry(self.image_container.geometry())
        self.ui_container.raise_()

    def _draw_background_image(self) -> None:
        """Draw screenshot as background image."""
        pixmap = QtGui.QPixmap()
        pixmap.convertFromImage(self.screen_.screenshot)
        self.image_container.setPixmap(pixmap)

    def _move_to_screen_on_wayland(self) -> None:
        """Move window to respective monitor on Wayland.

        In Wayland, the compositor has the responsibility for positioning windows, the
        client itself can't do this. However, there are DE dependent workarounds.
        """

        def move_to_screen(win: Window) -> None:
            if system_info.desktop_environment() == DesktopEnvironment.GNOME:
                result = dbus.move_windows_via_window_calls_extension(
                    title_id=win.windowTitle(), position=win.screen_
                )
                if not result:
                    dbus.move_window_via_gnome_shell_eval(
                        title_id=win.windowTitle(), position=win.screen_
                    )
            elif system_info.desktop_environment() == DesktopEnvironment.KDE:
                dbus.move_window_via_kde_kwin_scripting(
                    title_id=win.windowTitle(), position=win.screen_
                )
            else:
                logger.warning(
                    "No window move method for %s", system_info.desktop_environment()
                )

        # Delay move to ensure window is active & registered in window manager.
        QtCore.QTimer.singleShot(20, lambda: move_to_screen(win=self))

    def set_fullscreen(self) -> None:
        """Set window to full screen using platform specific methods."""
        # TODO: Test in Multi Display setups with different scaling
        # TODO: Test in Multi Display setups with different position
        # TODO: Position in Multi Display probably problematic!
        logger.debug("Set window of screen %s to fullscreen", self.screen_.index)

        if not self.screen_.screenshot:
            raise ValueError("Screenshot is missing on screen %s", self.screen_)

        # Using scaled window dims to fit sizing with dpr in case scaling is enabled
        # See: https://github.com/dynobo/normcap/issues/397
        if (
            system_info.display_manager_is_wayland()
            and self.screen_.size == self.screen_.screenshot.size().toTuple()
            and self.screen_.device_pixel_ratio != 1
        ):
            # TODO: Check if still necessary on latest supported Ubuntu.
            # If not, remove Screen.scale() and this condition.
            self.setGeometry(*self.screen_.scale().geometry)
        else:
            self.setGeometry(*self.screen_.geometry)

        if system_info.desktop_environment() != DesktopEnvironment.UNITY:
            # On some DEs, setting a fixed window size can enforce the correct size.
            # However, on Unity, it breaks the full screen view.
            self.setMinimumSize(self.geometry().size())
            self.setMaximumSize(self.geometry().size())

        self.showFullScreen()
        self.setFocus()

        # On Wayland, setting geometry doesn't move the window to the right screen, as
        # only the compositor is allowed to do this. In case of multi-display setups, we
        # need to use hacks to position the window:
        if system_info.display_manager_is_wayland() and len(system_info.screens()) > 1:
            self._move_to_screen_on_wayland()

    def clear_selection(self) -> None:
        self.selection_rect = QtCore.QRect()
        self.ui_container.rect = self.selection_rect
        self.update()

    def get_capture_mode(self) -> CaptureMode:
        """Read current capture mode from application settings."""
        mode_setting = str(self.settings.value("mode"))
        try:
            mode = CaptureMode[mode_setting.upper()]
        except KeyError:
            logger.warning("Unknown capture mode: %s. Fallback to PARSE.", mode_setting)
            mode = CaptureMode.PARSE
        return mode

    def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:  # noqa: N802
        """Handle ESC key pressed.

        Cancels the selection progress (if ongoing), otherwise emit signal.
        """
        super().keyPressEvent(event)
        if event.key() == QtCore.Qt.Key.Key_Escape:
            if self.selection_rect:
                self.clear_selection()
            else:
                self.com.on_esc_key_pressed.emit()

    def mousePressEvent(self, event: QtGui.QMouseEvent) -> None:  # noqa: N802
        """Handle left mouse button clicked.

        Creates a new selection rectangle with both points set to pointer position.
        Note that the points "topLeft" and "bottomRight" are more like start and end
        points and not necessarily relate to the geometrical position.

        The selection rectangle will be normalized just before emitting the signal in
        the mouseReleaseEvent.
        """
        super().mousePressEvent(event)
        if event.button() == QtCore.Qt.MouseButton.LeftButton:
            self.selection_rect = QtCore.QRect()
            self.selection_rect.setTopLeft(event.position().toPoint())
            self.selection_rect.setBottomRight(event.position().toPoint())
            self.ui_container.rect = self.selection_rect
            self.update()

    def mouseMoveEvent(self, event: QtGui.QMouseEvent) -> None:  # noqa: N802
        """Update position of bottom right point of selection rectangle."""
        super().mouseMoveEvent(event)
        if self.selection_rect:
            self.selection_rect.setBottomRight(event.position().toPoint())
            self.ui_container.rect = self.selection_rect
            self.update()

    def mouseReleaseEvent(self, event: QtGui.QMouseEvent) -> None:  # noqa: N802
        """Start OCR workflow on left mouse button release."""
        super().mouseReleaseEvent(event)
        if (
            event.button() != QtCore.Qt.MouseButton.LeftButton
            or not self.selection_rect
        ):
            return

        self.selection_rect.setBottomRight(event.position().toPoint())

        selection_coords = cast(tuple, self.selection_rect.normalized().getCoords())
        scaled_selection_rect = Rect(*selection_coords).scale(self._get_scale_factor())

        self.clear_selection()

        # Emit as last action, cause self might get destroyed by the slots
        self.com.on_region_selected.emit((scaled_selection_rect, self.screen_.index))

    def resizeEvent(self, event: QtGui.QResizeEvent) -> None:  # noqa: N802
        """Adjust child widget on resize."""
        super().resizeEvent(event)
        self.ui_container.resize(self.size())
        if self.ui_container.debug_info:
            self.ui_container.debug_info.scale_factor = self._get_scale_factor()

    def showEvent(self, event: QtGui.QShowEvent) -> None:  # noqa: N802
        """Update background image on show/reshow."""
        super().showEvent(event)
        self._draw_background_image()


class UiContainerLabel(QtWidgets.QLabel):
    """Widget to draw border, selection rectangle and potentially debug infos."""

    def __init__(
        self,
        parent: QtWidgets.QWidget,
        color: QtGui.QColor,
        capture_mode_func: Callable,
    ) -> None:
        super().__init__(parent)

        self.color: QtGui.QColor = color

        self.debug_info: Optional[DebugInfo] = None

        self.rect: QtCore.QRect = QtCore.QRect()
        self.rect_pen = QtGui.QPen(self.color, 2, QtCore.Qt.PenStyle.DashLine)
        self.get_capture_mode = capture_mode_func

        self.setObjectName("ui_container")
        self.setStyleSheet(f"#ui_container {{border: 3px solid {self.color.name()};}}")
        self.setCursor(QtCore.Qt.CursorShape.CrossCursor)
        self.setScaledContents(True)

    def _draw_debug_infos(self, painter: QtGui.QPainter, rect: QtCore.QRect) -> None:
        """Draw debug information to top left."""
        if (
            not self.debug_info
            or not self.debug_info.screen
            or not self.debug_info.screen.screenshot
            or not self.debug_info.window
        ):
            return

        selection = Rect(*cast(tuple, rect.normalized().getCoords()))
        selection_scaled = selection.scale(self.debug_info.scale_factor)

        lines = (
            "[ Screen ]",
            f"Size: {self.debug_info.screen.size}",
            f"Position: {self.debug_info.screen.coords}",
            f"Device pixel ratio: {self.debug_info.screen.device_pixel_ratio}",
            "",
            "[ Window ]",
            f"Size: {self.debug_info.window.size().toTuple()}",
            f"Position: {cast(tuple, self.debug_info.window.geometry().getCoords())}",
            f"Device pixel ratio: {self.debug_info.window.devicePixelRatio()}",
            f"Selected region: {selection.coords}",
            "",
            "[ Screenshot ]",
            f"Size: {self.debug_info.screen.screenshot.size().toTuple()}",
            f"Selected region (scaled): {selection_scaled.coords}",
            "",
            "[ Scaling detected ]",
            f"Factor: {self.debug_info.scale_factor:.2f}",
        )

        painter.setPen(QtGui.QColor(0, 0, 0, 0))
        painter.setBrush(QtGui.QColor(0, 0, 0, 175))
        painter.drawRect(3, 3, 300, 20 * len(lines) + 5)
        painter.setBrush(QtGui.QColor(0, 0, 0, 0))

        painter.setPen(self.color)
        painter.setFont(QtGui.QFont(QtGui.QFont().family(), 10, 600))
        for idx, line in enumerate(lines):
            painter.drawText(10, 20 * (idx + 1), line)

    def paintEvent(self, event: QtGui.QPaintEvent) -> None:  # noqa: N802
        """Draw selection rectangle and mode indicator icon."""
        super().paintEvent(event)

        if not (self.rect or self.debug_info):
            return

        painter = QtGui.QPainter(self)
        self.rect = self.rect.normalized()

        if self.debug_info:
            self._draw_debug_infos(painter, self.rect)

        if not self.rect:
            return

        painter.setPen(self.rect_pen)
        painter.drawRect(self.rect)

        if self.get_capture_mode() is CaptureMode.PARSE:
            mode_icon = QtGui.QIcon(":parse")
        else:
            mode_icon = QtGui.QIcon(":raw")
        mode_icon.paint(painter, self.rect.right() - 24, self.rect.top() - 30, 24, 24)

        painter.end()

1	"""Normcap window.	4✔
2
3	Supposed to show a screenshot of the current desktop in full screen, on which the
4	user can draw a selection rectangle.
5
6	One instance (single-display) or multiple instances (multi-display) might be created.
7
8	On Linux's Wayland DE, where the compositor and not the application is supposed to
9	control the window's position, some platform specific workarounds are implemented to
10	nevertheless display potentially multiple windows in fullscreen on multiple displays.
11	"""
12
13	import logging	4✔
14	from dataclasses import dataclass	4✔
15	from typing import Callable, Optional, cast	4✔
16
17	from PySide6 import QtCore, QtGui, QtWidgets	4✔
18
19	from normcap.gui import dbus, system_info	4✔
20	from normcap.gui.models import CaptureMode, DesktopEnvironment, Rect, Screen	4✔
21	from normcap.gui.settings import Settings	4✔
22
23	logger = logging.getLogger(__name__)	4✔
24
25
26	@dataclass	4✔
27	class DebugInfo:	4✔
28	screen: Optional[Screen] = None	4✔
29	window: Optional[QtWidgets.QMainWindow] = None	4✔
30	scale_factor: float = 1	4✔
31
32
33	class Communicate(QtCore.QObject):	4✔
34	"""Window's communication bus."""	4✔
35
36	on_esc_key_pressed = QtCore.Signal()	4✔
37	on_region_selected = QtCore.Signal(Rect)	4✔
38
39
40	class Window(QtWidgets.QMainWindow):	4✔
41	"""Provide fullscreen UI for interacting with NormCap."""	4✔
42
43	def __init__(	4✔
44	self,
45	screen: Screen,
46	settings: Settings,
47	parent: Optional[QtWidgets.QWidget] = None,
48	) -> None:
49	"""Initialize window."""
50	super().__init__(parent=parent)	4✔
51	logger.debug("Create window for screen %s", screen.index)	4✔
52
53	self.settings = settings	4✔
54	self.screen_ = screen	4✔
55
56	self.com = Communicate(parent=self)	4✔
57	self.color: QtGui.QColor = QtGui.QColor(str(settings.value("color")))	4✔
58
59	self.setWindowTitle(f"NormCap [{screen.index}]")	4✔
60	self.setWindowIcon(QtGui.QIcon(":normcap"))	4✔
61	self.setWindowFlags(	4✔
62	QtGui.Qt.WindowType.FramelessWindowHint
63	\| QtGui.Qt.WindowType.CustomizeWindowHint
64	\| QtGui.Qt.WindowType.WindowStaysOnTopHint
65	)
66	self.setFocusPolicy(QtCore.Qt.FocusPolicy.StrongFocus)	4✔
67	self.setAnimated(False)	4✔
68	self.setEnabled(True)	4✔
69
70	self.selection_rect: QtCore.QRect = QtCore.QRect()	4✔
71
72	self._add_image_container()	4✔
73	self._add_ui_container()	4✔
74
75	def _get_scale_factor(self) -> float:	4✔
76	"""Calculate scale factor from image and screen dimensions."""
77	if not self.screen_.screenshot:	4✔
78	raise ValueError("Screenshot image is missing!")	4✔
79	return self.screen_.screenshot.width() / self.width()	4✔
80
81	def _add_image_container(self) -> None:	4✔
82	"""Add widget showing screenshot."""
83	self.image_container = QtWidgets.QLabel()	4✔
84	self.image_container.setScaledContents(True)	4✔
85	self.setCentralWidget(self.image_container)	4✔
86
87	def _add_ui_container(self) -> None:	4✔
88	"""Add widget for showing selection rectangle and settings button."""
89	self.ui_container = UiContainerLabel(	4✔
90	parent=self, color=self.color, capture_mode_func=self.get_capture_mode
91	)
92
93	if logger.getEffectiveLevel() is logging.DEBUG:	4✔
94	self.ui_container.debug_info = DebugInfo(	4✔
95	scale_factor=self._get_scale_factor(), screen=self.screen_, window=self
96	)
97
98	self.ui_container.color = self.color	4!
99	self.ui_container.setGeometry(self.image_container.geometry())	4✔
100	self.ui_container.raise_()	4✔
101
102	def _draw_background_image(self) -> None:	4✔
103	"""Draw screenshot as background image."""
104	pixmap = QtGui.QPixmap()	4✔
105	pixmap.convertFromImage(self.screen_.screenshot)	4✔
106	self.image_container.setPixmap(pixmap)	4✔
107
108	def _move_to_screen_on_wayland(self) -> None:	4✔
109	"""Move window to respective monitor on Wayland.
110
111	In Wayland, the compositor has the responsibility for positioning windows, the
112	client itself can't do this. However, there are DE dependent workarounds.
113	"""
114
NEW 115	def move_to_screen(win: Window) -> None:	×
NEW 116	if system_info.desktop_environment() == DesktopEnvironment.GNOME:	×
NEW 117	result = dbus.move_windows_via_window_calls_extension(	×
118	title_id=win.windowTitle(), position=win.screen_
119	)
NEW 120	if not result:	×
NEW 121	dbus.move_window_via_gnome_shell_eval(	×
122	title_id=win.windowTitle(), position=win.screen_
123	)
NEW 124	elif system_info.desktop_environment() == DesktopEnvironment.KDE:	×
NEW 125	dbus.move_window_via_kde_kwin_scripting(	×
126	title_id=win.windowTitle(), position=win.screen_
127	)
128	else:
NEW 129	logger.warning(	×
130	"No window move method for %s", system_info.desktop_environment()
131	)
132
133	# Delay move to ensure window is active & registered in window manager.
NEW 134	QtCore.QTimer.singleShot(20, lambda: move_to_screen(win=self))	×
135
136	def set_fullscreen(self) -> None:	4✔
137	"""Set window to full screen using platform specific methods."""
138	# TODO: Test in Multi Display setups with different scaling
139	# TODO: Test in Multi Display setups with different position
140	# TODO: Position in Multi Display probably problematic!
141	logger.debug("Set window of screen %s to fullscreen", self.screen_.index)	4✔
142
143	if not self.screen_.screenshot:	4✔
144	raise ValueError("Screenshot is missing on screen %s", self.screen_)	×
145
146	# Using scaled window dims to fit sizing with dpr in case scaling is enabled
147	# See: https://github.com/dynobo/normcap/issues/397
148	if (	4✔
149	system_info.display_manager_is_wayland()
150	and self.screen_.size == self.screen_.screenshot.size().toTuple()
151	and self.screen_.device_pixel_ratio != 1
152	):
153	# TODO: Check if still necessary on latest supported Ubuntu.
154	# If not, remove Screen.scale() and this condition.
UNCOV 155	self.setGeometry(*self.screen_.scale().geometry)	×
156	else:
157	self.setGeometry(*self.screen_.geometry)	4✔
158
159	if system_info.desktop_environment() != DesktopEnvironment.UNITY:	4✔
160	# On some DEs, setting a fixed window size can enforce the correct size.
161	# However, on Unity, it breaks the full screen view.
162	self.setMinimumSize(self.geometry().size())	4✔
163	self.setMaximumSize(self.geometry().size())	4✔
164
165	self.showFullScreen()	4!
166	self.setFocus()	4✔
167
168	# On Wayland, setting geometry doesn't move the window to the right screen, as
169	# only the compositor is allowed to do this. In case of multi-display setups, we
170	# need to use hacks to position the window:
171	if system_info.display_manager_is_wayland() and len(system_info.screens()) > 1:	4✔
NEW 172	self._move_to_screen_on_wayland()	×
173
174	def clear_selection(self) -> None:	4✔
175	self.selection_rect = QtCore.QRect()	4✔
176	self.ui_container.rect = self.selection_rect	4✔
177	self.update()	4✔
178
179	def get_capture_mode(self) -> CaptureMode:	4✔
180	"""Read current capture mode from application settings."""
181	mode_setting = str(self.settings.value("mode"))	3✔
182	try:	3✔
183	mode = CaptureMode[mode_setting.upper()]	3✔
184	except KeyError:	3✔
185	logger.warning("Unknown capture mode: %s. Fallback to PARSE.", mode_setting)	3✔
186	mode = CaptureMode.PARSE	3✔
187	return mode	3✔
188
189	def keyPressEvent(self, event: QtGui.QKeyEvent) -> None: # noqa: N802	4✔
190	"""Handle ESC key pressed.
191
192	Cancels the selection progress (if ongoing), otherwise emit signal.
193	"""
194	super().keyPressEvent(event)	4✔
195	if event.key() == QtCore.Qt.Key.Key_Escape:	4✔
196	if self.selection_rect:	4✔
197	self.clear_selection()	4✔
198	else:
199	self.com.on_esc_key_pressed.emit()	4✔
200
201	def mousePressEvent(self, event: QtGui.QMouseEvent) -> None: # noqa: N802	4✔
202	"""Handle left mouse button clicked.
203
204	Creates a new selection rectangle with both points set to pointer position.
205	Note that the points "topLeft" and "bottomRight" are more like start and end
206	points and not necessarily relate to the geometrical position.
207
208	The selection rectangle will be normalized just before emitting the signal in
209	the mouseReleaseEvent.
210	"""
211	super().mousePressEvent(event)	4✔
212	if event.button() == QtCore.Qt.MouseButton.LeftButton:	4✔
213	self.selection_rect = QtCore.QRect()	4✔
214	self.selection_rect.setTopLeft(event.position().toPoint())	4✔
215	self.selection_rect.setBottomRight(event.position().toPoint())	4✔
216	self.ui_container.rect = self.selection_rect	4✔
217	self.update()	4✔
218
219	def mouseMoveEvent(self, event: QtGui.QMouseEvent) -> None: # noqa: N802	4✔
220	"""Update position of bottom right point of selection rectangle."""
221	super().mouseMoveEvent(event)	4✔
222	if self.selection_rect:	4✔
223	self.selection_rect.setBottomRight(event.position().toPoint())	4✔
224	self.ui_container.rect = self.selection_rect	4✔
225	self.update()	4✔
226
227	def mouseReleaseEvent(self, event: QtGui.QMouseEvent) -> None: # noqa: N802	4✔
228	"""Start OCR workflow on left mouse button release."""
229	super().mouseReleaseEvent(event)	4✔
230	if (	4✔
231	event.button() != QtCore.Qt.MouseButton.LeftButton
232	or not self.selection_rect
233	):
234	return	×
235
236	self.selection_rect.setBottomRight(event.position().toPoint())	4✔
237
238	selection_coords = cast(tuple, self.selection_rect.normalized().getCoords())	4✔
239	scaled_selection_rect = Rect(*selection_coords).scale(self._get_scale_factor())	4✔
240
241	self.clear_selection()	4✔
242
243	# Emit as last action, cause self might get destroyed by the slots
244	self.com.on_region_selected.emit((scaled_selection_rect, self.screen_.index))	4✔
245
246	def resizeEvent(self, event: QtGui.QResizeEvent) -> None: # noqa: N802	4✔
247	"""Adjust child widget on resize."""
248	super().resizeEvent(event)	4✔
249	self.ui_container.resize(self.size())	4✔
250	if self.ui_container.debug_info:	4✔
251	self.ui_container.debug_info.scale_factor = self._get_scale_factor()	4✔
252
253	def showEvent(self, event: QtGui.QShowEvent) -> None: # noqa: N802	4✔
254	"""Update background image on show/reshow."""
255	super().showEvent(event)	4✔
256	self._draw_background_image()	4✔
257
258
259	class UiContainerLabel(QtWidgets.QLabel):	4✔
260	"""Widget to draw border, selection rectangle and potentially debug infos."""	4✔
261
262	def __init__(	4✔
263	self,
264	parent: QtWidgets.QWidget,
265	color: QtGui.QColor,
266	capture_mode_func: Callable,
267	) -> None:
268	super().__init__(parent)	4✔
269
270	self.color: QtGui.QColor = color	4✔
271
272	self.debug_info: Optional[DebugInfo] = None	4✔
273
274	self.rect: QtCore.QRect = QtCore.QRect()	4✔
275	self.rect_pen = QtGui.QPen(self.color, 2, QtCore.Qt.PenStyle.DashLine)	4✔
276	self.get_capture_mode = capture_mode_func	4✔
277
278	self.setObjectName("ui_container")	4✔
279	self.setStyleSheet(f"#ui_container {{border: 3px solid {self.color.name()};}}")	4✔
280	self.setCursor(QtCore.Qt.CursorShape.CrossCursor)	4✔
281	self.setScaledContents(True)	4✔
282
283	def _draw_debug_infos(self, painter: QtGui.QPainter, rect: QtCore.QRect) -> None:	4✔
284	"""Draw debug information to top left."""
285	if (	4✔
286	not self.debug_info
287	or not self.debug_info.screen
288	or not self.debug_info.screen.screenshot
289	or not self.debug_info.window
290	):
291	return	×
292
293	selection = Rect(*cast(tuple, rect.normalized().getCoords()))	4✔
294	selection_scaled = selection.scale(self.debug_info.scale_factor)	4✔
295
296	lines = (	4✔
297	"[ Screen ]",
298	f"Size: {self.debug_info.screen.size}",
299	f"Position: {self.debug_info.screen.coords}",
300	f"Device pixel ratio: {self.debug_info.screen.device_pixel_ratio}",
301	"",
302	"[ Window ]",
303	f"Size: {self.debug_info.window.size().toTuple()}",
304	f"Position: {cast(tuple, self.debug_info.window.geometry().getCoords())}",
305	f"Device pixel ratio: {self.debug_info.window.devicePixelRatio()}",
306	f"Selected region: {selection.coords}",
307	"",
308	"[ Screenshot ]",
309	f"Size: {self.debug_info.screen.screenshot.size().toTuple()}",
310	f"Selected region (scaled): {selection_scaled.coords}",
311	"",
312	"[ Scaling detected ]",
313	f"Factor: {self.debug_info.scale_factor:.2f}",
314	)
315
316	painter.setPen(QtGui.QColor(0, 0, 0, 0))	4✔
317	painter.setBrush(QtGui.QColor(0, 0, 0, 175))	4✔
318	painter.drawRect(3, 3, 300, 20 * len(lines) + 5)	4✔
319	painter.setBrush(QtGui.QColor(0, 0, 0, 0))	4✔
320
321	painter.setPen(self.color)	4✔
322	painter.setFont(QtGui.QFont(QtGui.QFont().family(), 10, 600))	4✔
323	for idx, line in enumerate(lines):	4✔
324	painter.drawText(10, 20 * (idx + 1), line)	4✔
325
326	def paintEvent(self, event: QtGui.QPaintEvent) -> None: # noqa: N802	4✔
327	"""Draw selection rectangle and mode indicator icon."""
328	super().paintEvent(event)	4✔
329
330	if not (self.rect or self.debug_info):	4✔
331	return	×
332
333	painter = QtGui.QPainter(self)	4✔
334	self.rect = self.rect.normalized()	4✔
335
336	if self.debug_info:	4✔
337	self._draw_debug_infos(painter, self.rect)	4✔
338
339	if not self.rect:	4!
340	return	4✔
341
342	painter.setPen(self.rect_pen)	×
343	painter.drawRect(self.rect)	×
344
345	if self.get_capture_mode() is CaptureMode.PARSE:	×
346	mode_icon = QtGui.QIcon(":parse")	×
347	else:
348	mode_icon = QtGui.QIcon(":raw")	×
349	mode_icon.paint(painter, self.rect.right() - 24, self.rect.top() - 30, 24, 24)	×
350
351	painter.end()	×

dynobo / normcap / 9141916465

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous