Exemple #1
0
	def _setup_controls(self):
		is_momentary = True
		self._fader = [ None for index in range(8) ]
		self._dial = [ None for index in range(16) ]
		self._button = [ None for index in range(8) ]
		self._menu = [ None for index in range(6) ]
		for index in range(8):
			self._fader[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_FADERS[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, self)

		for index in range(8):
			self._button[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_' + str(index), self)

		for index in range(16):
			self._dial[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, OHM_DIALS[index], Live.MidiMap.MapMode.absolute, 'Encoder_' + str(index), index, self)

		self._knobs = []
		for index in range(12):
			self._knobs.append(self._dial[index])

		for index in range(6):
			self._menu[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_MENU[index], 'Menu_' + str(index), self)

		self._crossfader = EncoderElement(MIDI_CC_TYPE, CHANNEL, CROSSFADER, Live.MidiMap.MapMode.absolute)
		self._crossfader.name = 'Crossfader'
		self._livid = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self)
		self._shift_l = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Page_Button_Left', self)
		self._shift_r = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Page_Button_Right', self)
		self._matrix = ButtonMatrixElement()
		self._matrix.name = 'Matrix'
		self._grid = [ None for index in range(8) ]
		self._monomod = ButtonMatrixElement()
		self._monomod.name = 'Monomod'
		for column in range(8):
			self._grid[column] = [ None for index in range(8) ]
			for row in range(8):
				self._grid[column][row] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, column * 8 + row, 'Grid_' + str(column) + '_' + str(row), self)

		for row in range(5):
			button_row = []
			for column in range(7):
				button_row.append(self._grid[column][row])

			self._matrix.add_row(tuple(button_row))

		for row in range(8):
			button_row = []
			for column in range(8):
				button_row.append(self._grid[column][row])

			self._monomod.add_row(tuple(button_row))

		self._dial_matrix = ButtonMatrixElement()
		for row in range(3):
			dial_row = []
			for column in range(4):
				dial_row.append(self._dial[column + (row*4)])

			self._dial_matrix.add_row(tuple(dial_row))

		self._menu_matrix = ButtonMatrixElement([self._menu])
	def _setup_controls(self):
		is_momentary = True
		self._button = [MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, BUTTONS[index], 'Button_' + str(index), self) for index in range(10)]

		self._fader = [MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, SLIDERS[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, self) for index in range(3)]
		#self._fader_button = [MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, index, 'Fader_Button_' + str(index), self) for index in range(3)]
		self._fader_button = [MonoEncoderElement(MIDI_NOTE_TYPE, CHANNEL, SLIDERS[index], Live.MidiMap.MapMode.absolute, 'Fader_Button_' + str(index), index, self) for index in range(3)]

		self._ccs = [MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, CCS[index], Live.MidiMap.MapMode.absolute, 'CCs_' + str(index), index, self) for index in range(4)]

		self._pad =  [MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, PADS[index], 'Pad_' + str(index), self) for index in range(5)]
		self._padCC = [MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, PADS[index], Live.MidiMap.MapMode.absolute, 'PadCC_' + str(index), index, self) for index in range(5)]

		self._accel = [MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, ACCELS[index], Live.MidiMap.MapMode.absolute, 'Accel_' + str(index), index, self) for index in range(3)]
Exemple #3
0
 def _setup_controls(self):
     is_momentary = True
     self._fader = [
         MonoEncoderElement(
             MIDI_CC_TYPE,
             CHANNEL,
             ALIAS_FADERS[index],
             Live.MidiMap.MapMode.absolute,
             "Fader_" + str(index),
             index,
             self,
         )
         for index in range(9)
     ]
     self._button = [
         MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, ALIAS_BUTTONS[index], "Button_" + str(index), self)
         for index in range(16)
     ]
     self._dial = [
         MonoEncoderElement(
             MIDI_CC_TYPE,
             CHANNEL,
             ALIAS_DIALS[index],
             Live.MidiMap.MapMode.absolute,
             "Dial_" + str(index),
             index + 8,
             self,
         )
         for index in range(16)
     ]
     self._encoder = MonoEncoderElement(
         MIDI_CC_TYPE, CHANNEL, ALIAS_ENCODER, Live.MidiMap.MapMode.absolute, "Encoder", 0, self
     )
