1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
# Copyright 2014-2021 Florian Bruhin (The Compiler) <mail@qutebrowser.org>
#
# This file is part of qutebrowser.
#
# qutebrowser is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# qutebrowser is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with qutebrowser. If not, see <https://www.gnu.org/licenses/>.
"""Global Qt event filter which dispatches key events."""
from typing import cast
from qutebrowser.qt import machinery
from qutebrowser.qt.core import pyqtSlot, QObject, QEvent
from qutebrowser.qt.gui import QKeyEvent, QWindow
from qutebrowser.keyinput import modeman
from qutebrowser.misc import quitter, objects
from qutebrowser.utils import objreg, debug, log
class EventFilter(QObject):
"""Global Qt event filter.
Attributes:
_activated: Whether the EventFilter is currently active.
_handlers: A {QEvent.Type: callable} dict with the handlers for an
event.
"""
def __init__(self, parent: QObject = None) -> None:
super().__init__(parent)
self._activated = True
self._handlers = {
QEvent.Type.KeyPress: self._handle_key_event,
QEvent.Type.KeyRelease: self._handle_key_event,
QEvent.Type.ShortcutOverride: self._handle_key_event,
}
self._log_qt_events = "log-qt-events" in objects.debug_flags
def install(self) -> None:
objects.qapp.installEventFilter(self)
@pyqtSlot()
def shutdown(self) -> None:
objects.qapp.removeEventFilter(self)
def _handle_key_event(self, event: QKeyEvent) -> bool:
"""Handle a key press/release event.
Args:
event: The QEvent which is about to be delivered.
Return:
True if the event should be filtered, False if it's passed through.
"""
active_window = objects.qapp.activeWindow()
if active_window not in objreg.window_registry.values():
# Some other window (print dialog, etc.) is focused so we pass the
# event through.
return False
try:
man = modeman.instance('current')
return man.handle_event(event)
except objreg.RegistryUnavailableError:
# No window available yet, or not a MainWindow
return False
def eventFilter(self, obj: QObject, event: QEvent) -> bool:
"""Handle an event.
Args:
obj: The object which will get the event.
event: The QEvent which is about to be delivered.
Return:
True if the event should be filtered, False if it's passed through.
"""
ev_type = event.type()
if machinery.IS_QT6:
ev_type = cast(QEvent.Type, ev_type)
if self._log_qt_events:
try:
source = repr(obj)
except AttributeError: # might not be fully initialized yet
source = type(obj).__name__
ev_type_str = debug.qenum_key(QEvent, ev_type)
log.misc.debug(f"{source} got event: {ev_type_str}")
if not isinstance(obj, QWindow):
# We already handled this same event at some point earlier, so
# we're not interested in it anymore.
return False
if ev_type not in self._handlers:
return False
if not self._activated:
return False
handler = self._handlers[ev_type]
try:
return handler(cast(QKeyEvent, event))
except:
# If there is an exception in here and we leave the eventfilter
# activated, we'll get an infinite loop and a stack overflow.
self._activated = False
raise
def init() -> None:
"""Initialize the global EventFilter instance."""
event_filter = EventFilter(parent=objects.qapp)
event_filter.install()
quitter.instance.shutting_down.connect(event_filter.shutdown)
|
