def toggle_event(self, div, row):
time = div * self.clocks_per_division
if libseq.getPattern(self.parent.bank, self.sequence, self.track,
time) == -1:
self.add_event(div, self.sequence, self.track)
else:
self.remove_event(div, self.sequence, self.track)
self.select_cell(div, row)
def show_pattern_editor(self):
time = self.selected_cell[
0] * self.clocks_per_division # time in clock cycles
pattern = libseq.getPattern(self.parent.bank, self.sequence,
self.track, time)
channel = libseq.getChannel(self.parent.bank, self.sequence,
self.track)
if pattern > 0:
self.parent.show_child("pattern editor", {
'pattern': pattern,
'channel': channel
})
def show_editor(self):
tracks_in_sequence = libseq.getTracksInSequence(
self.parent.bank, self.selected_pad)
patterns_in_track = libseq.getPatternsInTrack(self.parent.bank,
self.selected_pad, 0)
pattern = libseq.getPattern(self.parent.bank, self.selected_pad, 0, 0)
if tracks_in_sequence != 1 or patterns_in_track != 1 or pattern == -1:
self.parent.show_child("arranger")
return
channel = libseq.getChannel(self.parent.bank, self.selected_pad, 0)
self.parent.show_child("pattern editor", {
"pattern": pattern,
"channel": channel,
"pad": self.selected_pad
})
def show_editor(self):
tracks_in_sequence = libseq.getTracksInSequence(
self.parent.bank, self.selected_pad)
patterns_in_track = libseq.getPatternsInTrack(self.parent.bank,
self.selected_pad, 0)
pattern = libseq.getPattern(self.parent.bank, self.selected_pad, 0, 0)
if tracks_in_sequence != 1 or patterns_in_track != 1 or pattern == -1:
self.parent.show_child(self.parent.arranger)
return
channel = libseq.getChannel(self.parent.bank, self.selected_pad, 0)
self.parent.show_child(
self.parent.pattern_editor, {
"pattern":
pattern,
"channel":
channel,
"name":
zynseq.get_sequence_name(self.parent.bank, self.selected_pad)
})
def test_ae00_track(self):
self.assertEqual(libseq.getTracks(0, 0), 1)
self.assertTrue(libseq.addPattern(0, 0, 0, 0, 5, False))
self.assertEqual(libseq.getPattern(0, 0, 0, 0), 5)
libseq.removePattern(0, 0, 0, 0)
self.assertEqual(libseq.getPattern(0, 0, 0, 0), -1)
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 draw_cell(self, col, row):
if row >= self.vertical_zoom:
return
cell_index = row * self.horizontal_zoom + col # Cells are stored in array sequentially: 1st row, 2nd row...
if cell_index >= len(self.cells):
return
sequence = self.sequence_tracks[row + self.row_offset][0]
track = self.sequence_tracks[row + self.row_offset][1]
time = (self.col_offset +
col) * self.clocks_per_division # time in clock cycles
pattern = libseq.getPattern(self.parent.bank, sequence, track, time)
if pattern == -1 and col == 0:
pattern = libseq.getPatternAt(self.parent.bank, sequence, track,
time)
if pattern != -1:
duration = int(
libseq.getPatternLength(pattern) /
self.clocks_per_division)
while time > 0:
time -= self.clocks_per_division
duration -= 1
if pattern != libseq.getPatternAt(self.parent.bank,
sequence, track, time):
break
elif pattern != -1:
duration = int(
libseq.getPatternLength(pattern) / self.clocks_per_division)
if pattern == -1:
duration = 1
fill = CANVAS_BACKGROUND
else:
fill = CELL_BACKGROUND
if col + duration > self.col_offset + self.horizontal_zoom:
duration = self.col_offset + self.horizontal_zoom - col
if duration < 1:
duration = 1
cell = self.cells[cell_index][0]
celltext = self.cells[cell_index][1]
coord = self.get_cell_coord(col, row, duration)
if not cell:
# Create new cell
cell = self.grid_canvas.create_rectangle(
coord,
fill=fill,
width=0,
tags=("%d,%d" % (col, row), "gridcell"))
celltext = self.grid_canvas.create_text(
coord[0] + 1,
coord[1] + self.row_height / 2,
fill=CELL_FOREGROUND,
tags=("celltext:%d,%d" % (col, row)))
self.grid_canvas.tag_bind(cell, '<ButtonPress-1>',
self.on_grid_press)
self.grid_canvas.tag_bind(cell, '<ButtonRelease-1>',
self.on_grid_release)
self.grid_canvas.tag_bind(cell, '<B1-Motion>', self.on_grid_motion)
self.grid_canvas.tag_lower(
cell) # Assume cells are always created left to right
self.cells[cell_index][0] = cell
self.cells[cell_index][1] = celltext
# Update existing cell
else:
self.grid_canvas.itemconfig(cell, fill=fill)
self.grid_canvas.coords(cell, coord)
if pattern == -1:
self.grid_canvas.itemconfig(celltext, state='hidden')
else:
self.grid_canvas.itemconfig(
celltext,
text=pattern,
state='normal',
font=tkFont.Font(family=zynthian_gui_config.font_topbar[0],
size=self.fontsize))
self.grid_canvas.coords(
celltext, coord[0] + int(duration * self.column_width / 2),
int(coord[1] + self.row_height / 2))