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 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: 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 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, 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() == 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: QKeyEvent) -> None: if event.key() in (Qt.Key_Return, Qt.Key_Enter): if self.state() == QAbstractItemView.EditingState: # if we are editing, inform base super(TreeView, self).keyPressEvent(event) else: self.onEnterEvent() else: # any other key was pressed, inform base super(TreeView, self).keyPressEvent(event)
def keyPressEvent(self, a0: QKeyEvent): if (a0.key() == QtCore.Qt.Key_Escape): self.stop() for Mod in self.Modules: Mod.__del__() super().keyPressEvent(a0) for Mod in self.Modules: Mod.keyPressEvent(a0) self.update()
def keyPressEvent(self, event: QKeyEvent): if type(event) == QKeyEvent: # here accept the event and do something if (event.key() == Qt.Key_W): print("w") runMotors("w") elif (event.key() == Qt.Key_A): runMotors("a") print("a") elif (event.key() == Qt.Key_S): runMotors("s") print("s") elif (event.key() == Qt.Key_D): runMotors("d") print("d") event.accept() else: event.ignore()
def keyReleaseEvent(self, event: QKeyEvent): if event.key() == Qt.Key_Shift: self.shift_mode = False self.shift_state_changed.emit(False) if self.hold_shift_to_drag: self.unsetCursor() self.grab_start = None else: self.setCursor(Qt.OpenHandCursor)
def keyPressEvent(self, e: QtGui.QKeyEvent) -> None: """ Replace tab inputs with spaces, if desired (for 'grammar' and 'transformer' mode only) """ if self.mode in ('grammar', 'transformer') and settings[ 'options.edit.tabs.replace'] and e.key() == QtCore.Qt.Key_Tab: self.insertPlainText( ' ' * settings['options.edit.tabs.replacement_spaces']) else: super().keyPressEvent(e)
def keyPressEvent(self, e: QKeyEvent) -> None: """ Fonction héritée de Qt qui permet de prendre en charge les évènements du type touche clavier. Args: e (PyQt5.QtGui.QKeyEvent): évènement de type touche de clavier """ if e.key() == Qt.Key_Escape: self.close()
def keyReleaseEvent(self, event0: QtGui.QKeyEvent) -> None: event0.accept() if event0.key() == Qt.Key_A: self._select_items_flag = False if self._temp_seed: compare_to_seed( self._image, self._circle_seed_items[self._current_item_index], self._temp_seed) self._temp_seed = None
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, ev: QKeyEvent): # Player 1 if ev.key() == QtCore.Qt.Key_Left: self.__engine.setSnakeDirection(0, Direction.Left) if ev.key() == QtCore.Qt.Key_Right: self.__engine.setSnakeDirection(0, Direction.Right) if ev.key() == QtCore.Qt.Key_Up: self.__engine.setSnakeDirection(0, Direction.Up) if ev.key() == QtCore.Qt.Key_Down: self.__engine.setSnakeDirection(0, Direction.Down) # Player 2 # if ev.key() == QtCore.Qt.Key_W: # self.__engine.setSnakeDirection(1, Direction.Up) # if ev.key() == QtCore.Qt.Key_A: # self.__engine.setSnakeDirection(1, Direction.Left) # if ev.key() == QtCore.Qt.Key_S: # self.__engine.setSnakeDirection(1, Direction.Down) # if ev.key() == QtCore.Qt.Key_D: # self.__engine.setSnakeDirection(1, Direction.Right) return super().keyPressEvent(ev)
def keyReleaseEvent(self, event0: QtGui.QKeyEvent) -> None: event0.accept() if event0.key() == Qt.Key_A: self._select_items_flag = False if self._temp_seed: compare_tow_seed_of_spectral_info( self._cv_image, self._circle_seeds_list[self._current_item_index], self._temp_seed) # self._selected_indexes = self._road_detection.validation_road_pixels_proportion(self._circle_seeds_list[self._current_item_index]) self._temp_seed = None
def keyPressEvent(self, event: QKeyEvent) -> None: """ Listen to the user's input """ # Enter is the key located in the keypad, usually denoted by the text "Intro" # Return is the big key we usually use to create a break in a sentence start = [Qt.Key_Return, Qt.Key_Enter] # Game can be played using Arrow keys and WASD directions = [ Qt.Key_Left, Qt.Key_A, Qt.Key_Right, Qt.Key_D, Qt.Key_Up, Qt.Key_W, Qt.Key_Down, Qt.Key_S ] # Starts a new game if not already playing if not self.playing and event.key() in start: self.startGame() # Change the Snake's movement direction if self.playing and event.key() in directions: self.snake.changeDirection(event.key())
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) -> None: """This event handler, for event event, can be reimplemented in a subclass to receive key press events for the widget. We add handling of 'Esc' and 'Q' to close the window. """ key = event.key() if key in (Qt.Key_Q, Qt.Key_Escape) and self._application is not None: self._application.quit() else: super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent) -> None: if event.key() in {Qt.Key_F, Qt.Key_Escape}: event.accept() if self.parent is None: self.originalParent.toggleFullscreen() else: self.parent.toggleFullscreen() elif self.isFullScreen(): self.originalParent.keyPressEvent(event) else: super(mpvWidget, self).keyPressEvent(event)
def keyPressEvent(self, event: QtGui.QKeyEvent) -> None: """ ctrl+shift+alt+F8 :param event: :return: """ if (event.modifiers() == Qt.ControlModifier | Qt.AltModifier | Qt.ShiftModifier) \ and (event.key() == Qt.Key_F8): if MIN_AFTER_SHOT: self.parentWidget().showMinimized() self.ui.pushButtonCapture.clicked.emit()
def keyReleaseEvent(self, a0: QKeyEvent): if a0.key() == Qt.Key_Return: c = self.ui.dsCostBt.value() self.ui.canvas.dang_state.dang_state.setCost(c) if self.selectedState is not None and self.selectedState.isClass( figures.IniStateFigure): p = self.ui.doubleSpinBox.value() self.selectedState.setProbability(p) self.ui.probLabel.setText('Вероятность') self.selectedState = None self.ui.canvas.update()
def keyPressEvent(self, event: QKeyEvent) -> None: if event.key() == Qt.Key_Return and self.input_open: text = self.toPlainText() line = text.split('\n')[-1] self.line.emit(line) cursor = self.textCursor() cursor.movePosition(QTextCursor.End) self.setTextCursor(cursor) QTextEdit.keyPressEvent(self, event) elif event.modifiers() == Qt.ControlModifier and event.key( ) == Qt.Key_C: if not self.textCursor().selectedText(): self.RaiseKeyboardInterrupt() else: self.copy() elif event.key() in [Qt.Key_Backspace, Qt.Key_Delete]: if self.textCursor().position() - 1 >= self.min_char: QTextEdit.keyPressEvent(self, event) else: QTextEdit.keyPressEvent(self, event)
def keyPressEvent(self, event: QtGui.QKeyEvent): code = event.key() if code in self._key_map: functions = self._key_map[code] if type(functions) == list: for func in functions: func() else: functions() else: log.info('key: code %i not mapped to any function' % code)
def eventFilter(self, obj, event: QtGui.QKeyEvent): if obj is not self.ui.recordsTableView: return False if event.type() != QtCore.QEvent.KeyPress: return False if event.key() == QtCore.Qt.Key_Delete: self._remove_selected_records() return True return False
def keyPressEvent(self, event: QtGui.QKeyEvent) -> None: row = self.images_list_widget.currentRow() last_index = self.images_list_widget.count() - 1 if event.key() == QtCore.Qt.Key_A: self.save_annotations() if row > 0: self.images_list_widget.setCurrentRow(row - 1) else: self.images_list_widget.setCurrentRow(last_index) if event.key() == QtCore.Qt.Key_D: self.save_annotations() if row < last_index: self.images_list_widget.setCurrentRow(row + 1) else: self.images_list_widget.setCurrentRow(0) if event.key() == QtCore.Qt.Key_W: self.viewer.selection_mode = SELECTION_MODE.POLYGON if event.key() == QtCore.Qt.Key_S: self.viewer.selection_mode = SELECTION_MODE.BOX super(ImageViewerWidget, self).keyPressEvent(event)
def __init__(self, key_event: QtGui.QKeyEvent): if key_event is None: self.key = None self.char = '' self.count = 0 self.modifiers = QtCore.Qt.NoModifier else: self.key = key_event.key() self.char = key_event.text() self.count = key_event.count() self.modifiers = key_event.modifiers()
def from_event(cls, e: QKeyEvent) -> 'KeyInfo': """Get a KeyInfo object from a QKeyEvent. This makes sure that key/modifiers are never mixed and also remaps UTF-16 surrogates to work around QTBUG-72776. """ key = _remap_unicode(Qt.Key(e.key()), e.text()) modifiers = e.modifiers() _assert_plain_key(key) _assert_plain_modifier(modifiers) return cls(key, modifiers)
def keyPressEvent(self, e: QKeyEvent): # if len(self.tanks) == 0: return key = e.key() if key == Qt.Key_Escape: self.paused = (self.paused + 1) % 2 if self.paused: self.stop_game() return else: self.start_game() self.do_for_every_player(partial(self.treat_key, key))
def keyPressEvent(self, event: QtGui.QKeyEvent): current_level = self.current_level if not current_level: return if event.key() == 0x41: # A current_level.left = True current_level.right = False elif event.key() == 0x44: # D current_level.right = True current_level.left = False elif event.key() == 0x20: # Space current_level.shoot(self.penetrate) elif event.key() == 0x01000020: # Shift self.penetrate = True elif event.key() == 0x01000000: # Esc if self.paused: self.game.resume() else: self.game.pause() self.paused = not self.paused
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>", } 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() == Qt.Key_Colon: # Required as : is the separator return ("<colon>",) if event.text().isprintable(): return (event.text(),) return (QKeySequence(event.key()).toString().lower(),)
def keyPressEvent(self, event: QKeyEvent): key = event.key() if key == Qt.Key_Up: self.translateVerticalEvent(-100) elif key == Qt.Key_Down: self.translateVerticalEvent(100) elif key == Qt.Key_Left: self.translateHorizontalEvent(-100) elif key == Qt.Key_Right: self.translateHorizontalEvent(100) else: super().keyPressEvent(event)
def keyPressEvent(self, ke: QtGui.QKeyEvent): key = ke.key() if key == QtCore.Qt.Key_Left or key == QtCore.Qt.Key_Q: self.prev_frame() elif key == QtCore.Qt.Key_Right or key == QtCore.Qt.Key_E: self.next_frame() elif key == QtCore.Qt.Key_Delete or key == QtCore.Qt.Key_D: idx = self.ui.listWidget.currentRow() if idx is not None and len(self.tag_list[self.current_frame]): self.tag_list[self.current_frame].pop(idx) self.update_list()
def keyPressEvent(self, event: QKeyEvent): if event.key() == Qt.Key_Shift: self.shift_mode = True self.shift_state_changed.emit(True) if self.hold_shift_to_drag: self.setCursor(Qt.OpenHandCursor) else: self.unsetCursor() self.grab_start = None super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent) -> None: """Overriden method. Args: event (QKeyEvent): [description]""" if event.key() in (Qt.Key_Enter, Qt.Key_Return): self.control_window.Callbacks.send_command( command=self.toPlainText(), stocker=self.control_window.stocker, log_scroll_area=self.control_window.log_scroll_area) self.setText("") super().keyPressEvent(event)
def keyPressEvent(self, event: QKeyEvent) -> None: """Debug-related keyboard controls.""" if self.DEBUG: if event.key() == Qt.Key_Escape: possible_plants = [plant for i, plant in enumerate(self.PLANTS) if self.plant_checkboxes[i].isChecked()] if len(possible_plants) != 0: self.plant = choice(possible_plants)() self.canvas.set_drawable(self.plant) self.plant.set_max_age(1) self.plant.set_age(1) self.canvas.update()
def onKeyPress(self, event: QKeyEvent): try: event = dict(event="gui", type="keyPress", key=event.key(), modifiers=event.modifiers(), nativeModifiers=event.nativeModifiers(), nativeScanCode=event.nativeScanCode(), nativeVirtualKey=event.nativeVirtualKey()) except Exception as err: print(f"HCApplication.keyPressEvent error: {err}") self.submitEvent(event, EventMode.Gui)
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, 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): """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 cflagsListKeyPressed(self, event: QKeyEvent): key = event.key() if key == Qt.Key_Return or key == Qt.Key_Enter: self.cFlagAddClicked(False)
def keyReleaseEvent(self, e: QKeyEvent): self._handleEvent(Event(evType=Event.Type.KeyReleased, key=e.key()))
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_F: self.scene().views()[0].zoomToFit()
def keyPressEvent(self, event: QKeyEvent): """ Args: event: Description """ self.prexoveritem_manager.handlePreXoverKeyPress(event.key())
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)