def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Delete:
# Delete selected rows
rows = [i.row() for i in self.selectedIndexes()]
for row in sorted(rows, reverse=True):
self.model().remove_label_at(row)
else:
event.accept()
def keyReleaseEvent(self, event : QKeyEvent):
if event.key() == 0x01000013:
self.keyboard_state['North'] = False
elif event.key() == 0x01000015:
self.keyboard_state['South'] = False
elif event.key() == 0x01000012:
self.keyboard_state['West'] = False
elif event.key() == 0x01000014:
self.keyboard_state['East'] = False
def keyPressEvent(self, event: QKeyEvent):
if event.key() == 0x01000013:
self.keyboard_state['North'] = True
elif event.key() == 0x01000015:
self.keyboard_state['South'] = True
elif event.key() == 0x01000012:
self.keyboard_state['West'] = True
elif event.key() == 0x01000014:
self.keyboard_state['East'] = True
def keyPressEvent(self, event: QKeyEvent):
if self.window().is_dirty() \
and (event.matches(QKeySequence.MoveToNextLine) or event.matches(QKeySequence.MoveToPreviousLine)):
veto = self.window().central_widget.promptToSave()
if not veto:
QTreeWidget.keyPressEvent(self, event)
else:
event.ignore()
else:
QTreeWidget.keyPressEvent(self, 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 keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
if event.text() or event.key() in (Qt.Key_Left, Qt.Key_Right):
QtWidgets.QLineEdit.keyPressEvent(self, event)
self.reset_ac_suggestions.emit()
self.reset_history_travel.emit()
elif event.key() == Qt.Key_Up:
self.history_up.emit()
elif event.key() == Qt.Key_Down:
self.history_down.emit()
else:
return super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent):
"""
Handle key presses for mouse-drag transforms and arrow-key panning.
"""
if not self._has_focus: # we don't have focus -> ignore keypress
return
if event.key() == self._key_mod:
self._transform_enable = True
QGraphicsView.keyPressEvent(self, event)
elif event.key() == Qt.Key_Left:
transform = self.scene_root_item.transform()
transform.translate(self.keyPanDeltaX(), 0)
self.scene_root_item.setTransform(transform)
elif event.key() == Qt.Key_Up:
transform = self.scene_root_item.transform()
transform.translate(0, self.keyPanDeltaY())
self.scene_root_item.setTransform(transform)
elif event.key() == Qt.Key_Right:
transform = self.scene_root_item.transform()
transform.translate(-self.keyPanDeltaX(), 0)
self.scene_root_item.setTransform(transform)
elif event.key() == Qt.Key_Down:
transform = self.scene_root_item.transform()
transform.translate(0, -self.keyPanDeltaY())
self.scene_root_item.setTransform(transform)
elif event.key() == Qt.Key_Plus:
self.zoomIn(0.3)
elif event.key() == Qt.Key_Minus:
self.zoomIn(0.03)
elif event.key() == Qt.Key_Escape:
QGraphicsView.keyPressEvent(self, event)
else:
if hasattr(self.scene_root_item, KEY_PRESS_EVENT):
getattr(self.scene_root_item, KEY_PRESS_EVENT)(event)
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_F:
self.scene().views()[0].zoomToFit()
for na_part_item in self.instance_items.values():
if hasattr(na_part_item, 'keyPressEvent'):
getattr(na_part_item, 'keyPressEvent')(event)
def keyPressEvent(self, event: QKeyEvent):
if event.key() in (Qt.Key_Enter, Qt.Key_Return):
selected = [index.row() for index in self.selectedIndexes()]
if len(selected) > 0:
self.edit_on_item_triggered.emit(min(selected))
else:
super().keyPressEvent(event)
def keyReleaseEvent(self, event: QKeyEvent):
if event.key() == self._key_mod:
self._transform_enable = False
self._dolly_zoom_enable = False
self._panDisable()
else:
if hasattr(self.scene_root_item, KEY_RELEASE_EVENT):
getattr(self.scene_root_item, KEY_RELEASE_EVENT)(event)
def keyPressEvent(self, event):
key = event.key()
cursor = self.textCursor()
if event.text() and self.tableModeEnabled:
cursor.beginEditBlock()
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.getMarkupClass()
if markupClass and markupClass == MarkdownMarkup:
cursor.insertText(' ')
if event.modifiers() & Qt.ControlModifier:
cursor.insertText('\n')
else:
self.handleReturn(cursor)
else:
QTextEdit.keyPressEvent(self, event)
if event.text() and self.tableModeEnabled:
cursor.endEditBlock()
def keyPressEvent(self, event: QKeyEvent):
"""Must intercept invalid input events. Make changes here
"""
a = event.key()
text = event.text()
if a in [Qt.Key_Space, Qt.Key_Tab]:
return
elif a in [Qt.Key_Escape]:
self.updateLabel()
self.focusOut()
return
elif a in [Qt.Key_Return, Qt.Key_Enter]:
self.inputMethodEvent(event)
return
elif text.isalpha():
return
else:
return QGraphicsTextItem.keyPressEvent(self, event)
def keyPressEvent(self, event: QKeyEvent):
"""event.key() seems to be capital only?
Args:
event (TYPE): Description
"""
# print("press", ord('g'))
if event.text() == 'g':
print("hey het")
return QGraphicsItem.keyPressEvent(self, event)
def keyReleaseEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Shift:
self.shift_mode = False
if self.hold_shift_to_drag:
self.unsetCursor()
self.grab_start = None
else:
self.setCursor(Qt.OpenHandCursor)
super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent):
"""Must intercept invalid input events. Make changes here
Args:
event: Description
"""
a = event.key()
if a in [Qt.Key_Control, Qt.Key_Left, Qt.Key_Right, Qt.Key_Up, Qt.Key_Down]:
QGraphicsObject.keyPressEvent(self, event)
else:
self.deactivate()
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Escape:
self.next_form = Exit(self)
selected = self.tableWidget.selectedItems()
if selected:
if event.key() == Qt.Key_Control:
for cell in selected:
cell.setBackground(QBrush(Qt.white))
cell.setForeground(QBrush(Qt.black))
self.tableWidget.clearSelection()
elif event.key() == Qt.Key_Shift:
color = QColorDialog.getColor()
if color.isValid():
for cell in selected:
cell.setBackground(QBrush(color))
self.tableWidget.clearSelection()
elif event.key() == Qt.Key_Alt:
color = QColorDialog.getColor()
if color.isValid():
for cell in selected:
cell.setForeground(QBrush(color))
self.tableWidget.clearSelection()
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Delete:
selected = self.selectionModel().selection()
""":type: QtGui.QItemSelection """
if selected.isEmpty():
return
min_row = numpy.min([rng.top() for rng in selected])
max_row = numpy.max([rng.bottom() for rng in selected])
self.deletion_wanted.emit(min_row, max_row)
else:
super().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()
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: QKeyEvent):
"""
Must intercept invalid input events. Make changes here
Args:
event (TYPE): Description
"""
key = event.key()
if key in [Qt.Key_Backspace, Qt.Key_Delete]:
self.selectionbox.deleteSelection()
self.clearSelection(False)
return QGraphicsItemGroup.keyPressEvent(self, event)
else:
return QGraphicsItemGroup.keyPressEvent(self, event)
def keyPressEvent(self, event: QtGui.QKeyEvent):
key = event.key()
if key == 16777220: # QtCore.Qt.Key_Enter
logging.debug('{}: keyPressEvent, event.key: {}, meaning: {}, history: {}'.format(
self.tag, key, 'enter', self.history))
text = self.text()
self.history = list(
filter(lambda x: x.lower() != text.lower(), self.history))
self.history.append(text)
len_history = len(self.history)
retain_index = len_history - self.retain_num if len_history > self.retain_num else 0
self.history = self.history[retain_index:]
self.current_index = -1
elif key == 16777235: # QtCore.Qt.Key_Up
logging.debug(
'{}: keyPressEvent, event.key: {}, meaning: {}, history: {}, current_index: {}'.format(
self.tag, key, 'up', self.history, self.current_index))
if len(self.history) == 0:
return
if self.current_index == -1:
self.retain_text = self.text()
self.current_index = len(self.history) - 1
self.setText(self.history[self.current_index])
elif self.current_index > 0:
self.current_index -= 1
self.setText(self.history[self.current_index])
elif self.current_index == 0:
self.current_index = -1
self.setText(self.retain_text)
return
elif key == 16777237: # QtCore.Qt.Key_Down
logging.debug(
'{}: keyPressEvent, event.key: {}, meaning: {}, history: {}, current_index: {}'.format(
self.tag, key, 'down', self.history, self.current_index))
if len(self.history) == 0:
return
if self.current_index == -1:
self.retain_text = self.text()
self.current_index = 0
self.setText(self.history[self.current_index])
elif self.current_index < len(self.history) - 1:
self.current_index += 1
self.setText(self.history[self.current_index])
elif self.current_index == len(self.history) - 1:
self.current_index = -1
self.setText(self.retain_text)
return
else:
self.current_index = -1
return QtWidgets.QLineEdit.keyPressEvent(self, event)
def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
if event.key() == QtCore.Qt.Key_Delete:
team_id, name, _ = tuple(
map(lambda item: item.text(), self.table.selectedItems()))
result = QtWidgets.QMessageBox.question(
self,
'Подтверждение удаления команды',
f'Вы действительно хотите удалить команду "{name}"?',
buttons=QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
if result == QtWidgets.QMessageBox.Yes:
self.cur.execute('DELETE FROM team WHERE team_id = ?',
(team_id, ))
self.db_connection.commit()
self.get_data()
def keyReleaseEvent(self, event: QKeyEvent) -> None:
modifier = QApplication.keyboardModifiers()
if modifier == Qt.ControlModifier:
if event.key() in (Qt.Key_D, 1042):
self.copy_self()
self.widget_manager.manager.update_core()
elif event.key() in (Qt.Key_B, 1048):
self.on_back()
self.widget_manager.manager.update_core()
elif event.key() in (Qt.Key_N, 1058):
w = self.widget_manager.add_widget(
self.widget_manager.manager.mouse_manager.get_mouse_pos())
self.update()
self.widget_manager.clear_focus()
w.setFocus()
w.show_angles()
self.widget_manager.manager.update_core()
elif modifier == Qt.ShiftModifier:
if event.key() == Qt.Key_Delete:
self.del_self()
self.widget_manager.manager.update_core()
def keyPressEvent(self, a0: QtGui.QKeyEvent) -> None:
key_e = a0.key()
_dir = None
if key_e == Qt.Key_Up or key_e == Qt.Key_W:
_dir = CPara.dir_up
elif key_e == Qt.Key_Down or key_e == Qt.Key_S:
_dir = CPara.dir_down
elif key_e == Qt.Key_Left or key_e == Qt.Key_A:
_dir = CPara.dir_left
elif key_e == Qt.Key_Right or key_e == Qt.Key_D:
_dir = CPara.dir_right
else:
return
self.re_build_array(_dir)
def keyPressEvent(self, event: QKeyEvent):
"""Must intercept invalid input events. Make changes here
Args:
event: Description
"""
a = event.key()
if a in [
Qt.Key_Control, Qt.Key_Left, Qt.Key_Right, Qt.Key_Up,
Qt.Key_Down
]:
QGraphicsObject.keyPressEvent(self, event)
else:
self.deactivate()
def openFile(self):
files, _ = QFileDialog.getOpenFileName(self, "Select file", "",
"Text Files(*.txt)")
if files == '':
return None
if not self.controller.check('defaulter_files', files):
if self.empty_flag:
self.setStat(files)
self.controller.setValue('reusable_titles', self.title)
self.controller.setValue('defaulter_files', files)
else:
self.controller.addWindow(files)
self.keyReleaseEvent(
QKeyEvent(QEvent.KeyPress, Qt.Key_Control, Qt.NoModifier, 0, 0, 0))
def keyPressEvent(self, event: QKeyEvent) -> None:
"""Process key events. The :py:class:`QImageView` supports
the following keys:
space: toggle tool tips
r: toggle the keepAspectRatio flag
"""
key = event.key()
if key == Qt.Key_C: # Toggle code widget
codeWidget = self._button2
codeWidget.setVisible(not codeWidget.isVisible())
else:
super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent) -> None:
if self.mediaPlayer.isVideoAvailable(
) or self.mediaPlayer.isAudioAvailable():
addtime = 0
if event.key() == Qt.Key_Left:
addtime = -1000
elif event.key() == Qt.Key_PageUp or event.key() == Qt.Key_Up:
addtime = -10000
elif event.key() == Qt.Key_Right:
addtime = 1000
elif event.key() == Qt.Key_PageDown or event.key() == Qt.Key_Down:
addtime = 10000
elif event.key() == Qt.Key_Enter:
self.toggleFullscreen()
elif event.key(
) == Qt.Key_Escape and self.videoWidget.isFullScreen():
self.videoWidget.setFullScreen(False)
if addtime != 0:
newval = self.seekSlider.value() + addtime
self.seekSlider.setValue(newval)
self.seekSlider.setSliderPosition(newval)
self.mediaPlayer.setPosition(newval)
event.accept()
def eventFilter(self, editor, event):
# check some key presses
if event.type() == QEvent.KeyPress:
# if we pressed return and aren't at the last column send a tab
# if event.key() == Qt.Key_Return and not self.lastcolumn:
# event.accept()
# event = QKeyEvent(QEvent.KeyPress, Qt.Key_Tab, Qt.NoModifier)
# if we pressed tab and are in the last column send a return
if event.key() == Qt.Key_Tab and self.lastcolumn:
event.accept()
event = QKeyEvent(QEvent.KeyPress, Qt.Key_Return,
Qt.NoModifier)
# just pass the event up
return QItemDelegate.eventFilter(self, editor, event)
def keyPressEvent(self, evt: QKeyEvent):
"""
Ignore escape key event, because it would close startup window.
Any other key will be passed to the super class key event handler for further
processing.
:param evt: key event
:return:
"""
if evt.key() == QtCore.Qt.Key_Escape:
self.close()
else:
super().keyPressEvent(evt)
pass
def keyPressEvent(self, event: QKeyEvent):
"""
Must intercept invalid input events. Make changes here
Args:
event (TYPE): Description
"""
key = event.key()
if key in [Qt.Key_Backspace, Qt.Key_Delete]:
self.selectionbox.deleteSelection()
self.clearSelection(False)
return QGraphicsItemGroup.keyPressEvent(self, event)
else:
return QGraphicsItemGroup.keyPressEvent(self, event)
def keyPressEvent(self, event: QKeyEvent):
"""
Keypress event
This allows capture widget escape to close, return or enter to capture
:param event: QKeyEvent instance
:type event: QKeyEvent
"""
if event.key() == Qt.Key.Key_Escape:
self.close()
if event.key() in [Qt.Key.Key_Return, Qt.Key.Key_Enter]:
if self._startpos is None or self._endpos is None:
return
screen = QApplication.screenAt(self._startpos)
ratio = screen.devicePixelRatio()
cropped = self.screenshot.copy(
QRect(
int(self._startpos.x() * ratio),
int(self._startpos.y() * ratio),
int((self._endpos.x() - self._startpos.x()) * ratio),
int((self._endpos.y() - self._startpos.y()) * ratio),
))
# noinspection PyUnresolvedReferences
self.captured.emit(cropped)
def keyPressEvent(self, a0: QtGui.QKeyEvent) -> None:
key = a0.key()
if key == QtCore.Qt.Key_Escape:
self.clearFocus()
elif key == QtCore.Qt.Key_Up:
return super().keyPressEvent(
QtGui.QKeyEvent(QtCore.QEvent.KeyPress, QtCore.Qt.Key_Tab,
QtCore.Qt.KeyboardModifier.ShiftModifier))
elif key == QtCore.Qt.Key_Down:
return super().keyPressEvent(
QtGui.QKeyEvent(QtCore.QEvent.KeyPress, QtCore.Qt.Key_Tab,
QtCore.Qt.KeyboardModifier.NoModifier))
else:
return super().keyPressEvent(a0)
def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
if event.key() == QtCore.Qt.Key_Delete:
item, = self.table.selectedItems()
if hasattr(item, 'id'):
name = item.text(1)
resp = QtWidgets.QMessageBox.warning(
self, 'Подтверждение удаления судьи',
'Вы действительно желаете удалить судью {}?'.format(name),
QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
if resp == QtWidgets.QMessageBox.Yes:
self.cur.execute('DELETE FROM judge WHERE judge_id = ?',
(item.id, ))
self.db_connection.commit()
self.refresh()
def toDoOnClick(self):
"""
When the user Left-Mouse-Click on the Image
Delegate the Click on the Image as a SPACE key press to up.
This event can be caught it in the higher level Widget as a SPACE key press
(for example in CardHolder)
I could have made a direct selection in the media_collector/media_storage
using the toDoOnClick() method, but I do not do this because in that case
I could not have the index of the selected Card
"""
event = QKeyEvent(QEvent.KeyPress, Qt.Key_Space, Qt.NoModifier, str(self.media.getIndex()))
QCoreApplication.postEvent(self, event)
def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
global p, q, Xangle, Yangle, Zangle
key = event.key()
mod = event.modifiers()
if key == Qt.Key_P and mod != Qt.ShiftModifier and p < 50:
p += 1
self.update()
elif key == Qt.Key_P and mod == Qt.ShiftModifier and p > 6:
p -= 1
self.update()
elif key == Qt.Key_Q and mod != Qt.ShiftModifier and q < 50:
q += 1
self.update()
elif key == Qt.Key_Q and mod == Qt.ShiftModifier and q > 4:
q -= 1
self.update()
elif key == Qt.Key_X:
if mod != Qt.ShiftModifier:
Xangle += 5.0
else:
Xangle -= 5.0
Xangle %= 360
self.update()
elif key == Qt.Key_Y:
if mod != Qt.ShiftModifier:
Yangle += 5.0
else:
Yangle -= 5.0
Yangle %= 360
self.update()
elif key == Qt.Key_Z:
if mod != Qt.ShiftModifier:
Zangle += 5.0
else:
Zangle -= 5.0
Zangle %= 360
self.update()
def generate_input_event(window_id, key_code, modifiers, low_level_data, x, y):
"""
The Lisp core tells us to generate this key event.
- window_id: str
- key_code: int
- modifiers: [str]
- low_level_data: key code from Qt (int).
- x, y: float
"""
modifiers_flag = create_modifiers_flag(modifiers)
logging.info("generate input, window: {} code: {}, modifiers {}, low_level_data {}".format(
window_id, key_code, modifiers, low_level_data))
# Scan Code set to very high value not in system to distinguish
# it as an artifical key press, this avoids infinite propagation
# of key presses when it is caught by the event filter
text = None
if x == -1:
# Key event.
if (low_level_data not in SPECIAL_KEYS):
text = chr(low_level_data)
event = QKeyEvent(QEvent.KeyPress, key_code, modifiers_flag,
10000, 10000, 10000, text=text)
receiver = window.get_window(window_id).buffer.focusProxy()
QCoreApplication.sendEvent(receiver, event)
else:
# TODO: Mouse event.
# mouse_event = QMouseEvent()
point = QPoint(x, y)
button = Qt.LeftButton
event = QMouseEvent(QEvent.MouseButtonPress, point, button, button, modifiers_flag)
event.is_generated = True
receiver = window.get_window(window_id).buffer.focusProxy()
logging.info("generate button event: button{}, modifiers {}".format(button, modifiers))
QCoreApplication.sendEvent(receiver, event)
def keyPressEvent(self, event: QKeyEvent) -> None:
if event.key() == Qt.Key_Escape and self.isFullScreen():
self.setFullScreen(False)
event.accept()
elif event.key() == Qt.Key_Enter:
self.setFullScreen(not self.isFullScreen())
event.accept()
else:
super(VideoWidget, self).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)
elif cursor.selectedText() and self.isSurroundKey(key):
self.surroundText(cursor, event, key)
else:
if event.text() and self.tableModeEnabled:
cursor.beginEditBlock()
QTextEdit.keyPressEvent(self, event)
if event.text() and self.tableModeEnabled:
cursor.endEditBlock()
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 keyReleaseEvent(self, event: QtGui.QKeyEvent):
if event.key() == Qt.Key_Shift:
self.waterbox_renderer.shift_is_pressed = False
if event.key() == Qt.Key_W:
self.waterbox_renderer.MOVE_FORWARD = 0
elif event.key() == Qt.Key_S:
self.waterbox_renderer.MOVE_BACKWARD = 0
elif event.key() == Qt.Key_A:
self.waterbox_renderer.MOVE_LEFT = 0
elif event.key() == Qt.Key_D:
self.waterbox_renderer.MOVE_RIGHT = 0
elif event.key() == Qt.Key_Q:
self.waterbox_renderer.MOVE_UP = 0
elif event.key() == Qt.Key_E:
self.waterbox_renderer.MOVE_DOWN = 0
elif event.key() == Qt.Key_R:
self.waterbox_renderer.ROTATE_LEFT = 0
elif event.key() == Qt.Key_T:
self.waterbox_renderer.ROTATE_RIGHT = 0
def keyPressEvent(self, a0: QtGui.QKeyEvent) -> None:
if a0.type() == QtCore.QEvent.KeyPress:
if a0.key() == QtCore.Qt.Key_Up and self.nextFrequency != -1:
a0.accept()
self.setText(str(self.nextFrequency))
self.editingFinished.emit() # self.text())
return
if a0.key() == QtCore.Qt.Key_Down and self.previousFrequency != -1:
a0.accept()
self.setText(str(self.previousFrequency))
self.editingFinished.emit() # self.text())
return
super().keyPressEvent(a0)
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, e: QtGui.QKeyEvent) -> None:
if self.is_locked:
return
key = e.key()
mod = e.modifiers()
if key == Qt.Key_Backspace:
if mod == Qt.NoModifier and \
self.textCursor().positionInBlock() > len(self.prompt):
super().keyPressEvent(e)
if key == Qt.Key_Return and mod == Qt.NoModifier:
self.on_enter()
if key == Qt.Key_Up and mod == Qt.NoModifier:
self.back_history()
if key == Qt.Key_Down and mod == Qt.NoModifier:
self.forward_history()
if 32 <= key <= 121 and \
(mod == Qt.NoModifier or mod == Qt.ShiftModifier):
super().keyPressEvent(e)
def keyReleaseEvent(self, event: QKeyEvent):
control = event.modifiers() & Qt.ControlModifier
if control:
if event.key() == Qt.Key_C:
active_widget = self.pane_edit.currentWidget()
if hasattr(active_widget, 'process_copy_event'):
active_widget.process_copy_event()
else:
print("widget has no attribute 'process_copy_event'")
if event.key() == Qt.Key_V:
active_widget = self.pane_edit.currentWidget()
if hasattr(active_widget, 'process_paste_event'):
active_widget.process_paste_event()
else:
print("widget has no attribute 'process_paste_event'")
if event.key() == Qt.Key_Delete:
active_widget = self.pane_edit.currentWidget()
if hasattr(active_widget, 'delete_selection'):
active_widget.delete_selection()
else:
print("widget has no attribute 'delete_selection'")
def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
key = event.key()
if key == Qt.Key_PageUp:
self.map_params.up_zoom()
elif key == Qt.Key_PageDown:
self.map_params.down_zoom()
elif key == Qt.Key_Up:
self.map_params.up()
elif key == Qt.Key_Down:
self.map_params.down()
elif key == Qt.Key_Left:
self.map_params.left()
elif key == Qt.Key_Right:
self.map_params.right()
self.show_map()
def event(self, event):
if (event.type() == QEvent.KeyPress) and (event.key() == Qt.Key_Tab):
if self.completionType == QCompleter.InlineCompletion:
eventTab = QKeyEvent(QEvent.KeyPress, Qt.Key_End,
Qt.NoModifier)
super(LineEditTabCompleter, self).event(eventTab)
else:
completion = self.completer.currentCompletion()
if os.path.isdir(completion):
completion += os.path.sep
self.selectAll()
self.insert(completion)
self.completer.popup().hide()
return True
return super(LineEditTabCompleter, self).event(event)
def _get_base_keysequence(event: QKeyEvent) -> SequenceT:
"""Get main keyname part of QKeyEvent.
Converts special keys to usable names and uses event.text() otherwise. Is a sequence
to allow prepending <shift> to special keys.
Args:
event: The emitted QKeyEvent.
Returns:
Name of the main key press escaping special keys.
"""
special_keys = {
Qt.Key_Space: "<space>",
Qt.Key_Backtab: "<tab>",
Qt.Key_Tab: "<tab>",
Qt.Key_Escape: "<escape>",
Qt.Key_Enter: "<enter>",
Qt.Key_Return: "<return>",
Qt.Key_Backspace: "<backspace>",
Qt.Key_Left: "<left>",
Qt.Key_Right: "<right>",
Qt.Key_Up: "<up>",
Qt.Key_Down: "<down>",
Qt.Key_Home: "<home>",
Qt.Key_End: "<end>",
Qt.Key_PageUp: "<page-up>",
Qt.Key_PageDown: "<page-down>",
Qt.Key_Home: "<home>",
Qt.Key_End: "<end>",
}
separator_keys = {
Qt.Key_Colon: "<colon>",
Qt.Key_Equal: "<equal>",
}
if event.key() in special_keys:
# Parse shift here as the key does not support it otherwise
text = special_keys[event.key()] # type: ignore
if event.modifiers() & Qt.ShiftModifier: # type: ignore
return "<shift>", text
return (text, )
if event.key(
) in separator_keys: # Required as configparser crashes otherwise
return (separator_keys[event.key()], ) # type: ignore
if event.text().isprintable():
return (event.text(), )
return (QKeySequence(event.key()).toString().lower(), )
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_F:
self.scene().views()[0].zoomToFit()
def keyPressEvent(self, event: QKeyEvent):
"""
Args:
event: Description
"""
self.prexoveritem_manager.handlePreXoverKeyPress(event.key())
def keyReleaseEvent(self, e: QKeyEvent):
self._handleEvent(Event(evType=Event.Type.KeyReleased,
key=e.key()))
def cflagsListKeyPressed(self, event: QKeyEvent):
key = event.key()
if key == Qt.Key_Return or key == Qt.Key_Enter:
self.cFlagAddClicked(False)
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return:
return
else:
super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Enter:
event.ignore()
else:
event.accept()
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)
