/
MonoEncoderElement2.py
executable file
·134 lines (119 loc) · 5.45 KB
/
MonoEncoderElement2.py
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
# emacs-mode: -*- python-*-
import Live
#from Aumpc import Aumpc
from _Framework.EncoderElement import EncoderElement
from _Framework.InputControlElement import InputControlElement
from _Framework.NotifyingControlElement import NotifyingControlElement
#from ValueListenerComponent import ValueListenerComponent
MIDI_NOTE_TYPE = 0
MIDI_CC_TYPE = 1
MIDI_PB_TYPE = 2
MIDI_MSG_TYPES = (MIDI_NOTE_TYPE,
MIDI_CC_TYPE,
MIDI_PB_TYPE)
MIDI_NOTE_ON_STATUS = 144
MIDI_NOTE_OFF_STATUS = 128
MIDI_CC_STATUS = 176
MIDI_PB_STATUS = 224
class MonoEncoderElement2(EncoderElement):
__module__ = __name__
__doc__ = ' Class representing a slider on the controller '
def __init__(self, msg_type, channel, identifier, map_mode, name, num, script):
EncoderElement.__init__(self, msg_type, channel, identifier, map_mode=Live.MidiMap.MapMode.absolute)
self.name = name
self.num = num
self._parameter = None
self._script = script
self._is_enabled = True
#self._report_input = True
#self._report_output = True
self._paramter_lcd_name = ' '
self._parameter_last_value = None
self._mapped_to_midi_velocity = False
self.set_report_values(True, False)
def _report_value(self, value, is_input):
self._script.touched()
def disconnect(self):
self.remove_parameter_listener(self._parameter)
EncoderElement.disconnect(self)
def connect_to(self, parameter):
assert (parameter != None)
assert isinstance(parameter, Live.DeviceParameter.DeviceParameter)
self._mapped_to_midi_velocity = False
assignment = parameter
if(str(parameter.name) == str('Track Volume')): #checks to see if parameter is track volume
if(parameter.canonical_parent.canonical_parent.has_audio_output is False): #checks to see if track has audio output
if(len(parameter.canonical_parent.canonical_parent.devices) > 0):
if(str(parameter.canonical_parent.canonical_parent.devices[0].class_name)==str('MidiVelocity')): #if not, looks for velicty as first plugin
assignment = parameter.canonical_parent.canonical_parent.devices[0].parameters[6] #if found, assigns fader to its 'outhi' parameter
self._mapped_to_midi_velocity = True
self._parameter_to_map_to = assignment
self.add_parameter_listener(self._parameter_to_map_to)
def set_enabled(self, enabled):
self._is_enabled = enabled
# def send_midi(self, message):
# assert (message != None)
# assert isinstance(message, tuple)
# self._send_midi(message)
#self._script.log_message(str(message))
#if(message[2]!=self._listener._mode_index):
# self._script.notification_to_bridge(int(message[2]), self)
def set_value(self, value):
if(self._parameter_to_map_to != None):
newval = float(value * (self._parameter_to_map_to.max - self._parameter_to_map_to.min)) + self._parameter_to_map_to.min
self._parameter_to_map_to.value = newval
return [value, str(self.mapped_parameter())]
else:
self.receive_value(int(value*127))
def release_parameter(self):
if(self._parameter_to_map_to != None):
self.remove_parameter_listener(self._parameter_to_map_to)
self._parameter_to_map_to = None
def install_connections(self): #this override has to be here so that translation will happen when buttons are disabled
if self._is_enabled:
EncoderElement.install_connections(self)
elif ((self._msg_channel != self._original_channel) or (self._msg_identifier != self._original_identifier)):
self._install_translation(self._msg_type, self._original_identifier, self._original_channel, self._msg_identifier, self._msg_channel)
def forward_parameter_value(self):
if(not (type(self._parameter) is type(None))):
#new_value=int(((self._parameter.value - self._parameter.min) / (self._parameter.max - self._parameter.min)) * 127)
try:
parameter = str(self.mapped_parameter())
except:
parameter = ' '
if(parameter!=self._parameter_last_value):
#self._parameter_last_value = str(self.mapped_parameter())
try:
self._parameter_last_value = str(self.mapped_parameter())
except:
self._parameter_last_value = ' '
self._script.notification_to_bridge(self._parameter_lcd_name, self._parameter_last_value, self)
def add_parameter_listener(self, parameter):
self._parameter = parameter
if parameter:
if isinstance(parameter, Live.DeviceParameter.DeviceParameter):
if str(parameter.original_name) == 'Track Volume' or self._mapped_to_midi_velocity is True:
self._parameter_lcd_name = str(parameter.canonical_parent.canonical_parent.name)
elif str(parameter.original_name) == 'Track Panning':
self._parameter_lcd_name = 'Pan'
else:
self._parameter_lcd_name = str(parameter.name)
#self._last_value(int(((self._parameter.value - self._parameter.min) / (self._parameter.max - self._parameter.min)) * 127))
#self._parameter_last_value = str(self.mapped_parameter())
try:
self._parameter_last_value = str(self.mapped_parameter())
except:
self._parameter_last_value = ' '
self._script.notification_to_bridge(self._parameter_lcd_name, self._parameter_last_value, self)
cb = lambda: self.forward_parameter_value()
parameter.add_value_listener(cb)
def remove_parameter_listener(self, parameter):
self._parameter = None
#self._script.log_message('remove_parameter_listener ' + str(parameter.name + str(self.name)))
if parameter:
cb = lambda: self.forward_parameter_value()
if(parameter.value_has_listener is True):
parameter.remove_value_listener(cb)
self._parameter_lcd_name = ' '
self._parameter_last_value = ' '
self._script.notification_to_bridge(' ', ' ', self)