Merge branch 'load_action'1.3.0

11 files changed, 207 insertions, 133 deletions

diff --git a/music_sampler/action.py b/music_sampler/action.py
index 22a2bdc..bc62f33 100644
--- a/music_sampler/action.py
+++ b/music_sampler/action.py
@@ -9,8 +9,9 @@ class Action:
         'failed',
         {
             'name': 'loaded',
-            'children': ['running']
-        }
+            'children': ['stopped', 'running']
+        },
+        'destroyed'
     ]
 
     TRANSITIONS = [
@@ -21,36 +22,42 @@ class Action:
         },
         {
             'trigger': 'fail',
-            'source': 'loading',
+            'source': ['loading', 'loaded'],
             'dest': 'failed',
-            'after': 'poll_loaded'
         },
         {
             'trigger': 'success',
             'source': 'loading',
-            'dest': 'loaded',
-            'after': 'poll_loaded'
+            'dest': 'loaded_stopped',
         },
         {
-            'trigger': 'run',
+            'trigger': 'reload',
             'source': 'loaded',
+            'dest': 'loading',
+        },
+        {
+            'trigger': 'run',
+            'source': 'loaded_stopped',
             'dest': 'loaded_running',
             'after': 'finish_action',
-            # if a child has no transitions, then it is bubbled to the parent,
-            # and we don't want that. Not useful in that machine precisely.
-            'conditions': ['is_loaded']
         },
         {
             'trigger': 'finish_action',
             'source': 'loaded_running',
-            'dest': 'loaded'
+            'dest': 'loaded_stopped'
+        },
+        {
+            'trigger': 'destroy',
+            'source': '*',
+            'dest': 'destroyed'
         }
     ]
 
     def __init__(self, action, key, **kwargs):
         Machine(model=self, states=self.STATES,
                 transitions=self.TRANSITIONS, initial='initial',
-                ignore_invalid_triggers=True, queued=True)
+                ignore_invalid_triggers=True, queued=True,
+                after_state_change=self.notify_state_change)
 
         self.action = action
         self.key = key
@@ -62,18 +69,31 @@ class Action:
     def is_loaded_or_failed(self):
         return self.is_loaded(allow_substates=True) or self.is_failed()
 
-    def callback_music_loaded(self, success):
-        if success:
-            self.success()
-        else:
+    def callback_music_state(self, new_state):
+        # If a music gets unloaded while the action is loaded_running and
+        # depending on the music, it won't be able to do the finish_action.
+        # Can that happen?
+        # a: play 'mp3';
+        # z: wait 'mp3';
+        # e: pause 'mp3';
+        # r: stop 'mp3'; unload_music 'mp3'
+        if new_state == 'failed':
             self.fail()
+        elif self.is_loaded(allow_substates=True) and\
+                new_state in ['initial', 'loading']:
+            self.reload(reloading=True)
+        elif self.is_loading() and new_state.startswith('loaded_'):
+            self.success()
 
     # Machine states / events
-    def on_enter_loading(self):
+    def on_enter_loading(self, reloading=False):
+        if reloading:
+            return
         if hasattr(actions, self.action):
-            if 'music' in self.arguments:
-                self.arguments['music'].subscribe_loaded(
-                        self.callback_music_loaded)
+            if 'music' in self.arguments and\
+                    self.action not in ['unload_music', 'load_music']:
+                self.arguments['music'].subscribe_state_change(
+                        self.callback_music_state)
             else:
                 self.success()
         else:
@@ -86,9 +106,13 @@ class Action:
             getattr(actions, self.action).run(self,
                     key_start_time=key_start_time, **self.arguments)
 
-    def poll_loaded(self):
-        self.key.callback_action_ready(self,
-                self.is_loaded(allow_substates=True))
+    def on_enter_destroyed(self):
+        if 'music' in self.arguments:
+            self.arguments['music'].unsubscribe_state_change(
+                    self.callback_music_state)
+
+    def notify_state_change(self, *args, **kwargs):
+        self.key.callback_action_state_changed()
 
     # This one cannot be in the Machine state since it would be queued to run
     # *after* the wait is ended...
diff --git a/music_sampler/actions/__init__.py b/music_sampler/actions/__init__.py
index 7c812cb..e0671fe 100644
--- a/music_sampler/actions/__init__.py
+++ b/music_sampler/actions/__init__.py
@@ -1,4 +1,5 @@
 from . import interrupt_wait
