def __init__(self,
              selection=None,
              browser_component=None,
              browser_mode=None,
              browser_hotswap_mode=None,
              insert_left=False,
              *a,
              **k):
     super(CreateDeviceComponent, self).__init__(*a, **k)
     self._selection = selection
     self._add_effect_mode = BrowserAddEffectMode(
         selection=selection,
         browser=self.application().browser,
         application_view=self.application().view,
         insert_left=insert_left)
     self._create_device_modes = self.register_component(ModesComponent())
     self._create_device_modes.add_mode('create', [
         SetAttributeMode(browser_component, 'do_load_item',
                          self._do_browser_load_item),
         self._add_effect_mode, browser_mode,
         browser_component.reset_load_memory
     ])
     self._create_device_modes.add_mode(
         'hotswap', [browser_hotswap_mode, browser_mode])
     self._go_to_hotswap_task = self._tasks.add(
         Task.sequence(Task.delay(1), Task.run(self._go_to_hotswap)))
     self._go_to_hotswap_task.kill()
Beispiel #2
0
 def action_button(self, button):
     self._settings_task.kill()
     self._settings_task = self._tasks.add(
         Task.sequence(
             Task.wait(self.SETTINGS_DELAY),
             Task.run(self._do_show_settings)))
     self.trigger_action()
Beispiel #3
0
    def __init__(self, scrollable_list=None, data_sources=tuple(), *a, **k):
        super(ListComponent, self).__init__(*a, **k)
        self._data_sources = data_sources
        self._activation_task = Task.Task()
        self._action_on_scroll_task = Task.Task()
        self._scrollable_list = None
        self._scroller = self.register_component(ScrollComponent())
        self._pager = self.register_component(ScrollComponent())
        self.last_action_item = lambda: self._last_action_item
        self.item_formatter = DefaultItemFormatter()
        for c in (self._scroller, self._pager):
            for button in (c.scroll_up_button, c.scroll_down_button):
                button.color = 'List.ScrollerOn'
                button.pressed_color = None
                button.disabled_color = 'List.ScrollerOff'

        if scrollable_list == None:
            self.scrollable_list = ActionList(
                num_visible_items=len(data_sources))
        else:
            self.scrollable_list = scrollable_list
        self._scrollable_list.num_visible_items = len(data_sources)
        self._delay_activation = BooleanContext()
        self._selected_index_float = 0.0
        self._in_encoder_selection = BooleanContext(False)
        self._execute_action_task = self._tasks.add(
            Task.sequence(Task.delay(1), Task.run(self._execute_action)))
        self._execute_action_task.kill()
    def _setup_hardware(self):
        for msg in self._messages_to_send:
            self._tasks.add(
                Task.sequence(partial(self._send_midi, msg),
                              Task.wait(MESSAGE_DELAY)))

        self._messages_to_send = []
 def __init__(self, play_toggle_model_transform=const(True), *a, **k):
     super(TransportComponent, self).__init__(*a, **k)
     self._ffwd_button = None
     self._rwd_button = None
     self._tap_tempo_button = None
     self._tempo_control = None
     self._tempo_fine_control = None
     self._song_position_control = None
     self._rwd_task = Task.Task()
     self._ffwd_task = Task.Task()
     self._fine_tempo_needs_pickup = True
     self._prior_fine_tempo_value = -1
     self._end_undo_step_task = self._tasks.add(
         Task.sequence(Task.wait(1.5), Task.run(self.song().end_undo_step)))
     self._end_undo_step_task.kill()
     song = self.song()
     self._loop_toggle, self._punch_in_toggle, self._punch_out_toggle, self._record_toggle, self._play_toggle, self._stop_toggle, self._nudge_down_toggle, self._nudge_up_toggle, self._metronome_toggle, self._arrangement_overdub_toggle, self._overdub_toggle = self.register_components(
         ToggleComponent('loop', song),
         ToggleComponent('punch_in', song, is_momentary=True),
         ToggleComponent('punch_out', song, is_momentary=True),
         ToggleComponent('record_mode', song),
         ToggleComponent('is_playing',
                         song,
                         model_transform=play_toggle_model_transform),
         ToggleComponent('is_playing',
                         song,
                         model_transform=const(False),
                         view_transform=const(False)),
         ToggleComponent('nudge_down', song, is_momentary=True),
         ToggleComponent('nudge_up', song, is_momentary=True),
         ToggleComponent('metronome', song),
         ToggleComponent('arrangement_overdub', song),
         ToggleComponent('overdub', song))
     return
 def __init__(self,
              playing_clip_above_layer=None,
              playing_clip_below_layer=None,
              *a,
              **k):
     super(SelectPlayingClipComponent, self).__init__(*a, **k)
     self._update_mode_task = self._tasks.add(
         Task.sequence(Task.delay(1), Task.run(self._update_mode)))
     self._update_mode_task.kill()
     self._notification = self.register_component(
         NotificationComponent(notification_time=-1, is_enabled=False))
     self.add_mode('default', None)
     self.add_mode('above', [
         AddLayerMode(self, playing_clip_above_layer), self._notification,
         partial(self._show_notification,
                 MessageBoxText.PLAYING_CLIP_ABOVE_SELECTED_CLIP)
     ])
     self.add_mode('below', [
         AddLayerMode(self, playing_clip_below_layer), self._notification,
         partial(self._show_notification,
                 MessageBoxText.PLAYING_CLIP_BELOW_SELECTED_CLIP)
     ])
     self.selected_mode = 'default'
     self._on_detail_clip_changed.subject = self.song().view
     self._on_playing_slot_index_changed.subject = self.song(
     ).view.selected_track
 def __init__(self,
              selection=None,
              browser_component=None,
              browser_mode=None,
              browser_hotswap_mode=None,
              insert_left=False,
              *a,
              **k):
     super(CreateDeviceComponent, self).__init__(*a, **k)
     self._selection = selection
     self._add_effect_mode = BrowserAddEffectMode(
         selection=selection,
         browser=self.application().browser,
         application_view=self.application().view,
         insert_left=insert_left)
     self._create_device_modes = self.register_component(ModesComponent())
     self._create_device_modes.add_mode('create', [
         SetAttributeMode(browser_component, 'do_load_item',
                          self._do_browser_load_item),
         self._add_effect_mode, browser_mode,
         browser_component.reset_load_memory
     ])
     self._create_device_modes.add_mode(
         'hotswap', [browser_hotswap_mode, browser_mode])
     self._go_to_hotswap_task = self._tasks.add(
         Task.sequence(Task.delay(1), Task.run(self._go_to_hotswap)))
     self._go_to_hotswap_task.kill()
 def _on_length_release(self):
     song = self.song()
     slot = song_selected_slot(song)
     if slot == None:
         return
     clip = slot.clip
     if self._length_press_state is not None:
         press_slot, press_position = self._length_press_state
         if press_slot == slot and self._length_should_be_fixed(
         ) and slot.is_recording and not clip.is_overdubbing:
             length, _ = self._get_selected_length()
             one_bar = 4.0 * song.signature_numerator / song.signature_denominator
             loop_end = int(press_position / one_bar) * one_bar
             loop_start = loop_end - length
             if loop_start >= 0.0:
                 clip.loop_end = loop_end
                 clip.end_marker = loop_end
                 clip.loop_start = loop_start
                 clip.start_marker = loop_start
                 self._tasks.add(
                     Task.sequence(
                         Task.delay(0),
                         Task.run(
                             partial(slot.fire,
                                     force_legato=True,
                                     launch_quantization=_Q.q_no_q))))
                 self.song().overdub = False
             self._fixed_length.is_active = False
     self._length_press_state = None
