18953976799

Committed 30 Oct 2025 08:21PM UTC coverage: 80.119% (-1.4%) from 81.509%

Build # 18953976799

Build Type

Pull #798

github

Committed by

web-flow

Commit Message

Merge a4477b844 into 50be529a6

Pull Request Pull Request #798: Refactoring

Run Details

858 of 1175 new or added lines in 51 files covered. (73.02%)

23 existing lines in 5 files now uncovered.

2974 of 3712 relevant lines covered (80.12%)

4.57 hits per line

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

80.92

/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 collections.abc import Callable
from dataclasses import dataclass
from typing import cast

from PySide6 import QtCore, QtGui, QtWidgets

from normcap import positioning
from normcap.gui.menu_button import MenuButton
from normcap.gui.settings import Settings
from normcap.platform import system_info
from normcap.platform.models import DesktopEnvironment, Rect, Screen

logger = logging.getLogger(__name__)


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


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

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

        self.color: QtGui.QColor = color

        self.debug_info: DebugInfo | None = None

        self.rect: QtCore.QRect = QtCore.QRect()
        self.rect_pen = QtGui.QPen(self.color, 2, QtCore.Qt.PenStyle.DashLine)
        self.get_parse_text = parse_text_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_parse_text():
            selection_icon = QtGui.QIcon(":parse")
        else:
            selection_icon = QtGui.QIcon(":raw")
        selection_icon.paint(
            painter, self.rect.right() - 24, self.rect.top() - 30, 24, 24
        )

        painter.end()


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

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


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

    def __init__(
        self,
        screen: Screen,
        index: int,
        settings: Settings,
        installed_languages: list[str],
        debug_language_manager: bool = False,
    ) -> None:
        """Initialize window."""
        super().__init__()
        logger.debug("Create window for screen %s", screen.index)

        self.screen_ = screen
        self.index = index
        self.settings = settings
        self.installed_languages = installed_languages
        self.debug_language_manager = debug_language_manager

        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.setAttribute(QtCore.Qt.WidgetAttribute.WA_DeleteOnClose)
        self.setAnimated(False)
        self.setEnabled(True)

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

        self.image_container = QtWidgets.QLabel(scaledContents=True)
        self.setCentralWidget(self.image_container)
        self.ui_container = self._create_ui_container(
            geometry=self.image_container.geometry()
        )

        self.menu_button = None

        if self.index == 0:
            self.menu_button = self._create_menu_button()
            layout = self._create_layout()
            layout.addWidget(self.menu_button, 0, 1)
            self.ui_container.setLayout(layout)

    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 _create_ui_container(self, geometry: QtCore.QRect) -> UiContainerLabel:
        """Add widget for showing selection rectangle and settings button."""
        ui_container = UiContainerLabel(
            parent=self,
            color=self.color,
            parse_text_func=lambda: bool(self.settings.value("parse-text", type=bool)),
        )

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

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

    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 _create_menu_button(self) -> QtWidgets.QWidget:
        menu_button = MenuButton(
            settings=self.settings,
            show_language_manager=self.debug_language_manager
            or system_info.is_packaged(),
            installed_languages=self.installed_languages,
        )
        return menu_button

    @staticmethod
    def _create_layout() -> QtWidgets.QGridLayout:
        layout = QtWidgets.QGridLayout()
        layout.setContentsMargins(26, 26, 26, 26)
        layout.setRowStretch(1, 1)
        layout.setColumnStretch(0, 1)
        return layout

    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(f"Screenshot is missing on screen {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())

        if system_info.display_manager_is_wayland():
            # For unknown reason .showFullScreen() on Ubuntu 24.04 does not show the
            # window. Showing the Window in normal state upfront seems to help.
            # (It seems like .setWindowState(WindowFullScreen) should not be set before
            # .setVisible(True) on that system. Might be a QT bug.)
            self.show()

        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. That's why in case of multi-display
        # setups, we need to use hacks to position the window:
        if system_info.display_manager_is_wayland():
            # The delay should ensure window is active & registered in window manager.
            QtCore.QTimer.singleShot(
                20, lambda: positioning.move(window=self, screen=self.screen_)
            )

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

    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()

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

dynobo / normcap / 18953976799

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