def __init__(self, master, sproxy):
"""
Construct new TkSynthWindow
master - The Tk container for self. In practice this is an
instance of llia.gui.tk.GroupWindow
sproxy - An instance of llia.Proxy.
"""
Frame.__init__(self, master)
self.config(background=factory.bg())
self.synth = sproxy
self.synth.synth_editor = self
self.app = sproxy.app
self.sid = sproxy.sid
self.group_index = -1
factory.set_pallet(sproxy.specs["pallet"])
main = factory.paned_window(self)
main.pack(expand=True, fill="both")
self.bank_editor = TkBankEditor(main, self, sproxy)
self.bus_and_buffer_editor = None
east = factory.frame(main)
self.notebook = factory.notebook(east)
self.notebook.pack(anchor="nw", expand=True, fill="both")
south = factory.frame(east)
south.pack(after=self.notebook, anchor="w", expand=True, fill="x")
self._lab_status = factory.label(south, "<status>")
self._lab_extended = factory.label(south, "")
b_panic = factory.panic_button(south, command=self.panic)
b_lower = factory.button(south, "-", command=self.lower_window)
b_lift = factory.button(south, "+", command=self.lift_window)
b_panic.grid(row=0, column=0)
self._lab_status.grid(row=0, column=4, sticky='ew')
self._lab_extended.grid(row=0,column=5,sticky='e',padx=16)
self._lab_extended.config(fg="#f1f1cd")
self._progressbar = Progressbar(south,mode="indeterminate")
self._progressbar.grid(row=0,column=PROGRESSBAR_COLUMN, sticky='w', padx=8)
south.config(background=factory.bg())
main.add(self.bank_editor)
main.add(east)
self.list_channel = None
self.list_keytab = None
self.var_transpose = StringVar()
self.var_keyrange_low = StringVar()
self.var_keyrange_high = StringVar()
self.var_bendrange = StringVar()
self._init_midi_tab(self.notebook)
self._init_map1_tab(self.notebook) # MIDI controllers and pitchwheel
self._init_map2_tab(self.notebook) # velocity, aftertouch, keynumber
self._init_info_tab(self.notebook)
self._child_editors = {}
self.update_progressbar(100, 0)
def __init__(self, master, sproxy):
Frame.__init__(self, master)
self.config(background=factory.bg())
self.synth = sproxy
self.synth.synth_editor = self
self.app = sproxy.app
self.sid = sproxy.sid
self.group_index = -1
factory.set_pallet(sproxy.specs["pallet"])
main = factory.paned_window(self)
main.pack(expand=True, fill="both")
self.bank_editor = TkBankEditor(main, self, sproxy)
self.bus_and_buffer_editor = None
east = factory.frame(main)
self.notebook = factory.notebook(east)
self.notebook.pack(anchor="nw", expand=True, fill="both")
south = factory.frame(east)
south.pack(after=self.notebook, anchor="w", expand=True, fill="x")
# b_panic = factory.panic_button(south, command=self.panic)
# b_clear_status = factory.clear_button(south, command=self.clear_status)
# self._lab_status = factory.label(south, "<status>")
# b_panic.grid(row=0, column=0, sticky='w')
# b_clear_status.grid(row=0, column=1, sticky='w')
# self._lab_status.grid(row=0, column=2, sticky='w', padx=8)
self._lab_status = factory.label(south, "<status>")
b_panic = factory.panic_button(south, command=self.panic)
b_lower = factory.button(south, "-", command=self.lower_window)
b_lift = factory.button(south, "+", command=self.lift_window)
self._lab_status.grid(row=0, column=2, sticky='w', padx=8)
b_panic.grid(row=0, column=0)
self._lab_status.grid(row=0, column=3, sticky='w')
south.config(background=factory.bg())
main.add(self.bank_editor)
main.add(east)
self.list_channel = None
self.list_keytab = None
self.var_transpose = StringVar()
self.var_keyrange_low = StringVar()
self.var_keyrange_high = StringVar()
self.var_bendrange = StringVar()
self._init_info_tab(self.notebook)
self._init_busconnection_tab(self.notebook)
self._init_performance_tab(self.notebook)
self._init_map1_tab(self.notebook) # MIDI controllers and pitchwheel
self._init_map2_tab(self.notebook) # velocity, aftertouch, keynumber
self._child_editors = {}
self.sync()
def __init__(self, master, app):
Toplevel.__init__(self, master)
self.config(background=factory.bg())
config = app.config
id_ = config["global-osc-id"]
host, port = config['host'], config['port']
client, cport = config['client'], config['client_port']
midi_receiver = app.midi_receiver.port_name()
midi_transmitter = "n/a" # FIX ME
main = VFrame(self)
main.pack(anchor="nw", expand=True, fill=BOTH)
image = Image.open("resources/logos/llia_logo_medium.png")
photo = ImageTk.PhotoImage(image)
lab_logo = Label(main, image=photo)
main.add(lab_logo)
south = factory.frame(main)
main.add(south)
acc = "Llia Version %s.%s.%s \n" % VERSION[0:3]
acc += "(c) 2016 Steven Jones\n\n"
acc += "OSC ID : %s\n" % id_
acc += "OSC Host : %-12s port : %s\n" % (host, port)
acc += "OSC client : %-12s port : %s\n\n" % (client, cport)
acc += "MIDI Receiver : %s\n" % midi_receiver
acc += "MIDI Transmitter : %s\n" % midi_transmitter
tx = factory.read_only_text(south, acc)
tx.pack(pady=32)
self.grab_set()
self.mainloop()
def __init__(self,editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,565,478,self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self,canvas,editor,self.NAME)
editor.add_child_editor(self.NAME, self)
x0,y0 = 150, 75
x_scale = x0
x_delay = x0+22
x_phase = x_scale+75
x_wetamp = x_phase+108
x_amp = x_wetamp+75
y_scale = y0+150
y_delay = y_scale+50
y_phase = y_scale
y_wetamp = y_delay
y_amp = y_wetamp
msb_scale = self.msb("delayScale",3,x_scale,y_scale)
self.norm_slider("delay",x_delay,y_delay)
msb_phase =self.msb("phase",2,x_phase,y_phase)
self.volume_slider("wet",x_wetamp,y_wetamp)
self.volume_slider("amp",x_amp,y_amp)
self.msb_aspect(msb_scale, 0, 0.001, "x1")
self.msb_aspect(msb_scale, 1, 0.010, "x2")
self.msb_aspect(msb_scale, 2, 0.100, "x3")
msb_scale.update_aspect()
self.msb_aspect(msb_phase, 0, -1, "-")
self.msb_aspect(msb_phase, 1, 1, "+")
msb_phase.update_aspect()
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1000, 700, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 75
y_tumbler = y0 + 50
x0 = 75
x_port = x0
x_lfo = x_port + 75
x_delay = x_lfo + 100
x_vsens = x_delay + 60
x_vdepth = x_vsens + 60
x_xpitch = x_vdepth + 60
x_moddepth = x_xpitch + 90
x_xmod = x_moddepth + 60
x_xscale = x_xmod + 90
x_amp = x_xscale + 90
def norm_slider(param, x):
s = cf.normalized_slider(canvas, param, editor)
self.add_control(param, s)
s.widget().place(x=x, y=y0)
return s
def linear_slider(param, x, range_=(0, 4)):
s = cf.linear_slider(canvas, param, editor, range_=range_)
self.add_control(param, s)
s.widget().place(x=x, y=y0)
return s
def volume_slider(param, x):
s = cf.volume_slider(canvas, param, editor)
self.add_control(param, s)
s.widget().place(x=x, y=y0)
return s
def tumbler(param, x):
t = Tumbler(canvas, param, editor, digits=5, scale=0.001)
self.add_control(param, t)
t.layout((x, y_tumbler))
t.update_aspect()
return t
norm_slider("port", x_port)
tumbler("lfov_freq", x_lfo)
linear_slider("lfov_delay", x_delay)
norm_slider("vsens", x_vsens)
norm_slider("vdepth", x_vdepth)
norm_slider("xpitch", x_xpitch)
norm_slider("modDepth", x_moddepth)
norm_slider("xmod", x_xmod)
linear_slider("xscale", x_xscale, (0, 2))
volume_slider("amp", x_amp)
def __init__(self, editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1400, 700, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
x0 = 75
xdelay = x0+220
xmixer = xdelay+350
y0,y1 = 75,260
self.tumbler("pitchRatio",4,0.001,x0,y0,range_=(0,4000))
self.norm_slider("pitchDispersion",x0+80,y0)
self.norm_slider("timeDispersion",x0+140,y0)
self.toggle("delayInSelect",xdelay,y0,off=(0,"P.Shifter"),on=(1,"Drysig"))
self.exp_slider("delay",1,xdelay+80,y0)
self.exp_slider("delayMod",1,xdelay+140,y0)
self.tumbler("lfoFreq",5,0.001,xdelay+110,y1)
self.linear_slider("feedback",(-1,1),xdelay+200,y0)
self.exp_slider("lowpass",16000,xdelay+260,y0)
self.volume_slider("dryAmp",xmixer,y0)
self.volume_slider("psAmp",xmixer+60,y0)
self.volume_slider("delayAmp",xmixer+120,y0)
self.linear_slider("dryPan",(-1,1),xmixer,y1)
self.linear_slider("psPan",(-1,1),xmixer+60,y1)
self.linear_slider("delayPan",(-1,1),xmixer+120,y1)
self.toggle("feedbackDestination",xdelay,y1,off=(0,"P.shifter"),on=(1,"Delay"))
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 696, 361, self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 75
x0 = 100
xmix = x0 + 150
xsaw = xmix
xnoise = xsaw + 64
xexternal = xnoise + 60
xlag = xexternal + 90
def tumbler(param, x, y):
t = Tumbler(canvas,
param,
editor,
digits=5,
scale=0.001,
outline='#a5a08a',
foreground='#a5a08a',
fill='black')
self.add_control(param, t)
t.layout((x, y))
return y
def norm(param, x):
s = cf.normalized_slider(canvas, param, editor)
self.add_control(param, s)
s.widget().place(x=x, y=y0)
return s
def linear_slider(param, x, range_):
s = cf.linear_slider(canvas, param, editor, range_=range_)
self.add_control(param, s)
s.widget().place(x=x, y=y0)
tumbler("clockRate", x0, y0)
tumbler("sawFreq", xsaw - 30, y0 + 160)
tog = ToggleButton(canvas,
"clockSource",
editor,
text=["Internal", "External"],
fill='black',
foreground='#007d47',
selected_fill='black',
selected_foreground='#007d47')
self.add_control("clockSource", tog)
tog.layout((x0 + 8, y0 + 36))
tog.update_aspect()
norm("sawMix", xsaw)
norm("noiseMix", xnoise)
norm("externalMix", xexternal)
norm("lag", xlag)
norm("scale", xlag + 60)
linear_slider("bias", xlag + 120, (-4, 4))
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1000, 700, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
w = 900
h = 300
y0 = 50
x0 = 50
xmsb = w/2
ymsb = h-50
for i,prefix in enumerate("ab"):
x = x0
y = y0 + i*(300+25)
paramlist = []
for s in ("Attack","Decay1","Decay2","Release","Breakpoint",
"Sustain","Envmode"):
paramlist.append("%s%s" % (prefix,s))
env = ADDSREditor(canvas,i,(x,y),(w,h),paramlist,editor,12)
self.add_child_editor("ENV%s" % prefix, env)
env.sync()
param = "%sInvert" % prefix
msb = ToggleButton(canvas,param,editor,["+Pos","-Inv"])
self.add_control(param,msb)
msb.layout((x+xmsb,y+ymsb))
msb.update_aspect()
def __init__(self,stack,editor):
self.name = "Sol %s" % stack
self.image_file = "resources/Sol/editor_%s.png" % stack
self.tab_file = "resources/Sol/tab_%s.png" % stack
frame = editor.create_tab(self.name,self.tab_file)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,900,550,self.image_file)
canvas.pack()
TkSubEditor.__init__(self,canvas,editor,self.name)
editor.add_child_editor(self.name, self)
x0 = 50
xop = x0
xfilter = 640
y0 = 75
y1 = 300
if stack == 'x':
self.init_fm_op('a',xop,y0)
self.init_fm_op('b',xop,y1)
else:
self.init_wv_op('c',xop,y0)
self.init_wv_op('d',xop,y1)
self.init_stack_filter(stack,xfilter,y0,y1)
def __init__(self, master, app):
Toplevel.__init__(self, master)
self.config(background=factory.bg())
config = app.config
id_ = config["global-osc-id"]
host, port = config['host'], config['port']
client, cport = config['client'], config['client_port']
midi_receiver = app.midi_receiver.port_name()
midi_transmitter = "n/a" # FIX ME
main = VFrame(self)
main.pack(anchor="nw", expand=True, fill=BOTH)
image = Image.open("resources/logos/llia_logo_medium.png")
photo = ImageTk.PhotoImage(image)
lab_logo = Label(main, image=photo)
main.add(lab_logo)
south = factory.frame(main)
main.add(south)
acc = "Llia Version %s.%s.%s \n" % VERSION[0:3]
acc += "(c) 2016 Steven Jones\n\n"
acc += "OSC ID : %s\n" % id_
acc += "OSC Host : %-12s port : %s\n" % (host, port)
acc += "OSC client : %-12s port : %s\n\n" % (client, cport)
acc += "MIDI Receiver : %s\n" % midi_receiver
acc += "MIDI Transmitter : %s\n" % midi_transmitter
tx = factory.read_only_text(south, acc)
tx.pack(pady=32)
self.grab_set()
self.mainloop()
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 465, 478, self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
x0, y0 = 150, 75
x_scale = x0
x_delay = x0 + 22
x_phase = x_scale + 75
x_wetamp = x_phase + 108
y_scale = y0 + 150
y_delay = y_scale + 50
y_phase = y_scale
y_wetamp = y_delay
msb_scale = self.msb("delayScale", 3, x_scale, y_scale)
self.norm_slider("delay", x_delay, y_delay)
msb_phase = self.msb("phase", 2, x_phase, y_phase)
self.volume_slider("wet", x_wetamp, y_wetamp)
self.msb_aspect(msb_scale, 0, 0.001, "x1")
self.msb_aspect(msb_scale, 1, 0.010, "x2")
self.msb_aspect(msb_scale, 2, 0.100, "x3")
msb_scale.update_aspect()
self.msb_aspect(msb_phase, 0, -1, "-")
self.msb_aspect(msb_phase, 1, 1, "+")
msb_phase.update_aspect()
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1500, 708, self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0, y1 = 105,358
x_delay = 105
x_wow = x_delay + 60
x_wfreq = x_wow + 60
x_flutter = x_wfreq + 60
x_xdelay = x_flutter + 60
x_fb = x_xdelay + 90
x_gain = x_fb + 60
x_threshold = x_gain + 60
x_low = x_threshold + 60
x_high = x_low + 60
x_mix = x_high + 90
x_xmix = x_mix + 60
x_amp = x_xmix + 90
self.linear_slider("delayTime",(0,MAX_DELAY),x_delay,y0,height=200)
self.exp_slider("wow",1.0,x_wow,y0,height=200)
self.exp_slider("wowFreq",5.0,x_wfreq,y0,height=200)
self.exp_slider("flutter",1.0,x_flutter,y0,height=200)
self.exp_slider("xDelayMod",1.0,x_xdelay,y0,height=200)
self.norm_slider("feedback",x_fb,y0,height=200)
self.linear_slider("gain",(0.5,2.0),x_gain,y0,height=200)
self.exp_slider("threshold",1.0,x_threshold,y0,height=200)
self.third_octave_slider("lowcut",x_low,y0,height=200)
self.third_octave_slider("highcut",x_high,y0,height=200)
self.norm_slider("efxMix",x_mix,y0,height=200)
self.norm_slider("xEfxMix",x_xmix,y0,height=200)
self.volume_slider("amp",x_amp,y0,height=200)
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1400, 700, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 50
x0 = 75
xim = x0 + 120
xxm = xim + 90
xxbleed = xxm + 60
xcbleed = xxbleed + 90
xamp = xcbleed + 90
def vslider(param, x):
s = cf.volume_slider(canvas, param, editor)
self.add_control(param, s)
s.widget().place(x=x, y=y0)
return s
tfreq = Tumbler(canvas, "imodfreq", editor, digits=5, scale=1)
self.add_control("imodfreq", tfreq)
tfreq.layout((x0, y0))
vslider("imodamp", xim)
vslider("xmodamp", xxm)
vslider("xmodbleed", xxbleed)
vslider("carbleed", xcbleed)
vslider("amp", xamp)
def __init__(self,editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1000, 700, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME,self)
y0 = 75
y_tumbler = y0 + 50
x0 = 75
x_port = x0
x_lfo = x_port + 75
x_delay = x_lfo + 100
x_vsens = x_delay + 60
x_vdepth = x_vsens + 60
x_xpitch= x_vdepth + 60
x_moddepth = x_xpitch + 90
x_xmod = x_moddepth + 60
x_xscale = x_xmod + 90
x_amp = x_xscale + 90
def norm_slider(param,x):
s = cf.normalized_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y0)
return s
def linear_slider(param,x,range_=(0,4)):
s = cf.linear_slider(canvas,param,editor,range_=range_)
self.add_control(param,s)
s.widget().place(x=x,y=y0)
return s
def volume_slider(param,x):
s = cf.volume_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y0)
return s
def tumbler(param,x):
t = Tumbler(canvas,param,editor,digits=5,scale=0.001)
self.add_control(param,t)
t.layout((x,y_tumbler))
t.update_aspect()
return t
norm_slider("port",x_port)
tumbler("lfov_freq",x_lfo)
linear_slider("lfov_delay",x_delay)
norm_slider("vsens",x_vsens)
norm_slider("vdepth",x_vdepth)
norm_slider("xpitch",x_xpitch)
norm_slider("modDepth",x_moddepth)
norm_slider("xmod",x_xmod)
linear_slider("xscale",x_xscale,(0,2))
volume_slider("amp",x_amp)
def __init__(self,editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,1000,700,self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self,canvas,editor,self.NAME)
editor.add_child_editor(self.NAME, self)
x0 = 75
y0 = 75
y1 = 380
self.norm_slider("spread_external",x0,y0)
self.norm_slider("cluster_external",x0+60,y0)
msb_harm = self.msb("harm2_external",len(POLAR_HARMONIC_MOD_RANGE),x0+120,y0)
msb_filter = self.msb("f1_freq_external",len(FILTER_MOD_VALUES),x0+120,y0+122)
for i,n in enumerate(POLAR_HARMONIC_MOD_RANGE):
fg = None
self.msb_aspect(msb_harm,i,n,foreground=fg)
for i,n in enumerate(FILTER_MOD_VALUES):
fg = None
self.msb_aspect(msb_filter,i,n,foreground=fg)
msb_harm.update_aspect()
msb_filter.update_aspect()
def __init__(self, editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
TkSubEditor.__init__(self, frame, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
lab_panel = factory.image_label(frame, self.IMAGE_FILE)
lab_panel.pack(anchor="nw", expand=False)
s_pos = cf.bipolar_slider(frame, "pos", editor)
s_lfo_freq = ExpSlider(frame, "lfoFreq", editor, range_=100, degree=3)
s_lfo_depth = cf.normalized_slider(frame, "lfoDepth", editor)
s_xscale = cf.linear_slider(frame, "xscale", editor, range_=(-2, 2))
s_xbias = cf.linear_slider(frame, "xbias", editor, range_=(-2,2))
s_amp = cf.volume_slider(frame, "amp", editor)
self.add_control("pos", s_pos)
self.add_control("lfoFreq", s_lfo_freq)
self.add_control("lfoDepth", s_lfo_depth)
self.add_control("xscale", s_xscale)
self.add_control("xbias", s_xbias)
self.add_control("amp", s_amp)
y0 = 60
x0 = 120
x_lfo_freq = x0 + 90
x_lfo_depth = x_lfo_freq + 60
x_xscale = x_lfo_depth + 90
x_xbias = x_xscale + 60
x_amp = x_xbias + 90
s_pos.widget().place(x=x0, y=y0, height=200)
s_lfo_freq.layout(offset=(x_lfo_freq, y0), height=200, checkbutton_offset=None)
s_lfo_depth.widget().place(x=x_lfo_depth, y=y0, height=200)
s_xscale.widget().place(x=x_xscale, y=y0, height=200)
s_xbias.widget().place(x=x_xbias, y=y0, height=200)
s_amp.widget().place(x=x_amp, y=y0, height=200)
def __init__(self,editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,736,604,self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self,canvas,editor,self.NAME)
editor.add_child_editor(self.NAME, self)
x0 = 75
xlfo = x0+180
xmix = xlfo + 320
y0=75
y1=340
for n,y in ((1,y0),(2,y1)):
def param(prefix):
return "%s%d" % (prefix,n)
self.linear_slider(param("delay"),(0,0.01),x0,y)
self.exp_slider(param("depth"),1.0,x0+60,y)
self.exp_slider(param("xmod"),1.0,x0+120,y)
msb = self.msb(param("lfoRatio"),len(LFO_RATIOS),xlfo,y)
for i,pair in enumerate(LFO_RATIOS):
val,text = pair
self.msb_aspect(msb,i,val,text=text)
msb.update_aspect()
self.linear_slider(param("feedback"),(-1,1),xlfo+100,y)
self.linear_slider(param("xfeedback"),(-1,1),xlfo+160,y)
self.exp_slider(param("lowpass"),16000,xlfo+220,y)
self.volume_slider(param("dryMix"),xmix,y,height=100)
self.linear_slider(param("dryPan"),(-1,1),xmix,y+130,height=75)
self.volume_slider(param("efxMix"),xmix+60,y,height=100)
self.linear_slider(param("efxPan"),(-1,1),xmix+60,y+130,height=75)
self.tumbler("timebase",5,0.001,xlfo-7,y0+100)
def __init__(self,editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,740,343,self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self,canvas,editor,self.NAME)
editor.add_child_editor(self.NAME, self)
x0,y0 = 75,75
x_tone = x0
x_feedback = x_tone+60
x_bandpass = x_feedback+90
x_filter = x_bandpass
x_mod = x_filter+60
x_xmod = x_mod+60
x_res = x_xmod+60
x_lfo = x_res+90
x_mix = x_lfo+90
x_amp = x_mix+60
self.norm_slider("tone",x_tone,y0)
self.linear_slider("feedback",(-1.0,1.0),x_feedback,y0)
self.norm_slider("filter",x_filter,y0)
self.norm_slider("modDepth",x_mod,y0)
self.norm_slider("xmodDepth",x_xmod,y0)
self.norm_slider("res",x_res,y0)
self.exp_slider("lfoFreq",16,x_lfo,y0,degree=3)
self.norm_slider("efxmix",x_mix,y0)
self.volume_slider("amp",x_amp,y0)
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
TkSubEditor.__init__(self, frame, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
lab_panel = factory.image_label(frame, self.IMAGE_FILE)
lab_panel.pack(anchor="nw", expand=False)
s_pos = cf.bipolar_slider(frame, "pos", editor)
s_lfo_freq = ExpSlider(frame, "lfoFreq", editor, range_=100, degree=3)
s_lfo_depth = cf.normalized_slider(frame, "lfoDepth", editor)
s_xscale = cf.linear_slider(frame, "xscale", editor, range_=(-2, 2))
s_xbias = cf.linear_slider(frame, "xbias", editor, range_=(-2, 2))
s_amp = cf.volume_slider(frame, "amp", editor)
self.add_control("pos", s_pos)
self.add_control("lfoFreq", s_lfo_freq)
self.add_control("lfoDepth", s_lfo_depth)
self.add_control("xscale", s_xscale)
self.add_control("xbias", s_xbias)
self.add_control("amp", s_amp)
y0 = 60
x0 = 120
x_lfo_freq = x0 + 90
x_lfo_depth = x_lfo_freq + 60
x_xscale = x_lfo_depth + 90
x_xbias = x_xscale + 60
x_amp = x_xbias + 90
s_pos.widget().place(x=x0, y=y0, height=200)
s_lfo_freq.layout(offset=(x_lfo_freq, y0),
height=200,
checkbutton_offset=None)
s_lfo_depth.widget().place(x=x_lfo_depth, y=y0, height=200)
s_xscale.widget().place(x=x_xscale, y=y0, height=200)
s_xbias.widget().place(x=x_xbias, y=y0, height=200)
s_amp.widget().place(x=x_amp, y=y0, height=200)
def __init__(self, editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,735,510,self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
def linear_slider(param, range_, x, y):
s = cf.linear_slider(canvas,param,editor,range_=range_)
self.add_control(param,s)
s.widget().place(x=x,y=y)
def norm_slider(param,x,y):
s = cf.normalized_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y)
def eq_slider(param,x,y):
s = cf.third_octave_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y)
def amp_slider(param,x,y):
s = cf.volume_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y)
def pan_slider(param,x,y):
s = cf.bipolar_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y)
y0 = 50
x0 = 75
x1 = x0 + 60
x2 = x1 + 60
x3 = x2 + 60
xeq = x3 + 75
xlp = xeq
xhp = xlp+60
xdry = xhp+75
xwet = xdry+120
linear_slider("preDelay",(0.0,0.333),x0,y0)
norm_slider("roomSize",x1,y0)
norm_slider("damp",x2,y0)
norm_slider("modDepth",x3,y0)
eq_slider("lpcutoff",xlp,y0)
eq_slider("hpcutoff",xhp,y0)
amp_slider("dryAmp", xdry,y0)
pan_slider("dryPan", xdry+60,y0)
amp_slider("wetAmp", xwet,y0)
pan_slider("wetPan", xwet+60,y0)
msb_gate = ToggleButton(canvas,"gatted",editor,)
self.add_control("gatted", msb_gate)
msb_gate.layout((x0+157,y0+200))
msb_gate.update_aspect()
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1000, 700, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 75
yfreq = y0
ygain = yfreq + 50
yq = ygain + 180
y_enable = yq + 180
x0 = 75
x_shelf = x0
def tumbler(param, x, y=yfreq):
t = Tumbler(canvas, param, editor, digits=5, scale=1)
self.add_control(param, t)
t.layout((x, y))
return t
def q_slider(param, x, y=yq):
s = cf.linear_slider(canvas, param, editor, range_=(1.0, 0.0))
self.add_control(param, s)
s.widget().place(x=x, y=y)
return s
def gain_slider(param, x, y=ygain):
s = cf.linear_slider(canvas, param, editor, range_=(-36, 36))
self.add_control(param, s)
s.widget().place(x=x, y=y)
return s
tumbler("hp", x_shelf, y=y0)
tumbler("lp", x_shelf, y=y0 + 60)
for i in (1, 2, 3, 4):
x = x_shelf + i * 100
tumbler("f%d" % i, x + 6)
gain_slider("gain%d" % i, x + 37)
q_slider("q%d" % i, x + 37)
p_enable = "enable%d" % i
m_enable = ToggleButton(canvas,
p_enable,
editor,
text=("Mute", "On"))
self.add_control(p_enable, m_enable)
m_enable.layout((x + 14, y_enable))
m_enable.update_aspect()
x_bleed = x + 150
s = cf.normalized_slider(canvas, "bleed", editor)
self.add_control("bleed", s)
s.widget().place(x=x_bleed, y=ygain, height=150)
x_amp = x_bleed + 60
gs = cf.linear_slider(canvas, "amp", editor, range_=(-12, 12))
self.add_control("amp", gs)
gs.widget().place(x=x_amp, y=ygain)
def __init__(self, root, app):
Toplevel.__init__(self, root)
self.config(background=factory.bg())
self.title("Llia Setup")
self.maxsize(800,870)
self.app = app
self.config = app.config()
main = VFrame(self)
main.pack(anchor="nw", expand=True, fill=BOTH)
image = Image.open("resources/logos/llia_logo_medium.png")
photo = ImageTk.PhotoImage(image)
lab_logo = factory.Label(main, image=photo)
main.add(lab_logo)
south = Frame(main, background=factory.bg())
main.add(south)
self._build_south_panel(south)
self.bind("<F1>", self.display_help)
root.wait_window(self)
def __init__(self,editor):
self.name = "Sol Mod"
self.image_file = "resources/Sol/editor_mod.png"
self.tab_file = "resources/Sol/tab_mod.png"
frame = editor.create_tab(self.name,self.tab_file)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,1100,580,self.image_file)
canvas.pack()
TkSubEditor.__init__(self,canvas,editor,self.name)
editor.add_child_editor(self.name, self)
x0 = 50
y0 = 75
y1 = 330
self.tumbler("timebase",5,0.001,x0,y0)
self.norm_slider("port",x0+30,y1)
xvib = x0+100
msb_vratio = self.msb("vratio",len(LFO_RATIOS),xvib,y0)
self.linear_slider("vdelay",(0,MAX_LFO_DELAY),xvib+100,y0)
self.norm_slider("vsens",xvib+160,y0)
self.norm_slider("vdepth",xvib+220,y0)
self.norm_slider("pitch_ctrlbus",xvib+280,y0)
msb_aratio = self.msb("alfo_ratio",len(LFO_RATIOS),xvib,y1)
self.linear_slider("alfo_delay",(0,MAX_LFO_DELAY),xvib+100,y1)
msb_bratio = self.msb("blfo_ratio",len(LFO_RATIOS),xvib+180,y1)
self.linear_slider("blfo_delay",(0,MAX_LFO_DELAY),xvib+280,y1)
lfo_ratio_msblist = (msb_vratio,msb_aratio,msb_bratio)
for i,r in enumerate(LFO_RATIOS):
n,d = r.numerator,r.denominator
if d == 1:
txt = "%d" % n
else:
txt = "%d/%d" % (n,d)
for msb in lfo_ratio_msblist:
self.msb_aspect(msb,i,float(r),text=txt)
for msb in lfo_ratio_msblist:
msb.update_aspect()
def env_slider(param,x,y):
self.exp_slider(param,MAX_ENV_SEGMENT_TIME,x,y)
xenv = xvib+340
for q in "ab":
if q == 'a':
y = y0
else:
y = y1
env_slider("%senv_attack" % q,xenv,y)
env_slider("%senv_decay" % q,xenv+40,y)
self.norm_slider("%senv_sustain" % q,xenv+80,y)
env_slider("%senv_release" % q,xenv+120,y)
self.toggle("%senv_lfo_trig" % q,xenv,y+175)
xcenv = xenv+170
cenv = ADDSREditor(canvas,1,(xcenv,y0),(400,400),
("cenv_attack","cenv_decay1","cenv_decay2",
"cenv_release","cenv_breakpoint","cenv_sustain",
"cenv_trig_mode"),
self,MAX_ENV_SEGMENT_TIME)
self.add_child_editor("Cenv",cenv)
cenv.sync()
def __init__(self, root, app):
Toplevel.__init__(self, root)
self.config(background=factory.bg())
self.title("Llia Setup")
self.maxsize(800, 870)
self.app = app
self.config = app.config
main = VFrame(self)
main.pack(anchor="nw", expand=True, fill=BOTH)
image = Image.open("resources/logos/llia_logo_medium.png")
photo = ImageTk.PhotoImage(image)
lab_logo = factory.Label(main, image=photo)
main.add(lab_logo)
south = Frame(main, background=factory.bg())
main.add(south)
self._build_south_panel(south)
self.bind("<F1>", self.display_help)
root.wait_window(self)
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1000, 700, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 75
y1 = y0 + 180
x0 = 75
xlow = x0
xcenter = xlow + 54
xhigh = xcenter + 100
def gain_slider(param, x):
range_ = (-12, 12)
s = cf.linear_slider(canvas, param, editor, range_=range_)
self.add_control(param, s)
s.widget().place(x=x, y=y1, height=125)
return s
def frequency_slider(param, x):
s = ExpSlider(canvas, param, editor, range_=20000, degree=3)
self.add_control(param, s)
s.layout((x, y0), checkbutton_offset=None)
return s
frequency_slider("fLow", xlow)
frequency_slider("fHigh", xhigh)
bwscales = ((0.333, "1/3"), (0.667, "2/3"), (1.000, "1"),
(1.333, "1 1/3"), (1.667, "1 2/3"), (2.00, "2"))
param = "bwScale"
m = MSB(canvas, param, editor, len(bwscales))
for i, p in enumerate(bwscales):
v, txt = p
if v >= 1:
cfill = "green"
else:
cfill = "red"
d = {
"fill": "black",
"foreground": cfill,
"outline": "gray",
"value": v,
"text": txt
}
m.define_aspect(i, v, d)
m.layout((xcenter, y0 + 50))
m.update_aspect()
gain_slider("gainLow", xlow)
gain_slider("gainCenter", xcenter + 23)
gain_slider("gainHigh", xhigh)
def __init__(self, app):
self.root = Tk()
self.root.title("Llia")
self.root.config(background=factory.bg())
super(TkApplicationWindow, self).__init__(app, self.root)
self.root.withdraw()
if app.config["enable-splash"]:
splash = TkSplashWindow(self.root, app)
self.root.deiconify()
self.root.protocol("WM_DELETE_WINDOW", self.exit_app)
self.llia_graph = None
self._main = layout.BorderFrame(self.root)
self._main.config(background=factory.bg())
self._main.pack(anchor="nw", expand=True, fill=BOTH)
self._init_status_panel()
self._init_menu()
self._init_center_frame(self._main.center)
self.root.minsize(width=665, height=375)
self.group_windows = []
self.add_synth_group()
def __init__(self, app):
self.root = Tk()
self.root.title("Llia")
self.root.config(background=factory.bg())
super(TkApplicationWindow, self).__init__(app, self.root)
self.root.withdraw()
if app.config["enable-splash"]:
splash = TkSplashWindow(self.root, app)
self.root.deiconify()
self.root.protocol("WM_DELETE_WINDOW", self.exit_app)
self.llia_graph = None
self._main = layout.BorderFrame(self.root)
self._main.config(background=factory.bg())
self._main.pack(anchor="nw", expand=True, fill=BOTH)
self._init_status_panel()
self._init_menu()
self._init_center_frame(self._main.center)
self.root.minsize(width=665, height=375)
self.group_windows = []
self.add_synth_group()
def __init__(self, master, app):
Frame.__init__(self, master)
self.app = app
self.proxy = app.proxy
self.config(background=factory.bg())
canvas = Canvas(self,
width=gconfig["graph-width"],
height=gconfig["graph-height"],
background=gconfig["graph-fill"])
self.canvas = canvas
info_canvas = InfoCanvas(self)
self.info_canvas = info_canvas
info_canvas.grid(row=0,
column=0,
rowspan=1,
columnspan=1,
sticky='wns')
canvas.grid(row=0, column=1, rowspan=1, columnspan=1, sticky='nsew')
self.grid_rowconfigure(0, weight=1)
self.grid_rowconfigure(1, weight=0)
self.grid_columnconfigure(0, weight=0)
self.grid_columnconfigure(1, weight=1)
# toolbar buttons
def tbutton(col, text, command=None):
bwidth = 75
b = factory.button(self.canvas, text, command=command)
y0 = 15
x0 = 15
x = x0 + col * bwidth
b.place(x=x, y=y0, width=bwidth)
tbutton(0, 'sync', self.sync)
tbutton(1, '+Audio', self.add_audio_bus)
tbutton(2, "+Control", self.add_control_bus)
tbutton(3, "Align", self.allign_tokens)
self.synth_tokens = {} # map [sid] -> SynthToken
self.audio_bus_tokens = {} # map [bus-name] -> BusToken
self.control_bus_tokens = {}
self.current_token_and_port = None # (token,port) dragdrop source
self.current_allied_ports = []
self._drag_data = {
'x': 0,
'y': 0,
'anchor-x': 0,
'anchor-y': 0,
'port1': None,
#'port2' : None,
'rubberband': None
}
canvas.bind("<B1-Motion>", self.bus_drag)
canvas.bind("<ButtonPress-1>", self.bus_drag_pickup)
canvas.bind("<ButtonRelease-1>", self.bus_drop)
def __init__(self, tk_master, parent, name):
Frame.__init__(self, tk_master)
self.parent = parent
self.synth = parent.synth
self.bank = self.synth.bank()
self.config(background=factory.bg())
self._child_editors = {}
self._controls = {}
# WARNING: For some 'old-stye' editors, tk_master may be a Frame
# WARNING: and not a Canvas!
self.canvas = tk_master
self.parent = parent
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILENAME)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 946, 777, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 50
y1 = y0 + 230
xfreq1, yfreq_offset = 50, 0
xamp1 = xfreq1 + 90
xfreq2 = xamp1 + 60
xamp2 = xfreq2 + 90
xattack = xamp2 + 75
xdecay = xattack + 60
xsustain = xdecay + 60
xrelease = xsustain + 60
xmod = xrelease + 75
xexternmod = xmod + 60
xexternpitch = xexternmod + 60
xchorus = xexternpitch + 75
xchorus_delay = xchorus + 60
xvfreq = xmod
xvdelay = xvfreq + 60
xvdepth = xvdelay + 60
xamp = xchorus_delay
self.tumbler("r2", xfreq1, y0 + yfreq_offset)
self.norm_slider("amp2", xamp1, y0)
self.tumbler("r4", xfreq2, y0 + yfreq_offset)
self.norm_slider("amp4", xamp2, y0)
self.env_time_slider("mattack", xattack, y0)
self.env_time_slider("mdecay", xdecay, y0)
self.env_time_slider("msustain", xsustain, y0)
self.env_time_slider("mrelease", xrelease, y0)
self.norm_slider("modulationDepth", xmod, y0)
self.norm_slider("xToModulationDepth", xexternmod, y0)
self.norm_slider("xToPitch", xexternpitch, y0)
self.norm_slider("chorus", xchorus, y0)
self.linear_slider("chorusDelay", (0, 4), xchorus_delay, y0)
self.tumbler("r1", xfreq1, y1 + yfreq_offset)
self.volume_slider("amp1", xamp1, y1)
self.tumbler('r3', xfreq2, y1 + yfreq_offset)
self.volume_slider("amp3", xamp2, y1)
self.env_time_slider("cattack", xattack, y1)
self.env_time_slider("cdecay", xdecay, y1)
self.env_time_slider("csustain", xsustain, y1)
self.env_time_slider("crelease", xrelease, y1)
self.linear_slider("vfreq", (0, 8), xvfreq, y1)
self.linear_slider("vdelay", (0, 4), xvdepth, y1)
self.norm_slider("vdepth", xvdelay, y1)
self.volume_slider("amp", xamp, y1)
def __init__(self, tk_master, parent, name):
Frame.__init__(self, tk_master)
self.parent = parent
self.synth = parent.synth
self.bank = self.synth.bank()
self.config(background=factory.bg())
self._child_editors = {}
self._controls = {}
# WARNING: For some 'old-stye' editors, tk_master may be a Frame
# WARNING: and not a Canvas!
self.canvas = tk_master
self.parent = parent
def __init__(self,editor):
frame = editor.create_tab(_NAME, _TAB_FILE)
frame.config(background=factory.bg())
self.editor = editor
TkSubEditor.__init__(self,frame,editor,_NAME)
editor.add_child_editor(_NAME,self)
self._layout_engion_selection(frame)
self._layout_env_type(frame)
self._layout_env_time(frame)
self._layout_slider_panel(frame)
lab_help = factory.label(frame,_BLURB)
lab_help.grid(row=2,column=0,rowspan=3,columnspan=4)
def __init__(self, editor):
frame = editor.create_tab(self.NAME,self.TAB_FILENAME)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 946,777, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 50
y1 = y0 + 230
xfreq1, yfreq_offset = 50, 0
xamp1 = xfreq1+90
xfreq2 = xamp1+60
xamp2 = xfreq2+90
xattack = xamp2+75
xdecay = xattack+60
xsustain = xdecay+60
xrelease = xsustain+60
xmod = xrelease+75
xexternmod = xmod + 60
xexternpitch = xexternmod + 60
xchorus = xexternpitch + 75
xchorus_delay = xchorus+60
xvfreq = xmod
xvdelay = xvfreq+60
xvdepth = xvdelay+60
xamp = xchorus_delay
self.tumbler("r2", xfreq1, y0+yfreq_offset)
self.norm_slider("amp2",xamp1,y0)
self.tumbler("r4", xfreq2,y0+yfreq_offset)
self.norm_slider("amp4",xamp2,y0)
self.env_time_slider("mattack", xattack, y0)
self.env_time_slider("mdecay", xdecay, y0)
self.env_time_slider("msustain", xsustain, y0)
self.env_time_slider("mrelease", xrelease, y0)
self.norm_slider("modulationDepth", xmod, y0)
self.norm_slider("xToModulationDepth", xexternmod, y0)
self.norm_slider("xToPitch", xexternpitch, y0)
self.norm_slider("chorus", xchorus, y0)
self.linear_slider("chorusDelay",(0,4),xchorus_delay, y0)
self.tumbler("r1", xfreq1, y1+yfreq_offset)
self.volume_slider("amp1", xamp1, y1)
self.tumbler('r3', xfreq2, y1+yfreq_offset)
self.volume_slider("amp3", xamp2, y1)
self.env_time_slider("cattack", xattack, y1)
self.env_time_slider("cdecay", xdecay, y1)
self.env_time_slider("csustain", xsustain, y1)
self.env_time_slider("crelease", xrelease, y1)
self.linear_slider("vfreq", (0,8), xvfreq, y1)
self.linear_slider("vdelay", (0,4), xvdepth, y1)
self.norm_slider("vdepth", xvdelay, y1)
self.volume_slider("amp", xamp, y1)
def __init__(self, editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1400, 700, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y,ypan = 50,250
x0 = 100
x1 = x0+90
x2 = x1+60
x3 = x2+60
x4 = x3+60
x5 = x4+90
x6 = x5+60
x7 = x6+60
def norm_slider(param,x,y):
s = cf.normalized_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y,width=14, height=150)
def bipolar_slider(param,x,y):
s = cf.bipolar_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y,width=14, height=75)
def amp_slider(param,x,y):
s = cf.volume_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y,width=14,height=150)
tratio = Tumbler(canvas,"pitchRatio",editor,
sign=False,digits=4,scale=0.001,
range_=(0,4000))
self.add_control("pitchRatio", tratio)
tratio.layout((x0,y))
norm_slider("pitchDispersion",x1,y)
norm_slider("timeDispersion",x2,y)
norm_slider("delay",x3,y)
norm_slider("feedback",x4,y)
amp_slider("dryAmp",x5,y)
amp_slider("psAmp",x6,y)
amp_slider("delayAmp",x7,y)
bipolar_slider("dryPan",x5,ypan)
bipolar_slider("psPan",x6,ypan)
bipolar_slider("delayPan",x7,ypan)
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas=factory.canvas(frame,696,361,self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 75
x0 = 100
xmix = x0 + 150
xsaw = xmix
xnoise = xsaw+64
xexternal = xnoise + 60
xlag = xexternal+90
def tumbler(param,x,y):
t = Tumbler(canvas,param,editor,digits=5,scale=0.001,
outline='#a5a08a',
foreground='#a5a08a',
fill='black')
self.add_control(param,t)
t.layout((x,y))
return y
def norm(param,x):
s = cf.normalized_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y0)
return s
def linear_slider(param,x,range_):
s = cf.linear_slider(canvas,param,editor,range_=range_)
self.add_control(param,s)
s.widget().place(x=x,y=y0)
tumbler("clockRate",x0,y0)
tumbler("sawFreq",xsaw-30,y0+160)
tog = ToggleButton(canvas,"clockSource",editor,
text=["Internal","External"],
fill='black',foreground='#007d47',
selected_fill='black',selected_foreground='#007d47')
self.add_control("clockSource", tog)
tog.layout((x0+8,y0+36))
tog.update_aspect()
norm("sawMix",xsaw)
norm("noiseMix",xnoise)
norm("externalMix",xexternal)
norm("lag",xlag)
norm("scale",xlag+60)
linear_slider("bias",xlag+120,(-4,4))
def __init__(self, master, title=None):
Frame.__init__(self, master)
self.configure(background=factory.bg())
self._row_count = 0
self.rows = []
self.grid_columnconfigure(0, weight=0)
self.grid_columnconfigure(1, weight=1)
if title:
self.lab_title = factory.center_label(self, str(title))
self.lab_title.grid(row=0, column=0, columnspan=2, pady=4)
self._row_count += 1
else:
self.lab_title = None
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1100,617, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 100
y1 = y0 + 250
y_ratio_offset = 25
y_bias_offset = 85
x0 = 100
xa = x0
xatone = xa+100
xaattack = xatone+60
xadecay = xaattack+60
xabend = xadecay+60
xavelocity = xabend+60
xaamp = xavelocity+60
xnoise = xaamp+90
xnseRes = xnoise+90
xnseAttack = xnseRes+60
xnseDecay = xnseAttack+60
xnseBend = xnseDecay+60
xnseVelocity = xnseBend+60
xnseAmp = xnseVelocity+60
self.tumbler("aRatio",5,0.001,xa,y0+y_ratio_offset)
self.norm_slider("aTone",xatone,y0)
self.time_slider("aAttack",xaattack,y0)
self.time_slider("aDecay",xadecay,y0)
self.bipolar_slider("aBend",xabend,y0)
self.norm_slider("aVelocity",xavelocity,y0)
self.amp_slider("aAmp",xaamp,y0)
self.tumbler("bRatio",5,0.001,xa,y1+y_ratio_offset)
self.linear_slider("bTune",xatone,y1)
self.time_slider("bAttack",xaattack,y1)
self.time_slider("bDecay",xadecay,y1)
self.bipolar_slider("bBend",xabend,y1)
self.norm_slider("bVelocity",xavelocity,y1)
self.amp_slider("bAmp",xaamp,y1)
self.tumbler("noiseRatio",5,0.001,xnoise,y0+y_ratio_offset)
self.tumbler("noiseBias",5,1,xnoise,y0+y_bias_offset)
self.norm_slider("noiseRes",xnseRes, y0)
self.time_slider("noiseAttack",xnseAttack,y0)
self.time_slider("noiseDecay",xnseDecay,y0)
self.bipolar_slider("noiseBend",xnseBend,y0)
self.norm_slider("noiseVelocity",xnseVelocity,y0)
self.amp_slider("noiseAmp",xnseAmp,y0)
self.amp_slider("amp",xnseAmp,y1)
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1100, 617, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 100
y1 = y0 + 250
y_ratio_offset = 25
y_bias_offset = 85
x0 = 100
xa = x0
xatone = xa + 100
xaattack = xatone + 60
xadecay = xaattack + 60
xabend = xadecay + 60
xavelocity = xabend + 60
xaamp = xavelocity + 60
xnoise = xaamp + 90
xnseRes = xnoise + 90
xnseAttack = xnseRes + 60
xnseDecay = xnseAttack + 60
xnseBend = xnseDecay + 60
xnseVelocity = xnseBend + 60
xnseAmp = xnseVelocity + 60
self.tumbler("aRatio", 5, 0.001, xa, y0 + y_ratio_offset)
self.norm_slider("aTone", xatone, y0)
self.time_slider("aAttack", xaattack, y0)
self.time_slider("aDecay", xadecay, y0)
self.bipolar_slider("aBend", xabend, y0)
self.norm_slider("aVelocity", xavelocity, y0)
self.amp_slider("aAmp", xaamp, y0)
self.tumbler("bRatio", 5, 0.001, xa, y1 + y_ratio_offset)
self.linear_slider("bTune", xatone, y1)
self.time_slider("bAttack", xaattack, y1)
self.time_slider("bDecay", xadecay, y1)
self.bipolar_slider("bBend", xabend, y1)
self.norm_slider("bVelocity", xavelocity, y1)
self.amp_slider("bAmp", xaamp, y1)
self.tumbler("noiseRatio", 5, 0.001, xnoise, y0 + y_ratio_offset)
self.tumbler("noiseBias", 5, 1, xnoise, y0 + y_bias_offset)
self.norm_slider("noiseRes", xnseRes, y0)
self.time_slider("noiseAttack", xnseAttack, y0)
self.time_slider("noiseDecay", xnseDecay, y0)
self.bipolar_slider("noiseBend", xnseBend, y0)
self.norm_slider("noiseVelocity", xnseVelocity, y0)
self.amp_slider("noiseAmp", xnseAmp, y0)
self.amp_slider("amp", xnseAmp, y1)
def __init__(self, master, app):
Frame.__init__(self, master)
self.config(background=factory.bg())
self.app = app
self.proxy = app.proxy
self.pack_propagate(False)
self.listbox = factory.listbox(self)
self.listbox.config(width=75, height=20)
sbv = factory.scrollbar(self, yclient=self.listbox)
sbh = factory.scrollbar(self, xclient=self.listbox, orientation=HORIZONTAL)
self.listbox.grid(row=0, column=0, rowspan=6, columnspan=8)
sbv.grid(row=0, column=8, rowspan=6, sticky=NS)
sbh.grid(row=6, column=0, columnspan=8, sticky=EW)
self.refresh()
def _init_status_panel(self):
south = self._main.south
south.configure(padx=4, pady=4)
self._lab_status = factory.label(south, "", modal=False)
b_panic = factory.panic_button(south)
b_down = factory.button(south, "-")
b_up = factory.button(south, "+")
b_panic.grid(row=0, column=0)
# b_down.grid(row=0,column=1)
# b_up.grid(row=0,column=2)
self._lab_status.grid(row=0, column=3, sticky='w')
south.config(background=factory.bg())
b_down.configure(command=lambda: self.root.lower())
b_up.configure(command=lambda: self.root.lift())
def __init__(self, editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1400, 700, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y,ypan = 50,250
x0 = 100
x1 = x0+90
x2 = x1+60
x3 = x2+60
x4 = x3+60
x5 = x4+90
x6 = x5+60
x7 = x6+60
def norm_slider(param,x,y):
s = cf.normalized_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y,width=14, height=150)
def bipolar_slider(param,x,y):
s = cf.bipolar_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y,width=14, height=75)
def amp_slider(param,x,y):
s = cf.volume_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y,width=14,height=150)
tratio = Tumbler(canvas,"pitchRatio",editor,
sign=False,digits=4,scale=0.001,
range_=(0,4000))
self.add_control("pitchRatio", tratio)
tratio.layout((x0,y))
norm_slider("pitchDispersion",x1,y)
norm_slider("timeDispersion",x2,y)
norm_slider("delay",x3,y)
norm_slider("feedback",x4,y)
amp_slider("dryAmp",x5,y)
amp_slider("psAmp",x6,y)
amp_slider("delayAmp",x7,y)
bipolar_slider("dryPan",x5,ypan)
bipolar_slider("psPan",x6,ypan)
bipolar_slider("delayPan",x7,ypan)
def _init_status_panel(self):
south = self._main.south
south.configure(padx=4, pady=4)
self._lab_status = factory.label(south, "", modal=False)
b_panic = factory.panic_button(south)
b_down = factory.button(south, "-")
b_up = factory.button(south, "+")
b_panic.grid(row=0, column=0)
# b_down.grid(row=0,column=1)
# b_up.grid(row=0,column=2)
self._lab_status.grid(row=0,column=3, sticky='w')
south.config(background=factory.bg())
b_down.configure(command=lambda: self.root.lower())
b_up.configure(command=lambda: self.root.lift())
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1200, 600, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 60
y1 = 300
yfreq_offset = 0
ybias_offset = 100
x0, xosc_offset = 50, 225
x_wave_offset = 105
x_amp_offset = x_wave_offset + 60
x_env1_wave_offset = x_wave_offset - 60
x_lfo_wave_offset = x_wave_offset
x_env1_amp_offset = x_amp_offset
for i, osc in enumerate(("osc1", "osc2", "osc3")):
x = x0 + (i * xosc_offset)
tumbler = Tumbler(canvas,
osc + "Freq",
editor,
digits=5,
scale=0.001)
self.add_control(osc + "Freq", tumbler)
tumbler.layout((x, y0 + yfreq_offset))
self.norm_slider(osc + "Wave", x + x_wave_offset, y0)
self.volume_slider(osc + "Amp", x + x_amp_offset, y0)
self.exp_slider(osc + "Wave_env1", x + x_env1_wave_offset, y1)
self.exp_slider(osc + "Wave_lfo", x + x_lfo_wave_offset, y1)
self.exp_slider(osc + "Amp_env1", x + x_env1_amp_offset, y1)
xosc3 = x
tumbler = Tumbler(canvas, "osc3Bias", editor, digits=5, scale=0.01)
self.add_control("osc3Bias", tumbler)
tumbler.layout((xosc3, y0 + ybias_offset))
self.norm_slider("osc3WaveLag",
xosc3 + x_wave_offset + 25,
y0,
width=10,
height=75)
xnoise = xosc3 + xosc_offset + 30
self.linear_slider("noiseFreq", xnoise, y0)
self.volume_slider("noiseAmp", xnoise + 60, y0)
self.norm_slider("noiseBW", xnoise, y1)
self.exp_slider("noiseAmp_env1", xnoise + 60, y1)
xpitch = xnoise + 150
self.linear_slider("port", xpitch, y0, range_=(0, 2))
self.norm_slider("xToPitch", xpitch, y1)
def _init_status_panel(self):
south = self._main.south
south.configure(padx=4, pady=4)
self._lab_status = factory.label(south, "", modal=False)
b_panic = factory.panic_button(south)
b_down = factory.button(south, "-")
b_up = factory.button(south, "+")
b_panic.grid(row=0, column=0)
self._progressbar = Progressbar(south,mode="indeterminate")
self._progressbar.grid(row=0,column=PROGRESSBAR_COLUMN, sticky='w', padx=8)
self._lab_status.grid(row=0,column=4, sticky='w')
south.config(background=factory.bg())
b_down.configure(command=lambda: self.root.lower())
b_up.configure(command=lambda: self.root.lift())
self.update_progressbar(100, 0)
def __init__(self,editor):
self.name = "Sol Vector"
self.image_file = "resources/Sol/editor_vector.png"
self.tab_file = "resources/Sol/tab_vector.png"
frame = editor.create_tab(self.name,self.tab_file)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,820,570,self.image_file)
canvas.pack()
TkSubEditor.__init__(self,canvas,editor,self.name)
editor.add_child_editor(self.name, self)
x0 = 50
y0 = 75
y1 = 330
def env_slider(param,x,y):
self.exp_slider(param,MAX_ENV_SEGMENT_TIME,x,y)
for v in "xy":
if v=='x':
y = y0
else:
y = y1
msb = self.msb("%slfo_ratio" % v, len(LFO_RATIOS),x0,y)
for i,r in enumerate(LFO_RATIOS):
n,d = r.numerator,r.denominator
if d == 1:
txt = "%d" % n
else:
txt = "%d/%d" % (n,d)
self.msb_aspect(msb,i,float(r),text=txt)
msb.update_aspect()
self.norm_slider("%slfo_wave" % v,x0+100,y)
self.linear_slider("%slfo_delay" % v,(0,MAX_LFO_DELAY),x0+160,y)
xenv = x0+220
env_slider("%senv_attack" % v,xenv,y)
env_slider("%senv_decay" % v, xenv+40,y)
self.norm_slider("%senv_sustain" % v, xenv+80,y)
env_slider("%senv_release" % v, xenv+120,y)
self.toggle("%senv_lfo_trig" % v,xenv,y+175)
xpos = xenv+180
self.linear_slider("%spos" % v, (-1,1),xpos,y)
self.linear_slider("%spos_%senv" % (v,v),(-1,1),xpos+60,y)
self.linear_slider("%spos_%slfo" % (v,v),(-1,1),xpos+120,y)
self.linear_slider("%spos_v%sbus" % (v,v),(-1,1),xpos+180,y)
self.volume_slider("%samp" % v,xpos+240,y)
self.volume_slider("amp",x0+720,(y0+y1)/2)
def __init__(self, master, app):
Frame.__init__(self, master)
self.config(background=factory.bg())
self.app = app
self.proxy = app.proxy
self.pack_propagate(False)
self.listbox = factory.listbox(self)
self.listbox.config(width=75, height=20)
sbv = factory.scrollbar(self, yclient=self.listbox)
sbh = factory.scrollbar(self,
xclient=self.listbox,
orientation=HORIZONTAL)
self.listbox.grid(row=0, column=0, rowspan=6, columnspan=8)
sbv.grid(row=0, column=8, rowspan=6, sticky=NS)
sbh.grid(row=6, column=0, columnspan=8, sticky=EW)
self.refresh()
def __init__(self, editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 900, 600, self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0,y1 = 50,364
x0 = 100
for i,d in enumerate("ABCD "):
x = x0 + (70 * i)
if d == ' ':
d == ''
x += 50
param = ("gain%s" % d).strip()
vs = self.volume_slider(param,x,y0,height=300)
self.mute_button(d, x,y1)
def __init__(self, master, app):
Frame.__init__(self, master)
self.app = app
self.proxy = app.proxy
self.config(background=factory.bg())
canvas = Canvas(self,
width=gconfig["graph-width"],
height=gconfig["graph-height"],
background=gconfig["graph-fill"])
self.canvas = canvas
info_canvas = InfoCanvas(self)
self.info_canvas = info_canvas
info_canvas.grid(row=0,column=0,rowspan=1,columnspan=1, sticky='wns')
canvas.grid(row=0,column=1,rowspan=1,columnspan=1, sticky='nsew')
self.grid_rowconfigure(0, weight=1)
self.grid_rowconfigure(1, weight=0)
self.grid_columnconfigure(0, weight=0)
self.grid_columnconfigure(1, weight=1)
# toolbar buttons
def tbutton(col, text, command=None):
bwidth=75
b = factory.button(self.canvas, text,command=command)
y0 = 15
x0 = 15
x = x0+col*bwidth
b.place(x=x,y=y0,width=bwidth)
tbutton(0, 'sync', self.sync)
tbutton(1, '+Audio', self.add_audio_bus)
tbutton(2, "+Control", self.add_control_bus)
tbutton(3, "Align", self.allign_tokens)
self.synth_tokens = {} # map [sid] -> SynthToken
self.audio_bus_tokens = {} # map [bus-name] -> BusToken
self.control_bus_tokens = {}
self.current_token_and_port = None # (token,port) dragdrop source
self.current_allied_ports = []
self._drag_data = {'x': 0,
'y': 0,
'anchor-x' : 0,
'anchor-y' : 0,
'port1' : None,
#'port2' : None,
'rubberband' : None}
canvas.bind("<B1-Motion>", self.bus_drag)
canvas.bind("<ButtonPress-1>", self.bus_drag_pickup)
canvas.bind("<ButtonRelease-1>", self.bus_drop)
def __init__(self, stack_id, name, imagefile, editor):
tab_image = "resources/Algo/tab_stack_%s.png" % stack_id.lower()
frame = editor.create_tab(name, tab_image)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1050, 700, imagefile)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, name)
editor.add_child_editor(name, self)
carrier = {"A": 1, "B": 5, "C": 7}[stack_id]
mod1 = {"A": 2, "B": 4, "C": 8}[stack_id]
mod2 = {"A": 3, "B": 6, "C": None}[stack_id]
self.layout_operator(carrier)
self.layout_operator(mod1)
if mod2: self.layout_operator(mod2)
self.layout_stack(stack_id, carrier)
def __init__(self,stack_id,editor):
name = "Env %s" % stack_id
image_file = "resources/Algo/envelope_editor_%s.png" % (stack_id.lower())
tab_image = "resources/Algo/tab_env_%s.png" % (stack_id.lower())
frame = editor.create_tab(name,tab_image)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1000, 700, image_file)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, name)
editor.add_child_editor(name, self)
carrier = {"A":1,"B":5,"C":7}[stack_id]
mod1 = {"A":2,"B":4,"C":8}[stack_id]
mod2 = {"A":3,"B":6,"C":None}[stack_id]
ec = ADDSREditor(canvas,
carrier,
self.coords(carrier),
(WIDTH,HEIGHT),
self.env_parameters(carrier),
self.editor,
acon.MAX_ENV_SEGMENT)
self.add_child_editor("OP%sENV" % carrier, ec)
ec.sync()
e1 = ADDSREditor(canvas,
mod1,
self.coords(mod1),
(WIDTH,HEIGHT),
self.env_parameters(mod1),
self.editor,
acon.MAX_ENV_SEGMENT)
self.add_child_editor("OP%sENV" % mod1, e1)
e1.sync()
if mod2:
e2 = ADDSREditor(canvas,
mod2,
self.coords(mod2),
(WIDTH,HEIGHT),
self.env_parameters(mod2),
self.editor,
acon.MAX_ENV_SEGMENT)
self.add_child_editor("OP%sENV" % mod2, e2)
e2.sync()
def __init__(self, master, app):
Toplevel.__init__(self, master)
self.config(background=factory.bg())
self.wm_title("Lliascript History")
self.app = app
self.filename = ""
toolbar = factory.frame(self)
south = factory.frame(self)
toolbar.pack(side=TOP, anchor=NW, expand=True, fill=X)
south.pack(anchor=SW, expand=True, fill=BOTH)
b_open = factory.button(toolbar,
"Open",
ttip="Open lliascript file",
command=self.open_lliascript_file)
b_save = factory.button(toolbar,
"Save",
ttip="Save lliascript file",
command=self.save_lliascript_file)
b_exec = factory.button(toolbar,
"Exec",
ttip="Execute text",
command=self.exec_)
b_compose = factory.button(toolbar,
"Compose",
ttip="Build script from current state",
command=self.compose_current_state)
b_help = factory.help_button(toolbar)
b_help.config(command=self.help_)
b_open.pack(side=LEFT, expand=True, fill=X)
b_save.pack(side=LEFT, expand=True, fill=X)
b_exec.pack(side=LEFT, expand=True, fill=X)
b_compose.pack(side=LEFT, expand=True, fill=X)
b_help.pack(side=LEFT, expand=True, fill=X)
self.text_widget = factory.text_widget(south, modal=True)
sb1 = factory.scrollbar(south)
sb2 = factory.scrollbar(south, orientation="horizontal")
sb1.config(command=self.text_widget.yview)
sb2.config(command=self.text_widget.xview)
self.text_widget.config(yscrollcommand=sb1.set)
self.text_widget.config(xscrollcommand=sb2.set)
self.text_widget.grid(row=0, column=0, rowspan=5, columnspan=5)
sb1.grid(row=0, column=5, rowspan=5, sticky=NS)
sb2.grid(row=5, column=0, columnspan=5, sticky=EW)
self._get_current_history()
self.grab_set()
self.mainloop()
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1000, 600, self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 75
x0 = 75
x1 = x0 + 160
xdelta = 75
x_tog_offset = -23
y_tog_offset = 160
self.tumbler("hold", 5, 0.001, x0, y0 + 160)
self.tumbler("clkfreq", 5, 0.001, x0, y0)
self.toggle("clksrc",
x0 + 7,
y0 + 40,
off=(0, "Internal"),
on=(1, "External"))
b_half_hold = factory.button(canvas, "1/2", self.half_hold_callback)
b_half_hold.place(x=x0 + 13, y=y0 + 194)
for i in range(6):
j = i + 1
x = x1 + i * xdelta
self.norm_slider("amp%d" % j, x, y0)
self.toggle("gate%d" % j,
x + x_tog_offset,
y0 + y_tog_offset,
off=[0, "On"],
on=[1, "Gate"])
xn = x + xdelta
self.norm_slider("ampn", xn, y0)
self.toggle("gaten",
xn + x_tog_offset,
y0 + y_tog_offset,
off=[0, "On"],
on=[1, "Gate"])
y_tumbler_n = y0 + y_tog_offset
self.tumbler("n", 2, 1, xn - 8, y_tumbler_n + 40)
xlag = x + 170
xscale = xlag + 60
xbias = xscale + 60
self.norm_slider("lag", xlag, y0)
self.norm_slider("scale", xscale, y0)
self.linear_slider("bias", (-4, 4), xbias, y0)
def __init__(self,stack_id,name,imagefile,editor):
tab_image = "resources/Algo/tab_stack_%s.png" % stack_id.lower()
frame = editor.create_tab(name,tab_image)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1050, 700, imagefile)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, name)
editor.add_child_editor(name, self)
carrier = {"A":1,"B":5,"C":7}[stack_id]
mod1 = {"A":2,"B":4,"C":8}[stack_id]
mod2 = {"A":3,"B":6,"C":None}[stack_id]
self.layout_operator(carrier)
self.layout_operator(mod1)
if mod2: self.layout_operator(mod2)
self.layout_stack(stack_id,carrier)
def __init__(self,editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,1000,700,self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self,canvas,editor,self.NAME)
editor.add_child_editor(self.NAME, self)
x0,y0 = 75,75
# Top row
x_in = x0
self.volume_slider("inputGain",x_in,y0)
x_env = x_in+90
self.linear_slider("envGain",(1,100),x_env,y0)
self.linear_slider("attack",(0,2),x_env+60,y0)
self.linear_slider("release",(0,2),x_env+120,y0)
x_clip = x_env+210
self.norm_slider("clipDrive",x_clip,y0)
self.norm_slider("clipLfo1",x_clip+60,y0)
self.norm_slider("clipMix",x_clip+120,y0)
x_filter = x_clip+210
for i,p in enumerate(("Freq","Env","Lfo2","Res","Mix")):
param = "filter%s" % p
x = x_filter+(60*i)
self.norm_slider(param,x,y0)
# 2nd row
y1 = 300
x_lfo = x_env
self.tumbler("lfo1Freq",5,0.001,x_lfo,y1)
self.norm_slider("lfo2Mod",x_lfo+120,y1)
self.tumbler("lfo2Freq",5,0.001,x_lfo+180,y1)
x_flanger = x_filter
for i,p in enumerate(("Delay1","Delay2","Lfo1","Feedback","Mix")):
param = "flanger%s" % p
x = x_flanger+(60*i)
if p != "Feedback":
self.norm_slider(param,x,y1)
else:
self.linear_slider(param,(-1,1),x,y1)
def __init__(self, master, parent_editor, synth):
Frame.__init__(self, master)
self.config(background=factory.bg())
self.parent_editor = parent_editor
self.synth = synth
self.app = synth.app
self.listbox = None
self._var_lock_current = StringVar()
north = self._init_north_toolbar()
center = self._init_list_frame()
perf_frame = self._init_performance_toolbar()
south = self._init_south_toolbar()
north.pack(pady=4, padx=4)
center.pack(expand=True, fill="both", padx=4, pady=4)
perf_frame.pack(padx=4, pady=4)
south.pack(padx=4, pady=4)
self.big_label = factory.big_label(self, "000 ABCDEFGH")
self.big_label.pack()
self.sync_no_propegate()
def __init__(self, master, parent_editor, synth):
print("DEPRECIATED: TkBusAndBufferEditor")
Frame.__init__(self, master)
self.parent_editor = parent_editor
self.synth = synth
self.config(background=factory.bg())
self.pack(anchor="nw", expand=True, fill="both")
main = layout.VFrame(self)
main.pack(anchor="nw", expand=True, fill="both")
frame_abus = factory.label_frame(main, "Audio Busses")
frame_cbus = factory.label_frame(main, "Control Busses")
frame_buf = factory.label_frame(main, "Buffers")
main.add(frame_abus, padx=8, pady=8)
main.add(frame_cbus, padx=8, pady=8)
main.add(frame_buf, padx=8, pady=8)
self.lab_abus = factory.label(frame_abus, "")
self.lab_abus.pack()
self.lab_cbus = factory.label(frame_cbus, "")
self.lab_cbus.pack()
self.lab_buffers = factory.label(frame_buf, "")
self.lab_buffers.pack()
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 660, 360, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 75
x0 = 75
self.exp_slider("cFreq",20000,x0,y0,degree=3)
self.exp_slider("cFreqLfo",2000,x0+60,y0,degree=3)
self.exp_slider("cFreqX",2000,x0+120,y0,degree=3)
x_res = x0+210
self.exp_slider("q", 100,x_res,y0,degree=3)
self.exp_slider("qLfo",100,x_res+60,y0,degree=3)
self.exp_slider("qX", 100,x_res+120,y0,degree=3)
x_out = x_res+210
self.linear_slider("filterGain",(-12,12),x_out,y0)
self.norm_slider("bleed",x_out+60,y0)
self.tumbler("lfoFreq",5,0.001,x0,y0+180)
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1000, 700, self.IMAGE_FILE)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 10
def y(n, delta=230):
return y0 + (n * delta)
y_lfo = y0 + 55
x0 = 75
for i, n in enumerate("abc"):
params = ("%sAttack" % n, "%sDecay1" % n, "%sDecay2" % n,
"%sRelease" % n, "%sBreakpoint" % n, "%sSustain" % n,
"%sTrigMode" % n)
ed = ADDSREditor(canvas, i, (x0, y(i)), (900, 230), params, editor)
self.add_child_editor("env_%s" % n, ed)
