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): """ 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)