+from . import load_music
 from . import pause
 from . import pause_wait
 from . import play
@@ -7,6 +8,7 @@ from . import run_command
 from . import seek
 from . import stop
 from . import stop_all_actions
+from . import unload_music
 from . import unpause
 from . import unpause_wait
 from . import volume
diff --git a/music_sampler/actions/load_music.py b/music_sampler/actions/load_music.py
new file mode 100644
index 0000000..f3e02ba
--- /dev/null
+++ b/music_sampler/actions/load_music.py
@@ -0,0 +1,12 @@
+import threading
+
+def run(action, music=None, **kwargs):
+    for music in action.music_list(music):
+        if not music.is_loaded(allow_substates=True):
+            threading.Thread(name="MSMusicLoad", target=music.load).start()
+
+def description(action, music=None, **kwargs):
+    if music is not None:
+        return "load music « {} » to memory".format(music.name)
+    else:
+        return "load all music to memory"
diff --git a/music_sampler/actions/unload_music.py b/music_sampler/actions/unload_music.py
new file mode 100644
index 0000000..b3de316
--- /dev/null
+++ b/music_sampler/actions/unload_music.py
@@ -0,0 +1,10 @@
+def run(action, music=None, **kwargs):
+    for music in action.music_list(music):
+        if music.is_unloadable():
+            music.unload()
+
+def description(action, music=None, **kwargs):
+    if music is not None:
+        return "unload music « {} » from memory".format(music.name)
+    else:
+        return "unload all music from memory"
diff --git a/music_sampler/app_blocks/actionlist.py b/music_sampler/app_blocks/actionlist.py
index f48072f..59315de 100644
--- a/music_sampler/app_blocks/actionlist.py
+++ b/music_sampler/app_blocks/actionlist.py
@@ -4,6 +4,8 @@ from kivy.uix.relativelayout import RelativeLayout
 from kivy.properties import ListProperty, StringProperty
 from ..lock import Lock
 
+from kivy.clock import mainthread
+
 __all__ = ["ActionList",
         "ActionListIcons", "ActionListIcon",
         "ActionListDescriptions", "ActionListDescription"]
@@ -14,6 +16,7 @@ class ActionList(RelativeLayout):
     action_title = StringProperty("")
     action_list = ListProperty([])
 