Exemple #4
0
    def _setup_custom_components(self):
        is_momentary = True
        master_select_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 0,
                                             80)
        master_select_button.name = 'Master_Select_Button'
        self._master_select_button = master_select_button
        select_buttons = []
        arm_buttons = []
        sliders = []
        for track in range(8):
            select_buttons.append(
                AumPCMonoButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 51,
                                       str(track) + '_Select_Button', self))
            arm_buttons.append(
                ButtonElement(is_momentary, MIDI_NOTE_TYPE, track, 48))
            sliders.append(
                MonoEncoderElement(MIDI_CC_TYPE, track, 7,
                                   Live.MidiMap.MapMode.absolute,
                                   'Slider_' + str(track), track, self))
            select_buttons[-1].name = str(track) + '_Select_Button'
            arm_buttons[-1].name = str(track) + '_Arm_Button'
            #sliders[-1].name = str(track) + '_Volume_Control'
        self._select_buttons = select_buttons

        transport = TransportComponent()
        transport.name = 'Transport'
        slider_modes = SliderModesComponent(self._mixer, tuple(sliders))
        slider_modes.name = 'Slider_Modes'
        self._shift_modes = AumPC20ShiftableSelectorComponent(
            tuple(select_buttons), master_select_button, tuple(arm_buttons),
            self._matrix, self._session, self._session_zoom, self._mixer,
            transport, slider_modes, self._send_introduction_message, self)
        self._shift_modes.name = 'Shift_Modes'
        self._shift_modes.set_mode_toggle(self._shift_button)
        self._device = DeviceComponent()
Exemple #5
0
	def _setup_controls(self):
		is_momentary = True
		self._fader = [None for index in range(8)]
		self._dial = [None for index in range(8)]
		self._button = [None for index in range(8)]
		self._menu = [None for index in range(6)]
		for index in range(2):
			self._fader[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, SLIDER_CC[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, self)
		#for index in range(8):
		#	self._button[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, OHM_BUTTONS[index], 'Button_' + str(index), self)
		for index in range(8):
			self._dial[index] = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, KNOB_CC[index], Live.MidiMap.MapMode.absolute, 'Dial_' + str(index), index + 8, self)
		for index in range(4):
			self._menu[index] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, FUNCTION_NOTES[index], 'Menu_' + str(index), self)	
		#self._livid = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self)
		self._livid = DoublePressElement(MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, LIVID, 'Livid_Button', self))
		self._shift_l = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_L, 'Shift_Button_Left', self)
		self._shift_r = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, SHIFT_R, 'Shift_Button_Right', self)
		self._matrix = ButtonMatrixElement()
		self._matrix.name = 'Matrix'
		self._monomod = ButtonMatrixElement()
		self._monomod.name = 'Monomod'
		self._grid = [None for index in range(8)]
		for column in range(8):
			self._grid[column] = [None for index in range(8)]
			for row in range(8):
				self._grid[column][row] = MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, (column * 8) + row, 'Grid_' + str(column) + '_' + str(row), self)
		for row in range(5):
			button_row = []
			for column in range(7):
				button_row.append(self._grid[column][row])
			self._matrix.add_row(tuple(button_row)) 
		for row in range(8):
			button_row = []
			for column in range(8):
				button_row.append(self._grid[column][row])
			self._monomod.add_row(tuple(button_row))
		self._dummy_button = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 125)
		self._dummy_button.name = 'Dummy1'
		self._dummy_button2 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 126)
		self._dummy_button2.name = 'Dummy2'
		self._dummy_button3 = ButtonElement(is_momentary, MIDI_NOTE_TYPE, 15, 127)
		self._dummy_button2.name = 'Dummy3'
		self._dial_matrix = ButtonMatrixElement()
		self._dial_matrix.add_row(self._dial)
