def test_ad00_trigger_channel(self):
self.assertEqual(libseq.getTriggerChannel(), 0xFF)
libseq.setTriggerChannel(5)
self.assertEqual(libseq.getTriggerChannel(), 5)
libseq.setTriggerChannel(16)
self.assertEqual(libseq.getTriggerChannel(), 0xFF)
self.assertEqual(libseq.getTriggerNote(0, 0), 0xFF)
libseq.setTriggerNote(0, 0, 0)
self.assertEqual(libseq.getTriggerNote(0, 0), 0)
libseq.setTriggerNote(0, 0, 127)
self.assertEqual(libseq.getTriggerNote(0, 0), 127)
libseq.setTriggerNote(0, 0, 128)
self.assertEqual(libseq.getTriggerNote(0, 0), 0xFF)
def refresh_status(self):
if self.refresh_pending == 1:
self.update_grid()
for pad in range(0, self.columns**2):
self.refresh_pad(pad)
if self.parent.param_editor_item == "Trigger note":
old_value = self.parent.get_param("Trigger note", "value")
value = libseq.getTriggerNote(self.parent.bank, self.selected_pad)
if old_value != value:
if value < 128:
self.parent.set_param("Trigger note", "value", value)
self.parent.param_title_canvas.itemconfig(
"lbl_param_editor_value",
text="Trigger note: %s%d(%d)" % ([
'C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#',
'A', 'A#', 'B'
][value % 12], int(value / 12) - 1, value))
def select_cell(self, time=None, row=None, snap=True):
if time == None:
time = self.selected_cell[0]
if row == None:
row = self.selected_cell[1]
if row >= len(self.sequence_tracks):
row = len(self.sequence_tracks) - 1
if row < 0:
row = 0
duration = int(
libseq.getPatternLength(self.pattern) / self.clocks_per_division)
sequence = self.sequence_tracks[row][0]
track = self.sequence_tracks[row][1]
self.parent.set_title(
"Bank %d %s%d-%d (%d) %s" %
(self.parent.bank,
chr(65 + libseq.getGroup(self.parent.bank, sequence)),
sequence + 1, track + 1,
libseq.getChannel(self.parent.bank, sequence, track) + 1,
self.get_note(libseq.getTriggerNote(self.parent.bank, sequence))))
if not duration:
duration = 1
forward = time > self.selected_cell[0]
backward = None
if time < self.selected_cell[0]:
backward = time
# Skip cells if pattern won't fit
if snap:
prev_start = 0
prev_end = 0
next_start = time
for previous in range(time - 1, -1, -1):
# Iterate time divs back to start
prev_pattern = libseq.getPattern(
self.parent.bank, sequence, track,
previous * self.clocks_per_division)
if prev_pattern == -1:
continue
prev_duration = int(
libseq.getPatternLength(prev_pattern) /
self.clocks_per_division)
prev_start = previous
prev_end = prev_start + prev_duration
break
for next in range(time + 1, time + duration * 2):
next_pattern = libseq.getPattern(
self.parent.bank, sequence, track,
next * self.clocks_per_division)
if next_pattern == -1:
continue
next_start = next
break
if next_start < prev_end:
next_start = prev_end
if time >= prev_end and time < next_start:
# Between patterns
if time + duration > next_start:
# Insufficient space for new pattern between pattern
if forward:
time = next_start
else:
if next_start - prev_end < duration:
time = prev_start
else:
time = next_start - duration
elif time == prev_start:
# At start of previous
pass
elif time > prev_start and time < prev_end:
# Within pattern
if forward:
if prev_end + duration > next_start:
time = next_start
else:
time = prev_end
else:
time = prev_start
if time == 0 and duration > next_start:
time = next_start
if time < 0:
time = 0
if time + duration > self.col_offset + self.horizontal_zoom:
# time is off right of display
self.col_offset = time + duration - self.horizontal_zoom
self.redraw_pending = 1
if time < self.col_offset:
# time is off left of display
self.col_offset = time
self.redraw_pending = 1
if row >= self.row_offset + self.vertical_zoom:
# row is off bottom of display
self.row_offset = row - self.vertical_zoom + 1
self.redraw_pending = 1
elif row < self.row_offset:
self.row_offset = row
self.redraw_pending = 1
if backward != None and self.col_offset > 0 and time > backward:
self.col_offset = self.col_offset - 1
self.redraw_pending = 1
self.selected_cell = [time, row]
self.sequence = self.sequence_tracks[row][0]
self.track = self.sequence_tracks[row][1]
coord = self.get_cell_coord(time - self.col_offset,
row - self.row_offset, duration)
coord[0] = coord[0] - 1
coord[1] = coord[1] - 1
coord[2] = coord[2]
coord[3] = coord[3]
selection_border = self.grid_canvas.find_withtag("selection")
if not selection_border:
selection_border = self.grid_canvas.create_rectangle(
coord,
fill="",
outline=SELECT_BORDER,
width=self.select_thickness,
tags="selection")
else:
self.grid_canvas.coords(selection_border, coord)
self.grid_canvas.itemconfig(selection_border, state='normal')
self.grid_canvas.tag_raise(selection_border)
if row < self.row_offset:
self.row_offset = row
self.redraw_pending = 1
if row > self.row_offset + self.vertical_zoom:
self.row_offset = row + self.vertical_zoom
self.redraw_pending = 1
def get_trigger(self):
trigger = libseq.getTriggerNote(self.parent.bank, self.sequence)
if trigger > 127:
trigger = 128
return trigger
def get_trigger_note(self):
trigger = libseq.getTriggerNote(self.parent.bank, self.selected_pad)
if trigger > 128:
trigger = 128
return trigger