def keyPressEvent(self, event: QKeyEvent):
if self._completedAndSelected and self.handledCompletedAndSelected(
event):
return
self._completedAndSelected = False
if self._completer.popup().isVisible():
ignoredKeys = [
Qt.Key_Up,
Qt.Key_Down,
Qt.Key_Enter,
Qt.Key_Return,
Qt.Key_Tab,
Qt.Key_Escape,
]
if event.key() in ignoredKeys:
event.ignore()
return
self._completer.popup().hide()
super().keyPressEvent(event)
if not self._enableAutoCompletion:
return
ctrlOrShift = (event.modifiers() & Qt.ShiftModifier == Qt.ShiftModifier
or event.modifiers() & Qt.ControlModifier
== Qt.ControlModifier)
if ctrlOrShift and not event.text():
return
if self.textCursor().atBlockEnd():
self.suggestCompletions()
def keyPressEvent(self, event: QKeyEvent) -> None:
"""Process key events for this :py:class:`QDataView`.
The following keys are recognized:
B: toggle visibility of the batch navigator
M: toggle visibility of multi image view
Return: set the annotation changed flag
Ctrl+Z: undo
Ctrl+S: save
"""
key = event.key()
if key == Qt.Key_B: # toggle visibility of batch navigator
visible = self._batchNavigator.isVisible()
self._batchNavigator.setVisible(not visible)
elif key == Qt.Key_M: # toggle visibility of multi image view
visible = self._multiImageScroller.isVisible()
self._multiImageScroller.setVisible(not visible)
elif key == Qt.Key_Return: # set the annotation changed flag
self._annotationsChanged = True
self.update()
elif key == Qt.Key_Z and event.modifiers() == Qt.ControlModifier:
# Ctrl+Z = undo
self._loadAnnotations()
self.update()
elif key == Qt.Key_S and event.modifiers() == Qt.ControlModifier:
# Ctrl+S = save
self._saveAnnotations()
self.update()
else:
super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent) -> None:
"""
Handles the player's keyboard input.
Possible actions:
-move player up, down, left, right
-reset level to the initial state
-start bfs algorithm (deterministic)
-start bfs algorithm (non-deterministic)
-start dfs algorithm (deterministic)
-start dfs algorithm (non-deterministic)
:param event: QKeyEvent to be handled
:return: None
"""
if not self._gameLock:
key = event.key()
if key in self._level.DIRECTIONS:
dRow = self._level.DIRECTIONS[key][0]
dColumn = self._level.DIRECTIONS[key][1]
self._level.movePlayer(dRow, dColumn, animated=True)
elif key == Qt.Key_R:
self._level.reset()
elif key == Qt.Key_B:
if event.modifiers() == Qt.ShiftModifier:
self._level.bfs(deterministic=False)
else:
self._level.bfs()
elif key == Qt.Key_D:
if event.modifiers() == Qt.ShiftModifier:
self._level.dfs(deterministic=False)
else:
self._level.dfs()
super().keyPressEvent(event)
def keyPressEvent(self, event):
key = event.key()
cursor = self.textCursor()
if key == Qt.Key_Backspace and event.modifiers(
) & Qt.GroupSwitchModifier:
# Workaround for https://bugreports.qt.io/browse/QTBUG-49771
event = QKeyEvent(event.type(), event.key(),
event.modifiers() ^ Qt.GroupSwitchModifier)
if key == Qt.Key_Tab:
documentIndentMore(self.document(), cursor)
elif key == Qt.Key_Backtab:
documentIndentLess(self.document(), cursor)
elif key == Qt.Key_Return:
markupClass = self.tab.getActiveMarkupClass()
if event.modifiers() & Qt.ControlModifier:
cursor.insertText('\n')
self.ensureCursorVisible()
elif self.tableModeEnabled and tablemode.handleReturn(
cursor,
markupClass,
newRow=(event.modifiers() & Qt.ShiftModifier)):
self.setTextCursor(cursor)
self.ensureCursorVisible()
else:
if event.modifiers(
) & Qt.ShiftModifier and markupClass == MarkdownMarkup:
# Insert Markdown-style line break
cursor.insertText(' ')
self.handleReturn(cursor)
else:
if event.text() and self.tableModeEnabled:
cursor.beginEditBlock()
QTextEdit.keyPressEvent(self, event)
if event.text() and self.tableModeEnabled:
cursor.endEditBlock()
def keyReleaseEvent(self, evt: QtGui.QKeyEvent) -> None:
if (not evt.isAutoRepeat() and evt.modifiers() == Qt.NoModifier
and evt.key() == Qt.Key_Period):
self.setPreviousTool()
evt.accept()
return
if (not evt.isAutoRepeat() and evt.modifiers() == Qt.NoModifier
and evt.key() == Qt.Key_F):
self.setPreviousTool()
evt.accept()
return
if (not evt.isAutoRepeat() and evt.modifiers() == Qt.NoModifier
and evt.key() == Qt.Key_S):
self.setPreviousTool()
evt.accept()
return
if (not evt.isAutoRepeat() and evt.modifiers() == Qt.NoModifier
and evt.key() == Qt.Key_N):
self.setPreviousTool()
evt.accept()
return
super().keyReleaseEvent(evt)
def keyPressEvent(self, event):
key = event.key()
cursor = self.textCursor()
if key == Qt.Key_Backspace and event.modifiers() & Qt.GroupSwitchModifier:
# Workaround for https://bugreports.qt.io/browse/QTBUG-49771
event = QKeyEvent(event.type(), event.key(),
event.modifiers() ^ Qt.GroupSwitchModifier)
if key == Qt.Key_Tab:
documentIndentMore(self.document(), cursor)
elif key == Qt.Key_Backtab:
documentIndentLess(self.document(), cursor)
elif key == Qt.Key_Return and not cursor.hasSelection():
if event.modifiers() & Qt.ShiftModifier:
# Insert Markdown-style line break
markupClass = self.tab.getActiveMarkupClass()
if markupClass == MarkdownMarkup:
cursor.insertText(' ')
if event.modifiers() & Qt.ControlModifier:
cursor.insertText('\n')
self.ensureCursorVisible()
else:
self.handleReturn(cursor)
else:
if event.text() and self.tableModeEnabled:
cursor.beginEditBlock()
QTextEdit.keyPressEvent(self, event)
if event.text() and self.tableModeEnabled:
cursor.endEditBlock()
def keyPressEvent(self, orig_event: QKeyEvent) -> None:
"""
Re-definition of QWidget.keyPressEvent(). This function is called by Qt
every time a key press is registered in the MainWindow / centralWidget.
"""
# check if this key needs to be translated
if orig_event.key() in self.keyTranslations:
# get the translated event
event = self.keyTranslations[orig_event.key()]
translated = True
# if the translation does not specify modifiers, keep the original modifiers
if not event.modifiers() & Qt.AltModifier and not event.modifiers(
) & Qt.ControlModifier:
event = QKeyEvent(QEvent.KeyPress, event.key(),
orig_event.modifiers())
translated = False
else:
# otherwise use the original event
event = orig_event
translated = False
# if a valid key was pressed
if event.key() in self.buttons:
# get the Button corresponding to the key
button = self.buttons[event.key()]
# check for mac or windows to know to switch what funcitons Alt
# and Ctrl correspond to
if is_mac() or translated:
# use modifiers() to determine which reference to animateClick on
# and therefore which function to perform
if event.modifiers(
) & Qt.AltModifier and button.ref_2 is not None:
# second function
button.ref_2.animateClick()
elif event.modifiers(
) & Qt.ControlModifier and button.ref_3 is not None:
# third function
button.ref_3.animateClick()
else:
# first / main funciton
button.ref_1.animateClick()
else:
# use modifiers() to determine which reference to animateClick on
# and therefore which function to perform
if event.modifiers(
) & Qt.ControlModifier and button.ref_2 is not None:
# second function
button.ref_2.animateClick()
elif event.modifiers(
) & Qt.AltModifier and button.ref_3 is not None:
# third function
button.ref_3.animateClick()
else:
# first / main funciton
button.ref_1.animateClick()
return
def __onTaxKeyPress(self, KeyEvent: QKeyEvent):
if (KeyEvent.modifiers() == Qt.AltModifier
and KeyEvent.key() == Qt.Key_Delete):
self.ui.fTax.refreshValueRaiseEvent(None, True)
self.cacuTax = False
elif (KeyEvent.modifiers() == Qt.AltModifier
and KeyEvent.key() == Qt.Key_T):
self.cacuTax = True
def append_event(self, ev: QKeyEvent) -> 'KeySequence':
"""Create a new KeySequence object with the given QKeyEvent added."""
key = Qt.Key(ev.key())
_assert_plain_key(key)
_assert_plain_modifier(ev.modifiers())
key = _remap_unicode(key, ev.text())
modifiers = int(ev.modifiers())
if key == _NIL_KEY:
raise KeyParseError(None, "Got nil key!")
# We always remove Qt.GroupSwitchModifier because QKeySequence has no
# way to mention that in a binding anyways...
modifiers &= ~Qt.GroupSwitchModifier
# We change Qt.Key_Backtab to Key_Tab here because nobody would
# configure "Shift-Backtab" in their config.
if modifiers & Qt.ShiftModifier and key == Qt.Key_Backtab:
key = Qt.Key_Tab
# We don't care about a shift modifier with symbols (Shift-: should
# match a : binding even though we typed it with a shift on an
# US-keyboard)
#
# However, we *do* care about Shift being involved if we got an
# upper-case letter, as Shift-A should match a Shift-A binding, but not
# an "a" binding.
#
# In addition, Shift also *is* relevant when other modifiers are
# involved. Shift-Ctrl-X should not be equivalent to Ctrl-X.
if (modifiers == Qt.ShiftModifier and
_is_printable(key) and
not ev.text().isupper()):
modifiers = Qt.KeyboardModifiers() # type: ignore[assignment]
# On macOS, swap Ctrl and Meta back
#
# We don't use Qt.AA_MacDontSwapCtrlAndMeta because that also affects
# Qt/QtWebEngine's own shortcuts. However, we do want "Ctrl" and "Meta"
# (or "Cmd") in a key binding name to actually represent what's on the
# keyboard.
if utils.is_mac:
# FIXME:qt6 Reevaluate the type ignores below
if modifiers & Qt.ControlModifier and modifiers & Qt.MetaModifier:
pass
elif modifiers & Qt.ControlModifier:
modifiers &= ~Qt.ControlModifier
modifiers |= Qt.MetaModifier # type: ignore[assignment]
elif modifiers & Qt.MetaModifier:
modifiers &= ~Qt.MetaModifier
modifiers |= Qt.ControlModifier # type: ignore[assignment]
keys = list(self._iter_keys())
keys.append(key | int(modifiers))
return self.__class__(*keys)
def keyPressEvent(self, a0: QKeyEvent):
if a0.modifiers() == Qt.ShiftModifier and a0.key() == Qt.Key_F4:
""" Create file """
self.create_obj("Create file")
elif a0.key() == Qt.Key_Tab:
# main.focusWidget().objectName()
""" Panel switching """
main.sync(self).setFocus(True)
elif a0.key() == Qt.Key_Enter or a0.key() == Qt.Key_Return:
""" Enter Key """
self.double()
elif a0.key() == Qt.Key_Backspace:
""" Backspace Key """
self.setCurrentItem(self.item(0, 0))
self.double()
elif a0.modifiers() == Qt.ControlModifier and a0.key() == Qt.Key_H:
""" Hide / Unhide """
self.hide = False if self.hide else True
self.generate_table()
elif a0.key() == Qt.Key_Insert:
""" Insert Key """
if self.currentItem().row() != 0:
item = self.currentItem()
self.to_insert(item) if item.text(
) not in self.insert else self.from_insert(item)
if item.row() < len(self.read_panel.folders) + len(
self.read_panel.files):
self.setCurrentItem(self.item(item.row() + 1, 0))
else:
self.setCurrentItem(self.item(1, 0))
elif a0.key() == Qt.Key_F3:
""" Read """
self.read_file('read')
elif a0.key() == Qt.Key_F4:
""" Edit """
self.read_file('write')
elif a0.key() == Qt.Key_F5:
""" F5 Key sorted(z, key=lambda x: Path(x).suffix[1:]) """
elif a0.key() == Qt.Key_F7:
""" Create folder """
self.create_obj("Create folder")
elif a0.key() == Qt.Key_F10:
""" Close App """
main.close()
elif a0.key() == Qt.Key_F11:
""" Full Screen """
if not main.isMaximized():
main.showMaximized()
else:
main.showNormal()
elif a0.key() == Qt.Key_Plus:
self.selectfind = SelectByMask(self, 1)
self.selectfind.show()
elif a0.key() == Qt.Key_Minus:
self.selectfind = SelectByMask(self, 2)
self.selectfind.show()
else:
return QTableWidget.keyPressEvent(self, a0)
def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
if event.key() == Qt.Key_Q and event.modifiers() & Qt.ControlModifier:
if self._road_detect_thread.isRunning():
self._road_detect_thread.pause()
event.accept()
elif event.key(
) == Qt.Key_A and event.modifiers() & Qt.ControlModifier:
self._road_detect_thread.resume()
event.accept()
else:
self._image_label.keyPressEvent(event)
def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
if not event.modifiers():
if event.key() == QtCore.Qt.Key_Return:
self.accept()
elif event.key() == QtCore.Qt.Key_Escape:
self.reject()
elif event.modifiers() == QtCore.Qt.KeypadModifier and event.key(
) == QtCore.Qt.Key_Enter:
self.accept()
else:
super(QDialog, self).keyPressEvent(event)
def keyPressEvent(self, event: QtGui.QKeyEvent):
"""Bugfix, disables SHIFT+RETURN misbehaviour."""
if (event.key() == QtCore.Qt.Key_Enter or event.key() == 16777220) and \
((event.modifiers() & QtCore.Qt.ShiftModifier) == QtCore.Qt.ShiftModifier):
# clone object but without shift
# current modifiers & all possible modifiers, but SHIFT,ALT,CTRL
event = QtGui.QKeyEvent(
event.type(), event.key(),
event.modifiers() & QtCore.Qt.MetaModifier
& QtCore.Qt.KeypadModifier, event.text(), event.isAutoRepeat(),
event.count())
super().keyPressEvent(event)
def append_event(self, ev: QKeyEvent) -> 'KeySequence':
"""Create a new KeySequence object with the given QKeyEvent added."""
key = Qt.Key(ev.key())
_assert_plain_key(key)
_assert_plain_modifier(ev.modifiers())
key = _remap_unicode(key, ev.text())
modifiers = int(ev.modifiers())
if key == _NIL_KEY:
raise KeyParseError(None, "Got nil key!")
# We always remove Qt.GroupSwitchModifier because QKeySequence has no
# way to mention that in a binding anyways...
modifiers &= ~Qt.GroupSwitchModifier
# We change Qt.Key_Backtab to Key_Tab here because nobody would
# configure "Shift-Backtab" in their config.
if modifiers & Qt.ShiftModifier and key == Qt.Key_Backtab:
key = Qt.Key_Tab
# We don't care about a shift modifier with symbols (Shift-: should
# match a : binding even though we typed it with a shift on an
# US-keyboard)
#
# However, we *do* care about Shift being involved if we got an
# upper-case letter, as Shift-A should match a Shift-A binding, but not
# an "a" binding.
#
# In addition, Shift also *is* relevant when other modifiers are
# involved. Shift-Ctrl-X should not be equivalent to Ctrl-X.
if (modifiers == Qt.ShiftModifier and
_is_printable(key) and
not ev.text().isupper()):
modifiers = Qt.KeyboardModifiers() # type: ignore[assignment]
# On macOS, swap Ctrl and Meta back
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-51293
if utils.is_mac:
if modifiers & Qt.ControlModifier and modifiers & Qt.MetaModifier:
pass
elif modifiers & Qt.ControlModifier:
modifiers &= ~Qt.ControlModifier
modifiers |= Qt.MetaModifier
elif modifiers & Qt.MetaModifier:
modifiers &= ~Qt.MetaModifier
modifiers |= Qt.ControlModifier
keys = list(self._iter_keys())
keys.append(key | int(modifiers))
return self.__class__(*keys)
def wrapper(event: QKeyEvent):
if event.key() == Qt.Key_C and event.modifiers(
) == Qt.ControlModifier:
QApplication.clipboard().setText(self.model().copy_range(
self.selectedIndexes()))
elif event.key() == Qt.Key_V and event.modifiers(
) == Qt.ControlModifier:
self.model().paste_range(self.selectedIndexes(),
QApplication.clipboard().text())
self.reset()
else:
func(event)
def keyPressEvent(self, a0: QtGui.QKeyEvent) -> None:
m = self.getActiveMarker()
if m is not None and a0.modifiers() == QtCore.Qt.NoModifier:
if a0.key() in [QtCore.Qt.Key_Down, QtCore.Qt.Key_Left]:
m.frequencyInput.keyPressEvent(
QtGui.QKeyEvent(a0.type(), QtCore.Qt.Key_Down,
a0.modifiers()))
elif a0.key() in [QtCore.Qt.Key_Up, QtCore.Qt.Key_Right]:
m.frequencyInput.keyPressEvent(
QtGui.QKeyEvent(a0.type(), QtCore.Qt.Key_Up,
a0.modifiers()))
else:
super().keyPressEvent(a0)
def keyPressEvent(self, event: QKeyEvent):
char = event.text()
if (char and ord(char) in range(ord(' '), ord('~') + 1) or char.isalpha()) \
and (event.modifiers() in (Qt.NoModifier, Qt.ShiftModifier)
or event.modifiers() & Qt.AltModifier):
if event.modifiers() & Qt.AltModifier:
return
if not (set(char) - (VALID_CHARS | set('vV'))):
self.insert(char)
else:
if event.matches(QKeySequence.Cancel):
self.clear()
elif event.matches(QKeySequence.Copy):
if not self.text():
return
if self.selectedText():
text_to_copy = self.selectedText()
else:
text_to_copy = self.text()
text_to_copy = toEditableExpr(text_to_copy)
clipboard = QApplication.clipboard()
clipboard.setText(text_to_copy)
elif event.matches(QKeySequence.Paste):
clipboard = QApplication.clipboard()
text = clipboard.text()
if not text:
return
self.insert(text.strip())
elif event.matches(QKeySequence.Cut):
if not self.text():
return
if self.selectedText():
text_to_copy = self.selectedText()
super().keyPressEvent(event)
else:
text_to_copy = self.text()
self.clear()
text_to_copy = toEditableExpr(text_to_copy)
clipboard = QApplication.clipboard()
clipboard.setText(text_to_copy)
else:
super().keyPressEvent(event)
def keyPressEvent(self, event: QtGui.QKeyEvent):
# Let the warning overlay process key presses when active
if self.parent().warningOverlay:
self.parent().warningOverlay.keyPressEvent(event)
return
if event.key() == QtCore.Qt.Key_Tab or event.key(
) == QtCore.Qt.Key_Backtab:
if (event.modifiers()
& QtCore.Qt.ControlModifier) == QtCore.Qt.ControlModifier:
# Ctrl + Tab / Ctrl + Shift + Tab for navigating the tab control, just let the parent handle it
pass
elif (event.modifiers()
& QtCore.Qt.ShiftModifier) == QtCore.Qt.ShiftModifier:
# Shift + Tab, give focus to previous widget
self.parent().focusPreviousChild()
return
else:
# No Ctrl / Shift pressed, show completions
self.parent().completions()
return
closed_completions = self.parent().hide_completions()
if event.key() in (QtCore.Qt.Key_Enter, QtCore.Qt.Key_Return):
self.parent().runCommand()
return
if event.key() == QtCore.Qt.Key_Home:
self.parent().setCursorPosition(0)
return
if event.key() == QtCore.Qt.Key_PageUp:
return
elif event.key() in (QtCore.Qt.Key_Left, QtCore.Qt.Key_Backspace):
if self.parent().getCursorPosition() == 0:
return
elif event.key() == QtCore.Qt.Key_Up:
self.parent().setCommand(self.parent().getPrevHistoryEntry())
return
elif event.key() == QtCore.Qt.Key_Down:
self.parent().setCommand(self.parent().getNextHistoryEntry())
return
elif event.key() == QtCore.Qt.Key_L and event.modifiers(
) == QtCore.Qt.ControlModifier:
self.parent().clear()
elif event.key() == QtCore.Qt.Key_Insert and event.modifiers(
) == QtCore.Qt.NoModifier:
self.setOverwriteMode(not self.overwriteMode())
super(ConsoleTextEdit, self).keyPressEvent(event)
def keyPressEvent(self, e: QKeyEvent):
# table state
# https://doc.qt.io/archives/qt-4.8/qabstractitemview.html#State-enum
state = self.state()
key = e.key()
index = self.currentIndex()
item = self.model().itemFromIndex(index)
if state == QAbstractItemView.NoEditTriggers:
if key == Qt.Key_E:
self.expandAll()
return
if key == Qt.Key_C:
self.collapseAll()
return
if key in (Qt.Key_S, Qt.Key_I):
# item.setData(
# 's', Qt.UserRole
# )
self.edit(index)
return
if key in key_remap.keys():
e = QKeyEvent(QEvent.KeyPress, key_remap.get(key),
e.modifiers(), e.text())
if key == Qt.Key_G: # press shift+g go to bottom of row
if e.modifiers() == Qt.ShiftModifier:
model = self.model().itemFromIndex(index.parent())
if model is None:
model = self.model()
row_cnt = model.rowCount() - 1
sibling = index.sibling(row_cnt, index.column())
else: # press g go to top of row
sibling = index.sibling(0, index.column())
self.setCurrentIndex(sibling)
return
pre_index = index
super(TreeView, self).keyPressEvent(e)
index = self.currentIndex()
if pre_index == index:
return
if e.key() in (Qt.Key_Up, Qt.Key_Down):
if state == QAbstractItemView.EditingState:
self.edit(index)
def keyPressEvent(self, e: QKeyEvent):
# table state
# https://doc.qt.io/archives/qt-4.8/qabstractitemview.html#State-enum
state = self.state()
key = e.key()
index = self.currentIndex()
if self.dialog.isVisible():
if key == Qt.Key_N:
self.nextMatch()
return
elif key == Qt.Key_R:
self.replace()
return
if state == QAbstractItemView.EditingState:
if e.modifiers() == Qt.ControlModifier:
if key in key_remap:
self.commitData(self.focusWidget())
self.closeEditor(self.focusWidget(),
QAbstractItemDelegate.NoHint)
e = QKeyEvent(QEvent.KeyPress, key_remap.get(key),
Qt.NoModifier, e.text())
super(TableView, self).keyPressEvent(e)
self.edit(self.currentIndex())
return
if state == QAbstractItemView.NoEditTriggers:
if key in (Qt.Key_I, Qt.Key_S):
self.edit(index)
return
if key in key_remap.keys():
e = QKeyEvent(QEvent.KeyPress, key_remap.get(key),
e.modifiers(), e.text())
if key == Qt.Key_G: # press shift+g go to bottom of row
if e.modifiers() == Qt.ShiftModifier:
row_cnt = self.model().rowCount() - 1
sibling = index.sibling(row_cnt, index.column())
else: # press g go to top of row
sibling = index.sibling(0, index.column())
self.setCurrentIndex(sibling)
return
if key == Qt.Key_Delete or key == Qt.Key_D:
self.deleteKeyPress.emit(self.currentIndex(), '', '')
return
super(TableView, self).keyPressEvent(e)
def keyPressEvent(self, event: QtGui.QKeyEvent):
key = event.key()
modifiers = event.modifiers()
if self.underMouse() and modifiers == Qt.NoModifier:
if key == Qt.Key_W:
self.isWDown = True
# self.camera.goUp(0.1)
elif key == Qt.Key_S:
self.isSDown = True
# self.camera.goUp(-0.1)
elif key == Qt.Key_A:
self.isADown = True
# self.camera.goRight(-0.1)
elif key == Qt.Key_D:
self.isDDown = True
# self.camera.goRight(0.1)
elif key == Qt.Key_Q:
self.isQDown = True
# self.camera.roll(0.05)
elif key == Qt.Key_E:
self.isEDown = True
# self.camera.roll(-0.05)
QtOpenGL.QGLWidget.keyPressEvent(self, event)
def keyPressEvent(self, e: QKeyEvent):
mod = e.modifiers() & ~QtCore.Qt.KeypadModifier
if e.key() == QtCore.Qt.Key_F4:
cur = self.textCursor()
format = QTextFrameFormat()
format.setBorder(2.0)
format.setBorderBrush(QColor(255,0,255))
format.setProperty(QTextFormat.UserProperty + 100, "code-block")
frame = cur.insertFrame(format)
self.setTextCursor(frame.firstCursorPosition())
print(int(mod), e.key())
if mod == QtCore.Qt.ControlModifier and e.key() == QtCore.Qt.Key_Return:
print("ctr-enter")
cur = self.textCursor()
fr = cur.currentFrame()
print(fr)
it = fr.begin()
code = ""
while not it.atEnd():
fragment = it.currentBlock()
if fragment.isValid():
code += fragment.text() + "\n"
it += 1
print(code)
try:
exec(code)
except Exception as ex:
QMessageBox.warning(self, "Exception in script", traceback.format_exc())
return
super().keyPressEvent(e)
def keyReleaseEvent(self, event: QtGui.QKeyEvent):
key = event.key()
modifiers = event.modifiers()
if key == Qt.Key_W:
self.isWDown = False
elif key == Qt.Key_S:
self.isSDown = False
elif key == Qt.Key_A:
self.isADown = False
elif key == Qt.Key_D:
self.isDDown = False
elif key == Qt.Key_Q:
self.isQDown = False
elif key == Qt.Key_E:
self.isEDown = False
elif key == Qt.Key_Return:
if self.currentMode == 0:
t = 1
elif self.currentMode == 1:
g = 3
QtOpenGL.QGLWidget.keyReleaseEvent(self, event)
def handle(self,
e: QKeyEvent,
*,
dry_run: bool = False) -> QKeySequence.SequenceMatch:
"""Handle a new keypress and call the respective handlers."""
if dry_run:
return super().handle(e, dry_run=True)
if keyutils.is_special_hint_mode(Qt.Key(e.key()), e.modifiers()):
log.keyboard.debug("Got special key, clearing keychain")
self.clear_keystring()
if dry_run:
raise AssertionError
match = super().handle(e)
if match == QKeySequence.PartialMatch:
self._last_press = LastPress.keystring
elif match == QKeySequence.ExactMatch:
self._last_press = LastPress.none
elif match == QKeySequence.NoMatch:
# We couldn't find a keychain so we check if it's a special key.
return self._handle_filter_key(e)
else:
raise ValueError("Got invalid match type {}!".format(match))
return match
def keyPressEvent(self, a0: QKeyEvent):
if a0.key() == QtCore.Qt.Key_Plus: # Increase or decrease point size
if self.PointSize < 20:
self.PointSize = self.PointSize + 1
if a0.modifiers() != QtCore.Qt.NoModifier:
return
if a0.key() == QtCore.Qt.Key_Minus: # Increase or decrease point size
if self.PointSize > 1:
self.PointSize = self.PointSize - 1
if a0.key() == QtCore.Qt.Key_T: # Toggle NOCS views
if self.nNM > 0:
self.activeNMIdx = (self.activeNMIdx + 1)%(self.nNM+1)
if a0.key() == QtCore.Qt.Key_N:
self.showNOCS = not self.showNOCS
if a0.key() == QtCore.Qt.Key_B:
self.showBB = not self.showBB
if a0.key() == QtCore.Qt.Key_P:
self.showPoints = not self.showPoints
if a0.key() == QtCore.Qt.Key_W:
self.showWireFrame = not self.showWireFrame
if a0.key() == QtCore.Qt.Key_S:
print('[ INFO ]: Taking snapshot.')
self.takeSS = True
def keyReleaseEvent(self, event: QtGui.QKeyEvent):
key = event.key()
modifiers = event.modifiers()
if key == Qt.Key_W:
self.isWDown = False
elif key == Qt.Key_S:
self.isSDown = False
elif key == Qt.Key_A:
self.isADown = False
elif key == Qt.Key_D:
self.isDDown = False
elif key == Qt.Key_Q:
self.isQDown = False
elif key == Qt.Key_E:
self.isEDown = False
elif key == Qt.Key_Return:
if self.currentMode == 0:
t = 1
# self.skelModel.AcceptConnection()
elif self.currentMode == 1:
g = 3
# self.skelModel.AcceptBreak()
QtOpenGL.QGLWidget.keyReleaseEvent(self, event)
def keyPressEvent(self, e: QKeyEvent):
key = e.key()
modifiers = e.modifiers()
if key == QtCore.Qt.Key_Escape or (modifiers == Qt.ControlModifier
and key == Qt.Key_W):
self.close()
def keyPressEvent(self, event: QKeyEvent) -> None:
""" Parse keyboard input events for special cases. """
key = event.key()
if key == Qt.Key_Up:
# Up - replace user text with the previous command history item.
self._history_prev()
elif key == Qt.Key_Down:
# Down - replace user text with the next command history item.
self._history_next()
elif key in (Qt.Key_Return, Qt.Key_Enter):
# Enter - submit user text as terminal input.
self._submit()
elif event.modifiers() & Qt.ControlModifier:
# Ctrl shortcuts have spurious event text.
if key == Qt.Key_C and not self.textCursor().selectedText():
# Ctrl-C is an interrupt if no text is selected; otherwise it is a copy.
self.interrupted.emit()
else:
super().keyPressEvent(event)
else:
# In all other cases, process the event as normal.
if event.text():
# Reset the cursor before inserting actual text.
self._set_cursor_valid()
super().keyPressEvent(event)
def keyPressEvent(self, event):
# hack -- force uppercase
if event.text().upper() != event.text().lower():
from PyQt5.QtGui import QKeyEvent
event = QKeyEvent(QKeyEvent.KeyPress, event.key(), event.modifiers(), event.text().upper(), False, 1)
tc = self.textCursor()
if event.key() == Qt.Key_Return and self.completer.popup().isVisible():
self.completer.insertText.emit(self.completer.getSelected())
self.completer.setCompletionMode(QCompleter.PopupCompletion)
return
QPlainTextEdit.keyPressEvent(self, event)
tc.select(QTextCursor.WordUnderCursor)
cr = self.cursorRect()
if len(tc.selectedText()) > 0:
self.completer.setCompletionPrefix(tc.selectedText())
popup = self.completer.popup()
popup.setCurrentIndex(self.completer.completionModel().index(0,0))
cr.setWidth(self.completer.popup().sizeHintForColumn(0)
+ self.completer.popup().verticalScrollBar().sizeHint().width())
self.completer.complete(cr)
else:
self.completer.popup().hide()
def handle(self, e: QKeyEvent, *,
dry_run: bool = False) -> QKeySequence.SequenceMatch:
"""Override to always match the next key and use the register."""
match = super().handle(e, dry_run=dry_run)
if match or dry_run:
return match
if keyutils.is_special(Qt.Key(e.key()), e.modifiers()):
# this is not a proper register key, let it pass and keep going
return QKeySequence.NoMatch
key = e.text()
tabbed_browser = objreg.get('tabbed-browser', scope='window',
window=self._win_id)
try:
if self._register_mode == usertypes.KeyMode.set_mark:
tabbed_browser.set_mark(key)
elif self._register_mode == usertypes.KeyMode.jump_mark:
tabbed_browser.jump_mark(key)
elif self._register_mode == usertypes.KeyMode.record_macro:
macros.macro_recorder.record_macro(key)
elif self._register_mode == usertypes.KeyMode.run_macro:
macros.macro_recorder.run_macro(self._win_id, key)
else:
raise ValueError("{} is not a valid register mode".format(
self._register_mode))
except cmdexc.Error as err:
message.error(str(err), stack=traceback.format_exc())
self.request_leave.emit(
self._register_mode, "valid register key", True)
return QKeySequence.ExactMatch
def event(key, text, modifiers, scancode=0):
ev = QKeyEvent(QKeyEvent.KeyPress, key, modifiers, text)
return {
"key": ev.key(),
"nativeScanCode": scancode,
"text": ev.text(),
"modifiers": ev.modifiers(),
}
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Delete:
min_row, max_row, start, end = self.selection_range()
if min_row == max_row == start == end == -1:
return
self.setEnabled(False)
self.setCursor(Qt.WaitCursor)
self.model().delete_range(min_row, max_row, start, end - 1)
self.unsetCursor()
self.setEnabled(True)
self.setFocus()
if event.matches(QKeySequence.Copy):
self.on_copy_action_triggered()
return
if event.key() == Qt.Key_Space:
min_row, max_row, start, _ = self.selection_range()
if start == -1:
return
self.model().insert_column(start, list(range(min_row, max_row + 1)))
if event.key() not in (Qt.Key_Right, Qt.Key_Left, Qt.Key_Up, Qt.Key_Down) \
or event.modifiers() == Qt.ShiftModifier:
super().keyPressEvent(event)
return
min_row, max_row, min_col, max_col = self.selection_range()
if min_row == max_row == min_col == max_col == -1:
super().keyPressEvent(event)
return
max_col -= 1
scroll_to_start = True
if event.key() == Qt.Key_Right and max_col < self.model().col_count - 1:
max_col += 1
min_col += 1
scroll_to_start = False
elif event.key() == Qt.Key_Left and min_col > 0:
min_col -= 1
max_col -= 1
elif event.key() == Qt.Key_Down and max_row < self.model().row_count - 1:
first_unhidden = -1
for row in range(max_row + 1, self.model().row_count):
if not self.isRowHidden(row):
first_unhidden = row
break
if first_unhidden != -1:
sel_len = max_row - min_row
max_row = first_unhidden
min_row = max_row - sel_len
scroll_to_start = False
elif event.key() == Qt.Key_Up and min_row > 0:
first_unhidden = -1
for row in range(min_row - 1, -1, -1):
if not self.isRowHidden(row):
first_unhidden = row
break
if first_unhidden != -1:
sel_len = max_row - min_row
min_row = first_unhidden
max_row = min_row + sel_len
start = self.model().index(min_row, min_col)
end = self.model().index(max_row, max_col)
selection = QItemSelection()
selection.select(start, end)
self.setCurrentIndex(start)
self.selectionModel().setCurrentIndex(end, QItemSelectionModel.ClearAndSelect)
self.selectionModel().select(selection, QItemSelectionModel.ClearAndSelect)
if scroll_to_start:
self.scrollTo(start)
else:
self.scrollTo(end)