Beispiel #9
0
 def __init__(self, clip_creator = None, measure_length = 4.0, follow_detail_clip = False, paginator = None, *a, **k):
     super(LoopSelectorComponent, self).__init__(*a, **k)
     self._clip_creator = clip_creator
     self._sequencer_clip = None
     self._paginator = Paginator()
     self._loop_start = 0
     self._loop_end = 0
     self._loop_length = 0
     self._is_following = False
     self._follow_button = None
     self._select_button = None
     self._short_loop_selector_matrix = None
     self._loop_selector_matrix = None
     self._pressed_pages = []
     self._page_colors = []
     self._measure_length = measure_length
     self._last_playhead_page = -1
     self._follow_task = self._tasks.add(Task.sequence(Task.wait(Defaults.MOMENTARY_DELAY), Task.run(partial(self._set_is_following, True))))
     self._follow_task.kill()
     if follow_detail_clip:
         self._on_detail_clip_changed.subject = self.song().view
     self._on_session_record_changed.subject = self.song()
     self._on_song_playback_status_changed.subject = self.song()
     if paginator is not None:
         self.set_paginator(paginator)
Beispiel #10
0
 def _on_length_release(self):
     song = self.song()
     slot = song_selected_slot(song)
     if slot == None:
         return
     clip = slot.clip
     if self._length_press_state is not None:
         press_slot, press_position = self._length_press_state
         if press_slot == slot and self._length_should_be_fixed() and slot.is_recording and not clip.is_overdubbing:
             length, _ = self._get_selected_length()
             one_bar = 4.0 * song.signature_numerator / song.signature_denominator
             loop_end = int(press_position / one_bar) * one_bar
             loop_start = loop_end - length
             if loop_start >= 0.0:
                 clip.loop_end = loop_end
                 clip.end_marker = loop_end
                 clip.loop_start = loop_start
                 clip.start_marker = loop_start
                 self._tasks.add(
                     Task.sequence(
                         Task.delay(0),
                         Task.run(partial(slot.fire, force_legato=True, launch_quantization=_Q.q_no_q)),
                     )
                 )
                 self.song().overdub = False
             self._fixed_length.is_active = False
     self._length_press_state = None
 def __init__(self,
              notification_time=2.5,
              blinking_time=0.3,
              display_lines=[],
              *a,
              **k):
     super(NotificationComponent, self).__init__(*a, **k)
     self._display_lines = display_lines
     self._token_control = _TokenControlElement()
     self._align_text_fn = self._default_align_text_fn
     self._message_box = self.register_component(MessageBoxComponent())
     self._message_box.set_enabled(False)
     self._notification_timeout_task = self._tasks.add(
         Task.sequence(Task.wait(notification_time),
                       Task.run(self.hide_notification))
     ).kill() if notification_time != -1 else self._tasks.add(Task.Task())
     self._blink_text_task = self._tasks.add(
         Task.loop(
             Task.sequence(
                 Task.run(lambda: self._message_box.
                          __setattr__('text', self._original_text)),
                 Task.wait(blinking_time),
                 Task.run(lambda: self._message_box.__setattr__(
                     'text', self._blink_text)),
                 Task.wait(blinking_time)))).kill()
     self._original_text = None
     self._blink_text = None
