def test_mouse_and_key_handlers(self):
handler = Mock()
control_handler = Mock()
self.main_widget.controls.on_keydown = control_handler
self.main_widget.controls.on_keyup = control_handler
self.main_widget.controls.on_mouseclick = control_handler
self.main_widget.controls.on_mousedrag = control_handler
self.frame.set_keyup_handler(handler)
self.frame.set_keydown_handler(handler)
self.frame.set_mouseclick_handler(handler)
self.frame.set_mousedrag_handler(handler)
self.frame.start()
key_press = QKeyEvent(QKeyEvent.KeyPress, Qt.Key_L, Qt.NoModifier)
key_release = QKeyEvent(QKeyEvent.KeyRelease, Qt.Key_L, Qt.NoModifier)
mouse_release = QMouseEvent(QMouseEvent.MouseButtonRelease, QPoint(75, 75),
Qt.MiddleButton, Qt.NoButton, Qt.NoModifier)
mouse_move = QMouseEvent(QMouseEvent.MouseMove, QPoint(100, 75),
Qt.MiddleButton, Qt.NoButton, Qt.NoModifier)
calls = [
call((75, 75)),
call((100, 75)),
call(int(Qt.Key_L)),
call(int(Qt.Key_L))
]
self.main_widget.canvas.mouseReleaseEvent(mouse_release)
self.main_widget.canvas.mouseMoveEvent(mouse_move)
self.main_widget.canvas.keyPressEvent(key_press)
self.main_widget.canvas.keyReleaseEvent(key_release)
handler.assert_has_calls(calls)
control_handler.assert_has_calls(calls)
def testIt(self):
# We need a qapp otherwise Qt will crash when trying to detect the
# current platform
app = QApplication([])
ev1 = QKeyEvent(QEvent.KeyRelease, Qt.Key_Delete, Qt.NoModifier)
ev2 = QKeyEvent(QEvent.KeyRelease, Qt.Key_Copy, Qt.NoModifier)
ks = QKeySequence.Delete
self.assertTrue(ev1.matches(ks))
self.assertFalse(ev2.matches(ks))
def testIt(self):
# We need a qapp otherwise Qt will crash when trying to detect the
# current platform
app = QApplication([])
ev1 = QKeyEvent(QEvent.KeyRelease, Qt.Key_Delete, Qt.NoModifier)
ev2 = QKeyEvent(QEvent.KeyRelease, Qt.Key_Copy, Qt.NoModifier)
ks = QKeySequence.Delete
self.assertEqual(ev1, ks)
self.assertEqual(ks, ev1)
self.assertNotEqual(ev2, ks)
self.assertNotEqual(ks, ev2)
def updateOptionSelected(self):
# print(self.buttonGroup.checkedId()) # for test purpose
# self.selectedOption = self.buttonGroup.checkedId()
# print(self._selectedOption) # for test purpose
self.selectedOption = self.buttonGroup.checkedId()
QApplication.postEvent(
self, QKeyEvent(QEvent.KeyPress, Qt.Key_Enter, Qt.NoModifier))
def test_plain_text(self):
"""Test event handling"""
widget = PlainTextSingleLine(None)
self.assertTrue(widget.tabChangesFocus())
handler = Mock()
widget.enter_pressed.connect(handler)
event = QKeyEvent(QKeyEvent.KeyPress, Qt.Key_Enter, Qt.NoModifier)
widget.setPlainText('text')
widget.keyPressEvent(event)
handler.assert_not_called()
self.assertTrue(event.isAccepted())
event = QKeyEvent(QKeyEvent.KeyRelease, Qt.Key_Enter, Qt.NoModifier)
widget.keyReleaseEvent(event)
handler.assert_called_once_with('text')
self.assertTrue(event.isAccepted())
def on_key_event(self, wl_view, type_, name, modifiers, keyval, keycode,
native_modifiers, text):
print(type_, name, modifiers, keyval, keycode, native_modifiers, text)
print(KEY_EVENTS[type_], get_qt_key(name),
deserialize_modifiers(modifiers), keycode, keyval,
native_modifiers, text)
event = QKeyEvent(KEY_EVENTS[type_], get_qt_key(name),
deserialize_modifiers(modifiers), keycode, keyval,
native_modifiers, text)
self.renderer.sendEvent(event)
def event(self, arg__1: PySide2.QtCore.QEvent) -> bool:
if isinstance(arg__1, QKeyEvent):
if arg__1.key() == Qt.Key_Tab or arg__1.modifiers(
) == Qt.ShiftModifier:
if arg__1.type() == QEvent.KeyRelease:
if QApplication.keyboardModifiers() == Qt.ShiftModifier:
print("s pressed")
e = QKeyEvent(QEvent.KeyPress,
Qt.Key_Up,
Qt.NoModifier,
autorep=False)
else:
e = QKeyEvent(QEvent.KeyPress,
Qt.Key_Down,
Qt.NoModifier,
autorep=False)
QApplication.sendEvent(self, e)
return False
return super().event(arg__1)
def event(self, ev):
"""Intercepts shortcurts and instead sends an equivalent event with the 'Alt' modifier,
so that mnemonics works with just the key.
Also sends a key press event with the 'Alt' key when this menu shows,
so that mnemonics are underligned on windows.
"""
if ev.type() == QEvent.KeyPress and ev.key() == Qt.Key_Alt:
return True
if ev.type() == QEvent.ShortcutOverride and ev.modifiers() == Qt.NoModifier:
actions = self.actions() + [a for child in self.findChildren(QWidget) for a in child.actions()]
mnemonics = [QKeySequence.mnemonic(a.text()) for a in actions]
key_seq = QKeySequence(Qt.ALT + ev.key())
if key_seq in mnemonics:
ev = QKeyEvent(QEvent.KeyPress, ev.key(), Qt.AltModifier)
qApp.postEvent(self, ev) # pylint: disable=undefined-variable
return True
if ev.type() == QEvent.Show:
pev = QKeyEvent(QEvent.KeyPress, Qt.Key_Alt, Qt.NoModifier)
qApp.postEvent(self, pev) # pylint: disable=undefined-variable
return super().event(ev)
def test_add_input(self):
handler = Mock()
inp = self.frame.add_input('INPUT', handler, 140)
inp = self.__control_to_widget(inp)
label, field, _ = inp.children()
self.assertEqual(label.text(), 'INPUT')
self.assertEqual(field.toPlainText(), '')
inp.setText('data')
self.assertEqual(field.toPlainText(), 'data')
self.assertEqual(inp.text(), 'data')
event = QKeyEvent(QKeyEvent.KeyRelease, Qt.Key_Enter, Qt.NoModifier)
field.keyPressEvent(event)
handler.assert_not_called()
field.keyReleaseEvent(event)
handler.assert_called_once_with('data')
def event(self, event):
"""
overwritten from base class
:param event:
:return:
"""
if event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Tab:
if not self._compl.popup().isVisible():
self._compl.complete()
self.nextCompletion(+1)
return True
if event.key() == Qt.Key_Backtab:
if not self._compl.popup().isVisible():
self._compl.complete()
self.nextCompletion(-1)
return True
if event.key() in [Qt.Key_Slash, Qt.Key_Backslash]:
event = QKeyEvent(event.type(), event.key(), event.modifiers(), event.text())
return super().event(event)
def formatBraces(self):
e = QKeyEvent(QEvent.KeyPress, Qt.Key_Return, Qt.NoModifier)
self.keyPressEvent(e)
self.moveCursor(QTextCursor.Up)
self.insertPlainText(self.tabSize * ' ')
def sendKbdEvent(self):
ev = QKeyEvent(QEvent.KeyPress, Qt.Key_A, Qt.NoModifier, 'a')
QCoreApplication.sendEvent(self.box, ev)
def wheelEvent(self, event):
e = QKeyEvent(QEvent.None_,
Qt.Key_Down if event.delta() < 0 else Qt.Key_Up,
Qt.NoModifier)
self._bar_hue.keyPressEvent(e)
event.accept()
def sendkeys(self, char, modifier=Qt.NoModifier):
event = QKeyEvent(QEvent.KeyPress, char, modifier)
QCoreApplication.postEvent(self.gameWidget, event)
def eventFilter(self, obj, ev):
if ev.type() == QEvent.KeyPress:
self._parent_key_press_event = QKeyEvent(ev.type(), ev.key(),
ev.modifiers())
return super().eventFilter(obj, ev)
def handle_wordcheck_key_events(self, e: QKeyEvent):
"""
Remaps key events to their Wordcheck mode equivalents. Only handles NoModifier and ShiftModifier events.
:param e: The key event to remap.
:return:
"""
if e.key() in [
Qt.Key_Delete, Qt.Key_Backspace, Qt.Key_Comma, Qt.Key_Period,
Qt.Key_Semicolon, Qt.Key_Colon, Qt.Key_Less, Qt.Key_Greater
]:
if e.type() == QKeyEvent.KeyPress:
super().keyPressEvent(e)
elif e.type() == QKeyEvent.KeyRelease:
super().keyReleaseEvent(e)
elif e.modifiers() == Qt.NoModifier:
if e.key() in [Qt.Key_S, Qt.Key_H]:
mapped_e = QKeyEvent(e.type(),
Qt.Key_Left,
Qt.AltModifier,
autorep=e.isAutoRepeat(),
count=e.count())
QApplication.sendEvent(self, mapped_e)
elif e.key() in [Qt.Key_G, Qt.Key_L]:
mapped_e = QKeyEvent(e.type(),
Qt.Key_Right,
Qt.AltModifier,
autorep=e.isAutoRepeat(),
count=e.count())
QApplication.sendEvent(self, mapped_e)
elif e.key() in [Qt.Key_F, Qt.Key_J]:
mapped_e = QKeyEvent(e.type(),
Qt.Key_Down,
Qt.KeypadModifier,
autorep=e.isAutoRepeat(),
count=e.count())
QApplication.sendEvent(self, mapped_e)
elif e.key() in [Qt.Key_D, Qt.Key_K]:
mapped_e = QKeyEvent(e.type(),
Qt.Key_Up,
Qt.KeypadModifier,
autorep=e.isAutoRepeat(),
count=e.count())
QApplication.sendEvent(self, mapped_e)
elif e.key() in [Qt.Key_C, Qt.Key_N]:
mapped_e = QKeyEvent(e.type(),
Qt.Key_Left,
Qt.KeypadModifier,
autorep=e.isAutoRepeat(),
count=e.count())
QApplication.sendEvent(self, mapped_e)
elif e.key() in [Qt.Key_V, Qt.Key_M]:
mapped_e = QKeyEvent(e.type(),
Qt.Key_Right,
Qt.KeypadModifier,
autorep=e.isAutoRepeat(),
count=e.count())
QApplication.sendEvent(self, mapped_e)
elif e.key() in [Qt.Key_R, Qt.Key_U
] and e.type() == QKeyEvent.KeyPress:
if self.wordcheck_entry is not None:
self.entry_idx += 1
self.next_word_replace()
elif e.key() in [Qt.Key_E, Qt.Key_I
] and e.type() == QKeyEvent.KeyPress:
if self.wordcheck_entry is not None:
self.entry_idx -= 1
self.next_word_replace()
elif e.key() in [Qt.Key_W, Qt.Key_O
] and e.type() == QKeyEvent.KeyPress:
self.set_wordcheck_word_as_default()
elif e.key() in [Qt.Key_A, Qt.Key_Z, Qt.Key_X]:
if e.key() == Qt.Key_A:
mapped_e = QKeyEvent(e.type(),
Qt.Key_Semicolon,
Qt.NoModifier,
text=';',
autorep=e.isAutoRepeat(),
count=e.count())
QApplication.sendEvent(self, mapped_e)
elif e.key() == Qt.Key_Z:
mapped_e = QKeyEvent(e.type(),
Qt.Key_Period,
Qt.NoModifier,
text='.',
autorep=e.isAutoRepeat(),
count=e.count())
QApplication.sendEvent(self, mapped_e)
else: # Key_X
mapped_e = QKeyEvent(e.type(),
Qt.Key_Comma,
Qt.NoModifier,
text=',',
autorep=e.isAutoRepeat(),
count=e.count())
QApplication.sendEvent(self, mapped_e)
elif e.modifiers() == Qt.ShiftModifier:
if e.key() in [Qt.Key_A, Qt.Key_Z, Qt.Key_X]:
if e.key() == Qt.Key_A:
mapped_e = QKeyEvent(e.type(),
Qt.Key_Colon,
Qt.ShiftModifier,
text=':',
autorep=e.isAutoRepeat(),
count=e.count())
QApplication.sendEvent(self, mapped_e)
elif e.key() == Qt.Key_Z:
mapped_e = QKeyEvent(e.type(),
Qt.Key_Greater,
Qt.ShiftModifier,
text='>',
autorep=e.isAutoRepeat(),
count=e.count())
QApplication.sendEvent(self, mapped_e)
else: # Key_X
mapped_e = QKeyEvent(e.type(),
Qt.Key_Less,
Qt.ShiftModifier,
text='<',
autorep=e.isAutoRepeat(),
count=e.count())
QApplication.sendEvent(self, mapped_e)