+    @mainthread
     def update_list(self, key, action_descriptions):
         if key.repeat_delay > 0:
             self.action_title = _(
diff --git a/music_sampler/app_blocks/playlist.py b/music_sampler/app_blocks/playlist.py
index 5894995..706e4fc 100644
--- a/music_sampler/app_blocks/playlist.py
+++ b/music_sampler/app_blocks/playlist.py
@@ -2,7 +2,7 @@ from kivy.uix.label import Label
 from kivy.uix.stacklayout import StackLayout
 from kivy.uix.relativelayout import RelativeLayout
 from kivy.properties import ListProperty
-from kivy.clock import Clock
+from kivy.clock import Clock, mainthread
 from ..helpers import duration_to_min_sec
 from ..lock import Lock
 
@@ -20,6 +20,7 @@ class PlayList(RelativeLayout):
         super(PlayList, self).__init__(**kwargs)
         Clock.schedule_interval(self.update_playlist, 0.5)
 
+    @mainthread
     def update_playlist(self, dt):
         if self.parent is None or 'Mapping' not in self.parent.ids:
             return True
diff --git a/music_sampler/helpers.py b/music_sampler/helpers.py
index 9403875..fbd338b 100644
--- a/music_sampler/helpers.py
+++ b/music_sampler/helpers.py
@@ -124,6 +124,13 @@ Configs = {
         'help_no': _("Don't show warning when focus is lost"),
         'type': 'boolean'
     },
+    'load_all_musics': {
+        'default': True,
+        'help_yes': _("Load all the musics at launch time (default)"),
+        'help_no': _("Don't load all the musics at launch time (use it if you \
+            have memory problems)"),
+        'type': 'boolean'
+    },
     'list_devices': {
         'help': _("List available sound devices"),
         'type': 'action'
@@ -142,6 +149,7 @@ Configs_order = [
     'language',
     'list_devices',
     'device',
+    'load_all_musics',
 ]
 def parse_args():
     argv = sys.argv[1 :]
diff --git a/music_sampler/key.py b/music_sampler/key.py
index ce2f45b..e05bb16 100644
--- a/music_sampler/key.py
+++ b/music_sampler/key.py
@@ -9,7 +9,11 @@ import time
 import threading
 from transitions.extensions import HierarchicalMachine as Machine
 
-class KeyMachine(Widget):
+# All drawing operations should happen in the main thread
+# https://github.com/kivy/kivy/wiki/Working-with-Python-threads-inside-a-Kivy-application
+from kivy.clock import mainthread
+
+class KeyMachine():
     STATES = [
         'initial',
         'configuring',
@@ -97,11 +101,15 @@ class KeyMachine(Widget):
         {
             'trigger': 'repeat_protection_finished',
             'source': 'loaded_protecting_repeat',
-            'dest': 'loaded'
+            'dest': 'loaded',
+            'after': 'callback_action_state_changed'
         },
     ]
 
-    state = StringProperty("")
+    def __setattr__(self, name, value):
+        if hasattr(self, 'initialized') and name == 'state':
+            self.key.update_state(value)
+        super().__setattr__(name, value)
 
     def __init__(self, key, **kwargs):
         self.key = key
@@ -109,7 +117,8 @@ class KeyMachine(Widget):
         Machine(model=self, states=self.STATES,
                 transitions=self.TRANSITIONS, initial='initial',
                 ignore_invalid_triggers=True, queued=True)
-        super(KeyMachine, self).__init__(**kwargs)
+
+        self.initialized = True
 
     # Machine states / events
     def is_loaded_or_failed(self):
@@ -118,22 +127,22 @@ class KeyMachine(Widget):
     def is_loaded_inactive(self):
         return self.is_loaded_no_config() or self.is_loaded_no_actions()
 
+    @mainthread
     def on_enter_configuring(self):
+        self.destroy_actions()
+        self.key.unset_description()
+        self.key.unset_color()
+
         if self.key.key_sym in self.key.parent.key_config:
             self.key.config = self.key.parent.key_config[self.key.key_sym]
 
-            self.key.actions = []
             for key_action in self.key.config['actions']:
                 self.key.add_action(key_action[0], **key_action[1])
 
             if 'description' in self.key.config['properties']:
                 self.key.set_description(self.key.config['properties']['description'])
-            else:
-                self.key.unset_description()
             if 'color' in self.key.config['properties']:
                 self.key.set_color(self.key.config['properties']['color'])
-            else:
-                self.key.unset_color()
             self.success()
         else:
             self.no_config()
@@ -145,6 +154,11 @@ class KeyMachine(Widget):
         else:
             self.no_actions()
 
+    def destroy_actions(self):
+        for action in self.key.actions:
+            action.destroy()
+        self.key.actions = []
+
     def run_actions(self, modifiers):
         self.key.parent.parent.ids['KeyList'].append(self.key.key_sym)
         debug_print("running actions for {}".format(self.key.key_sym))
@@ -168,9 +182,21 @@ class KeyMachine(Widget):
             self.key.repeat_protection_finished()
 
     # Callbacks
+    @mainthread
     def key_loaded_callback(self):
         self.key.parent.key_loaded_callback()
 
+    def callback_action_state_changed(self):
+        if self.state not in ['failed', 'loading', 'loaded']:
+            return
+
+        if any(action.is_failed() for action in self.key.actions):
+            self.to_failed()
+        elif any(action.is_loading() for action in self.key.actions):
+            self.to_loading()
+        else:
+            self.to_loaded()
+        self.key_loaded_callback()
 
 class Key(ButtonBehavior, Widget):
 
@@ -234,18 +260,18 @@ class Key(ButtonBehavior, Widget):
         else:
             raise AttributeError
 
-    def machine_state_changed(self, instance, machine_state):
-        self.machine_state = self.machine.state
-
     def __init__(self, **kwargs):
         self.actions = []
         self.current_action = None
         self.machine = KeyMachine(self)
-        self.machine.bind(state=self.machine_state_changed)
 
         super(Key, self).__init__(**kwargs)
 
     # Kivy events
+    @mainthread
+    def update_state(self, value):
+        self.machine_state = value
+
     def on_key_sym(self, key, key_sym):
         if key_sym != "":
             self.configure()
@@ -258,13 +284,6 @@ class Key(ButtonBehavior, Widget):
     def interrupt(self):
         self.current_action.interrupt()
 
-    # Callbacks
-    def callback_action_ready(self, action, success):
-        if not success:
-            self.fail()
-        elif all(action.is_loaded_or_failed() for action in self.actions):
-            self.success()
-
     # Setters
     def set_description(self, description):
         if description[0] is not None:
diff --git a/music_sampler/mapping.py b/music_sampler/mapping.py
index 9e40d40..a526ad2 100644
--- a/music_sampler/mapping.py
+++ b/music_sampler/mapping.py
@@ -22,8 +22,7 @@ class Mapping(RelativeLayout):
         'configuring',
         'configured',
         'loading',
-        'loaded',
-        'failed'
+        'loaded'
     ]
 
     TRANSITIONS = [
@@ -33,11 +32,6 @@ class Mapping(RelativeLayout):
             'dest': 'configuring'
         },
         {
-            'trigger': 'fail',
-            'source': 'configuring',
-            'dest': 'failed'
-        },
-        {
             'trigger': 'success',
             'source': 'configuring',
             'dest': 'configured',
@@ -49,11 +43,6 @@ class Mapping(RelativeLayout):
             'dest': 'loading'
         },
         {
-            'trigger': 'fail',
-            'source': 'loading',
-            'dest': 'failed'
-        },
-        {
             'trigger': 'success',
             'source': 'loading',
             'dest': 'loaded'
@@ -74,17 +63,18 @@ class Mapping(RelativeLayout):
         self.running = []
         self.wait_ids = {}
         self.open_files = {}
+        self.is_leaving_application = False
 
         Machine(model=self, states=self.STATES,
                 transitions=self.TRANSITIONS, initial='initial',
-                ignore_invalid_triggers=True, queued=True)
+                auto_transitions=False, queued=True)
         super(Mapping, self).__init__(**kwargs)
         self.keyboard = Window.request_keyboard(self.on_keyboard_closed, self)
         self.keyboard.bind(on_key_down=self.on_keyboard_down)
 
-        self.configure()
+        self.configure(initial=True)
 
-    def on_enter_configuring(self):
+    def on_enter_configuring(self, initial=True):
         if Config.builtin_mixing:
             self.mixer = Mixer()
         else:
@@ -94,9 +84,9 @@ class Mapping(RelativeLayout):
             self.key_config, self.open_files = self.parse_config()
         except Exception as e:
             error_print("Error while loading configuration: {}".format(e),
-                    with_trace=True, exit=True)
-        else:
-            self.success()
+                    with_trace=False, exit=initial)
+
+        self.success()
 
     def on_enter_loading(self):
         for key in self.keys:
@@ -127,13 +117,14 @@ class Mapping(RelativeLayout):
         elif 'ctrl' in modifiers and (keycode[0] == 113 or keycode[0] == '99'):
             self.leave_application()
             sys.exit()
-        elif 'ctrl' in modifiers and keycode[0] == 114:
-            threading.Thread(name="MSReload", target=self.reload).start()
+        elif 'ctrl' in modifiers and keycode[0] == 114 and self.is_loaded():
+            self.reload(initial=False)
         return True
 
     def leave_application(self):
         self.keyboard.unbind(on_key_down=self.on_keyboard_down)
         self.stop_all_running()
+        self.is_leaving_application = True
         for music in self.open_files.values():
             music.stop()
         for thread in threading.enumerate():
@@ -167,13 +158,20 @@ class Mapping(RelativeLayout):
 
     # Callbacks
     def key_loaded_callback(self):
+        if hasattr(self, 'finished_loading'):
+            return
+
+        opacity = int(Config.load_all_musics)
+
         result = self.all_keys_ready()
         if result == "success":
-            self.ready_color = [0, 1, 0, 1]
+            self.ready_color = [0, 1, 0, opacity]
+            self.finished_loading = True
         elif result == "partial":
-            self.ready_color = [1, 0, 0, 1]
+            self.ready_color = [1, 0, 0, opacity]
+            self.finished_loading = True
         else:
-            self.ready_color = [1, 165/255, 0, 1]
+            self.ready_color = [1, 165/255, 0, opacity]
 
     ## Some global actions
     def stop_all_running(self, except_key=None, key_start_time=0):