Beispiel #12
0
    def __init__(self, scrollable_list = None, data_sources = tuple(), *a, **k):
        super(ListComponent, self).__init__(*a, **k)
        self._data_sources = data_sources
        self._activation_task = Task.Task()
        self._action_on_scroll_task = Task.Task()
        self._scrollable_list = None
        self._scroller = self.register_component(ScrollComponent())
        self._pager = self.register_component(ScrollComponent())
        self.last_action_item = lambda : self._last_action_item
        self.item_formatter = DefaultItemFormatter()
        for c in (self._scroller, self._pager):
            for button in (c.scroll_up_button, c.scroll_down_button):
                button.color = 'List.ScrollerOn'
                button.pressed_color = None
                button.disabled_color = 'List.ScrollerOff'

        if scrollable_list == None:
            self.scrollable_list = ActionList(num_visible_items=len(data_sources))
        else:
            self.scrollable_list = scrollable_list
        self._scrollable_list.num_visible_items = len(data_sources)
        self._delay_activation = BooleanContext()
        self._selected_index_float = 0.0
        self._in_encoder_selection = BooleanContext(False)
        self._execute_action_task = self._tasks.add(Task.sequence(Task.delay(1), Task.run(self._execute_action)))
        self._execute_action_task.kill()
        return
 def _on_scroll(self):
     if self._trigger_action_on_scrolling:
         trigger_selected = partial(self._trigger_action, self.selected_item)
         self._action_on_scroll_task.kill()
         self._action_on_scroll_task = self._tasks.add(
             Task.sequence(Task.wait(Defaults.MOMENTARY_DELAY), Task.delay(1), Task.run(trigger_selected))
         )
    def _setup_hardware(self):
        sequence_to_run = [None] * (len(self._messages_to_send) * 2)
        sequence_to_run[::2] = [ Task.run(partial(self._send_midi, msg)) for msg in self._messages_to_send ]
        sequence_to_run[1::2] = [ Task.wait(INDIVIDUAL_MESSAGE_DELAY) for _ in self._messages_to_send ]
        for subsequence in split_list(sequence_to_run, 40):
            self._tasks.add(Task.sequence(*subsequence))

        self._messages_to_send = []
 def __init__(self, *a, **k):
     super(DetailViewCntrlComponent, self).__init__(*a, **k)
     self._detail_view_visibility_changed.subject = self.application().view
     self._detail_view_visibility_changed()
     self._go_to_playing_clip_task = self._tasks.add(Task.sequence(Task.wait(SHOW_PLAYING_CLIP_DELAY), Task.run(self._go_to_playing_clip)))
     self._go_to_playing_clip_task.kill()
     self.set_device_clip_toggle_button = self.device_clip_toggle_button.set_control_element
     self.set_detail_toggle_button = self.detail_toggle_button.set_control_element
Beispiel #16
0
 def _on_scroll(self):
     if self._trigger_action_on_scrolling:
         trigger_selected = partial(self._trigger_action,
                                    self.selected_item)
         self._action_on_scroll_task.kill()
         self._action_on_scroll_task = self._tasks.add(
             Task.sequence(Task.wait(Defaults.MOMENTARY_DELAY),
                           Task.delay(1), Task.run(trigger_selected)))
 def __init__(self, *a, **k):
     super(ArturiaControlSurface, self).__init__(*a, **k)
     self._messages_to_send = []
     self._setup_hardware_task = self._tasks.add(Task.sequence(Task.run(self._collect_setup_messages), Task.wait(SETUP_HARDWARE_DELAY), Task.run(self._setup_hardware)))
     self._setup_hardware_task.kill()
     with self.component_guard():
         self._collect_setup_messages()
         self._setup_hardware()
 def __init__(self, *a, **k):
     super(DetailViewCntrlComponent, self).__init__(*a, **k)
     self._detail_view_visibility_changed.subject = self.application().view
     self._detail_view_visibility_changed()
     self._go_to_playing_clip_task = self._tasks.add(Task.sequence(Task.wait(SHOW_PLAYING_CLIP_DELAY), Task.run(self._go_to_playing_clip)))
     self._go_to_playing_clip_task.kill()
     self.set_device_clip_toggle_button = self.device_clip_toggle_button.set_control_element
     self.set_detail_toggle_button = self.detail_toggle_button.set_control_element
