Cleanup key and action workflows

[perso/Immae/Projets/Python/MusicSampler.git] / music_sampler / mapping.py

diff --git a/music_sampler/mapping.py b/music_sampler/mapping.py
index 50b68a9d903df95b0236cf76b4c39245628e9403..5c61f8a5be6eb318949400bfb80398e3cd03472a 100644 (file)
--- a/music_sampler/mapping.py
+++ b/music_sampler/mapping.py
@@ -6,6 +6,7 @@ from kivy.clock import Clock
 import threading
 import yaml
 import sys
+import copy
 from collections import defaultdict
 
 from transitions.extensions import HierarchicalMachine as Machine
@@ -21,8 +22,7 @@ class Mapping(RelativeLayout):
         'configuring',
         'configured',
         'loading',
-        'loaded',
-        'failed'
+        'loaded'
     ]
 
     TRANSITIONS = [
@@ -31,11 +31,6 @@ class Mapping(RelativeLayout):
             'source': 'initial',
             'dest': 'configuring'
         },
-        {
-            'trigger': 'fail',
-            'source': 'configuring',
-            'dest': 'failed'
-        },
         {
             'trigger': 'success',
             'source': 'configuring',
@@ -47,11 +42,6 @@ class Mapping(RelativeLayout):
             'source': 'configured',
             'dest': 'loading'
         },
-        {
-            'trigger': 'fail',
-            'source': 'loading',
-            'dest': 'failed'
-        },
         {
             'trigger': 'success',
             'source': 'loading',
@@ -73,10 +63,11 @@ 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)
@@ -126,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()
         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():
@@ -166,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):
@@ -197,17 +196,53 @@ class Mapping(RelativeLayout):
             music.set_gain_with_effect(db_gain, fade=fade)
 
     # Wait handler methods
-    def add_wait_id(self, wait_id, action_or_wait):
-        self.wait_ids[wait_id] = action_or_wait
-
-    def interrupt_wait(self, wait_id):
-        if wait_id in self.wait_ids:
-            action_or_wait = self.wait_ids[wait_id]
-            del(self.wait_ids[wait_id])
-            if isinstance(action_or_wait, Action):
-                action_or_wait.interrupt()
-            else:
-                action_or_wait.set()
+    def add_wait(self, action_or_wait, wait_id=None):
+        if wait_id is not None:
+            self.wait_ids[wait_id] = [action_or_wait]
+        else:
+            if None not in self.wait_ids:
+                self.wait_ids[None] = []
+            self.wait_ids[None].append(action_or_wait)
+
+    def matching_wait_ids(self, wait_id=None):
+        if wait_id is None:
+            matching_ids = list(self.wait_ids.keys())
+        elif wait_id in self.wait_ids:
+            matching_ids = [wait_id]
+        else:
+            matching_ids = []
+        return matching_ids
+
+    def interrupt_wait(self, wait_id=None):
+        for _wait_id in self.matching_wait_ids(wait_id=wait_id):
+            action_or_waits = self.wait_ids[_wait_id]
+            del(self.wait_ids[_wait_id])
+            for action_or_wait in action_or_waits:
+                if isinstance(action_or_wait, Action):
+                    action_or_wait.interrupt()
+                else:
+                    action_or_wait.set()
+
+    def pause_wait(self, wait_id=None):
+        for _wait_id in self.matching_wait_ids(wait_id=wait_id):
+            action_or_waits = self.wait_ids[_wait_id]
+            for action_or_wait in action_or_waits:
+                if isinstance(action_or_wait, Action):
+                    action_or_wait.pause()
+
+    def unpause_wait(self, wait_id=None):
+        for _wait_id in self.matching_wait_ids(wait_id=wait_id):
+            action_or_waits = self.wait_ids[_wait_id]
+            for action_or_wait in action_or_waits:
+                if isinstance(action_or_wait, Action):
+                    action_or_wait.unpause()
+
+    def reset_wait(self, wait_id=None):
+        for _wait_id in self.matching_wait_ids(wait_id=wait_id):
+            action_or_waits = self.wait_ids[_wait_id]
+            for action_or_wait in action_or_waits:
+                if isinstance(action_or_wait, Action):
+                    action_or_wait.reset()
 
     # Methods to control running keys
     def start_running(self, key, start_time):
@@ -342,12 +377,13 @@ class Mapping(RelativeLayout):
                 isinstance(config['key_properties'], dict):
             common_key_properties = config['key_properties']['common']
             include_aliases(common_key_properties, aliases)
+            check_key_property(common_key_properties, 'common')
         elif 'common' in config['key_properties']:
             warn_print("'common' key in key_properties is not a hash, ignored")
 
         key_properties = defaultdict(lambda: {
                 "actions":    [],
-                "properties": {},
+                "properties": copy.deepcopy(common_key_properties),
                 "files":      []
             })
 
@@ -363,12 +399,9 @@ class Mapping(RelativeLayout):
                 continue
 
             include_aliases(key_prop, aliases)
-            for _key in common_key_properties:
-                key_prop.setdefault(_key, common_key_properties[_key])
-
             check_key_property(key_prop, key)
 
-            key_properties[key]["properties"] = key_prop
+            key_properties[key]["properties"].update(key_prop)
 
         for mapped_key in check_mapped_keys(config):
             for index, action in enumerate(check_mapped_key(