1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
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 .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():
music.set_gain_with_effect(db_gain, fade=fade)
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)
|