Beispiel #19
0
 def __init__(self, c_instance, *a, **k):
     super(LaunchControlXL, self).__init__(c_instance=c_instance, product_id_bytes=(0, 32, 41, 97), *a, **k)
     self._biled_skin = make_biled_skin()
     self._default_skin = make_default_skin()
     with self.component_guard():
         self._create_controls()
     self._initialize_task = self._tasks.add(Task.sequence(Task.wait(1), Task.run(self._create_components)))
     self._initialize_task.kill()
 def __init__(self, *a, **k):
     super(ArturiaControlSurface, self).__init__(*a, **k)
     self._messages_to_send = []
     self._setup_hardware_task = self._tasks.add(Task.sequence(Task.run(self._collect_setup_messages), Task.wait(SETUP_HARDWARE_DELAY), Task.run(self._setup_hardware)))
     self._setup_hardware_task.kill()
     with self.component_guard():
         self._collect_setup_messages()
         self._setup_hardware()
 def __init__(self, c_instance, *a, **k):
     super(LaunchControlXL, self).__init__(c_instance=c_instance, product_id_bytes=(0, 32, 41, 97), *a, **k)
     self._biled_skin = make_biled_skin()
     self._default_skin = make_default_skin()
     with self.component_guard():
         self._create_controls()
     self._initialize_task = self._tasks.add(Task.sequence(Task.wait(1), Task.run(self._create_components)))
     self._initialize_task.kill()
 def _make_scroll_task(self, scroll_step):
     task = self._tasks.add(
         Task.sequence(
             Task.wait(self.scrolling_delay),
             Task.loop(Task.wait(self.scrolling_step_delay),
                       Task.run(scroll_step))))
     task.kill()
     return task
    def _setup_hardware(self):
        sequence_to_run = [None] * (len(self._messages_to_send) * 2)
        sequence_to_run[::2] = [ Task.run(partial(self._send_midi, msg)) for msg in self._messages_to_send ]
        sequence_to_run[1::2] = [ Task.wait(INDIVIDUAL_MESSAGE_DELAY) for _ in self._messages_to_send ]
        for subsequence in split_list(sequence_to_run, 40):
            self._tasks.add(Task.sequence(*subsequence))

        self._messages_to_send = []
Beispiel #24
0
 def __init__(self, display_label = ' ', display_seg_start = 0, encoder = None, *a, **k):
     super(ValueComponentBase, self).__init__(*a, **k)
     self._display_mode = self.TOUCH_BASED
     self._button = None
     self._on_encoder_changed.subject = encoder
     self._display = self.register_component(self.create_display_component(display_label=display_label, display_seg_start=display_seg_start))
     self._display.set_enabled(False)
     self._hide_display_task = self._tasks.add(Task.sequence(Task.wait(self.AUTO_HIDE_IN_SEC), Task.run(partial(self._display.set_enabled, False))))
     self._hide_display_task.kill()
Beispiel #25
0
    def _setup_hardware(self):

        def send_subsequence(subseq):
            for msg in subseq:
                self._send_midi(msg)

        sequence_to_run = [ Task.run(partial(send_subsequence, subsequence)) for subsequence in split_list(self._messages_to_send, 20) ]
        self._tasks.add(Task.sequence(*sequence_to_run))
        self._messages_to_send = []
Beispiel #26
0
    def _setup_hardware(self):

        def send_subsequence(subseq):
            for msg in subseq:
                self._send_midi(msg)

        sequence_to_run = [ Task.run(partial(send_subsequence, subsequence)) for subsequence in split_list(self._messages_to_send, 20) ]
        self._tasks.add(Task.sequence(*sequence_to_run))
        self._messages_to_send = []
Beispiel #27
0
 def __init__(self, *a, **k):
     (super(ArturiaControlSurface, self).__init__)(*a, **k)
     self._messages_to_send = []
     self._setup_hardware_task = self._tasks.add(
         Task.sequence(Task.run(self._collect_setup_messages),
                       Task.wait(SETUP_HARDWARE_DELAY),
                       Task.run(self._setup_hardware)))
     self._setup_hardware_task.kill()
     self._start_hardware_setup()
 def __init__(self, display_label = ' ', display_seg_start = 0, encoder = None, *a, **k):
     super(ValueComponentBase, self).__init__(*a, **k)
     self._display_mode = self.TOUCH_BASED
     self._button = None
     self._on_encoder_changed.subject = encoder
     self._display = self.register_component(self.create_display_component(display_label=display_label, display_seg_start=display_seg_start))
     self._display.set_enabled(False)
     self._hide_display_task = self._tasks.add(Task.sequence(Task.wait(self.AUTO_HIDE_IN_SEC), Task.run(partial(self._display.set_enabled, False))))
     self._hide_display_task.kill()
