Add error message if the config file doesn't load

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

from kivy.uix.relativelayout import RelativeLayout
from kivy.properties import NumericProperty, ListProperty
from kivy.core.window import Window
from kivy.clock import Clock

import threading
import yaml
import sys

from .music_file import *
from .mixer import Mixer
from . import Config, gain, error_print
from .music_effect import GainEffect
from .action import Action

class Mapping(RelativeLayout):
    expected_keys = NumericProperty(0)
    master_volume = NumericProperty(100)
    ready_color = ListProperty([1, 165/255, 0, 1])

    def __init__(self, **kwargs):
        if Config.builtin_mixing:
            self.mixer = Mixer()
        else:
            self.mixer = None

        try:
            self.key_config, self.open_files = self.parse_config()
        except Exception as e:
            error_print("Error while loading configuration: {}".format(e))
            sys.exit()

        super(Mapping, self).__init__(**kwargs)
        self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
        self._keyboard.bind(on_key_down=self._on_keyboard_down)
        self.running = []
        self.wait_ids = {}
        Clock.schedule_interval(self.not_all_keys_ready, 1)

    @property
    def master_gain(self):
        return gain(self.master_volume)

    def set_master_volume(self, value, delta=False, fade=0):
        [db_gain, self.master_volume] = gain(
                value + int(delta) * self.master_volume,
                self.master_volume)

        for music in self.open_files.values():
            if not (music.is_loaded_playing() or music.is_loaded_paused()):
                continue

            if fade > 0:
                music.gain_effects.append(GainEffect(
                    "fade",
                    music.current_audio_segment,
                    music.current_loop,
                    music.sound_position,
                    music.sound_position + fade,
                    gain=db_gain))
            else:
                music.set_gain(db_gain)

    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 _keyboard_closed(self):
        self._keyboard.unbind(on_key_down=self._on_keyboard_down)
        self._keyboard = None

    def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
        key = self.find_by_key_code(keycode)
        if len(modifiers) == 0 and key is not None:
            threading.Thread(name="MSKeyAction", target=key.do_actions).start()
        elif 'ctrl' in modifiers and (keycode[0] == 113 or keycode[0] == '99'):
            for thread in threading.enumerate():
                if thread.getName()[0:2] != "MS":
                    continue
                thread.join()

            sys.exit()
        return True

    def find_by_key_code(self, key_code):
        if "Key_" + str(key_code[0]) in self.ids:
            return self.ids["Key_" + str(key_code[0])]
        return None

    def not_all_keys_ready(self, dt):
        for key in self.children:
            if not type(key).__name__ == "Key":
                continue
            if not key.is_key_ready:
                return True
        self.ready_color = [0, 1, 0, 1]
        return False

    def stop_all_running(self):
        running = self.running
        self.running = []
        for (key, start_time) in running:
            key.interrupt_action()

    def start_running(self, key, start_time):
        self.running.append((key, start_time))

    def keep_running(self, key, start_time):
        return (key, start_time) in self.running

    def finished_running(self, key, start_time):
        if (key, start_time) in self.running:
            self.running.remove((key, start_time))

    def parse_config(self):
        stream = open(Config.yml_file, "r")
        try:
            config = yaml.load(stream)
        except Exception as e:
            error_print("Error while loading config file: {}".format(e))
            sys.exit()
        stream.close()

        aliases = config['aliases']
        seen_files = {}

        key_properties = {}

        for key in config['key_properties']:
            if key not in key_properties:
                key_prop = config['key_properties'][key]
                if 'include' in key_prop:
                    included = key_prop['include']
                    del(key_prop['include'])

                    if isinstance(included, str):
                        key_prop.update(aliases[included], **key_prop)
                    else:
                        for included_ in included:
                            key_prop.update(aliases[included_], **key_prop)

                key_properties[key] = {
                    "actions":    [],
                    "properties": key_prop,
                    "files":      []
                }

        for mapped_key in config['keys']:
            if mapped_key not in key_properties:
                key_properties[mapped_key] = {
                    "actions":    [],
                    "properties": {},
                    "files":      []
                }
            for action in config['keys'][mapped_key]:
                action_name = list(action)[0]
                action_args = {}
                if action[action_name] is None:
                    action[action_name] = []

                if 'include' in action[action_name]:
                    included = action[action_name]['include']
                    del(action[action_name]['include'])

                    if isinstance(included, str):
                        action[action_name].update(
                                aliases[included],
                                **action[action_name])
                    else:
                        for included_ in included:
                            action[action_name].update(
                                    aliases[included_],
                                    **action[action_name])

                for argument in action[action_name]:
                    if argument == 'file':
                        filename = action[action_name]['file']
                        if filename not in seen_files:
                            if filename in config['music_properties']:
                                seen_files[filename] = MusicFile(
                                        filename,
                                        self,
                                        **config['music_properties'][filename])
                            else:
                                seen_files[filename] = MusicFile(
                                        self,
                                        filename)

                        if filename not in key_properties[mapped_key]['files']:
                            key_properties[mapped_key]['files'] \
                                    .append(seen_files[filename])

                        action_args['music'] = seen_files[filename]

                    else:
                        action_args[argument] = action[action_name][argument]

                key_properties[mapped_key]['actions'] \
                        .append([action_name, action_args])

        return (key_properties, seen_files)