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()