Beispiel #29
0
 def __init__(self, c_instance):
     super(LaunchControl, self).__init__(c_instance)
     with self.component_guard():
         self._init_mixer()
         self._init_session()
         self._init_device()
         self._init_modes()
         self._refresh_state_task = self._tasks.add(Task.sequence(Task.delay(3), Task.run(self._do_refresh_state)))
         self._refresh_state_task.kill()
     self.log_message('Launch Control script loaded')
 def __init__(self, undo_step_handler = None, delete_handler = None, *a, **k):
     super(TouchEncoderElement, self).__init__(*a, **k)
     self._trigger_undo_step = False
     self._undo_step_open = False
     self._undo_step_handler = undo_step_handler
     self._delete_handler = delete_handler
     self._tap_count = 0
     self._tap_task = self._tasks.add(Task.sequence(Task.wait(consts.TAPPING_DELAY), Task.run(self._reset_tapping)))
     self._tap_task.kill()
     self.set_observer(None)
Beispiel #31
0
 def __init__(self, identity_control = None, presentation_control = None, dongle_control = None, dongle = (0, 0), *a, **k):
     super(HandshakeComponent, self).__init__(*a, **k)
     self._identity_control = identity_control
     self._presentation_control = presentation_control
     self._dongle_control = dongle_control
     self._dongle_one, self._dongle_two = dongle
     self._on_identity_value.subject = identity_control
     self._on_dongle_value.subject = dongle_control
     self._identification_timeout_task = self._tasks.add(Task.sequence(Task.wait(HANDSHAKE_TIMEOUT), Task.run(self._do_fail)))
     self._identification_timeout_task.kill()
 def __init__(self, notification_time = 2.5, blinking_time = 0.3, display_lines = [], *a, **k):
     super(NotificationComponent, self).__init__(*a, **k)
     self._display_lines = display_lines
     self._token_control = _TokenControlElement()
     self._message_box = self.register_component(MessageBoxComponent())
     self._message_box.set_enabled(False)
     self._notification_timeout_task = self._tasks.add(Task.sequence(Task.wait(notification_time), Task.run(self.hide_notification))).kill()
     self._blink_text_task = self._tasks.add(Task.loop(Task.sequence(Task.run(lambda : self._message_box.__setattr__('text', self._original_text)), Task.wait(blinking_time), Task.run(lambda : self._message_box.__setattr__('text', self._blink_text)), Task.wait(blinking_time)))).kill()
     self._original_text = None
     self._blink_text = None
Beispiel #33
0
 def __init__(self, c_instance, *a, **k):
     super(Launchkey_MK2, self).__init__(c_instance=c_instance, *a, **k)
     self._is_25_key_model = False
     self._is_in_control_on = True
     with self.component_guard():
         self._skin = make_skin()
         with inject(skin=const(self._skin)).everywhere():
             self._create_controls()
     self._request_task = self._tasks.add(Task.sequence(Task.wait(self.identity_request_delay), Task.run(self._send_identity_request)))
     self._request_task.kill()
Beispiel #34
0
 def __init__(self, c_instance):
     super(LaunchControl, self).__init__(c_instance)
     with self.component_guard():
         self._init_mixer()
         self._init_session()
         self._init_device()
         self._init_modes()
         self._refresh_state_task = self._tasks.add(Task.sequence(Task.delay(3), Task.run(self._do_refresh_state)))
         self._refresh_state_task.kill()
     self.log_message(u'Launch Control script loaded')
