class MatrixTest(BasicEditor):
def __init__(self, layout_editor):
super().__init__()
self.layout_editor = layout_editor
self.keyboardWidget = KeyboardWidget(layout_editor)
self.keyboardWidget.set_enabled(False)
self.unlock_btn = QPushButton("Unlock")
self.reset_btn = QPushButton("Reset")
layout = QVBoxLayout()
layout.addWidget(self.keyboardWidget)
layout.setAlignment(self.keyboardWidget, Qt.AlignCenter)
self.addLayout(layout)
btn_layout = QHBoxLayout()
btn_layout.addStretch()
self.unlock_lbl = QLabel(tr("MatrixTest", "Unlock the keyboard before testing:"))
btn_layout.addWidget(self.unlock_lbl)
btn_layout.addWidget(self.unlock_btn)
btn_layout.addWidget(self.reset_btn)
self.addLayout(btn_layout)
self.keyboard = None
self.device = None
self.polling = False
self.timer = QTimer()
self.timer.timeout.connect(self.matrix_poller)
self.unlock_btn.clicked.connect(self.unlock)
self.reset_btn.clicked.connect(self.reset_keyboard_widget)
self.grabber = QWidget()
def rebuild(self, device):
super().rebuild(device)
if self.valid():
self.keyboard = device.keyboard
self.keyboardWidget.set_keys(self.keyboard.keys, self.keyboard.encoders)
self.keyboardWidget.setEnabled(self.valid())
def valid(self):
# Check if vial protocol is v3 or later
return isinstance(self.device, VialKeyboard) and \
(self.device.keyboard and self.device.keyboard.vial_protocol >= 3)
def reset_keyboard_widget(self):
# reset keyboard widget
for w in self.keyboardWidget.widgets:
w.setPressed(False)
w.setActive(False)
self.keyboardWidget.update_layout()
self.keyboardWidget.update()
self.keyboardWidget.updateGeometry()
def matrix_poller(self):
if not self.valid():
self.timer.stop()
return
try:
unlocked = self.keyboard.get_unlock_status(3)
except (RuntimeError, ValueError):
self.timer.stop()
return
if not unlocked:
self.unlock_btn.show()
self.unlock_lbl.show()
return
# we're unlocked, so hide unlock button and label
self.unlock_btn.hide()
self.unlock_lbl.hide()
# Get size for matrix
rows = self.keyboard.rows
cols = self.keyboard.cols
# Generate 2d array of matrix
matrix = [[None] * cols for x in range(rows)]
# Get matrix data from keyboard
try:
data = self.keyboard.matrix_poll()
except (RuntimeError, ValueError):
self.timer.stop()
return
# Calculate the amount of bytes belong to 1 row, each bit is 1 key, so per 8 keys in a row,
# a byte is needed for the row.
row_size = math.ceil(cols / 8)
for row in range(rows):
# Make slice of bytes for the row (skip first 2 bytes, they're for VIAL)
row_data_start = 2 + (row * row_size)
row_data_end = row_data_start + row_size
row_data = data[row_data_start:row_data_end]
# Get each bit representing pressed state for col
for col in range(cols):
# row_data is array of bytes, calculate in which byte the col is located
col_byte = len(row_data) - 1 - math.floor(col / 8)
# since we select a single byte as slice of byte, mod 8 to get nth pos of byte
col_mod = (col % 8)
# write to matrix array
matrix[row][col] = (row_data[col_byte] >> col_mod) & 1
# write matrix state to keyboard widget
for w in self.keyboardWidget.widgets:
if w.desc.row is not None and w.desc.col is not None:
row = w.desc.row
col = w.desc.col
if row < len(matrix) and col < len(matrix[row]):
w.setPressed(matrix[row][col])
if matrix[row][col]:
w.setActive(True)
self.keyboardWidget.update_layout()
self.keyboardWidget.update()
self.keyboardWidget.updateGeometry()
def unlock(self):
Unlocker.unlock(self.keyboard)
def activate(self):
self.grabber.grabKeyboard()
self.timer.start(20)
def deactivate(self):
self.grabber.releaseKeyboard()
self.timer.stop()
class KeymapEditor(BasicEditor):
def __init__(self, layout_editor):
super().__init__()
self.layout_editor = layout_editor
self.layout_layers = QHBoxLayout()
self.layout_size = QVBoxLayout()
layer_label = QLabel(tr("KeymapEditor", "Layer"))
layout_labels_container = QHBoxLayout()
layout_labels_container.addWidget(layer_label)
layout_labels_container.addLayout(self.layout_layers)
layout_labels_container.addStretch()
layout_labels_container.addLayout(self.layout_size)
# contains the actual keyboard
self.container = KeyboardWidget(layout_editor)
self.container.clicked.connect(self.on_key_clicked)
layout = QVBoxLayout()
layout.addLayout(layout_labels_container)
layout.addWidget(self.container)
layout.setAlignment(self.container, Qt.AlignHCenter)
self.layer_buttons = []
self.keyboard = None
self.current_layer = 0
layout_editor.changed.connect(self.on_layout_changed)
self.container.anykey.connect(self.on_any_keycode)
self.tabbed_keycodes = TabbedKeycodes()
self.tabbed_keycodes.keycode_changed.connect(self.on_keycode_changed)
self.tabbed_keycodes.anykey.connect(self.on_any_keycode)
self.addLayout(layout)
self.addWidget(self.tabbed_keycodes)
self.device = None
KeycodeDisplay.notify_keymap_override(self)
def on_container_clicked(self):
""" Called when a mouse click event is bubbled up to the editor's container """
self.container.deselect()
self.container.update()
def on_keycode_changed(self, code):
self.set_key(code)
def rebuild_layers(self):
# delete old layer labels
for label in self.layer_buttons:
label.hide()
label.deleteLater()
self.layer_buttons = []
# create new layer labels
for x in range(self.keyboard.layers):
btn = SquareButton(str(x))
btn.setFocusPolicy(Qt.NoFocus)
btn.setRelSize(1.667)
btn.setCheckable(True)
btn.clicked.connect(lambda state, idx=x: self.switch_layer(idx))
self.layout_layers.addWidget(btn)
self.layer_buttons.append(btn)
for x in range(0, 2):
btn = SquareButton("-") if x else SquareButton("+")
btn.setFocusPolicy(Qt.NoFocus)
btn.setCheckable(False)
btn.clicked.connect(lambda state, idx=x: self.adjust_size(idx))
self.layout_size.addWidget(btn)
self.layer_buttons.append(btn)
def adjust_size(self, minus):
if minus:
self.container.set_scale(self.container.get_scale() - 0.1)
else:
self.container.set_scale(self.container.get_scale() + 0.1)
self.refresh_layer_display()
def rebuild(self, device):
super().rebuild(device)
if self.valid():
self.keyboard = device.keyboard
# get number of layers
self.rebuild_layers()
self.container.set_keys(self.keyboard.keys, self.keyboard.encoders)
self.current_layer = 0
self.on_layout_changed()
recreate_keyboard_keycodes(self.keyboard)
self.tabbed_keycodes.recreate_keycode_buttons()
TabbedKeycodes.tray.recreate_keycode_buttons()
self.refresh_layer_display()
self.container.setEnabled(self.valid())
def valid(self):
return isinstance(self.device, VialKeyboard)
def save_layout(self):
return self.keyboard.save_layout()
def restore_layout(self, data):
if json.loads(
data.decode("utf-8")).get("uid") != self.keyboard.keyboard_id:
ret = QMessageBox.question(
self.widget(), "",
tr(
"KeymapEditor",
"Saved keymap belongs to a different keyboard,"
" are you sure you want to continue?"),
QMessageBox.Yes | QMessageBox.No)
if ret != QMessageBox.Yes:
return
self.keyboard.restore_layout(data)
self.refresh_layer_display()
def on_any_keycode(self):
if self.container.active_key is None:
return
current_code = self.code_for_widget(self.container.active_key)
if self.container.active_mask:
current_code &= 0xFF
dlg = AnyKeycodeDialog(current_code)
if dlg.exec_() and dlg.value >= 0:
self.on_keycode_changed(dlg.value)
def code_for_widget(self, widget):
if widget.desc.row is not None:
return self.keyboard.layout[(self.current_layer, widget.desc.row,
widget.desc.col)]
else:
return self.keyboard.encoder_layout[(self.current_layer,
widget.desc.encoder_idx,
widget.desc.encoder_dir)]
def refresh_layer_display(self):
""" Refresh text on key widgets to display data corresponding to current layer """
self.container.update_layout()
for idx, btn in enumerate(self.layer_buttons):
btn.setEnabled(idx != self.current_layer)
btn.setChecked(idx == self.current_layer)
for widget in self.container.widgets:
code = self.code_for_widget(widget)
KeycodeDisplay.display_keycode(widget, code)
self.container.update()
self.container.updateGeometry()
def switch_layer(self, idx):
self.container.deselect()
self.current_layer = idx
self.refresh_layer_display()
def set_key(self, keycode):
""" Change currently selected key to provided keycode """
if self.container.active_key is None:
return
if isinstance(self.container.active_key, EncoderWidget):
self.set_key_encoder(keycode)
else:
self.set_key_matrix(keycode)
self.container.select_next()
def set_key_encoder(self, keycode):
l, i, d = self.current_layer, self.container.active_key.desc.encoder_idx,\
self.container.active_key.desc.encoder_dir
# if masked, ensure that this is a byte-sized keycode
if self.container.active_mask:
if keycode > 0xFF:
return
keycode = (self.keyboard.encoder_layout[(l, i, d)]
& 0xFF00) | keycode
self.keyboard.set_encoder(l, i, d, keycode)
self.refresh_layer_display()
def set_key_matrix(self, keycode):
l, r, c = self.current_layer, self.container.active_key.desc.row, self.container.active_key.desc.col
if r >= 0 and c >= 0:
# if masked, ensure that this is a byte-sized keycode
if self.container.active_mask:
if keycode > 0xFF:
return
keycode = (self.keyboard.layout[(l, r, c)] & 0xFF00) | keycode
self.keyboard.set_key(l, r, c, keycode)
self.refresh_layer_display()
def on_key_clicked(self):
""" Called when a key on the keyboard widget is clicked """
self.refresh_layer_display()
def on_layout_changed(self):
if self.keyboard is None:
return
self.refresh_layer_display()
self.keyboard.set_layout_options(self.layout_editor.pack())
def on_keymap_override(self):
self.refresh_layer_display()