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))