Beispiel #35
0
 def __init__(self, c_instance, *a, **k):
     super(Launchkey_MK2, self).__init__(c_instance=c_instance, *a, **k)
     self._is_25_key_model = False
     self._is_in_control_on = True
     self._identity_response_pending = False
     with self.component_guard():
         self._skin = make_skin()
         with inject(skin=const(self._skin)).everywhere():
             self._create_controls()
     self._request_task = self._tasks.add(Task.sequence(Task.wait(self.identity_request_delay), Task.run(self._send_identity_request)))
     self._request_task.kill()
 def __init__(self, msg_type, channel, identifier, map_mode, undo_step_handler = None, delete_handler = None, touch_button = None, *a, **k):
     super(TouchEncoderElement, self).__init__(msg_type, channel, identifier, map_mode, *a, **k)
     self._trigger_undo_step = False
     self._undo_step_open = False
     self._undo_step_handler = undo_step_handler
     self._delete_handler = delete_handler
     self._tap_count = 0
     self._tap_task = self._tasks.add(Task.sequence(Task.wait(consts.TAPPING_DELAY), Task.run(self._reset_tapping)))
     self._tap_task.kill()
     self.set_touch_button(touch_button)
     self.set_observer(None)
 def __init__(self, all_pads = tuple(), parameter_sender = nop, default_profile = PadParameters(), update_delay = 0, *a, **k):
     raise find_if(lambda pad: pad < 0 or pad > 63, all_pads or []) == None or AssertionError
     super(PadUpdateComponent, self).__init__(*a, **k)
     self.parameter_sender = parameter_sender
     self._all_pads = set(all_pads)
     self._modified_pads = set(all_pads)
     self._profiles = {'default': default_profile}
     self._profile_for = dict(zip(all_pads, repeat('default')))
     self._profile_count = {'default': len(all_pads)}
     self._update_task = self._tasks.add(Task.sequence(Task.wait(update_delay), Task.run(self._update_modified)))
     self._update_task.restart()
 def __init__(self, playing_clip_above_layer = None, playing_clip_below_layer = None, *a, **k):
     super(SelectPlayingClipComponent, self).__init__(*a, **k)
     self._update_mode_task = self._tasks.add(Task.sequence(Task.delay(1), Task.run(self._update_mode)))
     self._update_mode_task.kill()
     self._notification = self.register_component(NotificationComponent(notification_time=-1, is_enabled=False))
     self.add_mode('default', None)
     self.add_mode('above', [AddLayerMode(self, playing_clip_above_layer), self._notification, partial(self._show_notification, MessageBoxText.PLAYING_CLIP_ABOVE_SELECTED_CLIP)])
     self.add_mode('below', [AddLayerMode(self, playing_clip_below_layer), self._notification, partial(self._show_notification, MessageBoxText.PLAYING_CLIP_BELOW_SELECTED_CLIP)])
     self.selected_mode = 'default'
     self._on_detail_clip_changed.subject = self.song().view
     self._on_playing_slot_index_changed.subject = self.song().view.selected_track
Beispiel #39
0
 def __init__(self, product_id_bytes=None, *a, **k):
     super(IdentifiableControlSurface, self).__init__(*a, **k)
     assert product_id_bytes is not None
     assert len(product_id_bytes) < 12
     self._product_id_bytes = product_id_bytes
     self._identity_response_pending = False
     self._request_task = self._tasks.add(
         Task.sequence(Task.wait(self.identity_request_delay),
                       Task.run(self._send_identity_request)))
     self._request_task.kill()
     return
 def __init__(self, selection = None, browser_mode = None, browser_component = None, browser_hotswap_mode = None, *a, **k):
     super(CreateInstrumentTrackComponent, self).__init__(*a, **k)
     self._selection = selection
     self._with_browser_modes = self.register_component(ModesComponent())
     self._with_browser_modes.add_mode('create', [self._prepare_browser,
      SetAttributeMode(self.application().browser, 'filter_type', Live.Browser.FilterType.instrument_hotswap),
      SetAttributeMode(browser_component, 'do_load_item', self._do_browser_load_item),
      browser_mode,
      browser_component.reset_load_memory])
     self._with_browser_modes.add_mode('hotswap', [browser_hotswap_mode, browser_mode])
     self._go_to_hotswap_task = self._tasks.add(Task.sequence(Task.delay(1), Task.run(self._go_to_hotswap)))
     self._go_to_hotswap_task.kill()
Beispiel #41
0
 def _on_action_button_value(self, value):
     if self.is_enabled():
         self._settings_task.kill()
         if value:
             self._settings_task = self._tasks.add(Task.sequence(Task.wait(self.SETTINGS_DELAY), Task.run(self._do_show_settings)))
             self.trigger_action()
         elif self._is_showing_settings:
             self.hide_settings()
             self._is_showing_settings = False
         else:
             self.post_trigger_action()
         self._update_action_button()
Beispiel #42
0
 def __init__(self, mode=None, delay=None, parent_task_group=None, *a, **k):
     super(DelayMode, self).__init__(*a, **k)
     assert mode is not None
     assert parent_task_group is not None
     delay = delay if delay is not None else Defaults.MOMENTARY_DELAY
     self._mode = tomode(mode)
     self._mode_entered = False
     self._delay_task = parent_task_group.add(
         Task.sequence(Task.wait(delay),
                       Task.run(self._enter_mode_delayed)))
     self._delay_task.kill()
     return
 def _on_selected_item_changed(self):
     self._scroller.update()
     self._update_display()
     self._update_action_feedback()
     self._activation_task.kill()
     self._action_on_scroll_task.kill()
     if self.SELECTION_DELAY and self._delay_activation:
         self._activation_task = self._tasks.add(Task.sequence(Task.wait(self.SELECTION_DELAY), Task.run(self._scrollable_list.request_notify_item_activated)))
     else:
         self._scrollable_list.request_notify_item_activated()
     if not self._in_encoder_selection:
         self._selected_index_float = float(self._scrollable_list.selected_item_index)
