def __init__(self, msg_type, channel, identifier, skin = Skin(), *a, **k):
self._skin = skin
self._header = None
self._type = consts.FADER_TYPE_STANDARD
self._color = 0
super(SliderElement, self).__init__(msg_type, channel, identifier, *a, **k)
self.set_needs_takeover(False)
def __init__(self, *a, **k):
super(MIDI_Mix, self).__init__(*a, **k)
with self.component_guard():
self._skin = Skin(Colors)
with inject(skin=const(self._skin)).everywhere():
self._create_controls()
self._create_mixer()
class ColorButtonElement(ConfigurableButtonElement):
""" Same as Push's but doesn't change channels """
class Colors:
class DefaultButton:
On = Rgb.GREEN
Off = Rgb.BLACK
Disabled = Rgb.BLACK
Alert = Rgb.RED
default_skin = Skin(Colors)
default_states = {True: 'DefaultButton.On', False: 'DefaultButton.Off'}
def __init__(self,
is_momentary,
msg_type,
channel,
identifier,
skin=None,
is_rgb=False,
default_states=None,
*a,
**k):
super(ConfigurableButtonElement,
self).__init__(is_momentary,
msg_type,
channel,
identifier,
skin=(skin or self.default_skin),
*a,
**k)
if default_states is not None:
self.default_states = default_states
self.states = dict(self.default_states)
self.is_rgb = is_rgb
self._force_next_value = False
def __init__(self, c_instance):
super(DS1, self).__init__(c_instance)
self._connected = False
self._host_name = 'DS1'
self.oscServer = None
self._rgb = 0
self._timer = 0
self.flash_status = 1
self._touched = 0
self._update_linked_device_selection = None
self._skin = Skin(DS1Colors)
with self.component_guard():
self._setup_monobridge()
self._setup_controls()
self._setup_m4l_interface()
self._define_sysex()
self._initialize_hardware()
self._setup_mixer_control()
self._setup_session_control()
self._setup_transport_control()
self._setup_device_control()
self._setup_session_recording_component()
#self._setup_translations()
self._setup_main_modes()
#self._device.add_device_listener(self._on_new_device_set)
self.log_message(
"<<<<<<<<<<<<<<<<<= DS1 log opened =>>>>>>>>>>>>>>>>>>>>>")
def __init__(self, *a, **k):
ControlSurface.__init__(self, *a, **k)
self._skin = Skin(LaunchModColors)
with self.component_guard():
self._monomod_version = 'b996'
self._host_name = 'LaunchMod'
self._color_type = 'Launchpad'
self._timer = 0
self._suppress_send_midi = True
self._suppress_session_highlight = True
self._suppress_highlight = False
is_momentary = True
self._suggested_input_port = 'Launchpad'
self._suggested_output_port = 'Launchpad'
self._control_is_with_automap = False
self._user_byte_write_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 16)
self._user_byte_write_button.name = 'User_Byte_Button'
self._user_byte_write_button.send_value(1)
self._user_byte_write_button.add_value_listener(self._user_byte_value)
self._wrote_user_byte = False
self._challenge = Live.Application.get_random_int(0, 400000000) & 2139062143
matrix = ButtonMatrixElement(name = 'Button_Matrix')
for row in range(8):
button_row = [ ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, row * 16 + column, str(column) + '_Clip_' + str(row) + '_Button', self, skin = self._skin) for column in range(8) ]
matrix.add_row(tuple(button_row))
self._matrix = matrix
self._config_button = ButtonElement(is_momentary, MIDI_CC_TYPE, 0, 0, optimized_send_midi=False)
self._config_button.add_value_listener(self._config_value)
top_button_names = ['Bank_Select_Up_Button',
'Bank_Select_Down_Button',
'Bank_Select_Left_Button',
'Bank_Select_Right_Button',
'Session_Button',
'User1_Button',
'User2_Button',
'Mixer_Button']
side_button_names = ['Vol_Button',
'Pan_Button',
'SndA_Button',
'SndB_Button',
'Stop_Button',
'Trk_On_Button',
'Solo_Button',
'Arm_Button']
top_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_CC_TYPE, 0, 104 + index, top_button_names[index], self, skin = self._skin) for index in range(8) ]
self._top_buttons = top_buttons
side_buttons = [ ConfigurableButtonElement(is_momentary, MIDI_NOTE_TYPE, 0, SIDE_NOTES[index], side_button_names[index], self, skin = self._skin) for index in range(8) ]
self._side_buttons = ButtonMatrixElement(name = 'SideButtons', rows = [side_buttons])
self._setup_monobridge()
self._setup_mod()
self._selector = MainSelectorComponent(self, matrix, tuple(top_buttons), tuple(side_buttons), self._config_button)
self._selector.name = 'Main_Modes'
for control in self.controls:
isinstance(control, MonoButtonElement) and control.add_value_listener(self._button_value)
self.set_highlighting_session_component(self._selector.session_component())
self._suppress_session_highlight = False
self.log_message('--------------= ' + str(self._monomod_version) + ' log opened =--------------')
def __init__(self, *a, **k):
super(BeatStep, self).__init__(*a, **k)
self._skin = Skin(Colors)
with self.component_guard():
self._create_controls()
self._create_device()
self._create_session()
self._create_mixer()
self._create_transport()
def __init__(self, *a, **k):
super(MIDI_Mix, self).__init__(*a, **k)
with self.component_guard():
self._skin = Skin(Colors)
with inject(skin=const(self._skin)).everywhere():
self._create_controls()
self._create_mixer()
self._create_session()
self._session.set_mixer(self._mixer)
self.set_highlighting_session_component(self._session)
def __init__(self,
is_momentary,
msg_type,
channel,
identifier,
skin=Skin(),
undo_step_handler=DummyUndoStepHandler(),
*a,
**k):
super(ButtonElement,
self).__init__(is_momentary, msg_type, channel, identifier, skin,
undo_step_handler, *a, **k)
self._skin = make_rgb_skin()
def _create_controls(self):
skin = Skin(SkinDefault)
def create_matrix_button(row, column):
return ButtonElement(True,
MIDI_NOTE_TYPE,
0,
row * 16 + column,
skin=skin)
def create_matrix(size):
return ButtonMatrixElement(
rows=[[create_matrix_button(x, y) for y in xrange(size)]
for x in xrange(size)])
self.matrix = create_matrix(8)
def __init__(self, *a, **k):
super(Faderfox, self).__init__(*a, **k)
self._version_check = '1.0'
self._host_name = 'Faderfox'
self._color_type = 'Monochrome'
self._rgb = 0
self._timer = 0
self._touched = 0
self.flash_status = 1
self._skin = Skin(FaderfoxColors)
self._main_modes = None
with self.component_guard():
self._setup_monobridge()
self._setup_controls()
self._setup_session()
self._setup_device_control()
self._setup_device_selector()
self._setup_modes()
self._device_selector.select_device(DEFAULT_DEVICE_INDEX)
self._on_device_changed.subject = self.song()
self.set_feedback_channels(range(14, 15))
#self._main_modes.selected_mode = 'MixMode'
self.schedule_message(1, self._open_log)
self._session.set_enabled(True)
def make_default_skin():
return Skin(Defaults)
def make_biled_skin():
return Skin(BiLedColors)
def pad_skin(): return Skin(Colors)
def make_default_skin():
return Skin(Colors)
def button_skin(index):
class Button:
On = mode_colors[index]
Off = mode_colors[index]
Alt = Rgb.YELLOW
return Skin(Button)
def make_skin():
return Skin(Colors)
class ConfigurableButtonElement(ButtonElement):
"""
Special button class that can be configured with custom on-
and off-values.
A ConfigurableButtonElement can have states other than True or
False, which can be defined by setting the 'states' property.
Thus 'set_light' can take any state or skin color.
"""
class Colors:
class DefaultButton:
On = Basic.ON
Off = Basic.HALF
Disabled = Basic.OFF
Alert = Basic.FULL_BLINK_FAST
default_skin = Skin(Colors)
default_states = {True: 'DefaultButton.On', False: 'DefaultButton.Off'}
num_delayed_messages = 2
send_depends_on_forwarding = False
def __init__(self,
is_momentary,
msg_type,
channel,
identifier,
skin=None,
is_rgb=False,
default_states=None,
*a,
**k):
super(ConfigurableButtonElement,
self).__init__(is_momentary,
msg_type,
channel,
identifier,
skin=(skin or self.default_skin),
*a,
**k)
if default_states is not None:
self.default_states = default_states
self.states = dict(self.default_states)
self.is_rgb = is_rgb
self._is_enabled = True
self._force_next_value = False
self.set_channel(NON_FEEDBACK_CHANNEL)
return
@property
def _on_value(self):
return self.states[True]
@property
def _off_value(self):
return self.states[False]
@property
def on_value(self):
return self._try_fetch_skin_value(self._on_value)
@property
def off_value(self):
return self._try_fetch_skin_value(self._off_value)
def _try_fetch_skin_value(self, value):
try:
return self._skin[value]
except SkinColorMissingError:
return value
def reset(self):
self.states = dict(self.default_states)
self.set_light('DefaultButton.Disabled')
self.set_identifier(self._original_identifier)
self.set_channel(NON_FEEDBACK_CHANNEL)
self.set_enabled(True)
def set_on_off_values(self, on_value, off_value):
self.states[True] = on_value
self.states[False] = off_value
def set_force_next_value(self):
self._force_next_value = True
def set_enabled(self, enabled):
if self._is_enabled != enabled:
self._is_enabled = enabled
self._request_rebuild()
def is_enabled(self):
return self._is_enabled
def set_light(self, value):
super(ConfigurableButtonElement,
self).set_light(self.states.get(value, value))
def send_value(self, value, **k):
if value is ON_VALUE:
self._do_send_on_value()
elif value is OFF_VALUE:
self._do_send_off_value()
else:
super(ConfigurableButtonElement, self).send_value(value, **k)
def _do_send_on_value(self):
self._skin[self._on_value].draw(self)
def _do_send_off_value(self):
self._skin[self._off_value].draw(self)
def script_wants_forwarding(self):
return self._is_enabled
def white_button_skin():
class Button:
On = Rgb.WHITE
Off = Rgb.BLACK
return Skin(Button)
def make_crossfade_button_skin():
return Skin(CrossfadeButtons)
def make_stop_button_skin():
return Skin(StopButtons)
def make_rgb_skin():
return Skin(RgbColors)
def make_rgb_skin():
return merge_skins(Skin(RgbColors), Skin(Defaults))
def make_default_skin(): #modified to use SeaPushSkin if elected.
if SEAPUSH_SKIN:
return Skin(SeaPushSkin.Colors)
else:
return Skin(Colors)
