helpers/mapping.py

   1 from kivy.uix.relativelayout import RelativeLayout
   2 from kivy.properties import NumericProperty, ListProperty
   3 from kivy.core.window import Window
   4 from kivy.clock import Clock
   5
   6 import threading
   7 import yaml
   8 import sys
   9
  10 from .music_file import *
  11 from .mixer import Mixer
  12 from . import Config, gain, error_print
  13
  14 class Mapping(RelativeLayout):
  15     expected_keys = NumericProperty(0)
  16     master_volume = NumericProperty(100)
  17     ready_color = ListProperty([1, 165/255, 0, 1])
  18
  19     def __init__(self, **kwargs):
  20         if Config.builtin_mixing:
  21             self.mixer = Mixer()
  22         else:
  23             self.mixer = None
  24         self.key_config, self.open_files = self.parse_config()
  25         super(Mapping, self).__init__(**kwargs)
  26         self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
  27         self._keyboard.bind(on_key_down=self._on_keyboard_down)
  28         self.running = []
  29         Clock.schedule_interval(self.not_all_keys_ready, 1)
  30
  31     @property
  32     def master_gain(self):
  33         return gain(self.master_volume)
  34
  35     def set_master_volume(self, value, delta=False):
  36         [db_gain, self.master_volume] = gain(
  37                 value + int(delta) * self.master_volume,
  38                 self.master_volume)
  39
  40         for music in self.open_files.values():
  41             music.set_gain(db_gain)
  42
  43     def _keyboard_closed(self):
  44         self._keyboard.unbind(on_key_down=self._on_keyboard_down)
  45         self._keyboard = None
  46
  47     def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
  48         key = self.find_by_key_code(keycode)
  49         if len(modifiers) == 0 and key is not None:
  50             threading.Thread(name="MSKeyAction", target=key.do_actions).start()
  51         elif 'ctrl' in modifiers and (keycode[0] == 113 or keycode[0] == '99'):
  52             for thread in threading.enumerate():
  53                 if thread.getName()[0:2] != "MS":
  54                     continue
  55                 thread.join()
  56
  57             sys.exit()
  58         return True
  59
  60     def find_by_key_code(self, key_code):
  61         if "Key_" + str(key_code[0]) in self.ids:
  62             return self.ids["Key_" + str(key_code[0])]
  63         return None
  64
  65     def not_all_keys_ready(self, dt):
  66         for key in self.children:
  67             if not type(key).__name__ == "Key":
  68                 continue
  69             if not key.is_key_ready:
  70                 return True
  71         self.ready_color = [0, 1, 0, 1]
  72         return False
  73
  74     def stop_all_running(self):
  75         running = self.running
  76         self.running = []
  77         for (key, start_time) in running:
  78             key.interrupt_action()
  79
  80     def start_running(self, key, start_time):
  81         self.running.append((key, start_time))
  82
  83     def keep_running(self, key, start_time):
  84         return (key, start_time) in self.running
  85
  86     def finished_running(self, key, start_time):
  87         if (key, start_time) in self.running:
  88             self.running.remove((key, start_time))
  89
  90     def parse_config(self):
  91         stream = open(Config.yml_file, "r")
  92         try:
  93             config = yaml.load(stream)
  94         except yaml.scanner.ScannerError as e:
  95             error_print("Error while loading config file: {}".format(e))
  96             sys.exit()
  97         stream.close()
  98
  99         aliases = config['aliases']
 100         seen_files = {}
 101
 102         key_properties = {}
 103
 104         for key in config['key_properties']:
 105             if key not in key_properties:
 106                 key_prop = config['key_properties'][key]
 107                 if 'include' in key_prop:
 108                     included = key_prop['include']
 109                     del(key_prop['include'])
 110
 111                     if isinstance(included, str):
 112                         key_prop.update(aliases[included], **key_prop)
 113                     else:
 114                         for included_ in included:
 115                             key_prop.update(aliases[included_], **key_prop)
 116
 117                 key_properties[key] = {
 118                     "actions":    [],
 119                     "properties": key_prop,
 120                     "files":      []
 121                 }
 122
 123         for mapped_key in config['keys']:
 124             if mapped_key not in key_properties:
 125                 key_properties[mapped_key] = {
 126                     "actions":    [],
 127                     "properties": {},
 128                     "files":      []
 129                 }
 130             for action in config['keys'][mapped_key]:
 131                 action_name = list(action)[0]
 132                 action_args = {}
 133                 if action[action_name] is None:
 134                     action[action_name] = []
 135
 136                 if 'include' in action[action_name]:
 137                     included = action[action_name]['include']
 138                     del(action[action_name]['include'])
 139
 140                     if isinstance(included, str):
 141                         action[action_name].update(
 142                                 aliases[included],
 143                                 **action[action_name])
 144                     else:
 145                         for included_ in included:
 146                             action[action_name].update(
 147                                     aliases[included_],
 148                                     **action[action_name])
 149
 150                 for argument in action[action_name]:
 151                     if argument == 'file':
 152                         filename = action[action_name]['file']
 153                         if filename not in seen_files:
 154                             if filename in config['music_properties']:
 155                                 seen_files[filename] = MusicFile(
 156                                         filename,
 157                                         self,
 158                                         **config['music_properties'][filename])
 159                             else:
 160                                 seen_files[filename] = MusicFile(
 161                                         self,
 162                                         filename)
 163
 164                         if filename not in key_properties[mapped_key]['files']:
 165                             key_properties[mapped_key]['files'] \
 166                                     .append(seen_files[filename])
 167
 168                         action_args['music'] = seen_files[filename]
 169
 170                     else:
 171                         action_args[argument] = action[action_name][argument]
 172
 173                 key_properties[mapped_key]['actions'] \
 174                         .append([action_name, action_args])
 175
 176         return (key_properties, seen_files)
 177
 178