Exemple #6
0
def make_slider(channel, identifier, name='', num=0, script=None, *a, **k):
    return MonoEncoderElement(MIDI_CC_TYPE,
                              channel,
                              identifier,
                              MapMode.absolute,
                              name=name,
                              num=num,
                              script=script,
                              *a,
                              **k)
Exemple #7
0
	def _setup_controls(self):
		is_momentary = True
		self._fader = [MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, DS1_FADERS[index], Live.MidiMap.MapMode.absolute, 'Fader_' + str(index), index, self) for index in range(8)]
		for fader in self._fader:
			fader._mapping_feedback_delay = -1
		self._dial = [[MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, DS1_DIALS[x][y], Live.MidiMap.MapMode.absolute, 'Dial_' + str(x) + '_' + str(y), x + (y*5), self) for x in range(8)] for y in range(5)]
		for row in self._dial:
			for dial in row:
				dial._mapping_feedback_delay = -1
		self._side_dial = [MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, DS1_SIDE_DIALS[x], Live.MidiMap.MapMode.absolute, 'Side_Dial_' + str(x), x, self) for x in range(4)]
		for dial in self._side_dial:
			dial._mapping_feedback_delay = -1
		self._encoder = [MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, DS1_ENCODERS[x], Live.MidiMap.MapMode.absolute, 'Encoder_' + str(x), x, self) for x in range(4)]
		for encoder in self._encoder:
			encoder._mapping_feedback_delay = -1
		self._encoder_button = [MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, DS1_ENCODER_BUTTONS[index], 'EncoderButton_' + str(index), self, skin = self._skin) for index in range(4)]
		self._master_fader = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, DS1_MASTER, Live.MidiMap.MapMode.absolute, 'MasterFader', 0, self)
		self._button = [MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, DS1_BUTTONS[index], 'Button_' + str(index), self, skin = self._skin) for index in range(16)]
		self._grid = [[MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, DS1_GRID[x][y], 'Button_' + str(x) + '_' + str(y), self, skin = self._skin) for x in range(3)] for y in range(3)]
		self._dummy = [MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, 120+x, Live.MidiMap.MapMode.absolute, 'Dummy_Dial_' + str(x), x, self) for x in range(5)]

		self._fader_matrix = ButtonMatrixElement(name = 'FaderMatrix', rows = [self._fader])
		self._top_buttons = ButtonMatrixElement(name = 'TopButtonMatrix', rows = [self._button[:8]])
		self._bottom_buttons = ButtonMatrixElement(name = 'BottomButtonMatrix', rows = [self._button[8:]])
		self._dial_matrix = ButtonMatrixElement(name = 'DialMatrix', rows = self._dial)
		self._side_dial_matrix = ButtonMatrixElement(name = 'SideDialMatrix', rows = [self._side_dial])
		self._encoder_matrix = ButtonMatrixElement(name = 'EncoderMatrix', rows = [self._encoder])
		self._encoder_button_matrix = ButtonMatrixElement(name = 'EncoderButtonMatrix', rows = [self._encoder_button])
		self._grid_matrix = ButtonMatrixElement(name = 'GridMatrix', rows = self._grid)
		self._selected_parameter_controls = ButtonMatrixElement(name = 'SelectedParameterControls', rows = [self._dummy + self._encoder[:1] + self._encoder[2:]])