Beispiel #44
0
 def __init__(self, undo_step_handler=None, delete_handler=None, *a, **k):
     super(TouchEncoderElement, self).__init__(*a, **k)
     self._trigger_undo_step = False
     self._undo_step_open = False
     self._undo_step_handler = undo_step_handler
     self._delete_handler = delete_handler
     self._tap_count = 0
     self._tap_task = self._tasks.add(
         Task.sequence(Task.wait(consts.TAPPING_DELAY),
                       Task.run(self._reset_tapping)))
     self._tap_task.kill()
     self.set_observer(None)
Beispiel #45
0
 def __init__(self, header, *a, **k):
     super(DisplayLineElement, self).__init__(*a, **k)
     self._header = header
     self._current_line = list(self.blank_line)
     self._momentary_line = []
     self._last_sent_message = None
     self._show_message_is_priority = False
     self._send_message_task = self._tasks.add(Task.run(self._send_message))
     self._send_message_task.kill()
     self._auto_revert_task = self._tasks.add(
         Task.sequence(Task.delay(15), self.revert))
     self._auto_revert_task.kill()
     return
Beispiel #46
0
 def _on_selected_item_changed(self):
     self._scroller.update()
     self._pager.update()
     self._update_display()
     self._update_action_feedback()
     self._activation_task.kill()
     self._action_on_scroll_task.kill()
     if self.SELECTION_DELAY and self._delay_activation:
         self._activation_task = self._tasks.add(Task.sequence(Task.wait(self.SELECTION_DELAY), Task.run(self._scrollable_list.request_notify_item_activated)))
     else:
         self._scrollable_list.request_notify_item_activated()
     if not self._in_encoder_selection:
         self._selected_index_float = float(self._scrollable_list.selected_item_index)
Beispiel #47
0
 def __init__(self,
              wrapped_control=None,
              double_press_context=None,
              *a,
              **k):
     super(DoublePressElement,
           self).__init__(wrapped_control=wrapped_control, *a, **k)
     self.register_control_element(self._wrapped_control)
     self._double_press_context = double_press_context
     self._double_press_task = self._tasks.add(
         Task.sequence(Task.wait(self.DOUBLE_PRESS_MAX_DELAY),
                       Task.run(self.finish_single_press))).kill()
     self.request_listen_nested_control_elements()