@@ -350,13 +348,11 @@ class Mapping(RelativeLayout):
         try:
             config = yaml.safe_load(stream)
         except Exception as e:
-            error_print("Error while loading config file: {}".format(e),
-                    exit=True)
+            raise Exception("Error while loading config file: {}".format(e)) from e
         stream.close()
 
         if not isinstance(config, dict):
-            error_print("Top level config is supposed to be a hash",
-                    exit=True)
+            raise Exception("Top level config is supposed to be a hash")
 
         if 'aliases' in config and isinstance(config['aliases'], dict):
             aliases = config['aliases']
diff --git a/music_sampler/music_file.py b/music_sampler/music_file.py
index 4ba65e3..ec50951 100644
--- a/music_sampler/music_file.py
+++ b/music_sampler/music_file.py
@@ -22,6 +22,7 @@ class MusicFile:
         {
             'name': 'loaded',
             'children': [
+                'stopped',
                 'playing',
                 'paused',
                 'stopping'
@@ -31,9 +32,8 @@ class MusicFile:
     TRANSITIONS = [
         {
             'trigger': 'load',
-            'source': 'initial',
-            'dest': 'loading',
-            'after': 'poll_loaded'
+            'source': ['initial', 'failed'],
+            'dest': 'loading'
         },
         {
             'trigger': 'fail',
@@ -41,17 +41,19 @@ class MusicFile:
             'dest': 'failed'
         },
         {
+            'trigger': 'unload',
+            'source': ['failed', 'loaded_stopped'],
+            'dest': 'initial',
+        },
+        {
             'trigger': 'success',
             'source': 'loading',
-            'dest': 'loaded'
+            'dest': 'loaded_stopped'
         },
         {
             'trigger': 'start_playing',
-            'source': 'loaded',
-            'dest': 'loaded_playing',
-            # if a child has no transitions, then it is bubbled to the parent,
-            # and we don't want that. Not useful in that machine precisely.
-            'conditions': ['is_loaded']
+            'source': 'loaded_stopped',
+            'dest': 'loaded_playing'
         },
         {
             'trigger': 'pause',
@@ -70,19 +72,20 @@ class MusicFile:
         },
         {
             'trigger': 'stopped',
-            'source': '*',
-            'dest': 'loaded',
+            'source': 'loaded',
+            'dest': 'loaded_stopped',
             'before': 'trigger_stopped_events',
-            'conditions': ['is_in_use']
+            'unless': 'is_loaded_stopped',
         }
     ]
 
     def __init__(self, filename, mapping, name=None, gain=1):
-        Machine(model=self, states=self.STATES,
+        machine = Machine(model=self, states=self.STATES,
                 transitions=self.TRANSITIONS, initial='initial',
-                ignore_invalid_triggers=True)
+                auto_transitions=False,
+                after_state_change=self.notify_state_change)
 
-        self.loaded_callbacks = []
+        self.state_change_callbacks = []
         self.mapping = mapping
         self.filename = filename
         self.name = name or filename
@@ -90,48 +93,41 @@ class MusicFile:
         self.initial_volume_factor = gain
         self.music_lock = Lock("music__" + filename)
 
-        threading.Thread(name="MSMusicLoad", target=self.load).start()
+        if Config.load_all_musics:
+            threading.Thread(name="MSMusicLoad", target=self.load).start()
 
     def reload_properties(self, name=None, gain=1):
         self.name = name or self.filename
         if gain != self.initial_volume_factor:
             self.initial_volume_factor = gain
-            self.reload_music_file()
+            self.stopped()
+            self.unload()
+            self.load(reloading=True)
 
-    def reload_music_file(self):
-        with file_lock:
-            try:
-                if self.filename.startswith("/"):
-                    filename = self.filename
-                else:
-                    filename = Config.music_path + self.filename
+    # Machine related events
+    def on_enter_initial(self):
+        self.audio_segment = None
 
-                debug_print("Reloading « {} »".format(self.name))
-                initial_db_gain = gain(self.initial_volume_factor * 100)
-                self.audio_segment = pydub.AudioSegment \
-                        .from_file(filename) \
-                        .set_frame_rate(Config.frame_rate) \
-                        .set_channels(Config.channels) \
-                        .set_sample_width(Config.sample_width) \
-                        .apply_gain(initial_db_gain)
-            except Exception as e:
-                error_print("failed to reload « {} »: {}"\
-                        .format(self.name, e))
-                self.loading_error = e
-                self.to_failed()
-            else:
-                debug_print("Reloaded « {} »".format(self.name))
+    def on_enter_loading(self, reloading=False):
+        if reloading:
+            prefix = 'Rel'
+            prefix_s = 'rel'
+        else:
+            prefix = 'L'
+            prefix_s = 'l'
 
-    # Machine related events
-    def on_enter_loading(self):
         with file_lock:
+            if self.mapping.is_leaving_application:
+                self.fail()
+                return
+
             try:
                 if self.filename.startswith("/"):
                     filename = self.filename
                 else:
                     filename = Config.music_path + self.filename
 
-                debug_print("Loading « {} »".format(self.name))
+                debug_print("{}oading « {} »".format(prefix, self.name))
                 self.mixer = self.mapping.mixer or Mixer()
                 initial_db_gain = gain(self.initial_volume_factor * 100)
                 self.audio_segment = pydub.AudioSegment \
@@ -142,12 +138,13 @@ class MusicFile:
                         .apply_gain(initial_db_gain)
                 self.sound_duration = self.audio_segment.duration_seconds
             except Exception as e:
-                error_print("failed to load « {} »: {}".format(self.name, e))
+                error_print("failed to {}oad « {} »: {}".format(
+                    prefix_s, self.name, e))
                 self.loading_error = e
                 self.fail()
             else:
                 self.success()
-                debug_print("Loaded « {} »".format(self.name))
+                debug_print("{}oaded « {} »".format(prefix, self.name))
 
     def on_enter_loaded(self):
         self.cleanup()
@@ -165,11 +162,15 @@ class MusicFile:
 
     # Machine related states
     def is_in_use(self):
-        return self.is_loaded(allow_substates=True) and not self.is_loaded()
+        return self.is_loaded(allow_substates=True) and\
+                not self.is_loaded_stopped()
 
     def is_in_use_not_stopping(self):
         return self.is_loaded_playing() or self.is_loaded_paused()
 
+    def is_unloadable(self):
+        return self.is_loaded_stopped() or self.is_failed()
+
     # Machine related triggers
     def trigger_stopped_events(self):
         self.mixer.remove_file(self)
@@ -243,7 +244,7 @@ class MusicFile:
             if wait:
                 self.mapping.add_wait(self.wait_event, wait_id=set_wait_id)
                 self.wait_end()
-        else:
+        elif self.is_loaded(allow_substates=True):
             self.stopped()
 
     def abandon_all_effects(self):
@@ -274,21 +275,19 @@ class MusicFile:
         self.wait_event.clear()
         self.wait_event.wait()
 
-    # Let other subscribe for an event when they are ready
-    def subscribe_loaded(self, callback):
-        # FIXME: should lock to be sure we have no race, but it makes the
-        # initialization screen not showing until everything is loaded
-        if self.is_loaded(allow_substates=True):
-            callback(True)
-        elif self.is_failed():
-            callback(False)
-        else:
-            self.loaded_callbacks.append(callback)
+    # Let other subscribe for state change
+    def notify_state_change(self, **kwargs):
+        for callback in self.state_change_callbacks:
+            callback(self.state)
+
+    def subscribe_state_change(self, callback):
+        if callback not in self.state_change_callbacks:
+            self.state_change_callbacks.append(callback)
+        callback(self.state)
 
-    def poll_loaded(self):
-        for callback in self.loaded_callbacks:
-            callback(self.is_loaded())
-        self.loaded_callbacks = []
+    def unsubscribe_state_change(self, callback):
+        if callback in self.state_change_callbacks:
+            self.state_change_callbacks.remove(callback)
 
     # Callbacks
     def finished_callback(self):
diff --git a/music_sampler/music_sampler.kv b/music_sampler/music_sampler.kv
index 0432e14..839d2ce 100644
--- a/music_sampler/music_sampler.kv
+++ b/music_sampler/music_sampler.kv
@@ -611,6 +611,8 @@
     key_sym: "^"
     row: 3
     col: 12.5
+    line_width: 1
+    enabled: False
   Key:
     id: Key_36
     key_code: 36
@@ -632,8 +634,6 @@
     row: 4
     col: 1
     key_width: 1.75
-    line_width: 1
-    enabled: False
 
   Key:
     id: Key_113