Python源码示例：PyQt5.QtCore.Qt.Key_Up()
示例1
def keyPressEvent(self, event):
if not self.isStarted or BOARD_DATA.currentShape == Shape.shapeNone:
super(Tetris, self).keyPressEvent(event)
return
key = event.key()
if key == Qt.Key_P:
self.pause()
return
if self.isPaused:
return
elif key == Qt.Key_Left:
BOARD_DATA.moveLeft()
elif key == Qt.Key_Right:
BOARD_DATA.moveRight()
elif key == Qt.Key_Up:
BOARD_DATA.rotateLeft()
elif key == Qt.Key_Space:
self.tboard.score += BOARD_DATA.dropDown()
else:
super(Tetris, self).keyPressEvent(event)
self.updateWindow()
示例2
def keyPressEvent(self, event: QKeyEvent) -> None:
if self.isReadOnly():
return
block: QTextBlock = self.textCursor().block()
if event.key() in [Qt.Key_Down, Qt.Key_Up, Qt.Key_Left, Qt.Key_Right]:
return
if not event.key() == 16777220:
super().keyPressEvent(event)
if not isinstance(self.ignoreLength, bool):
textToWrite: str = block.text()[self.ignoreLength:]
# TODO: Handle multiline input!!!
if event.key() == 16777220:
self.userInputSignal.emit(textToWrite)
return
示例3
def filterKeyPressInHostsTableView(self, key, receiver):
if not receiver.selectionModel().selectedRows():
return True
index = receiver.selectionModel().selectedRows()[0].row()
if key == Qt.Key_Down:
new_index = index + 1
receiver.selectRow(new_index)
receiver.clicked.emit(receiver.selectionModel().selectedRows()[0])
elif key == Qt.Key_Up:
new_index = index - 1
receiver.selectRow(new_index)
receiver.clicked.emit(receiver.selectionModel().selectedRows()[0])
elif QApplication.keyboardModifiers() == Qt.ControlModifier and key == Qt.Key_C:
selected = receiver.selectionModel().currentIndex()
clipboard = QApplication.clipboard()
clipboard.setText(selected.data().toString())
return True
示例4
def keyPressEvent(self, event):
"""Reimplemented."""
# Override the default QComboBox behavior
if event.key() == Qt.Key_Down and event.modifiers() & Qt.AltModifier:
self.showPopup()
return
ignored = {Qt.Key_Up, Qt.Key_Down,
Qt.Key_PageDown, Qt.Key_PageUp,
Qt.Key_Home, Qt.Key_End}
if event.key() in ignored:
event.ignore()
return
super(CheckComboBox, self).keyPressEvent(event)
示例5
def up(self, count=1):
self._key_press(Qt.Key_Up, count, 'scrollBarMinimum', Qt.Vertical)
示例6
def keyPressEvent(self, e):
"""Override keyPressEvent to handle special keypresses."""
if e.key() == Qt.Key_Up:
self.history_prev()
e.accept()
elif e.key() == Qt.Key_Down:
self.history_next()
e.accept()
elif e.modifiers() & Qt.ControlModifier and e.key() == Qt.Key_C:
self.setText('')
e.accept()
else:
super().keyPressEvent(e)
示例7
def keyPressEvent(self, event):
if not self.is_started or self.inner_board.current_tetris == tetrisShape().shape_empty:
super(TetrisGame, self).keyPressEvent(event)
return
key = event.key()
# P键暂停
if key == Qt.Key_P:
self.pause()
return
if self.is_paused:
return
# 向左
elif key == Qt.Key_Left:
self.inner_board.moveLeft()
# 向右
elif key == Qt.Key_Right:
self.inner_board.moveRight()
# 旋转
elif key == Qt.Key_Up:
self.inner_board.rotateAnticlockwise()
# 快速坠落
elif key == Qt.Key_Space:
self.external_board.score += self.inner_board.dropDown()
else:
super(TetrisGame, self).keyPressEvent(event)
self.updateWindow()
示例8
def eventFilter(self, obj, event):
if obj == self.edtCommand:
if event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Up:
self.prev_command()
return True
elif event.key() == Qt.Key_Down:
self.next_command()
return True
return False
else:
return super().eventFilter(obj, event)
示例9
def _qtKeyToUMKey(self, key):
if key == Qt.Key_Shift:
return KeyEvent.ShiftKey
elif key == Qt.Key_Control:
return KeyEvent.ControlKey
elif key == Qt.Key_Alt:
return KeyEvent.AltKey
elif key == Qt.Key_Space:
return KeyEvent.SpaceKey
elif key == Qt.Key_Meta:
return KeyEvent.MetaKey
elif key == Qt.Key_Enter or key == Qt.Key_Return:
return KeyEvent.EnterKey
elif key == Qt.Key_Up:
return KeyEvent.UpKey
elif key == Qt.Key_Down:
return KeyEvent.DownKey
elif key == Qt.Key_Left:
return KeyEvent.LeftKey
elif key == Qt.Key_Right:
return KeyEvent.RightKey
elif key == Qt.Key_Minus:
return KeyEvent.MinusKey
elif key == Qt.Key_Underscore:
return KeyEvent.UnderscoreKey
elif key == Qt.Key_Plus:
return KeyEvent.PlusKey
elif key == Qt.Key_Equal:
return KeyEvent.EqualKey
return key
示例10
def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
key_press = event.key()
# if key_press == Qt.Key_Up:
# self.snake.direction = 'u'
# elif key_press == Qt.Key_Down:
# self.snake.direction = 'd'
# elif key_press == Qt.Key_Right:
# self.snake.direction = 'r'
# elif key_press == Qt.Key_Left:
# self.snake.direction = 'l'
示例11
def __init__(self, ui):
super().__init__(ui)
self.rois = [
ROIWorm(
self.ui.wormCanvas1,
self.ui.comboBox_ROI1,
self.ui.checkBox_ROI1
),
ROIWorm(
self.ui.wormCanvas2,
self.ui.comboBox_ROI2,
self.ui.checkBox_ROI2
)
]
self.ui.radioButton_ROI1.setShortcut(QKeySequence(Qt.Key_Up))
self.ui.radioButton_ROI2.setShortcut(QKeySequence(Qt.Key_Down))
self.ui.checkBox_ROI1.stateChanged.connect(partial(self._updateROI, self.rois[0]))
self.ui.checkBox_ROI2.stateChanged.connect(partial(self._updateROI, self.rois[1]))
self.ui.comboBox_ROI1.activated.connect(partial(self._updateROI, self.rois[0]))
self.ui.comboBox_ROI2.activated.connect(partial(self._updateROI, self.rois[1]))
# flags for RW and FF
self.RW, self.FF = 1, 2
self.ui.pushButton_ROI1_RW.clicked.connect(partial(self.roiRWFF, self.RW, self.rois[0]))
self.ui.pushButton_ROI1_FF.clicked.connect(partial(self.roiRWFF, self.FF, self.rois[0]))
self.ui.pushButton_ROI2_RW.clicked.connect(partial(self.roiRWFF, self.RW, self.rois[1]))
self.ui.pushButton_ROI2_FF.clicked.connect(partial(self.roiRWFF, self.FF, self.rois[1]))
示例12
def keyPressEvent(self, event):
if event.modifiers() & Qt.ShiftModifier \
and event.key() in [Qt.Key_Up, Qt.Key_Down, Qt.Key_Left, Qt.Key_Right]:
dlat = 1.0 / (self.radarwidget.zoom * self.radarwidget.ar)
dlon = 1.0 / (self.radarwidget.zoom * self.radarwidget.flat_earth)
if event.key() == Qt.Key_Up:
self.radarwidget.panzoom(pan=(dlat, 0.0))
elif event.key() == Qt.Key_Down:
self.radarwidget.panzoom(pan=(-dlat, 0.0))
elif event.key() == Qt.Key_Left:
self.radarwidget.panzoom(pan=(0.0, -dlon))
elif event.key() == Qt.Key_Right:
self.radarwidget.panzoom(pan=(0.0, dlon))
elif event.key() == Qt.Key_Escape:
self.closeEvent()
elif event.key() == Qt.Key_F11: # F11 = Toggle Full Screen mode
if not self.isFullScreen():
self.showFullScreen()
else:
self.showNormal()
else:
# All other events go to the BlueSky console
self.console.keyPressEvent(event)
event.accept()
示例13
def textChanged(self, e): # QKeyEvent(QEvent.KeyPress, Qt.Key_Enter, Qt.NoModifier)
# if (32<e.key()<96 or 123<e.key()<126 or 0x1000001<e.key()<0x1000005 or e.key==Qt.Key_Delete):
# 大键盘为Ret小键盘为Enter
if (e.key() in (Qt.Key_Return, Qt.Key_Enter, Qt.Key_Semicolon, Qt.Key_BraceRight, Qt.Key_Up, Qt.Key_Down,
Qt.Key_Left, Qt.Key_Right, Qt.Key_Tab, Qt.Key_Delete, Qt.Key_Backspace)):
self.renderStyle()
self.loadColorPanel()
self.actions["undo"].setEnabled(self.editor.isUndoAvailable())
self.actions["redo"].setEnabled(self.editor.isRedoAvailable())
示例14
def test_var_refresh(self, qtbot, sharedwin):
win = sharedwin["main"]
qtbot.keyPress(win.editor, Qt.Key_Up)
assert "*" not in win.windowTitle()
示例15
def keyPressEvent(self, event):
"""Keyboard press event
Effective key: W, A, S, D, ↑, ↓, ←, →
Press a key on keyboard, the function will get an event, if the condition is met, call the function
run_action().
Args:
event, this argument will get when an event of keyboard pressed occured
"""
key_press = event.key()
# don't need autorepeat, while haven't released, just run once
if not event.isAutoRepeat():
if key_press == Qt.Key_Up: # up
run_action('camup')
elif key_press == Qt.Key_Right: # right
run_action('camright')
elif key_press == Qt.Key_Down: # down
run_action('camdown')
elif key_press == Qt.Key_Left: # left
run_action('camleft')
elif key_press == Qt.Key_W: # W
run_action('forward')
elif key_press == Qt.Key_A: # A
run_action('fwleft')
elif key_press == Qt.Key_S: # S
run_action('backward')
elif key_press == Qt.Key_D: # D
run_action('fwright')
示例16
def keyReleaseEvent(self, event):
"""Keyboard released event
Effective key: W,A,S,D, ↑, ↓, ←, →
Release a key on keyboard, the function will get an event, if the condition is met, call the function
run_action().
Args:
event, this argument will get when an event of keyboard release occured
"""
# don't need autorepeat, while haven't pressed, just run once
key_release = event.key()
if not event.isAutoRepeat():
if key_release == Qt.Key_Up: # up
run_action('camready')
elif key_release == Qt.Key_Right: # right
run_action('camready')
elif key_release == Qt.Key_Down: # down
run_action('camready')
elif key_release == Qt.Key_Left: # left
run_action('camready')
elif key_release == Qt.Key_W: # W
run_action('stop')
elif key_release == Qt.Key_A: # A
run_action('fwstraight')
elif key_release == Qt.Key_S: # S
run_action('stop')
elif key_release == Qt.Key_D: # D
run_action('fwstraight')
示例17
def keyPressEvent(self, event):
# when codecompletion popup dont respond to enter
if self.completer and self.completer.popup() and self.completer.popup(
).isVisible():
event.ignore()
return super().keyPressEvent(event)
if event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return:
cmd = self.toPlainText()
l = len(self.cmds)
if l > 0:
if l > 100:
self.cmds.pop(0)
if cmd != self.cmds[l - 1]:
self.cmds.append(cmd)
else:
self.cmds.append(cmd)
self.cmd_index = 0
self.onEnterKeyPressed.emit(cmd)
self.setPlainText('')
elif event.key() == Qt.Key_Up:
l = len(self.cmds)
try:
self.setPlainText(self.cmds[l - 1 - self.cmd_index])
if self.cmd_index < l - 1:
self.cmd_index += 1
except:
pass
elif event.key() == Qt.Key_Down:
try:
if self.cmd_index >= 0:
self.cmd_index -= 1
self.setPlainText(
self.cmds[len(self.cmds) - 1 - self.cmd_index])
except:
self.setPlainText('')
self.cmd_index = 0
else:
return super().keyPressEvent(event)
示例18
def test_eventFilter_whenKeyUpPressed_SelectsPreviousRowAndEmitsClickEvent(
self, hosts_table_view, selection_model, selected_row):
self.mock_view.ui.HostsTableView = hosts_table_view
event_filter = MyEventFilter(self.mock_view, self.mock_main_window)
self.simulateKeyPress(Qt.Key_Up)
self.mock_receiver = hosts_table_view
selected_row.row = Mock(return_value=1)
selection_model.selectedRows = Mock(return_value=[selected_row])
self.mock_receiver.selectionModel = Mock(return_value=selection_model)
result = event_filter.eventFilter(self.mock_receiver, self.mock_event)
self.assertTrue(result)
self.mock_receiver.selectRow.assert_called_once_with(0)
self.mock_receiver.clicked.emit.assert_called_with(selected_row)
示例19
def keyPressEvent(self, event):
if event.key() == Qt.Key_Up:
self.navigate_backward()
elif event.key() == Qt.Key_Down:
self.navigate_forward()
else:
super().keyPressEvent(event)
示例20
def test_MicroPythonREPLPane_keyPressEvent_up(qtapp):
"""
Ensure up arrows in the REPL are handled correctly.
"""
mock_serial = mock.MagicMock()
rp = mu.interface.panes.MicroPythonREPLPane(mock_serial)
data = mock.MagicMock
data.key = mock.MagicMock(return_value=Qt.Key_Up)
data.text = mock.MagicMock(return_value="1b")
data.modifiers = mock.MagicMock(return_value=None)
rp.keyPressEvent(data)
mock_serial.write.assert_called_once_with(b"\x1B[A")
示例21
def test_PythonProcessPane_parse_input_up_arrow(qtapp):
"""
Up Arrow causes the input line to be replaced with movement back in
command history.
"""
ppp = mu.interface.panes.PythonProcessPane()
ppp.history_back = mock.MagicMock()
key = Qt.Key_Up
text = ""
modifiers = None
ppp.parse_input(key, text, modifiers)
assert ppp.history_back.call_count == 1
示例22
def eventFilter(self, target, event):
def match(s1, s2):
for x in s2:
if s1.matches(x) == QKeySequence.ExactMatch:
return True
return False
if target == self.inputTextBox:
if isinstance(event, QKeyEvent):
if event.type() == QKeyEvent.KeyPress:
event_sequence = QtHelper.key_event_sequence(event)
if match(event_sequence, Settings().new_line_key):
return False
if match(event_sequence, Settings().send_key):
self.send_input()
return True
if event.key() == Qt.Key_Tab:
self.inputTextBox.insertPlainText(" "*Settings().terminal_tab_spaces)
return True
if event.key() == Qt.Key_Up and (event.modifiers() & Qt.ControlModifier):
if self._input_history_index > 0:
self._input_history_index -= 1
self.inputTextBox.clear()
self.inputTextBox.setPlainText(self.terminal.input(self._input_history_index))
if event.key() == Qt.Key_Down and (event.modifiers() & Qt.ControlModifier):
if self._input_history_index < self.terminal.last_input_idx():
self._input_history_index += 1
self.inputTextBox.clear()
self.inputTextBox.setPlainText(self.terminal.input(self._input_history_index))
elif target == self.outputTextEdit:
if isinstance(event, QKeyEvent):
if event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Up:
self.connection.send_bytes(b"\x1b[A")
if event.key() == Qt.Key_Down:
self.connection.send_bytes(b"\x1b[B")
else:
t = event.text()
if t:
self.connection.send_character(t)
return True
elif target == self.outputTextEdit.verticalScrollBar():
if isinstance(event, QHideEvent):
return True
return False
示例23
def keyPressEvent(self, event):
''' Handle keyboard input for bluesky. '''
# Enter-key: enter command
if event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return:
if self.command_line:
# emit a signal with the command for the simulation thread
self.stack(self.command_line)
# Clear any shape command preview on the radar display
# self.radarwidget.previewpoly(None)
return
newcmd = self.command_line
cursorpos = None
if event.key() >= Qt.Key_Space and event.key() <= Qt.Key_AsciiTilde:
pos = self.lineEdit.cursor_pos()
newcmd = newcmd[:pos] + event.text() + newcmd[pos:]
# Update the cursor position with the length of the added text
cursorpos = pos + len(event.text())
elif event.key() == Qt.Key_Backspace:
pos = self.lineEdit.cursor_pos()
newcmd = newcmd[:pos - 1] + newcmd[pos:]
cursorpos = pos - 1
elif event.key() == Qt.Key_Tab:
if newcmd:
newcmd, displaytext = autocomplete.complete(newcmd)
if displaytext:
self.echo(displaytext)
elif not event.modifiers() & (Qt.ControlModifier | Qt.ShiftModifier |
Qt.AltModifier | Qt.MetaModifier):
if event.key() == Qt.Key_Up:
if self.history_pos == 0:
self.command_mem = newcmd
if len(self.command_history) >= self.history_pos + 1:
self.history_pos += 1
newcmd = self.command_history[-self.history_pos]
elif event.key() == Qt.Key_Down:
if self.history_pos > 0:
self.history_pos -= 1
if self.history_pos == 0:
newcmd = self.command_mem
else:
newcmd = self.command_history[-self.history_pos]
elif event.key() == Qt.Key_Left:
self.lineEdit.cursor_left()
elif event.key() == Qt.Key_Right:
self.lineEdit.cursor_right()
else:
# Remaining keys are things like sole modifier keys, and function keys
super(Console, self).keyPressEvent(event)
else:
event.ignore()
return
# Final processing of the command line
self.set_cmdline(newcmd, cursorpos)
示例24
def keyPressEvent(self, event):
"""Keyboard press event
Press a key on keyboard, the function will get an event, if the condition is met, call the function
run_action().
In camera calibration mode, Effective key: W,A,S,D, ↑, ↓, ←, →, ESC
In front wheel calibration mode, Effective key: A, D, ←, →, ESC
In back wheel calibration mode, Effective key: A, D, ←, →, ESC
Args:
event, this argument will get when an event of keyboard pressed occured
"""
key_press = event.key()
if key_press in (Qt.Key_Up, Qt.Key_W): # UP
if self.calibration_status == 1:
cali_action('camcaliup')
elif self.calibration_status == 2:
pass
elif self.calibration_status == 3:
pass
elif key_press in (Qt.Key_Right, Qt.Key_D): # RIGHT
if self.calibration_status == 1:
cali_action('camcaliright')
elif self.calibration_status == 2:
cali_action('fwcaliright')
elif self.calibration_status == 3:
cali_action('bwcaliright')
elif key_press in (Qt.Key_Down, Qt.Key_S): # DOWN
if self.calibration_status == 1:
cali_action('camcalidown')
elif self.calibration_status == 2:
pass
elif self.calibration_status == 3:
pass
elif key_press in (Qt.Key_Left, Qt.Key_A): # LEFT
if self.calibration_status == 1:
cali_action('camcalileft')
elif self.calibration_status == 2:
cali_action('fwcalileft')
elif self.calibration_status == 3:
cali_action('bwcalileft')
cali_action('forward')
elif key_press == Qt.Key_Escape: # ESC
run_action('stop')
self.close()
示例25
def keyPressEvent(self, event):
print(event.key())
if event.key() == Qt.Key_M:
self.send_flag = False
self.com.write(b"m")
self.send_flag = False
elif event.key() == Qt.Key_Return or event.key()==Qt.Key_Enter:
self.send_flag = False
self.com.write(b"m")
self.send_flag = False
elif event.key() == Qt.Key_N or event.key() == 92:
self.send_flag = False
self.com.write(b"n")
self.send_flag = False
elif event.key() == Qt.Key_Minus:
self.send_flag = False
self.com.write(b"-")
self.send_flag = False
elif event.key() == Qt.Key_Equal:
self.send_flag = False
self.com.write(b"=")
self.send_flag = False
elif event.key() == Qt.Key_W or event.key() == Qt.Key_Up:
self.send_flag = True
self.key.append(b"w")
elif event.key() == Qt.Key_A or event.key() == Qt.Key_Left:
self.send_flag = True
self.key.append(b"a")
elif event.key() == Qt.Key_S or event.key() == Qt.Key_Down:
self.send_flag = True
self.key.append(b"s")
elif event.key() == Qt.Key_D or event.key() == Qt.Key_Right:
self.send_flag = True
self.key.append(b"d")
elif event.key() == Qt.Key_J:
self.send_flag = True
self.key.append(b"j")
elif event.key() == Qt.Key_K:
self.send_flag = True
self.key.append(b"k")
elif event.key() == Qt.Key_Escape:
self.send_flag = False
self.com.write(b"\x03")
elif event.key() == Qt.Key_Control:
self.keyControlPressed = True
elif event.key() == Qt.Key_C:
if self.keyControlPressed:
self.send_flag = False
self.com.write(b"\x03")
# self.key_label.setText(self.key.decode())
