def OnUpdateColorBlue(self, delta):
r, g, b = utils.ColorToRGB(
channels.getChannelColor(channels.selectedChannel()))
b = self.clip(0, 255, b + delta)
channels.setChannelColor(channels.selectedChannel(),
utils.RGBToColor(r, g, b))
self._controller.encoders().Refresh()
def _recolor_mixer_track(self, index):
if index != 0:
for i in range(channels.channelCount()):
if channels.getTargetFxTrack(i) == index:
mixer.setTrackColor(index, channels.getChannelColor(i))
return
mixer.setTrackColor(index, -10261391)
def _update_lights(self):
is_knobs_panning = (self._current_mode == ArturiaInputControls.INPUT_MODE_MIXER_OVERVIEW and
self._mixer_knobs_panning)
is_mixer_mode = self._current_mode == ArturiaInputControls.INPUT_MODE_MIXER_OVERVIEW
is_plugin_mode = self._current_mode == ArturiaInputControls.INPUT_MODE_CHANNEL_PLUGINS
self._lights.SetLights({
ArturiaLights.ID_BANK_NEXT: ArturiaLights.AsOnOffByte(is_knobs_panning),
ArturiaLights.ID_BANK_PREVIOUS: ArturiaLights.AsOnOffByte(is_mixer_mode),
})
channel_idx = channels.selectedChannel()
selected_idx = channel_idx - (self._current_index_mixer * 8)
if is_plugin_mode:
values = [ArturiaLights.rgb2int(0x7F, 0, 0) if v else 0 for v in self._get_current_toggle_values()]
self._lights.SetBankLights(values, rgb=True)
else:
values = [0]*9
if config.ENABLE_COLORIZE_BANK_LIGHTS:
for i in range(8):
idx = (self._current_index_mixer * 8) + i
if idx < channels.channelCount():
values[i] = ArturiaLights.fadedColor(channels.getChannelColor(idx))
# Bank lights
if not arturia_leds.ESSENTIAL_KEYBOARD:
if config.ENABLE_COLORIZE_BANK_LIGHTS:
if 0 <= selected_idx < 8:
values[selected_idx] = ArturiaLights.fullColor(channels.getChannelColor(channel_idx))
self._lights.SetBankLights(values, rgb=True)
else:
if 0 <= selected_idx < 8:
values[selected_idx] = ArturiaLights.LED_ON
self._lights.SetBankLights(values, rgb=False)
# Pad lights
should_color_pads = ((arturia_leds.ESSENTIAL_KEYBOARD and config.ENABLE_COLORIZE_BANK_LIGHTS) or
(not arturia_leds.ESSENTIAL_KEYBOARD and config.ENABLE_MK2_COLORIZE_PAD_LIGHTS))
if should_color_pads:
selected_color = ArturiaLights.fadedColor(channels.getChannelColor(channel_idx))
pad_values = ArturiaLights.ZeroMatrix(zero=selected_color)
self._lights.SetPadLights(pad_values, rgb=True)
def _new_empty_pattern(self, linked=True):
pattern_id = patterns.patternCount() + 1
if linked:
pattern_name = arturia_playlist.next_pattern_name()
color = channels.getChannelColor(channels.selectedChannel())
patterns.setPatternName(pattern_id, pattern_name)
patterns.setPatternColor(pattern_id, color)
patterns.jumpToPattern(pattern_id)
patterns.selectPattern(pattern_id, 1)
return pattern_id
def sync_current_color(unused_param_value):
"""Sync channel color"""
selected = channels.selectedChannel()
if selected < 0:
return
mixer_index = channels.getTargetFxTrack(selected)
if mixer_index <= 0:
return
color = channels.getChannelColor(selected)
mixer.setTrackColor(mixer_index, color)
def sync_all_colors(unused_param_value):
"""Sync all colors"""
num_channels = channels.channelCount()
for i in range(num_channels):
color = channels.getChannelColor(i)
mixer_index = channels.getTargetFxTrack(i)
if mixer_index <= 0:
# Nothing to sync
continue
mixer.setTrackColor(mixer_index, color)
def redraw(lights):
"""Called when a redraw is taking place. Use this to draw menus to allow your users to choose options. Most of the time, you should leave this empty.
Args:
lights (LightMap): The lights to draw to
"""
for ctr in range(min(channels.channelCount(1), 16)):
x = ctr % 8
y = ctr // 8
lights.setPadColour(x, y, lightingconsts.colours.getClosestInt(channels.getChannelColor(ctr)))
lights.solidifyAll()
def ProcessBeat(self, value):
""" Notify the metronome that a beat occured (e.g. OnUpdateBeatIndicator). """
if config.METRONOME_LIGHTS_ONLY_WHEN_METRONOME_ENABLED and not ui.isMetronomeEnabled():
# Disable metronome if configured to correlate to metronome toggle and is disabled.
return
should_color_pads = ((not arturia_leds.ESSENTIAL_KEYBOARD and config.ENABLE_MK2_COLORIZE_PAD_LIGHTS) or
(arturia_leds.ESSENTIAL_KEYBOARD and config.ENABLE_COLORIZE_BANK_LIGHTS))
zero_val = 0
on_val = ArturiaLights.LED_ON
if should_color_pads:
channel_idx = channels.selectedChannel()
color_val = channels.getChannelColor(channel_idx)
zero_val = ArturiaLights.fadedColor(color_val)
on_val = ArturiaLights.fullColor(color_val)
lights = ArturiaLights.ZeroMatrix(zero=zero_val)
current_bst_position = (playlist.getVisTimeBar(),
playlist.getVisTimeStep(),
playlist.getVisTimeTick())
if current_bst_position < self._last_bst_position:
self.Reset()
self._last_bst_position = current_bst_position
if value == 2:
# Indicates regular beat
self._beat_count += 1
if value == 1:
# Indicates beat at a bar
self._beat_count = 0
self._bar_count += 1
num_rows = len(lights)
num_cols = len(lights[0])
if value != 0:
row = self._bar_count % num_rows
col = self._beat_count % num_cols
lights[row][col] = on_val
two_step = self._beat_count % 2 == 0
if config.ENABLE_PAD_METRONOME_LIGHTS:
self._lights.SetPadLights(lights, rgb=should_color_pads)
if config.ENABLE_TRANSPORTS_METRONOME_LIGHTS:
self._lights.SetLights({
ArturiaLights.ID_TRANSPORTS_REWIND: ArturiaLights.AsOnOffByte(two_step),
ArturiaLights.ID_TRANSPORTS_FORWARD: ArturiaLights.AsOnOffByte(not two_step),
})
def OnUpdateTargetMixerTrack(self, delta):
max_track_idx = mixer.trackCount(
) - 2 # One of the track is a control track
prev_track = channels.getTargetFxTrack(channels.selectedChannel())
target_track = self.circular(0, max_track_idx, prev_track + delta)
# Remember to unset the name of the previous pointed to track.
mixer.setTrackNumber(target_track, midi.curfxMinimalLatencyUpdate)
mixer.linkTrackToChannel(midi.ROUTE_ToThis)
channel_idx = self._channel_with_route_to_mixer_track(prev_track)
if channel_idx < 0:
mixer.setTrackName(prev_track, '')
elif mixer.getTrackName(prev_track) == mixer.getTrackName(
target_track):
mixer.setTrackName(
prev_track,
arturia_playlist.strip_pattern_name(
channels.getChannelName(channel_idx)))
if target_track == 0:
mixer.setTrackName(target_track, '')
if target_track != 0:
mixer.setTrackNumber(
target_track,
channels.getChannelColor(channels.selectedChannel()))
self._recolor_mixer_track(prev_track)
def OnMidiMsg(event):
global _drop_note, _buttons_held, _recorder
note = event.data1
log_msg = True
should_color_pads = ((not arturia_leds.ESSENTIAL_KEYBOARD
and config.ENABLE_MK2_COLORIZE_PAD_LIGHTS)
or (arturia_leds.ESSENTIAL_KEYBOARD
and config.ENABLE_COLORIZE_BANK_LIGHTS))
if (event.status == MIDI_DRUM_PAD_STATUS_ON
and _drop_note != event.data1) or event.status == 153:
if MIDI_DRUM_PAD_DATA1_MIN <= note <= MIDI_DRUM_PAD_DATA1_MAX:
# Make sure to trigger short press event on the event down so as to avoid delay.
event.handled = True
if event.status == 153:
_fallback_pad_values[event.data1] = event.data2
if (note not in _longpress_status
and REC_BUTTON_ID not in _buttons_held
and not config.ENABLE_LONG_PRESS_SUSTAIN_ON_PADS):
log('midi', 'Schedule long press detection for %s' % str(note))
_longpress_status[note] = _scheduler.ScheduleTask(
lambda: OnLongPressDrumPad(note), delay=1000)
if REC_BUTTON_ID in _buttons_held:
OnLongPressDrumPad(note)
else:
OnShortPressDrumPad(event)
if should_color_pads:
channel_idx = channels.selectedChannel()
color_val = ArturiaLights.fullColor(
channels.getChannelColor(channel_idx))
led_id = ArturiaLights.getPadLedId(note)
_lights.SetLights({led_id: color_val}, rgb=True)
elif event.status == MIDI_DRUM_PAD_STATUS_OFF:
event.handled = True
if MIDI_DRUM_PAD_DATA1_MIN <= event.data1 <= MIDI_DRUM_PAD_DATA1_MAX:
if event.data1 == _drop_note:
_drop_note = None
else:
OnShortPressDrumPad(event)
if event.data1 in _longpress_status:
if _scheduler.CancelTask(_longpress_status[event.data1]):
log('midi',
'Long press canceled for %s' % str(event.data1))
del _longpress_status[event.data1]
if should_color_pads:
channel_idx = channels.selectedChannel()
color_val = ArturiaLights.fadedColor(
channels.getChannelColor(channel_idx))
led_id = ArturiaLights.getPadLedId(note)
_lights.SetLights({led_id: color_val}, rgb=True)
elif 128 <= event.status <= 159: # Midi note on
_recorder.OnMidiNote(event)
elif event.status == arturia_midi.INTER_SCRIPT_STATUS_BYTE:
if event.data1 == arturia_midi.INTER_SCRIPT_DATA1_BTN_DOWN_CMD:
_buttons_held.add(event.data2)
if event.data2 == STOP_BUTTON_ID:
if _recorder.IsRecording():
_recorder.StopRecording()
else:
_recorder.StopPlaying()
elif event.data1 == arturia_midi.INTER_SCRIPT_DATA1_BTN_UP_CMD and event.data2 in _buttons_held:
_buttons_held.remove(event.data2)
elif event.data1 == arturia_midi.INTER_SCRIPT_DATA1_IDLE_CMD:
processIdle()
# All inter-cmd messages should be marked handled to ensure they do not contribute to influencing FL Studio
# state
event.handled = True
else:
if 0xB0 <= event.status <= 0xBF:
if event.data1 == 118 and event.data2 == 127:
# User switched to Analog Lab mode.
log('analoglab', 'Switched to Analog Lab.')
if event.data1 == 64:
global _sustain_enabled
_sustain_enabled = (event.data2 == 127)
log('sustain', 'enabled' if _sustain_enabled else 'disabled')
# Forward all remaining events to plugin
port_num = config.PLUGIN_FORWARDING_MIDI_IN_PORT
message = event.status + (event.data1 << 8) + (event.data2 << 16) + (
port_num << 24)
device.forwardMIDICC(message, 2)
if log_msg:
log(
'midi', 'status: %d, data1: %d, data2: %d handled: %s' %
(event.status, event.data1, event.data2, str(event.handled)))
def updateLEDs(self):
if device.isAssigned():
# play button
if transport.isPlaying() and transport.getLoopMode():
self.updateLED(CONTROLS.BUTTONS.PLAY, COLORS.RGB.GREEN,
ANIMATIONS.BLINKING.QUARTER)
elif transport.isPlaying():
self.updateLED(CONTROLS.BUTTONS.PLAY, COLORS.RGB.ORANGE,
ANIMATIONS.BLINKING.QUARTER)
else:
self.updateLED(CONTROLS.BUTTONS.PLAY)
# record button
if transport.isRecording():
self.updateLED(CONTROLS.BUTTONS.RECORD, COLORS.RGB.RED)
else:
self.updateLED(CONTROLS.BUTTONS.RECORD)
# double loop [song/pattern] button
if transport.getLoopMode():
self.updateLED(CONTROLS.BUTTONS.DOUBLE_LOOP)
else:
self.updateLED(CONTROLS.BUTTONS.DOUBLE_LOOP, COLORS.BW.WHITE)
# metronome button
if ui.isMetronomeEnabled():
self.updateLED(CONTROLS.BUTTONS.METRONOME, COLORS.BW.WHITE)
else:
self.updateLED(CONTROLS.BUTTONS.METRONOME)
# device [channel rack] button
if ui.getFocused(midi.widChannelRack):
self.updateLED(CONTROLS.BUTTONS.DEVICE, COLORS.BW.WHITE)
else:
self.updateLED(CONTROLS.BUTTONS.DEVICE)
# mix [mixer] button
if ui.getFocused(midi.widMixer):
self.updateLED(CONTROLS.BUTTONS.MIX, COLORS.BW.WHITE)
else:
self.updateLED(CONTROLS.BUTTONS.MIX)
# clip [playlist] button
if ui.getFocused(midi.widPlaylist):
self.updateLED(CONTROLS.BUTTONS.CLIP, COLORS.BW.WHITE)
else:
self.updateLED(CONTROLS.BUTTONS.CLIP)
# browse [browser] button
# if ui.getFocused(midi.widBrowser):
# self.updateLED(CONTROLS.BUTTONS.BROWSE, COLORS.BW.WHITE)
# else:
# self.updateLED(CONTROLS.BUTTONS.BROWSE)
# layout button
if ui.getFocused(midi.widPlaylist):
if self.playlist.layout == LAYOUTS.PLAYLIST.PATTERNS:
self.updateLED(CONTROLS.BUTTONS.LAYOUT, COLORS.BW.WHITE)
else:
self.updateLED(CONTROLS.BUTTONS.LAYOUT)
# quantize/snap button
if ui.getSnapMode() != 3:
self.updateLED(CONTROLS.BUTTONS.QUANTIZE, COLORS.BW.WHITE)
else:
self.updateLED(CONTROLS.BUTTONS.QUANTIZE)
# numbered upper buttons
for idx, button in enumerate(CONTROLS.BUTTONS_UPPER, 1):
if ui.getFocused(midi.widMixer):
if (idx == self.mixer.encodersTarget):
self.updateLED(button, COLORS.RGB.WHITE)
else:
self.updateLED(button)
elif ui.getFocused(midi.widChannelRack):
if (idx == self.channels.encodersTarget):
self.updateLED(button, COLORS.RGB.ORANGE)
else:
self.updateLED(button)
elif ui.getFocused(midi.widPlaylist):
if (idx == self.playlist.encodersTarget):
self.updateLED(button, COLORS.RGB.GREEN)
else:
self.updateLED(button)
else:
self.updateLED(button)
# pads
for idx, pad in enumerate(CONTROLS.PADS_64):
self.updateLED(pad, 0)
if ui.getFocused(midi.widMixer):
idx += 1 # do not include the master track (0)
if idx < mixer.trackCount():
self.updateLED(
pad, getClosestColor(mixer.getTrackColor(idx)))
if mixer.isTrackSelected(
idx) and not mixer.isTrackEnabled(idx):
self.updateLED(pad, COLORS.RGB.GREEN)
self.updateLED(pad, COLORS.RGB.RED,
ANIMATIONS.BLINKING.HALF)
elif mixer.isTrackSelected(idx):
self.updateLED(pad, COLORS.RGB.GREEN)
self.updateLED(
pad, getClosestColor(mixer.getTrackColor(idx)),
ANIMATIONS.PULSING.HALF)
elif not mixer.isTrackEnabled(idx):
self.updateLED(pad, COLORS.RGB.RED,
ANIMATIONS.PULSING.HALF)
elif ui.getFocused(midi.widChannelRack):
if idx < channels.channelCount():
self.updateLED(
pad,
getClosestColor(channels.getChannelColor(idx)))
if channels.isChannelSelected(
idx) and not channels.isChannelMuted(
idx): # NOTE asked this bug to be fixed!
self.updateLED(pad, COLORS.RGB.GREEN)
self.updateLED(pad, COLORS.RGB.RED,
ANIMATIONS.BLINKING.HALF)
elif channels.isChannelSelected(idx):
self.updateLED(pad, COLORS.RGB.GREEN)
self.updateLED(
pad,
getClosestColor(channels.getChannelColor(idx)),
ANIMATIONS.PULSING.HALF)
elif not channels.isChannelMuted(
idx): # NOTE asked this bug to be fixed!
self.updateLED(pad, COLORS.RGB.RED,
ANIMATIONS.PULSING.HALF)
elif ui.getFocused(midi.widPlaylist):
idx += 1 # NOTE asked this bug to be fixed!
if idx <= patterns.patternCount():
# self.updateLED(pad, getClosestColor(patterns.getPatternColor(idx)))
# if patterns.isPatternSelected(idx) and not patterns.isPatternEnabled(idx):
# self.updateLED(pad, COLORS.RGB.GREEN)
# self.updateLED(pad, COLORS.RGB.RED, ANIMATIONS.BLINKING.HALF)
# elif patterns.isPatternSelected(idx):
# self.updateLED(pad, COLORS.RGB.GREEN)
# self.updateLED(pad, getClosestColor(patterns.getPatternColor(idx)), ANIMATIONS.PULSING.HALF)
# elif not patterns.isPatternEnabled(idx):
# self.updateLED(pad, COLORS.RGB.RED, ANIMATIONS.PULSING.HALF)
if (idx == patterns.patternNumber()):
# self.updateLED(pad, getClosestColor(patterns.getPatternColor(idx)))
self.updateLED(pad, COLORS.RGB.GREEN)
self.updateLED(pad, COLORS.RGB.RED,
ANIMATIONS.PULSING.HALF)
else:
self.updateLED(
pad,
getClosestColor(patterns.getPatternColor(idx)))
def switch_moment(event):
"""handles momentary witch midi events"""
if event.data1 == button["pad_mode_toggle"]: # This Rotates through pad modes - standard, step sequencer, pad to channel
Switch.mode_toggle += 1
if Switch.mode_toggle == 4:
Switch.mode_toggle = 0
print('Pad Mode: ' + mode[Switch.mode_toggle])
ui.setHintMsg(mode[Switch.mode_toggle])
elif event.midiId == 224: # pitch wheel
Switch.pitch_num = event.data2
if Switch.shift_status == True:
print(data.notes_list[int(mapvalues(Switch.pitch_num, 0, 11, 0, 244))])
elif event.data1 == button["play"]:
transport.start()
event.handled = True
elif event.data1 == button["offset_range"]:
Switch.offset_iter += 1
if Switch.offset_iter == 2: # 2 here will limit to 32 steps, knobs. Changing to 4 will allow up to 64 steps, knobs.
Switch.offset_iter = 0
ui.setHintMsg("Offset Range: " + str(Switch.offset_iter))
elif event.data1 == button["stop"]:
print('Stop')
transport.stop()
event.handled = True
elif event.data1 == button["record"]:
print('Record')
transport.record()
event.handled = True
elif event.data1 == button["pattern_down"]:
if ui.getFocused(5):
print("Previous Preset")
ui.previous()
else:
print('Pattern Down')
transport.globalTransport(midi.FPT_PatternJog, -1)
event.handled = True
elif event.data1 == button["pattern_up"]:
if ui.getFocused(5):
print("Next Preset")
ui.next()
else:
print('Pattern Up')
transport.globalTransport(midi.FPT_PatternJog, 1)
event.handled = True
# Set mod wheel to control channels when channels focused and tracks when mixer
elif event.data1 == button["mod_wheel"]:
if ui.getFocused(0):
mixer.setTrackNumber(int(mapvalues(event.data2, 0, 64, 0, 127)))
ui.scrollWindow(midi.widMixer, mixer.trackNumber())
elif ui.getFocused(1):
print("Channel Number: " + str(channels.selectedChannel()))
channels.selectOneChannel(int(round(mapvalues(event.data2, channels.channelCount()-1, 0, 0, 127), 0)))
elif event.data1 == 72:
print(channels.getChannelColor(channels.selectedChannel()))
Switch.color_num += 1
if Switch.color_num == len(colors):
Switch.color_num = 0
if ui.getFocused(1):
channels.setChannelColor(channels.selectedChannel(), colors[Switch.color_num])
elif ui.getFocused(0):
mixer.setTrackColor(mixer.trackNumber(), colors[Switch.color_num])
event.handled = True
elif event.data1 == button["enter"]:
if ui.getFocused(4):
print("Select Browser Item")
ui.selectBrowserMenuItem()
event.handled = True
elif ui.getFocused(1):
print("Mute Channel")
channels.muteChannel(channels.selectedChannel())
elif ui.getFocused(0):
print("Mute Track")
mixer.muteTrack(mixer.trackNumber())
else:
print('enter')
ui.enter()
event.handled = True
elif event.data1 in range(59, 64) and config.PATTERN_JUMP_ON: # Sets jump to pattern
patterns.jumpToPattern(event.data1 - 58)
event.handled = True
elif event.data1 in range(75, 80) and config.PATTERN_JUMP_ON:
patterns.jumpToPattern(event.data1 - 69)
event.handled = True
elif event.data1 == button["solo"]:
print('Solo')
if ui.getFocused(0):
mixer.soloTrack(mixer.trackNumber())
elif ui.getFocused(1):
channels.soloChannel(channels.selectedChannel())
elif event.data1 == button["view_plugin_picker"]:
print('View Plugin Picker')
transport.globalTransport(midi.FPT_F8, 67)
event.handled = True
elif event.data1 == button["song_mode_toggle"]:
print('Toggle Song and Pattern Mode')
transport.setLoopMode()
event.handled = True
elif event.data1 == button["view_playlist"]:
print('View Playlist')
transport.globalTransport(midi.FPT_F5, 65)
event.handled = True
elif event.data1 == button["view_piano_roll"]:
print('View Piano Roll')
transport.globalTransport(midi.FPT_F7, 66)
event.handled = True
elif event.data1 == button["view_channel_rack"]:
print('View Channel Rack')
transport.globalTransport(midi.FPT_F6, 65)
event.handled = True
elif event.data1 == button["view_mixer"]:
print('View Mixer')
transport.globalTransport(midi.FPT_F9, 68)
event.handled = True
# Toggle through step parameter options - pitch, pan etc. No Shift control right now.
elif event.data1 == button["step_parameter"]:
if ui.getFocused(1) and Switch.mode_toggle == 1:
print('Toggle Step Parameter')
Switch.parameter += 1
if Switch.parameter == 7:
Switch.parameter = 0
print(Switch.parameter)
ui.setHintMsg(parameters[Switch.parameter])
elif ui.getFocused(0):
Switch.mixer_num += 1
if Switch.mixer_num == 2:
Switch.mixer_num = 0
print('Mixer Mode: ' + str(Switch.mixer_num))
ui.setHintMsg(mixer_choice[Switch.mixer_num])
event.handled = True
elif event.data1 == button["open_channel_sampler"]:
print('Open Sampler Channel')
channels.showCSForm(channels.channelNumber(), -1)
event.handled = True
elif event.data1 == button["left"]:
print('Left')
ui.left()
event.handled = True
elif event.data1 == button["down"]:
print('Down')
ui.down()
event.handled = True
elif event.data1 == button["right"]:
print('Right')
ui.right()
event.handled = True
elif event.data1 == button["save"]:
print('Save')
transport.globalTransport(midi.FPT_Save, 92)
# If mixer is open and mute mode selected, top row will mute respective track
elif event.data1 == button["undo"]:
print('Undo')
transport.globalTransport(midi.FPT_Undo, 20)
device.midiOutMsg(144, 1, 63, 80)
event.handled = True
elif event.data1 == button["escape"]:
print('Escape')
ui.escape()
event.handled = True
elif event.data1 == button["up"]:
print('Up')
ui.up()
event.handled = True
elif event.data1 == button["rotate_window"]:
print('Rotate Window')
ui.nextWindow()
event.handled = True
elif event.data1 == button["browser"]:
print('Browser')
if Switch.shift_status == False:
if ui.getFocused(4):
ui.hideWindow(4)
event.handled = True
else:
ui.showWindow(4)
ui.setFocused(4)
event.handled = True
elif event.data1 == button["step_rec"]:
if ui.getFocused(0):
mixer.armTrack(mixer.trackNumber())
print("Toggle Track Rec")
else:
transport.globalTransport(midi.FPT_StepEdit, 114)
print('Step Record')
event.handled = True
elif event.data1 == button["quantize"]:
print('quantize')
channels.quickQuantize(channels.channelNumber())
event.handled = True
elif event.data1 == button["link_chan"]:
print('link channel')
mixer.linkTrackToChannel(0)
elif event.data1 == button["rand_steps"]:
print("Random")
print(f'Pitch Bend: {event.pitchBend}')
for i in range(patterns.getPatternLength(patterns.patternNumber())):
channels.setGridBit(channels.channelNumber(), i, 0)
for z in range (patterns.getPatternLength(patterns.patternNumber())):
y = num_gen()
if y > ( Switch.pitch_num * 516):
channels.setGridBit(channels.channelNumber(), z, 1)
else:
pass
event.handled = True
elif event.data1 == button["rand_notes"]:
print("Randomize Notes")
Switch.note_gen()
event.handled = True
def get_color_blue_line():
r, g, b = utils.ColorToRGB(channels.getChannelColor(channels.selectedChannel()))
return ' %3d %3d [%3d]' % (r, g, b)
def get_color_red_line():
r, g, b = utils.ColorToRGB(channels.getChannelColor(channels.selectedChannel()))
return '[%3d] %3d %3d ' % (r, g, b)
def OnUpdateColorBlue(self, delta):
r, g, b = utils.ColorToRGB(channels.getChannelColor(channels.selectedChannel()))
b = self.clip(0, 255, b + delta)
channels.setChannelColor(channels.selectedChannel(), utils.RGBToColor(r, g, b))