def keyPressEvent(self, event):
current_frame = self.player.preview_thread.current_frame
key_value = event.key()
print(key_value)
modifiers = int(event.modifiers())
if (key_value > 0 and key_value != Qt.Key_Shift
and key_value != Qt.Key_Alt and key_value != Qt.Key_Control
and key_value != Qt.Key_Meta):
# A valid keysequence was detected
key = QKeySequence(modifiers + key_value)
else:
# No valid keysequence detected
return
# Debug
log.info("keyPressEvent: %s" % (key.toString()))
color = self.getColorByName("actionCut+" + key.toString())
print("actionCut+" + key.toString(), color)
if color:
self.timelineWidget.cut(key.toString(), current_frame, color)
elif key.matches(self.getShortcutByName(
"actionAddTrack")) == QKeySequence.ExactMatch:
self.timelineWidget.addTrack("track_test")
def _bind(self, seq, cmd):
''' Binds a hotkey to a command name.
seq can either be a QKeySequence or a string parseable by QKeySequence
eg "ctrl+shift+k" '''
try:
seq = QKeySequence(seq)
except:
pass
t = seqToTuple(seq)
log.debug('Binding hotkey "{hotkey}" => "{command}"',
hotkey=seq.toString(),
command=cmd)
try:
self.hk.register(t, cmd)
except SystemRegisterError:
log.exception('Failed to bind hotkey "{hotkey}"',
hotkey=seq.toString())
else:
return True
#endtry
return False
def add(self, seq, command):
''' Add a new hotkey with with a command name intended to be saved to the config '''
try:
seq = QKeySequence(seq)
except:
pass
seq = seq.toString(
) # TODO: Removed this (use kyseq directly). UPDATE LOGS when you do (toString)
hks = config.default.get('hotkeys', {})
if seq in hks:
log.warning('Reassigning existing sequence "{hotkey}"',
hotkey=seq)
#endif
hks[seq] = command
config.default.set('hotkeys', hks)
config.default.save() # TODO: Move this to settings UI?
log.debug('Attempting to bind "{sequence}"', sequence=seq)
if command not in self.commands:
log.warning(
'Saved hotkey "{hotkey}" to unknown command "{command}"',
hotkey=seq,
command=command)
#endif
return True
def hasHotkey(self, seq):
try:
seq = QKeySequence(seq)
except:
pass
return seq.toString() in config.default.get('hotkeys', {})
def setShortcut(self, shortcut: QtGui.QKeySequence):
action = None
try:
for action in self.actions_list:
if (action.shortcut
== shortcut) and (self is not action) and not (
shortcut == QtGui.QKeySequence('')):
raise ValueError(
'Shortcut is already in use by "{}"\n'.format(
action.text))
else: # the shortcut is free
self.lineEdit.setStyleSheet(self.regularLineEditStyleSheet)
self.lineEdit.setKeySequence(shortcut)
self.dataBase.update_shortcut(self.text, shortcut.toString())
self.shortcut = shortcut
except ValueError as e:
self.lineEdit.clearText()
reply = QtWidgets.QMessageBox.question(
self.parent, "Shortcut in use",
str(e) + "What would you like to do?",
QtWidgets.QMessageBox.Retry | QtWidgets.QMessageBox.Ignore
| QtWidgets.QMessageBox.Cancel)
if reply == QtWidgets.QMessageBox.Retry:
self.tableWidget.parent().activateWindow()
self.lineEdit.setFocus()
self.lineEdit.setStyleSheet(self.errorLineEditStyleSheet)
elif reply == QtWidgets.QMessageBox.Cancel:
self.lineEdit.clearFocus()
else: # Ignore - solve the collision
action.setShortcut(QtGui.QKeySequence(''))
self.setShortcut(shortcut)
def change_keyseq(self, group, name, old_keyseq, keyseq):
"""
Customize a shortcut's activating key sequence.
"""
if old_keyseq:
old_keyseq = QKeySequence(old_keyseq)
old_keytext = str(old_keyseq.toString())
self._keyseq_target_actions[old_keytext].remove((group, name))
try:
keyseq = QKeySequence(keyseq)
keytext = str(keyseq.toString())
target_name_set = self._keyseq_target_actions[keytext]
except KeyError:
target_name_set = self._keyseq_target_actions[keytext] = set()
self._add_global_shortcut_listener(keyseq)
target_name_set.add((group, name))
self._update_tooltip(group, name, keyseq)
def change_keyseq(self, group, name, old_keyseq, keyseq):
"""
Customize a shortcut's activating key sequence.
"""
if old_keyseq:
old_keyseq = QKeySequence(old_keyseq)
old_keytext = str(old_keyseq.toString())
self._keyseq_target_actions[old_keytext].remove((group, name))
try:
keyseq = QKeySequence(keyseq)
keytext = str(keyseq.toString())
target_name_set = self._keyseq_target_actions[keytext]
except KeyError:
target_name_set = self._keyseq_target_actions[keytext] = set()
self._add_global_shortcut_listener(keyseq)
target_name_set.add((group, name))
self._update_tooltip(group, name, keyseq)
def add_shortcut(self, scope: qw.QWidget, shortcut: str) -> None:
""" Adds shortcut and tooltip. """
keys = QKeySequence(shortcut, QKeySequence.PortableText)
self.scoped_shortcut = qw.QShortcut(keys, scope)
self.scoped_shortcut.setContext(Qt.WidgetWithChildrenShortcut)
self.scoped_shortcut.activated.connect(self.click)
self.setToolTip(keys.toString(QKeySequence.NativeText))
def keyPressEvent(self, event):
try:
key_sequence = QKeySequence(event.modifiers() | event.key())
key_sequence_ascii_representation = key_sequence.toString(
).encode('ascii', errors='ignore').decode()
self.setText(key_sequence_ascii_representation)
except Exception as e:
# Ignoring unknown errors since we can't do anything about it.
pass
def getQKeySequence(self, key):
if key.startswith('0x'):
try:
key = int(key, 16)
except ValueError:
pass
seq = QKeySequence(key)
s = seq.toString()
if len(s) == 1 and s.isalpha():
self.ignore_keys.append(ord(s))
return seq
def setShortcut(self, identifier, shortcut: QtGui.QKeySequence):
"""Set a shortcut for the action named `identifier`."""
action = self.actions[identifier]
action.shortcut = shortcut
if action.shortcut == action.defaultShortcut:
# remove from storage, if it's there (we only store non-defaults)
if identifier in config.storage.gui.shortcuts:
del config.storage.gui.shortcuts[identifier]
else:
config.storage.gui.shortcuts[identifier] = shortcut.toString()
self.shortcutChanged.emit(identifier, shortcut)
def test_load_default_shortcuts(self):
shorts_count = self.shortcuts_manager.result_widget.topLevelItemCount()
item = self.shortcuts_manager.result_widget.topLevelItem(0)
shortcut_keys = item.text(1)
# Expected data
expected_key = QKeySequence(Qt.CTRL + Qt.Key_N)
expected_key_str = expected_key.toString(QKeySequence.NativeText)
# Just one shortcut should be loaded
self.assertEqual(shorts_count, 1)
# The key should be the same as the expected
self.assertEqual(shortcut_keys, expected_key_str)
def setShortcut(self, identifier, shortcut: QtGui.QKeySequence):
"""Set a shortcut for the action named `identifier`."""
action = self.actions[identifier]
action.shortcut = shortcut
if action.shortcut == action.defaultShortcut:
# remove from storage, if it's there (we only store non-defaults)
if identifier in config.storage.gui.shortcuts:
del config.storage.gui.shortcuts[identifier]
else:
config.storage.gui.shortcuts[identifier] = shortcut.toString()
self.shortcutChanged.emit(identifier, shortcut)
def on_new_shortcut(self):
new_shortcut = str(QKeySequence.toString(self.new_shortcut.keySequence()))
self.controller.update_hotkey(self.selected_option, new_shortcut)
# Regenerate list
self.ui.listWidget_hotkey.clear()
self.generate_hotkey_list()
# Update inputs
self.ui.lineEdit_current_shortcut.setText(new_shortcut)
self.new_shortcut.clear()
def on_new_shortcut(self):
_new_shortcut = str(QKeySequence.toString(self.new_shortcut.keySequence()))
self.controller.update_hotkey(self.selected_option, _new_shortcut)
# Regenerate list
self.ui.listWidget.clear()
self.generate_hotkey_list()
# Update inputs
self.ui.input_cur_shortcut.setText(_new_shortcut) # possible self.model.get('Hotkeys', self.selected_option)
self.new_shortcut.clear()
def _unbind(self, seq, quiet=False):
''' Removes a hotkey binding. If Quiet is true, will not warn if the binding doesn't exist '''
try:
seq = QKeySequence(seq)
except:
pass
t = seqToTuple(seq)
log.debug('Unbinding hotkey "{hotkey}"', hotkey=seq.toString())
try:
self.hk.unregister(t)
except UnregisterError:
if not quiet:
log.warn('Tried to unbind nonexistent hotkey "{hotkey}"',
hotkey=seq.toString())
else:
return True
#endtry
return False
class HotkeyLineEdit(QLineEdit):
key_sequence = None
def __init__(self, parent=None):
super(HotkeyLineEdit, self).__init__(parent)
self.clearKeySequence()
def clearKeySequence(self):
self.key_sequence = QKeySequence()
self.updateText()
def setKeySequence(self, keyseq):
if not isinstance(keyseq, QKeySequence): raise RuntimeError
self.key_sequence = keyseq
self.updateText()
def updateText(self):
self.setText(self.key_sequence.toString(QKeySequence.NativeText))
def mousePressEvent(self, event):
log.info("Mouse press")
# TODO: construct a data structure to hold mouse presses that can be used as shortcuts
def keyPressEvent(self, event):
log.info("Key Press")
key = event.key();
key = Qt.Key(key);
# Ignore unknown keys
# and if modifier keys come alone
if key == Qt.Key_unknown or key in (Qt.Key_Control, Qt.Key_Alt, Qt.Key_AltGr, Qt.Key_Shift):
return
# Pressing Backspace will clear the content
if key == Qt.Key_Backspace:
self.setText(None)
self.clearKeySequence()
return
# Checking for key combinations
modifiers = event.modifiers();
if(modifiers & Qt.NoModifier):
return
if(modifiers & Qt.ShiftModifier):
key += Qt.SHIFT
if(modifiers & Qt.ControlModifier):
key += Qt.CTRL
if(modifiers & Qt.AltModifier):
key += Qt.ALT
self.setKeySequence(QKeySequence(key))
def keyPressEvent(self, event):
"""Handler when a key is pressed.
* use Escape to leave the control
* use Enter to accept the sequence
"""
if event.key() == Qt.Key_Escape:
self.setFocus(False)
elif event.key() == Qt.Key_Return:
self._accept()
elif not event.isAutoRepeat():
modifiers = 0
# event.modifiers().testFlag(...)
if event.modifiers() & Qt.ControlModifier:
modifiers |= Qt.CTRL
if event.modifiers() & Qt.ShiftModifier:
modifiers |= Qt.SHIFT
if event.modifiers() & Qt.AltModifier:
modifiers |= Qt.ALT
if event.modifiers() & Qt.MetaModifier:
modifiers |= Qt.META
if Qt.Key_Shift <= event.key() <= Qt.Key_Meta:
self._logger.info(
'Only modifiers were pressed ({} / {} / {} ignoring'.
format(event.text(), _key_name(event.key()),
QKeySequence(event.key()).toString()))
else:
self._pressed_keys.append(event.key() | modifiers)
self._logger.info(
'Adding key {} / {} / {} with modifiers ({}) to pressed keys'
.format(
event.text(),
_key_name(event.key()),
QKeySequence(event.key()).toString(),
# UnicodeEncodeError: 'utf-8' codec can't encode character '\udc21' in position 188: surrogates not allowed
QKeySequence(self._pressed_keys[-1]).toString(),
))
sequence = QKeySequence(*self._pressed_keys) # up to 4 keys
self._set_edited_sequence(sequence.toString())
if len(self._pressed_keys) == 4:
# That was the last key out of four possible keys end it here.
self._accept()
event.accept()
def _add_global_shortcut_listener(self, keyseq):
# Create a shortcut for this new key sequence
# Note: We associate the shortcut with the ENTIRE WINDOW.
# We intercept the shortcut and decide which widget to direct it to.
# (We don't rely on Qt to do this for us.)
# Note: This class assumes that all widgets using shortcuts belong to the SAME main window.
assert keyseq not in self._global_shortcuts
keyseq = QKeySequence(keyseq)
keytext = str(keyseq.toString())
self._global_shortcuts[keytext] = QShortcut(
QKeySequence(keyseq),
getMainWindow(),
member=partial(self._handle_shortcut_pressed, keytext),
context=Qt.ApplicationShortcut)
def _add_global_shortcut_listener(self, keyseq):
# Create a shortcut for this new key sequence
# Note: We associate the shortcut with the ENTIRE WINDOW.
# We intercept the shortcut and decide which widget to direct it to.
# (We don't rely on Qt to do this for us.)
# Note: This class assumes that all widgets using shortcuts belong to the SAME main window.
assert keyseq not in self._global_shortcuts
keyseq = QKeySequence(keyseq)
keytext = str(keyseq.toString())
self._global_shortcuts[keytext] = QShortcut(
QKeySequence(keyseq),
getMainWindow(),
member=partial(self._handle_shortcut_pressed, keytext),
context=Qt.ApplicationShortcut,
)
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
self.setKeyboardShortcut("")
self.close()
return
if event.key() == Qt.Key_Backspace:
self.setKeyboardShortcut("")
self._should_be_reset = True
self.close()
return
try:
key_sequence = QKeySequence(event.modifiers() | event.key())
key_sequence_ascii_representation = key_sequence.toString().encode(
'ascii', errors='ignore').decode()
self.setKeyboardShortcut(key_sequence_ascii_representation)
except Exception as e:
# Ignoring unknown errors since we can't do anything about it.
pass
def __create_style_button(self, text, tooltip, keys, font_style):
def toggled(value):
self.__font = self.__font.change(font_style, value)
self.__refresh_example_font()
shortcut = QKeySequence(keys)
widget = QPushButton(text)
widget.setShortcut(shortcut)
widget.setToolTip("{0} ({1})".format(tooltip, shortcut.toString()))
font = widget.font()
if font_style == FontStyle.bold:
font.setBold(True)
elif font_style == FontStyle.italic:
font.setItalic(True)
elif font_style == FontStyle.underline:
font.setUnderline(True)
elif font_style == FontStyle.strike:
font.setStrikeOut(True)
widget.setFont(font)
widget.setCheckable(True)
widget.toggled.connect(toggled)
return widget
def test_save_shortcuts(self):
data = []
def called():
data.append(True)
actions = gui.FakeActions()
setattr(actions, 'update_shortcuts', called)
self.patch(shortcut_manager.actions, 'Actions', lambda: actions)
self.shortcuts_manager.result_widget.clear()
key = QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_N)
key_str = key.toString(QKeySequence.NativeText)
tree_data = ["New File", key_str, "New-File"]
item = QTreeWidgetItem(self.shortcuts_manager.result_widget, tree_data)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
# Before save there is nothing in QSettings
self.assertEqual(self.settings.value("New-File", None), None)
# Save
self.shortcuts_manager.save()
# After save there is a value for New-File QSettings
self.assertEqual(self.settings.values["New-File"], key_str)
# After save check if NINJA call the update_shortcuts in actios.Actions
self.assertEqual(data, [True])
class QtKeySequenceEdit(QWidget):
keySequenceChangedSignal = pyqtSignal(QKeySequence)
def __init__(self,parent=None):
super(QtKeySequenceEdit, self).__init__(parent)
self.m_keySequence = QKeySequence()
self.m_num = 0
self.m_lineEdit = QLineEdit(self)
layout = QHBoxLayout(self)
layout.addWidget(self.m_lineEdit)
layout.setContentsMargins(0, 0, 0, 0)
self.m_lineEdit.installEventFilter(self)
self.m_lineEdit.setReadOnly(True)
self.m_lineEdit.setFocusProxy(self)
self.setFocusPolicy(self.m_lineEdit.focusPolicy())
self.setAttribute(Qt.WA_InputMethodEnabled)
def eventFilter(self, o, e):
if o == self.m_lineEdit and e.type() == QEvent.ContextMenu:
c = e
menu = self.m_lineEdit.createStandardContextMenu()
actions = menu.actions()
for action in actions:
action.setShortcut(QKeySequence())
actionString = action.text()
pos = actionString.rfind('\t')
if (pos > 0):
actionString = actionString[:pos]
action.setText(actionString)
actionBefore = None
if (len(actions) > 0):
actionBefore = actions[0]
clearAction = QAction(self.tr("Clear Shortcut"), menu)
menu.insertAction(actionBefore, clearAction)
menu.insertSeparator(actionBefore)
clearAction.setEnabled(not len(self.m_keySequence)<=0)
clearAction.triggered.connect(self.slotClearShortcut)
menu.exec(c.globalPos())
e.accept()
return True
return super(QtKeySequenceEdit, self).eventFilter(o, e)
def slotClearShortcut(self):
if len(self.m_keySequence) <= 0:
return
self.setKeySequence(QKeySequence())
self.keySequenceChangedSignal.emit(self.m_keySequence)
def handleKeyEvent(self, e):
nextKey = e.key()
if (nextKey == Qt.Key_Control or nextKey == Qt.Key_Shift or
nextKey == Qt.Key_Meta or nextKey == Qt.Key_Alt or
nextKey == Qt.Key_Super_L or nextKey == Qt.Key_AltGr):
return
nextKey |= self.translateModifiers(e.modifiers(), e.text())
k0 = 0
k1 = 0
k2 = 0
k3 = 0
l = len(self.m_keySequence)
if l==1:
k0 = self.m_keySequence[0]
elif l==2:
k0 = self.m_keySequence[0]
k1 = self.m_keySequence[1]
elif l==3:
k0 = self.m_keySequence[0]
k1 = self.m_keySequence[1]
k2 = self.m_keySequence[2]
elif l==4:
k0 = self.m_keySequence[0]
k1 = self.m_keySequence[1]
k2 = self.m_keySequence[2]
k3 = self.m_keySequence[3]
if self.m_num==0:
k0 = nextKey
k1 = 0
k2 = 0
k3 = 0
elif self.m_num==1:
k1 = nextKey
k2 = 0
k3 = 0
elif self.m_num==2:
k2 = nextKey
k3 = 0
elif self.m_num==3:
k3 = nextKey
else:
pass
self.m_num += 1
if (self.m_num > 3):
self.m_num = 0
self.m_keySequence = QKeySequence(k0, k1, k2, k3)
self.m_lineEdit.setText(self.m_keySequence.toString(QKeySequence.NativeText))
e.accept()
self.keySequenceChangedSignal.emit(self.m_keySequence)
def setKeySequence(self, sequence):
if (sequence == self.m_keySequence):
return
self.m_num = 0
self.m_keySequence = sequence
self.m_lineEdit.setText(self.m_keySequence.toString(QKeySequence.NativeText))
def keySequence(self):
return self.m_keySequence
def translateModifiers(self, state, text):
result = 0
if ((state & Qt.ShiftModifier) and (len(text) == 0 or not text[0].isprintable() or text[0].isalpha() or text[0].isspace())):
result |= Qt.SHIFT
if (state & Qt.ControlModifier):
result |= Qt.CTRL
if (state & Qt.MetaModifier):
result |= Qt.META
if (state & Qt.AltModifier):
result |= Qt.ALT
return result
def focusInEvent(self, e):
self.m_lineEdit.event(e)
self.m_lineEdit.selectAll()
super(QtKeySequenceEdit, self).focusInEvent(e)
def focusOutEvent(self, e):
self.m_num = 0
self.m_lineEdit.event(e)
super(QtKeySequenceEdit, self).focusOutEvent(e)
def keyPressEvent(self, e):
self.handleKeyEvent(e)
e.accept()
def keyReleaseEvent(self, e):
self.m_lineEdit.event(e)
def paintEvent(self, ptQPaintEvent):
opt = QStyleOption()
opt.initFrom(self)
p = QPainter(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, p, self)
def event(self,e):
if (e.type() == QEvent.Shortcut or
e.type() == QEvent.ShortcutOverride or
e.type() == QEvent.KeyRelease):
e.accept()
return True
return super(QtKeySequenceEdit, self).event(e)
class KeySequenceEditor(QQuickItem):
_logger = _module_logger.getChild('KeySequenceEditor')
##############################################
def __init__(self, parent):
super().__init__(parent)
self._default_sequence = QKeySequence() # default sequence
self._edited_sequence = QKeySequence() # current/edited sequence
self._new_sequence = QKeySequence() # customised sequence
self._reset_pressed_keys()
##############################################
def _reset_pressed_keys(self):
self._logger.info('Clearing pressed keys')
self._pressed_keys = []
##############################################
default_sequence_changed = Signal()
@Property(str, notify=default_sequence_changed)
def default_sequence(self):
return self._default_sequence.toString()
##############################################
@default_sequence.setter
def default_sequence(self, default_sequence):
if default_sequence != self._default_sequence.toString():
self._default_sequence = QKeySequence(default_sequence,
QKeySequence.PortableText)
self._set_edited_sequence('') # Fixme: why reset ???
self.new_sequence = ''
self.default_sequence_changed.emit()
# This might not always be the case, I'm just lazy.
self.is_customised_changed.emit()
self.display_sequence_changed.emit()
##############################################
new_sequence_changed = Signal()
@Property(str, notify=new_sequence_changed)
def new_sequence(self):
return self._new_sequence.toString()
@new_sequence.setter
def new_sequence(self, new_sequence):
if new_sequence != self._new_sequence.toString():
self._new_sequence = QKeySequence(new_sequence,
QKeySequence.PortableText)
self._logger.info('Set new sequence to {}'.format(
self._new_sequence.toString()))
self.new_sequence_changed.emit()
self.is_customised_changed.emit()
self.display_sequence_changed.emit()
##############################################
display_sequence_changed = Signal()
@Property(str, notify=display_sequence_changed)
def display_sequence(self):
"""Text to show in the sequence editor"""
if self.hasActiveFocus():
# we are editing the sequence
sequence = self._edited_sequence
elif self._new_sequence.isEmpty():
# no new sequence
sequence = self._default_sequence
else:
sequence = self._new_sequence
return sequence.toString()
##############################################
is_customised_changed = Signal()
@Property(bool, notify=is_customised_changed)
def is_customised(self):
"""Flag to indicate a new valid sequence is set"""
return not self._new_sequence.isEmpty(
) and self._new_sequence != self._default_sequence
##############################################
@Slot()
def reset(self):
"""Reset the sequence to the default one"""
self._set_edited_sequence(self.default_sequence)
self.new_sequence = self.default_sequence
self._reset_pressed_keys()
##############################################
def _set_edited_sequence(self, edited_sequence=''):
"""Update the edited sequence.
emit *is_customised* and *display_sequence*
"""
if edited_sequence != self._edited_sequence.toString():
self._edited_sequence = QKeySequence(edited_sequence,
QKeySequence.PortableText)
self._logger.info('Edited sequence changed to {}'.format(
self._edited_sequence.toString()))
self.is_customised_changed.emit()
self.display_sequence_changed.emit()
##############################################
def keyPressEvent(self, event):
"""Handler when a key is pressed.
* use Escape to leave the control
* use Enter to accept the sequence
"""
if event.key() == Qt.Key_Escape:
self.setFocus(False)
elif event.key() == Qt.Key_Return:
self._accept()
elif not event.isAutoRepeat():
modifiers = 0
# event.modifiers().testFlag(...)
if event.modifiers() & Qt.ControlModifier:
modifiers |= Qt.CTRL
if event.modifiers() & Qt.ShiftModifier:
modifiers |= Qt.SHIFT
if event.modifiers() & Qt.AltModifier:
modifiers |= Qt.ALT
if event.modifiers() & Qt.MetaModifier:
modifiers |= Qt.META
if Qt.Key_Shift <= event.key() <= Qt.Key_Meta:
self._logger.info(
'Only modifiers were pressed ({} / {} / {} ignoring'.
format(event.text(), _key_name(event.key()),
QKeySequence(event.key()).toString()))
else:
self._pressed_keys.append(event.key() | modifiers)
self._logger.info(
'Adding key {} / {} / {} with modifiers ({}) to pressed keys'
.format(
event.text(),
_key_name(event.key()),
QKeySequence(event.key()).toString(),
# UnicodeEncodeError: 'utf-8' codec can't encode character '\udc21' in position 188: surrogates not allowed
QKeySequence(self._pressed_keys[-1]).toString(),
))
sequence = QKeySequence(*self._pressed_keys) # up to 4 keys
self._set_edited_sequence(sequence.toString())
if len(self._pressed_keys) == 4:
# That was the last key out of four possible keys end it here.
self._accept()
event.accept()
##############################################
def keyReleaseEvent(self, event):
event.accept()
##############################################
def focusInEvent(self, event):
event.accept()
# The text displaying the shortcut should be cleared when editing begins.
self.display_sequence_changed.emit()
##############################################
def focusOutEvent(self, event):
event.accept()
self._cancel()
##############################################
def _accept(self):
"""Update *new_sequence* if the input is valid."""
self._logger.info('Attempting to accept input...')
# If there hasn't been anything new successfully entered yet, check against the original
# sequence, otherwise check against the latest successfully entered sequence.
# Note: is_customised() assumes that an empty sequence isn't possible we might want to account
# for this in the future.
if ((self._edited_sequence != self._default_sequence)
or (self.is_customised
and self._edited_sequence != self._new_sequence)):
if self._validate(self._edited_sequence):
self._logger.info('Input valid')
self.new_sequence = self._edited_sequence.toString()
else:
self._logger.info('Input invalid')
self._cancel()
else:
self._logger.info('Nothing has changed in the input')
# Nothing's changed.
self._reset_pressed_keys()
self.setFocus(False)
##############################################
def _cancel(self):
self._reset_pressed_keys()
if self._edited_sequence.isEmpty():
# If the edited sequence is empty, setting it to an empty string
# obviously won't change anything, and it will return early.
# We need the display sequence to update though, so call it here.
self.display_sequence_changed.emit()
else:
self._set_edited_sequence('')
##############################################
def _validate(self, sequence):
"""Method to validate the new sequence"""
self._logger.info('Validating key sequence {} ...'.format(
sequence.toString()))
valid = True # False
# do some checks
return valid
class QtKeySequenceEdit(QWidget):
keySequenceChangedSignal = pyqtSignal(QKeySequence)
def __init__(self, parent=None):
super(QtKeySequenceEdit, self).__init__(parent)
self.m_keySequence = QKeySequence()
self.m_num = 0
self.m_lineEdit = QLineEdit(self)
layout = QHBoxLayout(self)
layout.addWidget(self.m_lineEdit)
layout.setContentsMargins(0, 0, 0, 0)
self.m_lineEdit.installEventFilter(self)
self.m_lineEdit.setReadOnly(True)
self.m_lineEdit.setFocusProxy(self)
self.setFocusPolicy(self.m_lineEdit.focusPolicy())
self.setAttribute(Qt.WA_InputMethodEnabled)
def eventFilter(self, o, e):
if o == self.m_lineEdit and e.type() == QEvent.ContextMenu:
c = e
menu = self.m_lineEdit.createStandardContextMenu()
actions = menu.actions()
for action in actions:
action.setShortcut(QKeySequence())
actionString = action.text()
pos = actionString.rfind('\t')
if (pos > 0):
actionString = actionString[:pos]
action.setText(actionString)
actionBefore = None
if (len(actions) > 0):
actionBefore = actions[0]
clearAction = QAction(self.tr("Clear Shortcut"), menu)
menu.insertAction(actionBefore, clearAction)
menu.insertSeparator(actionBefore)
clearAction.setEnabled(not len(self.m_keySequence) <= 0)
clearAction.triggered.connect(self.slotClearShortcut)
menu.exec(c.globalPos())
e.accept()
return True
return super(QtKeySequenceEdit, self).eventFilter(o, e)
def slotClearShortcut(self):
if len(self.m_keySequence) <= 0:
return
self.setKeySequence(QKeySequence())
self.keySequenceChangedSignal.emit(self.m_keySequence)
def handleKeyEvent(self, e):
nextKey = e.key()
if (nextKey == Qt.Key_Control or nextKey == Qt.Key_Shift
or nextKey == Qt.Key_Meta or nextKey == Qt.Key_Alt
or nextKey == Qt.Key_Super_L or nextKey == Qt.Key_AltGr):
return
nextKey |= self.translateModifiers(e.modifiers(), e.text())
k0 = 0
k1 = 0
k2 = 0
k3 = 0
l = len(self.m_keySequence)
if l == 1:
k0 = self.m_keySequence[0]
elif l == 2:
k0 = self.m_keySequence[0]
k1 = self.m_keySequence[1]
elif l == 3:
k0 = self.m_keySequence[0]
k1 = self.m_keySequence[1]
k2 = self.m_keySequence[2]
elif l == 4:
k0 = self.m_keySequence[0]
k1 = self.m_keySequence[1]
k2 = self.m_keySequence[2]
k3 = self.m_keySequence[3]
if self.m_num == 0:
k0 = nextKey
k1 = 0
k2 = 0
k3 = 0
elif self.m_num == 1:
k1 = nextKey
k2 = 0
k3 = 0
elif self.m_num == 2:
k2 = nextKey
k3 = 0
elif self.m_num == 3:
k3 = nextKey
else:
pass
self.m_num += 1
if (self.m_num > 3):
self.m_num = 0
self.m_keySequence = QKeySequence(k0, k1, k2, k3)
self.m_lineEdit.setText(
self.m_keySequence.toString(QKeySequence.NativeText))
e.accept()
self.keySequenceChangedSignal.emit(self.m_keySequence)
def setKeySequence(self, sequence):
if (sequence == self.m_keySequence):
return
self.m_num = 0
self.m_keySequence = sequence
self.m_lineEdit.setText(
self.m_keySequence.toString(QKeySequence.NativeText))
def keySequence(self):
return self.m_keySequence
def translateModifiers(self, state, text):
result = 0
if ((state & Qt.ShiftModifier)
and (len(text) == 0 or not text[0].isprintable()
or text[0].isalpha() or text[0].isspace())):
result |= Qt.SHIFT
if (state & Qt.ControlModifier):
result |= Qt.CTRL
if (state & Qt.MetaModifier):
result |= Qt.META
if (state & Qt.AltModifier):
result |= Qt.ALT
return result
def focusInEvent(self, e):
self.m_lineEdit.event(e)
self.m_lineEdit.selectAll()
super(QtKeySequenceEdit, self).focusInEvent(e)
def focusOutEvent(self, e):
self.m_num = 0
self.m_lineEdit.event(e)
super(QtKeySequenceEdit, self).focusOutEvent(e)
def keyPressEvent(self, e):
self.handleKeyEvent(e)
e.accept()
def keyReleaseEvent(self, e):
self.m_lineEdit.event(e)
def paintEvent(self, ptQPaintEvent):
opt = QStyleOption()
opt.initFrom(self)
p = QPainter(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, p, self)
def event(self, e):
if (e.type() == QEvent.Shortcut or e.type() == QEvent.ShortcutOverride
or e.type() == QEvent.KeyRelease):
e.accept()
return True
return super(QtKeySequenceEdit, self).event(e)
class KeySequenceButton(QPushButton):
def __init__(self, parent=None):
super(KeySequenceButton, self).__init__(parent)
self.setIcon(icons.get("configure"))
self._modifierlessAllowed = False
self._seq = QKeySequence()
self._timer = QTimer()
self._timer.setSingleShot(True)
self._isrecording = False
self.clicked.connect(self.startRecording)
self._timer.timeout.connect(self.doneRecording)
def setKeySequence(self, seq):
self._seq = seq
self.updateDisplay()
def keySequence(self):
if self._isrecording:
self.doneRecording()
return self._seq
def updateDisplay(self):
if self._isrecording:
s = self._recseq.toString(QKeySequence.NativeText).replace(
'&', '&&')
if self._modifiers:
if s: s += ","
s += QKeySequence(self._modifiers).toString(
QKeySequence.NativeText)
elif self._recseq.isEmpty():
s = _("Input")
s += " ..."
else:
s = self._seq.toString(QKeySequence.NativeText).replace('&', '&&')
self.setText(s)
def isRecording(self):
return self._isrecording
def event(self, ev):
if self._isrecording:
# prevent Qt from special casing Tab and Backtab
if ev.type() == QEvent.KeyPress:
self.keyPressEvent(ev)
return True
return super(KeySequenceButton, self).event(ev)
def keyPressEvent(self, ev):
if not self._isrecording:
return super(KeySequenceButton, self).keyPressEvent(ev)
if ev.isAutoRepeat():
return
modifiers = int(ev.modifiers()
& (Qt.SHIFT | Qt.CTRL | Qt.ALT | Qt.META))
ev.accept()
key = ev.key()
# check if key is a modifier or a character key without modifier (and if that is allowed)
if (
# don't append the key if the key is -1 (garbage) or a modifier ...
key not in (-1, Qt.Key_AltGr, Qt.Key_Shift, Qt.Key_Control,
Qt.Key_Alt, Qt.Key_Meta, Qt.Key_Menu)
# or if this is the first key and without modifier and modifierless keys are not allowed
and (self._modifierlessAllowed or self._recseq.count() > 0
or modifiers & ~Qt.SHIFT or not ev.text() or
(modifiers & Qt.SHIFT and key in
(Qt.Key_Return, Qt.Key_Space, Qt.Key_Tab, Qt.Key_Backtab,
Qt.Key_Backspace, Qt.Key_Delete, Qt.Key_Escape)))):
# change Shift+Backtab into Shift+Tab
if key == Qt.Key_Backtab and modifiers & Qt.SHIFT:
key = Qt.Key_Tab | modifiers
# remove the Shift modifier if it doesn't make sense
# elif (Qt.Key_Exclam <= key <= Qt.Key_At
# or Qt.Key_Z < key <= 0x0ff):
# key = key | (modifiers & ~Qt.SHIFT)
else:
key = key | modifiers
# append max. 4 keystrokes
if self._recseq.count() < 4:
l = list(self._recseq)
l.append(key)
self._recseq = QKeySequence(*l)
self._modifiers = modifiers
self.controlTimer()
self.updateDisplay()
def keyReleaseEvent(self, ev):
if not self._isrecording:
return super(KeySequenceButton, self).keyReleaseEvent(ev)
modifiers = int(ev.modifiers()
& (Qt.SHIFT | Qt.CTRL | Qt.ALT | Qt.META))
ev.accept()
self._modifiers = modifiers
self.controlTimer()
self.updateDisplay()
def hideEvent(self, ev):
if self._isrecording:
self.cancelRecording()
super(KeySequenceButton, self).hideEvent(ev)
def controlTimer(self):
if self._modifiers or self._recseq.isEmpty():
self._timer.stop()
else:
self._timer.start(600)
def startRecording(self):
self.setFocus(True) # because of QTBUG 17810
self.setDown(True)
self.setStyleSheet("text-align: left;")
self._isrecording = True
self._recseq = QKeySequence()
self._modifiers = int(QApplication.keyboardModifiers()
& (Qt.SHIFT | Qt.CTRL | Qt.ALT | Qt.META))
self.grabKeyboard()
self.updateDisplay()
def doneRecording(self):
self._seq = self._recseq
self.cancelRecording()
self.clearFocus()
self.parentWidget().keySequenceChanged.emit(self.parentWidget().num())
def cancelRecording(self):
if not self._isrecording:
return
self.setDown(False)
self.setStyleSheet(None)
self._isrecording = False
self.releaseKeyboard()
self.updateDisplay()
return
else:
self.key_seq_list[11] = key_seq
# self.shortcut_settings.setValue("location_right", key_seq)
self.location_right_label.setText(key_seq.toString())
def accept(self):
print(self.key_seq_list)
self.shortcut_settings.setValue("show_hide_detail",
self.key_seq_list[3])
self.shortcut_settings.setValue("show_hide_company",
self.key_seq_list[4])
self.shortcut_settings.setValue("page_down", self.key_seq_list[6])
self.shortcut_settings.setValue("page_up", self.key_seq_list[7])
self.shortcut_settings.setValue("location_up", self.key_seq_list[8])
self.shortcut_settings.setValue("location_down", self.key_seq_list[9])
self.shortcut_settings.setValue("location_left", self.key_seq_list[10])
self.shortcut_settings.setValue("location_right",
self.key_seq_list[11])
# 接下来 要那拿着这些设置去配置快捷键
self.reset_shortcut_signal.emit()
super(ShortCutSetDialogControl, self).accept()
if __name__ == '__main__':
x = QKeySequence(Qt.CTRL + Qt.Key_Insert)
y = QKeySequence(Qt.CTRL + Qt.Key_Insert)
print(x == y)
print(str(x))
print(x.toString())
class ShortCutSetDialogControl(QDialog, Ui_shortCutDialog):
reset_shortcut_signal = pyqtSignal()
def __init__(self, parent):
super(ShortCutSetDialogControl, self).__init__(parent)
self.setupUi(self)
# self.setAttribute(Qt.WA_DeleteOnClose)
# self.setWindowFlags(Qt.WindowStaysOnTopHint)
self.shortcut_settings = QSettings("short_cut")
self.input_short_cut_dialog_control = InputShortCutDialogControl(self)
self.key_seq_list = [None] * 16
self.move_right_label.setText(
QKeySequence(Qt.ALT + Qt.Key_Space).toString())
self.switch_behind_label.setText(
QKeySequence(Qt.ALT + Qt.Key_Down).toString())
self.switch_front_label.setText(
QKeySequence(Qt.ALT + Qt.Key_Up).toString())
self.hide_detail_company_label.setText(
QKeySequence(Qt.ALT + Qt.Key_Z).toString())
#
self.sell_new_option_label.setText(
QKeySequence(Qt.CTRL + Qt.Key_Insert).toString())
self.this_module_confirm_label.setText(
QKeySequence(Qt.CTRL + Qt.Key_Enter).toString())
self.add_price_label.setText(
QKeySequence(Qt.CTRL + Qt.Key_PageUp).toString())
self.recove_price_label.setText(
QKeySequence(Qt.CTRL + Qt.Key_Home).toString())
# self.show_hide_detail_seq = self.shortcut_settings.value("show_hide_detail")
# if self.show_hide_detail_seq:
# self.show_hide_detail_label.setText(self.show_hide_detail_seq)
#
# self.show_hide_company_seq = self.shortcut_settings.value("show_hide_company")
# if self.show_hide_company_seq:
# self.show_hide_company_label.setText(self.show_hide_company_seq)
#
# self.page_down_seq = self.shortcut_settings.value("page_down")
# if self.page_down_seq:
# self.page_down_label.setText(self.page_down_seq)
#
# self.page_up_seq = self.shortcut_settings.value("page_up")
# if self.page_up_seq:
# self.page_up_label.setText(self.page_up_seq)
#
# self.location_up_seq = self.shortcut_settings.value("location_up")
# if self.location_up_seq:
# self.location_up_label.setText(self.location_up_seq)
#
# self.location_right_seq = self.shortcut_settings.value("location_right")
# if self.location_right_seq:
# self.location_right_label.setText(self.location_right_seq)
#
# self.location_left_seq = self.shortcut_settings.value("location_left")
# if self.location_left_seq:
# self.location_left_label.setText(self.location_left_seq)
#
# self.location_down_seq = self.shortcut_settings.value("location_down")
# if self.location_down_seq:
# self.location_down_label.setText(self.location_down_seq)
self.show_hide_detail_seq = None
self.show_hide_company_seq = None
self.page_down_seq = None
self.page_up_seq = None
self.location_up_seq = None
self.location_right_seq = None
self.location_left_seq = None
self.location_down_seq = None
def set_seq(self):
# self.move_right_label.setText(QKeySequence(Qt.ALT + Qt.Key_Tab).toString())
# self.switch_behind_label.setText(QKeySequence(Qt.ALT + Qt.Key_Down).toString())
# self.switch_front_label.setText(QKeySequence(Qt.ALT + Qt.Key_Up).toString())
# self.hide_detail_company_label.setText(QKeySequence(Qt.ALT + Qt.Key_Z).toString())
# #
# self.sell_new_option_label.setText(QKeySequence(Qt.CTRL + Qt.Key_Insert).toString())
# self.this_module_confirm_label.setText(QKeySequence(Qt.CTRL + Qt.Key_Enter).toString())
# self.add_price_label.setText(QKeySequence(Qt.CTRL + Qt.Key_PageUp).toString())
# self.recove_price_label.setText(QKeySequence(Qt.CTRL + Qt.Key_Home).toString())
self.show_hide_detail_seq = QKeySequence(
self.shortcut_settings.value("show_hide_detail"))
if self.show_hide_detail_seq:
self.show_hide_detail_label.setText(
self.show_hide_detail_seq.toString())
self.show_hide_company_seq = QKeySequence(
self.shortcut_settings.value("show_hide_company"))
if self.show_hide_company_seq:
self.show_hide_company_label.setText(
self.show_hide_company_seq.toString())
self.page_down_seq = QKeySequence(
self.shortcut_settings.value("page_down"))
if self.page_down_seq:
self.page_down_label.setText(self.page_down_seq.toString())
self.page_up_seq = QKeySequence(
self.shortcut_settings.value("page_up"))
if self.page_up_seq:
self.page_up_label.setText(self.page_up_seq.toString())
self.location_up_seq = QKeySequence(
self.shortcut_settings.value("location_up"))
if self.location_up_seq:
self.location_up_label.setText(self.location_up_seq.toString())
self.location_right_seq = QKeySequence(
self.shortcut_settings.value("location_right"))
if self.location_right_seq:
self.location_right_label.setText(
self.location_right_seq.toString())
self.location_left_seq = QKeySequence(
self.shortcut_settings.value("location_left"))
if self.location_left_seq:
self.location_left_label.setText(self.location_left_seq.toString())
self.location_down_seq = QKeySequence(
self.shortcut_settings.value("location_down"))
if self.location_down_seq:
self.location_down_label.setText(self.location_down_seq.toString())
self.key_seq_list = [
QKeySequence(Qt.ALT + Qt.Key_Tab),
QKeySequence(Qt.ALT + Qt.Key_Down),
QKeySequence(Qt.ALT + Qt.Key_Up), self.show_hide_detail_seq,
self.show_hide_company_seq,
QKeySequence(Qt.ALT + Qt.Key_Z), self.page_down_seq,
self.page_up_seq, self.location_up_seq, self.location_right_seq,
self.location_left_seq, self.location_down_seq,
QKeySequence(Qt.CTRL + Qt.Key_Insert),
QKeySequence(Qt.CTRL + Qt.Key_Enter),
QKeySequence(Qt.CTRL + Qt.Key_PageUp),
QKeySequence(Qt.CTRL + Qt.Key_Home)
]
@pyqtSlot()
def on_show_hide_detail_toolButton_clicked(self):
''''''
self.input_short_cut_dialog_control.change_set_who_label_signal.emit(
"显/隐明细")
self.input_short_cut_dialog_control.lineEdit.setFocus()
self.input_short_cut_dialog_control.exec_()
key_seq = self.input_short_cut_dialog_control.get_keysequence()
self.input_short_cut_dialog_control.lineEdit.clear()
if key_seq:
if key_seq in self.key_seq_list:
QMessageBox.warning(self, "错误", "快捷键不可重复")
return
else:
self.key_seq_list[3] = key_seq
# self.shortcut_settings.setValue("show_hide_detail", key_seq)
self.show_hide_detail_label.setText(key_seq.toString())
@pyqtSlot()
def on_show_hide_company_toolButton_clicked(self):
''''''
self.input_short_cut_dialog_control.change_set_who_label_signal.emit(
"显/隐对公")
self.input_short_cut_dialog_control.lineEdit.setFocus()
self.input_short_cut_dialog_control.exec_()
key_seq = self.input_short_cut_dialog_control.get_keysequence()
self.input_short_cut_dialog_control.lineEdit.clear()
if key_seq:
if key_seq in self.key_seq_list:
QMessageBox.warning(self, "错误", "快捷键不可重复")
return
else:
self.key_seq_list[4] = key_seq
# self.shortcut_settings.setValue("show_hide_company", key_seq)
self.show_hide_company_label.setText(key_seq.toString())
@pyqtSlot()
def on_page_down_toolButton_clicked(self):
''''''
self.input_short_cut_dialog_control.change_set_who_label_signal.emit(
"向下翻页")
self.input_short_cut_dialog_control.lineEdit.setFocus()
self.input_short_cut_dialog_control.exec_()
key_seq = self.input_short_cut_dialog_control.get_keysequence()
self.input_short_cut_dialog_control.lineEdit.clear()
if key_seq:
if key_seq in self.key_seq_list:
QMessageBox.warning(self, "错误", "快捷键不可重复")
return
else:
self.key_seq_list[6] = key_seq
# self.shortcut_settings.setValue("page_down", key_seq)
self.page_down_label.setText(key_seq.toString())
@pyqtSlot()
def on_page_up_toolButton_clicked(self):
''''''
self.input_short_cut_dialog_control.change_set_who_label_signal.emit(
"向上翻页")
self.input_short_cut_dialog_control.lineEdit.setFocus()
self.input_short_cut_dialog_control.exec_()
key_seq = self.input_short_cut_dialog_control.get_keysequence()
self.input_short_cut_dialog_control.lineEdit.clear()
if key_seq:
if key_seq in self.key_seq_list:
QMessageBox.warning(self, "错误", "快捷键不可重复")
return
else:
self.key_seq_list[7] = key_seq
# self.shortcut_settings.setValue("page_up", key_seq)
self.page_up_label.setText(key_seq.toString())
@pyqtSlot()
def on_location_up_toolButton_clicked(self):
''''''
self.input_short_cut_dialog_control.change_set_who_label_signal.emit(
"定位最上")
self.input_short_cut_dialog_control.lineEdit.setFocus()
self.input_short_cut_dialog_control.exec_()
key_seq = self.input_short_cut_dialog_control.get_keysequence()
self.input_short_cut_dialog_control.lineEdit.clear()
if key_seq:
if key_seq in self.key_seq_list:
QMessageBox.warning(self, "错误", "快捷键不可重复")
return
else:
self.key_seq_list[8] = key_seq
# self.shortcut_settings.setValue("location_up", key_seq)
self.location_up_label.setText(key_seq.toString())
@pyqtSlot()
def on_location_down_toolButton_clicked(self):
''''''
self.input_short_cut_dialog_control.change_set_who_label_signal.emit(
"定位最下")
self.input_short_cut_dialog_control.lineEdit.setFocus()
self.input_short_cut_dialog_control.exec_()
key_seq = self.input_short_cut_dialog_control.get_keysequence()
self.input_short_cut_dialog_control.lineEdit.clear()
if key_seq:
if key_seq in self.key_seq_list:
QMessageBox.warning(self, "错误", "快捷键不可重复")
return
else:
self.key_seq_list[9] = key_seq
print(key_seq)
# self.shortcut_settings.setValue("location_down",key_seq)
self.location_down_label.setText(key_seq.toString())
@pyqtSlot()
def on_location_left_toolButton_clicked(self):
''''''
self.input_short_cut_dialog_control.change_set_who_label_signal.emit(
"定位最左")
self.input_short_cut_dialog_control.lineEdit.setFocus()
self.input_short_cut_dialog_control.exec_()
key_seq = self.input_short_cut_dialog_control.get_keysequence()
self.input_short_cut_dialog_control.lineEdit.clear()
if key_seq:
if key_seq in self.key_seq_list:
QMessageBox.warning(self, "错误", "快捷键不可重复")
return
else:
self.key_seq_list[10] = key_seq
# self.shortcut_settings.setValue("location_left", key_seq)
self.location_left_label.setText(key_seq.toString())
@pyqtSlot()
def on_location_right_toolButton_clicked(self):
''''''
self.input_short_cut_dialog_control.change_set_who_label_signal.emit(
"定位最右")
self.input_short_cut_dialog_control.lineEdit.setFocus()
self.input_short_cut_dialog_control.exec_()
key_seq = self.input_short_cut_dialog_control.get_keysequence()
self.input_short_cut_dialog_control.lineEdit.clear()
if key_seq:
if key_seq in self.key_seq_list:
QMessageBox.warning(self, "错误", "快捷键不可重复")
return
else:
self.key_seq_list[11] = key_seq
# self.shortcut_settings.setValue("location_right", key_seq)
self.location_right_label.setText(key_seq.toString())
def accept(self):
print(self.key_seq_list)
self.shortcut_settings.setValue("show_hide_detail",
self.key_seq_list[3])
self.shortcut_settings.setValue("show_hide_company",
self.key_seq_list[4])
self.shortcut_settings.setValue("page_down", self.key_seq_list[6])
self.shortcut_settings.setValue("page_up", self.key_seq_list[7])
self.shortcut_settings.setValue("location_up", self.key_seq_list[8])
self.shortcut_settings.setValue("location_down", self.key_seq_list[9])
self.shortcut_settings.setValue("location_left", self.key_seq_list[10])
self.shortcut_settings.setValue("location_right",
self.key_seq_list[11])
# 接下来 要那拿着这些设置去配置快捷键
self.reset_shortcut_signal.emit()
super(ShortCutSetDialogControl, self).accept()
class KeySequenceButton(QPushButton):
def __init__(self, parent=None):
super(KeySequenceButton, self).__init__(parent)
self.setIcon(icons.get("configure"))
self._modifierlessAllowed = False
self._seq = QKeySequence()
self._timer = QTimer()
self._timer.setSingleShot(True)
self._isrecording = False
self.clicked.connect(self.startRecording)
self._timer.timeout.connect(self.doneRecording)
def setKeySequence(self, seq):
self._seq = seq
self.updateDisplay()
def keySequence(self):
if self._isrecording:
self.doneRecording()
return self._seq
def updateDisplay(self):
if self._isrecording:
s = self._recseq.toString(QKeySequence.NativeText).replace('&', '&&')
if self._modifiers:
if s: s += ","
s += QKeySequence(self._modifiers).toString(QKeySequence.NativeText)
elif self._recseq.isEmpty():
s = _("Input")
s += " ..."
else:
s = self._seq.toString(QKeySequence.NativeText).replace('&', '&&')
self.setText(s)
def isRecording(self):
return self._isrecording
def event(self, ev):
if self._isrecording:
# prevent Qt from special casing Tab and Backtab
if ev.type() == QEvent.KeyPress:
self.keyPressEvent(ev)
return True
return super(KeySequenceButton, self).event(ev)
def keyPressEvent(self, ev):
if not self._isrecording:
return super(KeySequenceButton, self).keyPressEvent(ev)
if ev.isAutoRepeat():
return
modifiers = int(ev.modifiers() & (Qt.SHIFT | Qt.CTRL | Qt.ALT | Qt.META))
ev.accept()
key = ev.key()
# check if key is a modifier or a character key without modifier (and if that is allowed)
if (
# don't append the key if the key is -1 (garbage) or a modifier ...
key not in (-1, Qt.Key_AltGr, Qt.Key_Shift, Qt.Key_Control,
Qt.Key_Alt, Qt.Key_Meta, Qt.Key_Menu)
# or if this is the first key and without modifier and modifierless keys are not allowed
and (self._modifierlessAllowed
or self._recseq.count() > 0
or modifiers & ~Qt.SHIFT
or not ev.text()
or (modifiers & Qt.SHIFT
and key in (Qt.Key_Return, Qt.Key_Space, Qt.Key_Tab, Qt.Key_Backtab,
Qt.Key_Backspace, Qt.Key_Delete, Qt.Key_Escape)))):
# change Shift+Backtab into Shift+Tab
if key == Qt.Key_Backtab and modifiers & Qt.SHIFT:
key = Qt.Key_Tab | modifiers
# remove the Shift modifier if it doesn't make sense
# elif (Qt.Key_Exclam <= key <= Qt.Key_At
# or Qt.Key_Z < key <= 0x0ff):
# key = key | (modifiers & ~Qt.SHIFT)
else:
key = key | modifiers
# append max. 4 keystrokes
if self._recseq.count() < 4:
l = list(self._recseq)
l.append(key)
self._recseq = QKeySequence(*l)
self._modifiers = modifiers
self.controlTimer()
self.updateDisplay()
def keyReleaseEvent(self, ev):
if not self._isrecording:
return super(KeySequenceButton, self).keyReleaseEvent(ev)
modifiers = int(ev.modifiers() & (Qt.SHIFT | Qt.CTRL | Qt.ALT | Qt.META))
ev.accept()
self._modifiers = modifiers
self.controlTimer()
self.updateDisplay()
def hideEvent(self, ev):
if self._isrecording:
self.cancelRecording()
super(KeySequenceButton, self).hideEvent(ev)
def controlTimer(self):
if self._modifiers or self._recseq.isEmpty():
self._timer.stop()
else:
self._timer.start(600)
def startRecording(self):
self.setFocus(True) # because of QTBUG 17810
self.setDown(True)
self.setStyleSheet("text-align: left;")
self._isrecording = True
self._recseq = QKeySequence()
self._modifiers = int(QApplication.keyboardModifiers() & (Qt.SHIFT | Qt.CTRL | Qt.ALT | Qt.META))
self.grabKeyboard()
self.updateDisplay()
def doneRecording(self):
self._seq = self._recseq
self.cancelRecording()
self.clearFocus()
self.parentWidget().keySequenceChanged.emit(self.parentWidget().num())
def cancelRecording(self):
if not self._isrecording:
return
self.setDown(False)
self.setStyleSheet(None)
self._isrecording = False
self.releaseKeyboard()
self.updateDisplay()
def shortcut_help_to_string(self, shortcut, help_text):
"""Formats a shortcut string and help text."""
return (QKeySequence.toString(QKeySequence(shortcut),
QKeySequence.NativeText) + '\t' +
help_text + '\n')
def setKey(self, key_string):
self.key_string = key_string
qkeyseq = QKeySequence(key_string, QKeySequence.PortableText)
native_key_string = qkeyseq.toString(format=QKeySequence.NativeText)
self.setText(native_key_string)
