def get_system_keymap(self, machine_type=None):
if machine_type is None:
machine_type = self.get_machine_type()
try:
machine_class = machine_registry.get(machine_type)
except:
log.error("invalid machine type: %s", machine_type, exc_info=True)
return None
section = SYSTEM_CONFIG_SECTION % DEFAULT_SYSTEM
option = SYSTEM_KEYMAP_OPTION % machine_type
mappings = self._get(section, option, None)
if mappings is None:
mappings = system.KEYMAPS.get(machine_type)
else:
try:
mappings = dict(json.loads(mappings))
except ValueError as e:
log.error("invalid machine keymap, resetting to default",
exc_info=True)
mappings = system.KEYMAPS.get(machine_type)
self.set_system_keymap(mappings, machine_type)
keymap = Keymap(machine_class.get_keys(),
system.KEYS + machine_class.get_actions())
keymap.set_mappings(mappings)
return keymap
def machine(request, capture):
machine = Keyboard({'arpeggiate': request.param})
keymap = Keymap(Keyboard.KEYS_LAYOUT.split(),
system.KEYS + Keyboard.ACTIONS)
keymap.set_mappings(system.KEYMAPS['Keyboard'])
machine.set_keymap(keymap)
return machine
def __init__(self, _): super(TinyMod4Machine, self).__init__() keys = self.get_keys() self.keymap = Keymap(keys, keys) self.keymap.set_mappings(zip(keys, keys)) self._pressed = False self._stack = ForthStack(8, 7) self._modeSelectPin = 12
def __init__(self):
# Setup default keymap with no translation of keys.
keys = self.get_keys()
self.keymap = Keymap(keys, keys)
self.keymap.set_mappings(zip(keys, keys))
self.stroke_subscribers = []
self.state_subscribers = []
self.state = STATE_STOPPED
def test_engine(engine):
# Config load.
assert engine.load_config()
assert engine.events == []
# Startup.
engine.start()
assert engine.events == [
('machine_state_changed', ('Fake', 'initializing'), {}),
('machine_state_changed', ('Fake', 'connected'), {}),
('config_changed', (engine.config, ), {}),
]
assert FakeMachine.instance is not None
assert not FakeMachine.instance.is_suppressed
# Output enabled.
engine.events.clear()
engine.output = True
assert engine.events == [
('output_changed', (True, ), {}),
]
assert FakeMachine.instance.is_suppressed
# Machine reconnection.
engine.events.clear()
engine.reset_machine()
assert engine.events == [
('machine_state_changed', ('Fake', 'stopped'), {}),
('machine_state_changed', ('Fake', 'initializing'), {}),
('machine_state_changed', ('Fake', 'connected'), {}),
]
assert FakeMachine.instance is not None
assert FakeMachine.instance.is_suppressed
# No machine reset on keymap change.
engine.events.clear()
new_keymap = Keymap(system.KEYS, system.KEYS)
new_keymap.set_mappings(zip(system.KEYS, reversed(system.KEYS)))
config_update = {'system_keymap': new_keymap}
assert FakeMachine.instance.keymap != new_keymap
engine.config = config_update
assert engine.events == [
('config_changed', (config_update, ), {}),
]
assert FakeMachine.instance.keymap == new_keymap
# Output disabled
engine.events.clear()
engine.output = False
assert engine.events == [
('output_changed', (False, ), {}),
]
assert not FakeMachine.instance.is_suppressed
# Stopped.
engine.events.clear()
engine.quit(42)
assert engine.join() == 42
assert engine.events == [
('machine_state_changed', ('Fake', 'stopped'), {}),
('quit', (), {}),
]
assert FakeMachine.instance is None
def build_keymap(config, key, mappings=None):
system = registry.get_plugin('system', key[1]).obj
machine_class = registry.get_plugin('machine', key[2]).obj
keymap = Keymap(machine_class.get_keys(), system.KEYS + machine_class.get_actions())
if mappings is None:
mappings = system.KEYMAPS.get(key[2])
if mappings is None:
if machine_class.KEYMAP_MACHINE_TYPE is not None:
# Try fallback.
return build_keymap(config, (key[0], key[1], machine_class.KEYMAP_MACHINE_TYPE))
# No fallback...
mappings = {}
keymap.set_mappings(mappings)
return keymap
def __init__(self, options, parent, config):
self.config = config
self.options = options
pos = (config.get_keyboard_config_frame_x(),
config.get_keyboard_config_frame_y())
wx.Dialog.__init__(self, parent, title=DIALOG_TITLE, pos=pos)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer_flags = wx.SizerFlags().Border(wx.ALL, UI_BORDER).Align(
wx.ALIGN_CENTER_HORIZONTAL)
instructions = wx.StaticText(self, label=ARPEGGIATE_INSTRUCTIONS)
sizer.AddF(instructions, sizer_flags.Align(wx.LEFT))
self.arpeggiate_option = wx.CheckBox(self, label=ARPEGGIATE_LABEL)
self.arpeggiate_option.SetValue(options.arpeggiate)
sizer.AddF(self.arpeggiate_option, sizer_flags)
# editable list for keymap bindings
self.keymap = Keymap(KeyboardMachine.KEYS_LAYOUT.split(),
KeyboardMachine.ACTIONS)
mappings = config.get_system_keymap('Keyboard')
if mappings is not None:
self.keymap.set_mappings(mappings)
self.keymap_widget = EditKeymapWidget(self)
self.keymap_widget.set_mappings(self.keymap.get_mappings())
sizer.AddF(self.keymap_widget, sizer_flags.Expand())
ok_button = wx.Button(self, id=wx.ID_OK)
ok_button.SetDefault()
cancel_button = wx.Button(self, id=wx.ID_CANCEL, label='Cancel')
reset_button = wx.Button(self,
id=wx.ID_RESET,
label='Reset to default')
button_sizer = wx.BoxSizer(wx.HORIZONTAL)
button_sizer.AddF(ok_button, sizer_flags)
button_sizer.AddF(cancel_button, sizer_flags)
button_sizer.AddF(reset_button, sizer_flags)
sizer.AddF(button_sizer, sizer_flags)
self.SetSizerAndFit(sizer)
self.SetRect(AdjustRectToScreen(self.GetRect()))
self.Bind(wx.EVT_MOVE, self.on_move)
ok_button.Bind(wx.EVT_BUTTON, lambda e: self.EndModal(wx.ID_OK))
cancel_button.Bind(wx.EVT_BUTTON,
lambda e: self.EndModal(wx.ID_CANCEL))
reset_button.Bind(wx.EVT_BUTTON, self.on_reset)
def get_system_keymap(self, machine_type=None, system_name=None):
if machine_type is None:
machine_type = self.get_machine_type()
try:
machine_class = registry.get_plugin('machine',
machine_type).resolve()
except:
log.error("invalid machine type: %s", machine_type, exc_info=True)
return None
if system_name is None:
system_name = self.get_system_name()
try:
system = registry.get_plugin('system', system_name).resolve()
except:
log.error("invalid system name: %s", system_name, exc_info=True)
return None
section = SYSTEM_CONFIG_SECTION % system_name
option = SYSTEM_KEYMAP_OPTION % machine_type
mappings = self._get(section, option, None)
if mappings is None:
# No user mappings, use system default.
mappings = system.KEYMAPS.get(machine_type)
else:
try:
mappings = dict(json.loads(mappings))
except ValueError as e:
log.error("invalid machine keymap, resetting to default",
exc_info=True)
self.set_system_keymap(None, machine_type)
mappings = system.KEYMAPS.get(machine_type)
if mappings is None:
if machine_class.KEYMAP_MACHINE_TYPE is not None:
# Try fallback.
return self.get_system_keymap(
machine_type=machine_class.KEYMAP_MACHINE_TYPE,
system_name=system_name)
# No fallback...
mappings = {}
keymap = Keymap(machine_class.get_keys(),
system.KEYS + machine_class.get_actions())
keymap.set_mappings(mappings)
return keymap
def __init__(self):
self.keymap = Keymap(self.KEYS_LAYOUT.split(), self.ACTIONS)
self.stroke_subscribers = []
self.state_subscribers = []
self.state = STATE_STOPPED
{'path': short_path, 'enabled': True}
assert DictionaryConfig(short_path, False).to_dict() == \
{'path': short_path, 'enabled': False}
# Test from_dict creation helper.
assert DictionaryConfig.from_dict({'path': short_path}) == \
DictionaryConfig(short_path)
assert DictionaryConfig.from_dict({'path': full_path, 'enabled': False}) == \
DictionaryConfig(short_path, False)
if sys.platform.startswith('win32'):
ABS_PATH = os.path.normcase(r'c:/foo/bar')
else:
ABS_PATH = '/foo/bar'
DEFAULT_KEYMAP = Keymap(Keyboard.get_keys(),
english_stenotype.KEYS + Keyboard.get_actions())
DEFAULT_KEYMAP.set_mappings(english_stenotype.KEYMAPS['Keyboard'])
DEFAULTS = {
'space_placement':
'Before Output',
'start_attached':
False,
'start_capitalized':
False,
'undo_levels':
config.DEFAULT_UNDO_LEVELS,
'log_file_name':
expand_path('strokes.log'),
'enable_stroke_logging':
False,
def new_keymap():
return Keymap(('k%u' % n for n in range(8)), ('a%u' % n for n in range(4)))
def test_decoding(self):
inputs = [
binascii.unhexlify(packet) for packet in '''
A90020
00
05464000
A904
0400
0D065000
A1008000
05
820400
17
00
8000
05
08
00
00
'''.split()
]
# Mi piace mangiare la pizza.
expected = 'CHRi/PIAce/CHRAh/PCIAre/HRa/PIsh/SPTa/P*'.split('/')
keymap_mappings = {
'#': '#',
'S': 'S-',
'P': 'T-',
'C': 'K-',
'T': 'P-',
'H': 'W-',
'V': 'H-',
'R': 'R-',
'I': 'A-',
'A': 'O-',
'*': '*',
'E': '-E',
'O': '-U',
'c': '-F',
's': '-R',
't': '-P',
'h': '-B',
'p': '-L',
'r': '-G',
'i': '-T',
'e': '-S',
'a': '-D',
'o': '-Z',
}
serial_params = {
name: value[0]
for name, value in ItalianStentura.get_option_info().items()
}
keymap = Keymap(ItalianStentura.KEYS_LAYOUT.split(),
keymap_mappings.keys())
keymap.set_mappings(keymap_mappings)
with patch('plover.machine.base.serial.Serial', MockSerial) as mock:
machine = ItalianStentura(serial_params)
def stroke_callbak(steno_keys):
self.assertEqual(''.join(steno_keys), expected.pop(0))
if not expected:
machine.stop_capture()
machine.add_stroke_callback(stroke_callbak)
machine.set_keymap(keymap)
mock.inputs = inputs
mock.machine = machine
machine.start_capture()
machine.finished.wait()
self.assertFalse(bool(expected))
