Sampled Instrument Player with static and monolithic design. All instruments are built-in.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

603 lines
24 KiB

#from gui_tools import *
from gi.repository import GObject, Gdk, Gtk, GooCanvas, GLib
import gui_tools
def guint(x):
value = GObject.Value()
value.init(GObject.TYPE_UINT)
value.set_uint(x)
return value
PPQN = 48
def standard_filter(patterns, name):
f = Gtk.FileFilter()
for p in patterns:
f.add_pattern(p)
f.set_name(name)
return f
def hide_item(citem):
citem.visibility = GooCanvas.CanvasItemVisibility.HIDDEN
def show_item(citem):
citem.visibility = GooCanvas.CanvasItemVisibility.VISIBLE
def polygon_to_path(points):
assert len(points) % 2 == 0, "Invalid number of points (%d) in %s" % (len(points), repr(points))
path = ""
if len(points) > 0:
path += "M %s %s" % (points[0], points[1])
if len(points) > 1:
for i in range(2, len(points), 2):
path += " L %s %s" % (points[i], points[i + 1])
return path
class NoteModel(object):
def __init__(self, pos, channel, row, vel, len = 1):
self.pos = int(pos)
self.channel = int(channel)
self.row = int(row)
self.vel = int(vel)
self.len = int(len)
self.item = None
self.selected = False
def __str__(self):
return "pos=%s row=%s vel=%s len=%s" % (self.pos, self.row, self.vel, self.len)
# This is stupid and needs rewriting using a faster data structure
class DrumPatternModel(GObject.GObject):
def __init__(self, beats, bars):
GObject.GObject.__init__(self)
self.ppqn = PPQN
self.beats = beats
self.bars = bars
self.notes = []
def import_data(self, data):
self.clear()
active_notes = {}
for t in data:
cmd = t[1] & 0xF0
if len(t) == 4 and (cmd == 0x90) and (t[3] > 0):
note = NoteModel(t[0], (t[1] & 15) + 1, t[2], t[3])
active_notes[t[2]] = note
self.add_note(note)
if len(t) == 4 and ((cmd == 0x90 and t[3] == 0) or cmd == 0x80):
if t[2] in active_notes:
active_notes[t[2]].len = t[0] - active_notes[t[2]].pos
del active_notes[t[2]]
end = self.get_length()
for n in active_notes.values():
n.len = end - n.pos
def clear(self):
self.notes = []
self.changed()
def add_note(self, note, send_changed = True):
self.notes.append(note)
if send_changed:
self.changed()
def remove_note(self, pos, row, channel):
self.notes = [note for note in self.notes if note.pos != pos or note.row != row or (channel is not None and note.channel != channel)]
self.changed()
def set_note_vel(self, note, vel):
note.vel = int(vel)
self.changed()
def set_note_len(self, note, len):
note.len = int(len)
self.changed()
def has_note(self, pos, row, channel):
for n in self.notes:
if n.pos == pos and n.row == row and (channel is None or n.channel == channel):
return True
return False
def get_note(self, pos, row, channel):
for n in self.notes:
if n.pos == pos and n.row == row and (channel is None or n.channel == channel):
return n
return None
def items(self):
return self.notes
def get_length(self):
return int(self.beats * self.bars * self.ppqn)
def changed(self):
self.emit('changed')
def delete_selected(self):
self.notes = [note for note in self.notes if not note.selected]
self.changed()
def group_set(self, **vals):
for n in self.notes:
if not n.selected:
continue
for k, v in vals.items():
setattr(n, k, v)
self.changed()
def transpose_selected(self, amount):
for n in self.notes:
if not n.selected:
continue
if n.row + amount < 0 or n.row + amount > 127:
continue
n.row += amount
self.changed()
GObject.type_register(DrumPatternModel)
GObject.signal_new("changed", DrumPatternModel, GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, ())
channel_ls = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_INT)
for ch in range(1, 17):
channel_ls.append((str(ch), ch))
snap_settings_ls = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_INT)
for row in [("1/4", PPQN), ("1/8", PPQN // 2), ("1/8T", PPQN//3), ("1/16", PPQN//4), ("1/16T", PPQN//6), ("1/32", PPQN//8), ("1/32T", PPQN//12), ("1/64", PPQN//4)]:
snap_settings_ls.append(row)
edit_mode_ls = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_STRING)
for row in [("Drum", "D"), ("Melodic", "M")]:
edit_mode_ls.append(row)
class DrumEditorToolbox(Gtk.HBox):
def __init__(self, canvas):
Gtk.HBox.__init__(self, spacing = 5)
self.canvas = canvas
self.vel_adj = Gtk.Adjustment(100, 1, 127, 1, 10, 0)
self.pack_start(Gtk.Label("Channel:"), False, False, 0)
self.channel_setting = gui_tools.standard_combo(channel_ls, active_item_lookup = self.canvas.channel, lookup_column = 1)
self.channel_setting.connect('changed', lambda w: self.canvas.set_channel(w.get_model()[w.get_active()][1]))
self.pack_start(self.channel_setting, False, True, 0)
self.pack_start(Gtk.Label("Mode:"), False, False, 0)
self.mode_setting = gui_tools.standard_combo(edit_mode_ls, active_item_lookup = self.canvas.edit_mode, lookup_column = 1)
self.mode_setting.connect('changed', lambda w: self.canvas.set_edit_mode(w.get_model()[w.get_active()][1]))
self.pack_start(self.mode_setting, False, True, 0)
self.pack_start(Gtk.Label("Snap:"), False, False, 0)
self.snap_setting = gui_tools.standard_combo(snap_settings_ls, active_item_lookup = self.canvas.grid_unit, lookup_column = 1)
self.snap_setting.connect('changed', lambda w: self.canvas.set_grid_unit(w.get_model()[w.get_active()][1]))
self.pack_start(self.snap_setting, False, True, 0)
self.pack_start(Gtk.Label("Velocity:"), False, False, 0)
self.pack_start(Gtk.SpinButton(adjustment = self.vel_adj, climb_rate = 0, digits = 0), False, False, 0)
button = Gtk.Button("Load")
button.connect('clicked', self.load_pattern)
self.pack_start(button, True, True, 0)
button = Gtk.Button("Save")
button.connect('clicked', self.save_pattern)
self.pack_start(button, True, True, 0)
button = Gtk.Button("Double")
button.connect('clicked', self.double_pattern)
self.pack_start(button, True, True, 0)
self.pack_start(Gtk.Label("--"), False, False, 0)
def update_edit_mode(self):
self.mode_setting.set_active(gui_tools.ls_index(edit_mode_ls, self.canvas.edit_mode, 1))
def load_pattern(self, w):
dlg = Gtk.FileChooserDialog('Open a drum pattern', self.get_toplevel(), Gtk.FileChooserAction.OPEN,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.APPLY))
dlg.add_filter(standard_filter(["*.cbdp"], "Drum patterns"))
dlg.add_filter(standard_filter(["*"], "All files"))
try:
if dlg.run() == Gtk.ResponseType.APPLY:
pattern = self.canvas.pattern
f = file(dlg.get_filename(), "r")
pattern.clear()
pattern.beats, pattern.bars = [int(v) for v in f.readline().strip().split(";")]
for line in f.readlines():
line = line.strip()
if not line.startswith("n:"):
pos, row, vel = line.split(";")
row = int(row) + 36
channel = 10
len = 1
else:
pos, channel, row, vel, len = line[2:].split(";")
self.canvas.pattern.add_note(NoteModel(pos, channel, row, vel, len), send_changed = False)
f.close()
self.canvas.pattern.changed()
self.canvas.update_grid()
self.canvas.update_notes()
finally:
dlg.destroy()
def save_pattern(self, w):
dlg = Gtk.FileChooserDialog('Save a drum pattern', self.get_toplevel(), Gtk.FileChooserAction.SAVE,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_SAVE, Gtk.ResponseType.APPLY))
dlg.add_filter(standard_filter(["*.cbdp"], "Drum patterns"))
dlg.add_filter(standard_filter(["*"], "All files"))
dlg.set_current_name("pattern.cbdp")
try:
if dlg.run() == Gtk.ResponseType.APPLY:
pattern = self.canvas.pattern
f = file(dlg.get_filename(), "w")
f.write("%s;%s\n" % (pattern.beats, pattern.bars))
for i in self.canvas.pattern.items():
f.write("n:%s;%s;%s;%s;%s\n" % (i.pos, i.channel, i.row, i.vel, i.len))
f.close()
finally:
dlg.destroy()
def double_pattern(self, w):
len = self.canvas.pattern.get_length()
self.canvas.pattern.bars *= 2
new_notes = []
for note in self.canvas.pattern.items():
new_notes.append(NoteModel(note.pos + len, note.channel, note.row, note.vel, note.len))
for note in new_notes:
self.canvas.pattern.add_note(note, send_changed = False)
self.canvas.pattern.changed()
self.canvas.update_size()
self.canvas.update_grid()
self.canvas.update_notes()
class DrumCanvasCursor(object):
def __init__(self, canvas):
self.canvas = canvas
self.canvas_root = canvas.get_root_item()
self.frame = GooCanvas.CanvasRect(parent = self.canvas_root, x = -6, y = -6, width = 12, height = 12 , stroke_color = "gray", line_width = 1)
hide_item(self.frame)
self.vel = GooCanvas.CanvasText(parent = self.canvas_root, x = 0, y = 0, fill_color = "blue", stroke_color = "blue", anchor = GooCanvas.CanvasAnchorType.S)
hide_item(self.vel)
self.rubberband = False
self.rubberband_origin = None
self.rubberband_current = None
def hide(self):
hide_item(self.frame)
hide_item(self.vel)
def show(self):
show_item(self.frame)
show_item(self.vel)
def move_to_note(self, note):
self.move(note.pos, note.row, note)
def move(self, pulse, row, note):
x = self.canvas.pulse_to_screen_x(pulse)
y = self.canvas.row_to_screen_y(row) + self.canvas.row_height / 2
dx = 0
if note is not None:
dx = self.canvas.pulse_to_screen_x(pulse + note.len) - x
self.frame.set_properties(x = x - 6, width = 12 + dx, y = y - 6, height = 12)
cy = y - self.canvas.row_height * 1.5 if y >= self.canvas.rows * self.canvas.row_height / 2 else y + self.canvas.row_height * 1.5
if note is None:
text = ""
else:
text = "[%s] %s" % (note.channel, note.vel)
self.vel.set_properties(x = x, y = cy, text = text)
def start_rubberband(self, x, y):
self.rubberband = True
self.rubberband_origin = (x, y)
self.rubberband_current = (x, y)
self.update_rubberband_frame()
show_item(self.frame)
def update_rubberband(self, x, y):
self.rubberband_current = (x, y)
self.update_rubberband_frame()
def end_rubberband(self, x, y):
self.rubberband_current = (x, y)
self.update_rubberband_frame()
hide_item(self.frame)
self.rubberband = False
def cancel_rubberband(self):
hide_item(self.frame)
self.rubberband = False
def update_rubberband_frame(self):
self.frame.set_properties(x = self.rubberband_origin[0],
y = self.rubberband_origin[1],
width = self.rubberband_current[0] - self.rubberband_origin[0],
height = self.rubberband_current[1] - self.rubberband_origin[1])
def get_rubberband_box(self):
x1, y1 = self.rubberband_origin
x2, y2 = self.rubberband_current
return (min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2))
class DrumCanvas(GooCanvas.Canvas):
def __init__(self, rows, pattern):
GooCanvas.Canvas.__init__(self)
self.rows = rows
self.pattern = pattern
self.row_height = 24
self.grid_unit = PPQN / 4 # unit in pulses
self.zoom_in = 2
self.instr_width = 120
self.edited_note = None
self.orig_velocity = None
self.orig_length = None
self.orig_y = None
self.channel_modes = ['D' if ch == 10 else 'M' for ch in range(1, 17)]
self.update_size()
self.grid = GooCanvas.CanvasGroup(parent = self.get_root_item(), x = self.instr_width)
self.update_grid()
self.notes = GooCanvas.CanvasGroup(parent = self.get_root_item(), x = self.instr_width)
self.names = GooCanvas.CanvasGroup(parent = self.get_root_item(), x = 0)
self.update_names()
self.cursor = DrumCanvasCursor(self)
hide_item(self.cursor)
self.connect('event', self.on_grid_event)
self.channel = 10
self.edit_mode = self.channel_modes[self.channel - 1]
self.toolbox = DrumEditorToolbox(self)
self.add_events(Gdk.EventMask.POINTER_MOTION_HINT_MASK)
self.grab_focus(self.grid)
self.update_notes()
def set_edit_mode(self, mode):
self.edit_mode = mode
self.channel_modes[self.channel - 1] = mode
def calc_size(self):
return (self.instr_width + self.pattern.get_length() * self.zoom_in + 1, self.rows * self.row_height + 1)
def set_grid_unit(self, grid_unit):
self.grid_unit = grid_unit
self.update_grid()
def set_channel(self, channel):
self.channel = channel
self.set_edit_mode(self.channel_modes[self.channel - 1])
self.update_notes()
self.toolbox.update_edit_mode()
def update_size(self):
sx, sy = self.calc_size()
self.set_bounds(0, 0, sx, self.rows * self.row_height)
self.set_size_request(sx, sy)
def update_names(self):
for i in self.names.items:
i.destroy()
for i in range(0, self.rows):
#GooCanvas.CanvasText(parent = self.names, text = gui_tools.note_to_name(i), x = self.instr_width - 10, y = (i + 0.5) * self.row_height, anchor = Gtk.AnchorType.E, size_points = 10, font = "Sans", size_set = True)
GooCanvas.CanvasText(parent = self.names, text = gui_tools.note_to_name(i), x = self.instr_width - 10, y = (i + 0.5) * self.row_height, anchor = GooCanvas.CanvasAnchorType.E, font = "Sans")
def update_grid(self):
for i in self.grid.items:
i.destroy()
bg = GooCanvas.CanvasRect(parent = self.grid, x = 0, y = 0, width = self.pattern.get_length() * self.zoom_in, height = self.rows * self.row_height, fill_color = "white")
bar_fg = "blue"
beat_fg = "darkgray"
grid_fg = "lightgray"
row_grid_fg = "lightgray"
row_ext_fg = "black"
for i in range(0, self.rows + 1):
color = row_ext_fg if (i == 0 or i == self.rows) else row_grid_fg
GooCanvas.CanvasPath(parent = self.grid, data = "M %s %s L %s %s" % (0, i * self.row_height, self.pattern.get_length() * self.zoom_in, i * self.row_height), stroke_color = color, line_width = 1)
for i in range(0, self.pattern.get_length() + 1, int(self.grid_unit)):
color = grid_fg
if i % self.pattern.ppqn == 0:
color = beat_fg
if (i % (self.pattern.ppqn * self.pattern.beats)) == 0:
color = bar_fg
GooCanvas.CanvasPath(parent = self.grid, data = "M %s %s L %s %s" % (i * self.zoom_in, 1, i * self.zoom_in, self.rows * self.row_height - 1), stroke_color = color, line_width = 1)
def update_notes(self):
while self.notes.get_n_children() > 0:
self.notes.remove_child(0)
for item in self.pattern.items():
x = self.pulse_to_screen_x(item.pos) - self.instr_width
y = self.row_to_screen_y(item.row + 0.5)
if item.channel == self.channel:
fill_color = 0xC0C0C0 - int(item.vel * 1.5) * 0x000101
stroke_color = 0x808080
if item.selected:
stroke_color = 0xFF8080
else:
fill_color = 0xE0E0E0
stroke_color = 0xE0E0E0
if item.len > 1:
x2 = self.pulse_to_screen_x(item.pos + item.len) - self.pulse_to_screen_x(item.pos)
polygon = [-2, 0, 0, -5, x2 - 5, -5, x2, 0, x2 - 5, 5, 0, 5]
else:
polygon = [-5, 0, 0, -5, 5, 0, 0, 5, -5, 0]
item.item = GooCanvas.CanvasPath(parent = self.notes, data = polygon_to_path(polygon), line_width = 1, fill_color = ("#%06x" % fill_color), stroke_color = ("#%06x" % stroke_color))
#item.item.set_property('stroke_color_rgba', guint(stroke_color))
item.item.translate(x, y)
def set_selection_from_rubberband(self):
sx, sy, ex, ey = self.cursor.get_rubberband_box()
for item in self.pattern.items():
x = self.pulse_to_screen_x(item.pos)
y = self.row_to_screen_y(item.row + 0.5)
item.selected = (x >= sx and x <= ex and y >= sy and y <= ey)
self.update_notes()
def on_grid_event(self, item, event):
if event.type == Gdk.EventType.KEY_PRESS:
return self.on_key_press(item, event)
if event.type in [Gdk.EventType.BUTTON_PRESS, Gdk.EventType._2BUTTON_PRESS, Gdk.EventType.LEAVE_NOTIFY, Gdk.EventType.MOTION_NOTIFY, Gdk.EventType.BUTTON_RELEASE]:
return self.on_mouse_event(item, event)
def on_key_press(self, item, event):
keyval, state = event.keyval, event.state
kvname = Gdk.keyval_name(keyval)
if kvname == 'Delete':
self.pattern.delete_selected()
self.update_notes()
elif kvname == 'c':
self.pattern.group_set(channel = self.channel)
self.update_notes()
elif kvname == 'v':
self.pattern.group_set(vel = int(self.toolbox.vel_adj.get_value()))
self.update_notes()
elif kvname == 'plus':
self.pattern.transpose_selected(1)
self.update_notes()
elif kvname == 'minus':
self.pattern.transpose_selected(-1)
self.update_notes()
#else:
# print kvname
def on_mouse_event(self, item, event):
ex, ey = self.convert_to_item_space(self.get_root_item(), event.x, event.y)
column = self.screen_x_to_column(ex)
row = self.screen_y_to_row(ey)
pulse = column * self.grid_unit
epulse = (ex - self.instr_width) / self.zoom_in
unit = self.grid_unit * self.zoom_in
if self.cursor.rubberband:
if event.type == Gdk.EventType.MOTION_NOTIFY:
self.cursor.update_rubberband(ex, ey)
return
button = event.get_button()[1]
if event.type == Gdk.EventType.BUTTON_RELEASE and button == 1:
self.cursor.end_rubberband(ex, ey)
self.set_selection_from_rubberband()
self.request_update()
return
return
if event.type == Gdk.EventType.BUTTON_PRESS:
button = event.get_button()[1]
self.grab_focus(self.grid)
if ((event.state & Gdk.ModifierType.SHIFT_MASK) == Gdk.ModifierType.SHIFT_MASK) and button == 1:
self.cursor.start_rubberband(ex, ey)
return
if pulse < 0 or pulse >= self.pattern.get_length():
return
note = self.pattern.get_note(pulse, row, self.channel)
if note is not None:
if button == 3:
vel = int(self.toolbox.vel_adj.get_value())
self.pattern.set_note_vel(note, vel)
self.cursor.move(pulse, row, note)
self.update_notes()
return
self.toolbox.vel_adj.set_value(note.vel)
else:
note = NoteModel(pulse, self.channel, row, int(self.toolbox.vel_adj.get_value()), self.grid_unit if self.edit_mode == 'M' else 1)
self.pattern.add_note(note)
self.edited_note = note
self.orig_length = note.len
self.orig_velocity = note.vel
self.orig_y = ey
self.grab_add()
self.cursor.move(self.edited_note.pos, self.edited_note.row, note)
self.update_notes()
return
if event.type == Gdk.EventType._2BUTTON_PRESS:
if pulse < 0 or pulse >= self.pattern.get_length():
return
if self.pattern.has_note(pulse, row, self.channel):
self.pattern.remove_note(pulse, row, self.channel)
self.cursor.move(pulse, row, None)
self.update_notes()
if self.edited_note is not None:
self.grab_remove()
self.edited_note = None
return
if event.type == Gdk.EventType.LEAVE_NOTIFY and self.edited_note is None:
hide_item(self.cursor)
return
if event.type == Gdk.EventType.MOTION_NOTIFY and self.edited_note is None:
if pulse < 0 or pulse >= self.pattern.get_length():
hide_item(self.cursor)
return
if abs(pulse - epulse) > 5:
hide_item(self.cursor)
return
note = self.pattern.get_note(column * self.grid_unit, row, self.channel)
self.cursor.move(pulse, row, note)
show_item(self.cursor)
return
if event.type == Gdk.EventType.MOTION_NOTIFY and self.edited_note is not None:
vel = int(self.orig_velocity - self.snap(ey - self.orig_y) / 2)
if vel < 1: vel = 1
if vel > 127: vel = 127
self.pattern.set_note_vel(self.edited_note, vel)
len = pulse - self.edited_note.pos
if self.edit_mode == 'D':
len = 1
elif len <= -self.grid_unit:
len = self.orig_length
elif len <= self.grid_unit:
len = self.grid_unit
else:
len = int((len + 1) / self.grid_unit) * self.grid_unit - 1
self.pattern.set_note_len(self.edited_note, len)
self.toolbox.vel_adj.set_value(vel)
self.cursor.move_to_note(self.edited_note)
self.update_notes()
self.request_update()
return
if event.type == Gdk.EventType.BUTTON_RELEASE and self.edited_note is not None:
self.edited_note = None
self.grab_remove()
return
def screen_x_to_column(self, x):
unit = self.grid_unit * self.zoom_in
return int((x - self.instr_width + unit / 2) / unit)
def screen_y_to_row(self, y):
return int((y - 1) / self.row_height)
def pulse_to_screen_x(self, pulse):
return pulse * self.zoom_in + self.instr_width
def column_to_screen_x(self, column):
unit = self.grid_unit * self.zoom_in
return column * unit + self.instr_width
def row_to_screen_y(self, row):
return row * self.row_height + 1
def snap(self, val):
if val > -10 and val < 10:
return 0
if val >= 10:
return val - 10
if val <= -10:
return val + 10
assert False
class DrumSeqWindow(Gtk.Window):
def __init__(self, length, pat_data):
Gtk.Window.__init__(self, Gtk.WindowType.TOPLEVEL)
self.vbox = Gtk.VBox(spacing = 5)
self.pattern = DrumPatternModel(4, length / (4 * PPQN))
if pat_data is not None:
self.pattern.import_data(pat_data)
self.canvas = DrumCanvas(128, self.pattern)
sw = Gtk.ScrolledWindow()
sw.set_size_request(640, 400)
sw.add_with_viewport(self.canvas)
self.vbox.pack_start(sw, True, True, 0)
self.vbox.pack_start(self.canvas.toolbox, False, False, 0)
self.add(self.vbox)
if __name__ == "__main__":
w = DrumSeqWindow()
w.set_title("Drum pattern editor")
w.show_all()
w.connect('destroy', lambda w: Gtk.main_quit())
Gtk.main()