Beispiel #48
0
 def __init__(self, c_instance=None, publish_self=True, *a, **k):
     u""" Define and Initialize standard behavior """
     super(ControlSurface, self).__init__(*a, **k)
     assert c_instance
     self.canonical_parent = None
     if publish_self:
         publish_control_surface(self)
     self._c_instance = c_instance
     self.log_message('Initialising...')
     self._pad_translations = None
     self._suggested_input_port = str('')
     self._suggested_output_port = str('')
     self._components = []
     self._displays = []
     self.controls = []
     self._highlighting_session_component = None
     self._device_component = None
     self._forwarding_long_identifier_registry = {}
     self._forwarding_registry = {}
     self._is_sending_scheduled_messages = BooleanContext()
     self._remaining_scheduled_messages = []
     self._task_group = Task.TaskGroup(auto_kill=False)
     self._in_build_midi_map = BooleanContext()
     self._suppress_requests_counter = 0
     self._rebuild_requests_during_suppression = 0
     self._enabled = True
     self._in_component_guard = BooleanContext()
     self._accumulate_midi_messages = BooleanContext()
     self._midi_message_dict = {}
     self._midi_message_list = []
     self._midi_message_count = 0
     self.mxd_midi_scheduler = MessageScheduler(
         self._do_send_midi, self._task_group.add(Task.TimedCallbackTask()))
     self._control_surface_injector = inject(
         parent_task_group=const(self._task_group),
         show_message=const(self.show_message),
         log_message=const(self.log_message),
         register_component=const(self._register_component),
         register_control=const(self._register_control),
         request_rebuild_midi_map=const(self.request_rebuild_midi_map),
         set_pad_translations=const(self.set_pad_translations),
         send_midi=const(self._send_midi),
         song=self.song).everywhere()
     self.register_slot(self.song(), self._on_track_list_changed,
                        'visible_tracks')
     self.register_slot(self.song(), self._on_scene_list_changed, 'scenes')
     self.register_slot(self.song().view, self._on_selected_track_changed,
                        'selected_track')
     self.register_slot(self.song().view, self._on_selected_scene_changed,
                        'selected_scene')
     return
	def __init__(self, settings_mode = None, clip_creator = None, grid_resolution = None, *a, **k):
		super(NoteEditorComponent, self).__init__(*a, **k)
		self.loop_steps = False
		self.full_velocity = False
		self._selected_page_point = 0
		self._page_index = 0
		self._clip_creator = clip_creator
		self._matrix = None
		self._width = 0
		self._height = 0
		self._sequencer_clip = None
		self._step_colors = []
		if settings_mode:
			self._settings_mode = self.register_component(settings_mode)
			self._mute_button = None
			self._pressed_steps = []
			self._modified_steps = []
			self._pressed_step_callback = None
			self._modify_task = self._tasks.add(Task.run(self._do_modification))
			self._modify_task.kill()
			self._modify_all_notes_enabled = False
			self._step_tap_tasks = {}
			self._clip_notes = []
			self._note_index = 36
			self._grid_resolution = grid_resolution
			self._on_resolution_changed.subject = self._grid_resolution
			self._nudge_offset = 0
			self._length_offset = 0
			self._velocity_offset = 0
			self._settings_mode and self._settings_mode.add_editor(self)
			self._settings = settings_mode.settings
			self._on_setting_changed.subject = self._settings
		else:
			self._mute_button = None
			self._pressed_steps = []
			self._modified_steps = []
			self._pressed_step_callback = None
			self._modify_task = self._tasks.add(Task.run(self._do_modification))
			self._modify_task.kill()
			self._modify_all_notes_enabled = False
			self._step_tap_tasks = {}
			self._clip_notes = []
			self._note_index = 36
			self._grid_resolution = grid_resolution
			self._on_resolution_changed.subject = self._grid_resolution
			self._nudge_offset = 0
			self._length_offset = 0
			self._velocity_offset = 0
		self._triplet_factor = 1.0
		self._update_from_grid()
		self.background_color = 'NoteEditor.StepEmpty'
 def __init__(self, *a, **k):
     super(SpecialChanStripComponent, self).__init__(*a, **k)
     self.empty_color = 'Option.Unused'
     self._invert_mute_feedback = True
     self._delete_button = None
     self._duplicate_button = None
     self._selector_button = None
     self._track_parameter_name_sources = [ DisplayDataSource(' ') for _ in xrange(14) ]
     self._track_parameter_data_sources = [ DisplayDataSource(' ') for _ in xrange(14) ]
     self._track_parameter_graphic_sources = [ DisplayDataSource(' ') for _ in xrange(14) ]
     self._on_return_tracks_changed.subject = self.song()
     self._on_selected_track_changed.subject = self.song().view
     self._fold_task = self._tasks.add(Task.sequence(Task.wait(TRACK_FOLD_DELAY), Task.run(self._do_fold_track)))
     self._cue_volume_slot = self.register_disconnectable(ParameterSlot())
 def __init__(self, c_instance, *a, **k):
     super(Launchkey_MK1, self).__init__(c_instance=c_instance, *a, **k)
     set_log_instance(self) # For Debug Output only
     self._is_25_key_model = False
     self._is_in_control_on = True
     with self.component_guard():
         self._skin = make_skin()
         with inject(skin=const(self._skin)).everywhere():
             self._create_controls()
     self._request_task = self._tasks.add(Task.sequence(Task.wait(self.identity_request_delay), Task.run(self._send_identity_request)))
     self._request_task.kill()
     self._encoder_mode_toggle_enabled = False
     self._encoder_mode_task = self._tasks.add(Task.sequence(Task.wait(self.encoder_in_control_double_click_time), Task.run(self._disable_toggle_encoder_mode)))
     self._encoder_mode_task.kill()
    def _set_recording_quantization(self, value):
        Live.Base.log("NoteRepeatComponent - _set_recording_quantization Start: " + str(value))
        def doit():
            self.song().midi_recording_quantization = value

        self._tasks.parent_task.add(Task.run(doit))
        Live.Base.log("NoteRepeatComponent - _set_recording_quantization End")
    def _do_load_item(self, item):
        self.do_load_item(item)
        self._update_load_memory(item)
        self._skip_next_preselection = True

        def reset_skip_next_preselection():
            self._skip_next_preselection = False

        self._tasks.add(Task.run(reset_skip_next_preselection))
 def __init__(self, scrollable_list = None, data_sources = tuple(), *a, **k):
     super(ListComponent, self).__init__(*a, **k)
     self._data_sources = data_sources
     self._activation_task = Task.Task()
     self._action_on_scroll_task = Task.Task()
     self._scrollable_list = None
     self._scroller = self.register_component(ScrollComponent())
     self.last_action_item = lambda : self._last_action_item
     if scrollable_list == None:
         self.scrollable_list = ActionList(num_visible_items=len(data_sources))
     else:
         self.scrollable_list = scrollable_list
     self._scrollable_list.num_visible_items = len(data_sources)
     self._delay_activation = BooleanContext()
     self._selected_index_float = 0.0
     self._in_encoder_selection = BooleanContext(False)
     self._execute_action_task = self._tasks.add(Task.sequence(Task.delay(1), Task.run(self._execute_action)))
     self._execute_action_task.kill()
 def _on_has_clip_changed(self, clip_slot):
     # When a clip is created, we asign to it the color of its track.
     if clip_slot.has_clip:
         # We get an error if we change the color of the clip here,
         # because we are in a callback... so we defer it in a Task
         def do_change_color():
             if clip_slot.has_clip:
                 clip_slot.clip.color = clip_slot.canonical_parent.color
         self._tasks.add(Task.run(do_change_color))