Update

2023/scripts/animation_tools/dwpicker/hotkeyseditor.py

@@ -0,0 +1,194 @@
+
+from .pyside import QtWidgets, QtCore, QtGui
+from .hotkeys import get_hotkeys_config, save_hotkey_config
+
+
+class HotkeysEditor(QtWidgets.QWidget):
+    hotkey_changed = QtCore.Signal()
+
+    def __init__(self, parent=None):
+        super(HotkeysEditor, self).__init__(parent)
+        self.model = HotkeysTableModel()
+        self.model.hotkey_changed.connect(self.hotkey_changed.emit)
+        self.table = QtWidgets.QTableView()
+        self.table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
+        self.table.setModel(self.model)
+        self.table.selectionModel().selectionChanged.connect(
+            self.selection_changed)
+        self.hotkey_editor = HotkeyEditor()
+        self.hotkey_editor.hotkey_edited.connect(self.update_hotkeys)
+        self.clear = QtWidgets.QPushButton('Clear')
+        self.clear.released.connect(self.do_clear)
+
+        hotkey_layout = QtWidgets.QVBoxLayout()
+        hotkey_layout.setContentsMargins(0, 0, 0, 0)
+        hotkey_layout.addWidget(self.hotkey_editor)
+        hotkey_layout.addWidget(self.clear)
+        hotkey_layout.addStretch(1)
+
+        layout = QtWidgets.QHBoxLayout(self)
+        layout.addWidget(self.table)
+        layout.addLayout(hotkey_layout)
+
+    def do_clear(self):
+        self.hotkey_editor.clear_values()
+        self.update_hotkeys()
+        self.hotkey_changed.emit()
+
+    def update_hotkeys(self):
+        self.model.set_keysequence(
+            self.hotkey_editor.function_name,
+            self.hotkey_editor.key_sequence())
+
+    def selection_changed(self, *_):
+        indexes = self.table.selectionModel().selectedIndexes()
+        if not indexes:
+            self.hotkey_editor.clear()
+            return
+        row = indexes[0].row()
+        function_name = sorted(list(self.model.config))[row]
+        data = self.model.config[function_name]
+        self.hotkey_editor.set_key_sequence(
+            function_name, data['key_sequence'])
+
+
+class HotkeyEditor(QtWidgets.QWidget):
+    hotkey_edited = QtCore.Signal()
+
+    def __init__(self, parent=None):
+        super(HotkeyEditor, self).__init__(parent)
+        self.function_name = None
+        self.function_name_label = QtWidgets.QLabel()
+        self.alt = QtWidgets.QCheckBox('Alt')
+        self.alt.released.connect(self.emit_hotkey_edited)
+        self.ctrl = QtWidgets.QCheckBox('Ctrl')
+        self.ctrl.released.connect(self.emit_hotkey_edited)
+        self.shift = QtWidgets.QCheckBox('Shift')
+        self.shift.released.connect(self.emit_hotkey_edited)
+        self.string = KeyField()
+        self.string.changed.connect(self.hotkey_edited.emit)
+
+        modifiers = QtWidgets.QHBoxLayout()
+        modifiers.addWidget(self.alt)
+        modifiers.addWidget(self.ctrl)
+        modifiers.addWidget(self.shift)
+
+        layout = QtWidgets.QVBoxLayout(self)
+        layout.addWidget(self.function_name_label)
+        layout.addLayout(modifiers)
+        layout.addWidget(self.string)
+
+    def clear(self):
+        self.function_name = None
+        self.clear_values()
+        self.function_name_label.setText('')
+
+    def clear_values(self):
+        self.ctrl.setChecked(False)
+        self.alt.setChecked(False)
+        self.shift.setChecked(False)
+        self.string.setText('')
+
+    def emit_hotkey_edited(self, *_):
+        self.hotkey_edited.emit()
+
+    def key_sequence(self):
+        if not self.string.text():
+            return None
+        sequence = []
+        if self.ctrl.isChecked():
+            sequence.append('CTRL')
+        if self.alt.isChecked():
+            sequence.append('ALT')
+        if self.shift.isChecked():
+            sequence.append('SHIFT')
+        sequence.append(self.string.text())
+        return '+'.join(sequence)
+
+    def set_key_sequence(self, function_name, key_sequence):
+        self.function_name = function_name
+        self.function_name_label.setText(function_name.title())
+        if key_sequence is None:
+            self.ctrl.setChecked(False)
+            self.alt.setChecked(False)
+            self.shift.setChecked(False)
+            self.string.setText('')
+            return
+        self.ctrl.setChecked('ctrl' in key_sequence.lower())
+        self.alt.setChecked('alt' in key_sequence.lower())
+        self.shift.setChecked('shift' in key_sequence.lower())
+        self.string.setText(key_sequence.split('+')[-1])
+
+
+class KeyField(QtWidgets.QLineEdit):
+    changed = QtCore.Signal()
+
+    def __init__(self, parent=None):
+        super(KeyField, self).__init__(parent)
+        self.setReadOnly(True)
+
+    def keyPressEvent(self, event):
+        if event.key() == QtCore.Qt.Key_Shift:
+            return
+        self.setText(QtGui.QKeySequence(event.key()).toString())
+        self.changed.emit()
+
+
+class HotkeysTableModel(QtCore.QAbstractTableModel):
+    HEADERS = 'Function', 'Key sequence'
+    hotkey_changed = QtCore.Signal()
+
+    def __init__(self, parent=None):
+        super(HotkeysTableModel, self).__init__(parent)
+        self.config = get_hotkeys_config()
+
+    def rowCount(self, *_):
+        return len(self.config)
+
+    def columnCount(self, *_):
+        return len(self.HEADERS)
+
+    def set_keysequence(self, function_name, key_sequence):
+        self.layoutAboutToBeChanged.emit()
+        self.config[function_name]['key_sequence'] = key_sequence
+        if key_sequence is None:
+            self.config[function_name]['enabled'] = False
+        save_hotkey_config(self.config)
+        self.layoutChanged.emit()
+        self.hotkey_changed.emit()
+
+    def flags(self, index):
+        flags = QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable
+        if index.column() == 0:
+            flags |= QtCore.Qt.ItemIsUserCheckable
+        return flags
+
+    def headerData(self, section, orientation, role):
+        if orientation == QtCore.Qt.Vertical or role != QtCore.Qt.DisplayRole:
+            return
+        return self.HEADERS[section]
+
+    def setData(self, index, value, role):
+
+        if role != QtCore.Qt.CheckStateRole or index.column() != 0:
+            return
+        function = sorted(list(self.config))[index.row()]
+        self.config[function]['enabled'] = value
+        save_hotkey_config(self.config)
+        self.hotkey_changed.emit()
+        return True
+
+    def data(self, index, role):
+        if not index.isValid():
+            return
+
+        function = sorted(list(self.config))[index.row()]
+        data = self.config[function]
+        if role == QtCore.Qt.DisplayRole:
+            if index.column() == 0:
+                return function.title()
+            else:
+                return data['key_sequence']
+        if role == QtCore.Qt.CheckStateRole and index.column() == 0:
+            return (
+                QtCore.Qt.Checked if data['enabled'] else QtCore.Qt.Unchecked)