Exemple #8
0
 def _setup_controls(self):
     is_momentary = True
     self._fader = [
         MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, ALIAS_FADERS[index],
                            Live.MidiMap.MapMode.absolute,
                            'Fader_' + str(index), index, self)
         for index in range(9)
     ]
     self._button = [
         MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
                           ALIAS_BUTTONS[index], 'Button_' + str(index),
                           self) for index in range(16)
     ]
     self._dial = [
         MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, ALIAS_DIALS[index],
                            Live.MidiMap.MapMode.absolute,
                            'Dial_' + str(index), index + 8, self)
         for index in range(16)
     ]
     self._encoder = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL,
                                        ALIAS_ENCODER,
                                        Live.MidiMap.MapMode.absolute,
                                        'Encoder', 0, self)
Exemple #9
0
	def set_value(self, value):
		MonoEncoderElement.set_value(self, value)
		self._timer = self._script._timer
Exemple #10
0
 def set_value(self, value):
     MonoEncoderElement.set_value(self, value)
     self._timer = self._script._timer
Exemple #11
0
class Alias(ControlSurface):
    __module__ = __name__
    __doc__ = " Alias 8 controller script "

    def __init__(self, c_instance):
        super(Alias, self).__init__(c_instance)
        with self.component_guard():
            self._host_name = 'Alias'
            self._color_type = 'OhmRGB'
            self.log_message(
                "--------------= Alias log opened =--------------")
            self._rgb = 0
            self._timer = 0
            self.flash_status = 1
            self._clutch_device_selection = False
            self._touched = 0
            self._update_linked_device_selection = None
            self._setup_monobridge()
            self._setup_controls()
            self._setup_m4l_interface()
            self._setup_mixer_control()
            self._setup_session_control()
            self._setup_mixer_nav()

    """script initialization methods"""

    def _setup_monobridge(self):
        self._monobridge = MonoBridgeElement(self)
        self._monobridge.name = 'MonoBridge'

    def _setup_controls(self):
        is_momentary = True
        self._fader = [
            MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, ALIAS_FADERS[index],
                               Live.MidiMap.MapMode.absolute,
                               'Fader_' + str(index), index, self)
            for index in range(9)
        ]
        self._button = [
            MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL,
                              ALIAS_BUTTONS[index], 'Button_' + str(index),
                              self) for index in range(16)
        ]
        self._dial = [
            MonoEncoderElement(MIDI_CC_TYPE, CHANNEL, ALIAS_DIALS[index],
                               Live.MidiMap.MapMode.absolute,
                               'Dial_' + str(index), index + 8, self)
            for index in range(16)
        ]
        self._encoder = MonoEncoderElement(MIDI_CC_TYPE, CHANNEL,
                                           ALIAS_ENCODER,
                                           Live.MidiMap.MapMode.absolute,
                                           'Encoder', 0, self)

    def _setup_m4l_interface(self):
        self._m4l_interface = M4LInterfaceComponent(
            controls=self.controls, component_guard=self.component_guard)
        self.get_control_names = self._m4l_interface.get_control_names
        self.get_control = self._m4l_interface.get_control
        self.grab_control = self._m4l_interface.grab_control
        self.release_control = self._m4l_interface.release_control

    def _setup_mixer_control(self):
        is_momentary = True
        self._num_tracks = (8)  #A mixer is one-dimensional;
        self._mixer = AliasMixerComponent(8, 0, False, False)
        self._mixer.name = 'Mixer'
        self._mixer.set_track_offset(
            0)  #Sets start point for mixer strip (offset from left)
        for index in range(8):
            self._mixer.channel_strip(index).set_volume_control(
                self._fader[index])
            self._mixer.channel_strip(index).set_send_controls(
                tuple([self._dial[index], self._dial[index + 8]]))
            self._mixer.channel_strip(index).set_mute_button(
                self._button[index])
            self._button[index].set_on_off_values(MUTE_TOG, 0)
            self._mixer.channel_strip(index)._invert_mute_feedback = True
            self._mixer.channel_strip(index).set_arm_button(
                self._button[index + 8])
            self._button[index + 8].set_on_off_values(REC_TOG, 0)
            self._mixer.channel_strip(
                index).name = 'Mixer_ChannelStrip_' + str(index)
        self._mixer.master_strip().set_volume_control(self._fader[8])
        self.song().view.selected_track = self._mixer.channel_strip(0)._track

    def _setup_session_control(self):
        self._session = SessionComponent(8, 1)
        self._session.set_mixer(self._mixer)
        self.set_highlighting_session_component(self._session)

    def _setup_mixer_nav(self):
        if not self._encoder.value_has_listener(self._nav_change):
            self._encoder.add_value_listener(self._nav_change)

    """shift/zoom methods"""

    def _nav_change(self, value):
        self._session.set_offsets(
            int((float(value) / float(127)) *
                max(8,
                    len(self._mixer.tracks_to_use()) - 8)),
            self._session._scene_offset)

    """called on timer"""

    def update_display(self):
        ControlSurface.update_display(self)
        self._timer = (self._timer + 1) % 256
        self.flash()

    def flash(self):
        if (self.flash_status > 0):
            for control in self.controls:
                if isinstance(control, MonoButtonElement):
                    control.flash(self._timer)

    """m4l bridge"""

    def generate_strip_string(self, display_string):
        NUM_CHARS_PER_DISPLAY_STRIP = 12
        if (not display_string):
            return (' ' * NUM_CHARS_PER_DISPLAY_STRIP)
        if ((len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1))
                and (display_string.endswith('dB') and
                     (display_string.find('.') != -1))):
            display_string = display_string[:-2]
        if (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)):
            for um in [' ', 'i', 'o', 'u', 'e', 'a']:
                while ((len(display_string) >
                        (NUM_CHARS_PER_DISPLAY_STRIP - 1))
                       and (display_string.rfind(um, 1) != -1)):
                    um_pos = display_string.rfind(um, 1)
                    display_string = (display_string[:um_pos] +
                                      display_string[(um_pos + 1):])
        else:
            display_string = display_string.center(
                (NUM_CHARS_PER_DISPLAY_STRIP - 1))
        ret = u''
        for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)):
            if ((ord(display_string[i]) > 127)
                    or (ord(display_string[i]) < 0)):
                ret += ' '
            else:
                ret += display_string[i]

        ret += ' '
        ret = ret.replace(' ', '_')
        assert (len(ret) == NUM_CHARS_PER_DISPLAY_STRIP)
        return ret

    def notification_to_bridge(self, name, value, sender):
        if isinstance(sender, MonoEncoderElement):
            self._monobridge._send(sender.name, 'lcd_name',
                                   str(self.generate_strip_string(name)))
            self._monobridge._send(sender.name, 'lcd_value',
                                   str(self.generate_strip_string(value)))

    def touched(self):
        if self._touched is 0:
            self._monobridge._send('touch', 'on')
            self.schedule_message(2, self.check_touch)
        self._touched += 1

    def check_touch(self):
        if self._touched > 5:
            self._touched = 5
        elif self._touched > 0:
            self._touched -= 1
        if self._touched is 0:
            self._monobridge._send('touch', 'off')
        else:
            self.schedule_message(2, self.check_touch)

    """general functionality"""

    def allow_updates(self, allow_updates):
        for component in self.components:
            component.set_allow_update(int(allow_updates != 0))

    def disconnect(self):
        if self._encoder.value_has_listener(self._nav_change):
            self._encoder.remove_value_listener(self._nav_change)
        self.log_message("--------------= Alias log closed =--------------")
        super(Alias, self).disconnect()
        rebuild_sys()

    def handle_sysex(self, midi_bytes):
        pass

    def device_follows_track(self, val):
        self._device_selection_follows_track_selection = (val == 1)
        return self

    def assign_alternate_mappings(self):
        pass

    def _get_num_tracks(self):
        return self.num_tracks

    def _on_device_changed(self, device):
        #self.log_message('new device ' + str(type(device)))
        if self._update_linked_device_selection != None:
            self._update_linked_device_selection(device)

    def _on_session_offset_changes(self):
        if self._r_function_mode._mode_index in range(0, 3):
            self._mem[int(self._r_function_mode._mode_index
                          )] = self._session2.track_offset()

    def connect_script_instances(self, instanciated_scripts):
        pass


#	a
Exemple #12
0
class Alias(ControlSurface):
    __module__ = __name__
    __doc__ = " Alias 8 controller script "

    def __init__(self, c_instance):
        super(Alias, self).__init__(c_instance)
        with self.component_guard():
            self._host_name = "Alias"
            self._color_type = "OhmRGB"
            self.log_message("--------------= Alias log opened =--------------")
            self._rgb = 0
            self._timer = 0
            self.flash_status = 1
            self._clutch_device_selection = False
            self._touched = 0
            self._update_linked_device_selection = None
            self._setup_monobridge()
            self._setup_controls()
            self._setup_m4l_interface()
            self._setup_mixer_control()
            self._setup_session_control()
            self._setup_mixer_nav()

    """script initialization methods"""

    def _setup_monobridge(self):
        self._monobridge = MonoBridgeElement(self)
        self._monobridge.name = "MonoBridge"

    def _setup_controls(self):
        is_momentary = True
        self._fader = [
            MonoEncoderElement(
                MIDI_CC_TYPE,
                CHANNEL,
                ALIAS_FADERS[index],
                Live.MidiMap.MapMode.absolute,
                "Fader_" + str(index),
                index,
                self,
            )
            for index in range(9)
        ]
        self._button = [
            MonoButtonElement(is_momentary, MIDI_NOTE_TYPE, CHANNEL, ALIAS_BUTTONS[index], "Button_" + str(index), self)
            for index in range(16)
        ]
        self._dial = [
            MonoEncoderElement(
                MIDI_CC_TYPE,
                CHANNEL,
                ALIAS_DIALS[index],
                Live.MidiMap.MapMode.absolute,
                "Dial_" + str(index),
                index + 8,
                self,
            )
            for index in range(16)
        ]
        self._encoder = MonoEncoderElement(
            MIDI_CC_TYPE, CHANNEL, ALIAS_ENCODER, Live.MidiMap.MapMode.absolute, "Encoder", 0, self
        )

    def _setup_m4l_interface(self):
        self._m4l_interface = M4LInterfaceComponent(controls=self.controls, component_guard=self.component_guard)
        self.get_control_names = self._m4l_interface.get_control_names
        self.get_control = self._m4l_interface.get_control
        self.grab_control = self._m4l_interface.grab_control
        self.release_control = self._m4l_interface.release_control

    def _setup_mixer_control(self):
        is_momentary = True
        self._num_tracks = 8  # A mixer is one-dimensional;
        self._mixer = AliasMixerComponent(8, 0, False, False)
        self._mixer.name = "Mixer"
        self._mixer.set_track_offset(0)  # Sets start point for mixer strip (offset from left)
        for index in range(8):
            self._mixer.channel_strip(index).set_volume_control(self._fader[index])
            self._mixer.channel_strip(index).set_send_controls(tuple([self._dial[index], self._dial[index + 8]]))
            self._mixer.channel_strip(index).set_mute_button(self._button[index])
            self._button[index].set_on_off_values(MUTE_TOG, 0)
            self._mixer.channel_strip(index)._invert_mute_feedback = True
            self._mixer.channel_strip(index).set_arm_button(self._button[index + 8])
            self._button[index + 8].set_on_off_values(REC_TOG, 0)
            self._mixer.channel_strip(index).name = "Mixer_ChannelStrip_" + str(index)
        self._mixer.master_strip().set_volume_control(self._fader[8])
        self.song().view.selected_track = self._mixer.channel_strip(0)._track

    def _setup_session_control(self):
        self._session = SessionComponent(8, 1)
        self._session.set_mixer(self._mixer)
        self.set_highlighting_session_component(self._session)

    def _setup_mixer_nav(self):
        if not self._encoder.value_has_listener(self._nav_change):
            self._encoder.add_value_listener(self._nav_change)

    """shift/zoom methods"""

    def _nav_change(self, value):
        self._session.set_offsets(
            int((float(value) / float(127)) * max(8, len(self._mixer.tracks_to_use()) - 8)), self._session._scene_offset
        )

    """called on timer"""

    def update_display(self):
        ControlSurface.update_display(self)
        self._timer = (self._timer + 1) % 256
        self.flash()

    def flash(self):
        if self.flash_status > 0:
            for control in self.controls:
                if isinstance(control, MonoButtonElement):
                    control.flash(self._timer)

    """m4l bridge"""

    def generate_strip_string(self, display_string):
        NUM_CHARS_PER_DISPLAY_STRIP = 12
        if not display_string:
            return " " * NUM_CHARS_PER_DISPLAY_STRIP
        if (len(display_string.strip()) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (
            display_string.endswith("dB") and (display_string.find(".") != -1)
        ):
            display_string = display_string[:-2]
        if len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1):
            for um in [" ", "i", "o", "u", "e", "a"]:
                while (len(display_string) > (NUM_CHARS_PER_DISPLAY_STRIP - 1)) and (display_string.rfind(um, 1) != -1):
                    um_pos = display_string.rfind(um, 1)
                    display_string = display_string[:um_pos] + display_string[(um_pos + 1) :]
        else:
            display_string = display_string.center((NUM_CHARS_PER_DISPLAY_STRIP - 1))
        ret = u""
        for i in range((NUM_CHARS_PER_DISPLAY_STRIP - 1)):
            if (ord(display_string[i]) > 127) or (ord(display_string[i]) < 0):
                ret += " "
            else:
                ret += display_string[i]

        ret += " "
        ret = ret.replace(" ", "_")
        assert len(ret) == NUM_CHARS_PER_DISPLAY_STRIP
        return ret

    def notification_to_bridge(self, name, value, sender):
        if isinstance(sender, MonoEncoderElement):
            self._monobridge._send(sender.name, "lcd_name", str(self.generate_strip_string(name)))
            self._monobridge._send(sender.name, "lcd_value", str(self.generate_strip_string(value)))

    def touched(self):
        if self._touched is 0:
            self._monobridge._send("touch", "on")
            self.schedule_message(2, self.check_touch)
        self._touched += 1

    def check_touch(self):
        if self._touched > 5:
            self._touched = 5
        elif self._touched > 0:
            self._touched -= 1
        if self._touched is 0:
            self._monobridge._send("touch", "off")
        else:
            self.schedule_message(2, self.check_touch)

    """general functionality"""

    def allow_updates(self, allow_updates):
        for component in self.components:
            component.set_allow_update(int(allow_updates != 0))

    def disconnect(self):
        if self._encoder.value_has_listener(self._nav_change):
            self._encoder.remove_value_listener(self._nav_change)
        self.log_message("--------------= Alias log closed =--------------")
        super(Alias, self).disconnect()
        rebuild_sys()

    def handle_sysex(self, midi_bytes):
        pass

    def device_follows_track(self, val):
        self._device_selection_follows_track_selection = val == 1
        return self

    def assign_alternate_mappings(self):
        pass

    def _get_num_tracks(self):
        return self.num_tracks

    def _on_device_changed(self, device):
        # self.log_message('new device ' + str(type(device)))
        if self._update_linked_device_selection != None:
            self._update_linked_device_selection(device)

    def _on_session_offset_changes(self):
        if self._r_function_mode._mode_index in range(0, 3):
            self._mem[int(self._r_function_mode._mode_index)] = self._session2.track_offset()

    def connect_script_instances(self, instanciated_scripts):
        pass