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())
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, 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, 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,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())
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, 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,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, 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, 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, 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()
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,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,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, 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, 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_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,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, 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, 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, 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, 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__(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, 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, 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,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, 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,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, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 626, 562,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 = 50
x_delay = x0+90
x_sens = x_delay+60
x_depth = x_sens+60
x_xpitch = x_depth+90
x_xmod = x_xpitch+60
x_amp = x_xmod+90
def tumbler(param,digits,scale,x,y):
t = Tumbler(canvas,param,editor,digits=digits,scale=scale)
self.add_control(param,t)
t.layout((x,y))
return y
def norm_slider(param,x,y,height=150):
s = cf.normalized_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y,height=height)
return s
def linear_slider(param,range_,x,y,height=150):
s = cf.linear_slider(canvas,param,editor,range_=range_)
self.add_control(param,s)
s.widget().place(x=x,y=y,height=height)
return s
def volume_slider(param,x,y):
s = cf.volume_slider(canvas,param,editor)
self.add_control(param,s)
s.widget().place(x=x,y=y)
return s
tumbler("lfoFreq",5,0.001,x0,y0)
linear_slider("lfoDelay",(0,4),x_delay,y0)
norm_slider("vsens",x_sens,y0)
norm_slider("vdepth",x_depth,y0)
norm_slider("xPitch",x_xpitch,y0)
norm_slider("xModDepth",x_xmod,y0)
volume_slider("amp",x_amp,y0)
def __init__(self,editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,803,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_tab= x0
y_tab = y0
for i,param in enumerate(("reed16","reed8","flute8","flute4","flute3","flute2")):
msb = self.msb(param,3,x_tab,y_tab)
for j, value in enumerate(((0, "Off"),(1, "1"),(2,"2"))):
mag,label = value
self.msb_aspect(msb,j,mag,text=label)
x_tab += 65
if i==1: x_tab += 170
msb.update_aspect()
x_wave = x0 + 130
msb = self.msb("reedWave",2,x_wave,y_tab)
self.msb_aspect(msb,0,0.0,"Brass")
self.msb_aspect(msb,1,1.0,"Reed")
msb.update_aspect()
x_chorus = x_wave+65
self.toggle("chorus",x_chorus, y_tab,(0.0, "Off"),(1.0,"On"))
x_vib = x0
y_vib = 200
for i,param in enumerate(("vspeed","vdepth")):
msb = self.msb(param,3,x_vib,y_vib)
if i == 0:
plist = ((0.0, "Slow"),(0.5,"Med"),(1.0,"Fast"))
else:
plist = ((0.0, "Off"),(0.5, "Light"),(1.0, "Deep"))
for j,value in enumerate(plist):
mag,label = value
self.msb_aspect(msb,j,mag,text=label)
x_vib += 65
msb.update_aspect()
x_amp = x_tab+65
self.volume_slider("amp",x_amp,y_tab)
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__(self,editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,847,620,self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self,canvas,editor,self.NAME)
editor.add_child_editor(self.NAME, self)
x0 = 75
xmod = x0+100
xfb = xmod+130
xclip = xfb+240
xmix = xclip+130
y0 = 75
y1 = 340
for n,y in ((1,y0),(2,y1)):
def param(prefix):
return "%s%d" % (prefix,n)
self.tumbler(param("delayTime"),4,0.0001,x0,y)
msb = self.msb(param("lfoRatio"),len(LFO_RATIOS),x0-7,y+60)
for i,pair in enumerate(LFO_RATIOS):
value,text = pair
self.msb_aspect(msb,i,value,text=text)
msb.update_aspect()
# self.norm_slider(param("modDepth"),xmod,y)
# self.norm_slider(param("xmodDepth"),xmod+60,y)
self.exp_slider(param("modDepth"),1.0,xmod,y,degree=3)
self.exp_slider(param("xmodDepth"),1.0,xmod+60,y,degree=3)
self.linear_slider(param("feedback"),(-1,1),xfb,y)
self.linear_slider(param("xfeedback"),(-1,1),xfb+60,y)
self.exp_slider(param("lowcut"),16000,xfb+120,y,degree=3)
self.exp_slider(param("highcut"),16000,xfb+180,y,degree=3)
self.toggle(param("clipEnable"),xclip,y,off=(0,"Off"),on=(1,"On"))
self.linear_slider(param("clipGain"),(0,4),xclip,y+60,height=100)
self.norm_slider(param("clipThreshold"),xclip+47,y+60,height=100)
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,x0-14,y1+190)
def __init__(self, editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,1000,700)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self,canvas,editor,self.NAME)
self.mutation_object = self.synth.specs["mutation"]
self._strips = {}
for k,v in self.mutation_object.items():
strip = TkMutationStrip(canvas,v)
self._strips[k] = strip
self._var_fill_start = StringVar()
self._var_fill_start.set(127)
self._var_fill_end = StringVar()
self._var_fill_end.set(128)
self._var_progressive_fill = StringVar()
self._var_progressive_fill.set(0)
self._layout_common_widgets()
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, 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)
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()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
y0 = 50
y1 = 250
x0 = 100
x_port = x0
x_lfo = x_port + 90
x_delay = x_lfo
x_vsens = x_delay + 60
x_vdepth = x_vsens + 60
x_extern = x_vdepth + 90
x_xpitch = x_extern
x_xdepth = x_xpitch + 60
x_xscale = x_xdepth + 60
x_xbias = x_xscale + 60
x_amp = x_xbias + 90
self.norm_slider("port", x0, y0)
self.tumbler("lfoFreq", x_lfo, y1)
self.linear_slider("lfoDelay", (0, 4), x_delay, y0)
self.norm_slider("vsens", x_vsens, y0)
self.norm_slider("vdepth", x_vdepth, y0)
self.norm_slider("xPitch", x_xpitch, y0)
self.norm_slider("xModDepth", x_xdepth, y0)
self.linear_slider("xScale", (0, 4), x_xscale, y0)
self.linear_slider("xBias", (-4, 4), x_xbias, y0)
svol = cf.volume_slider(self.canvas, "amp", editor)
self.add_control("amp", svol)
svol.widget().place(x=x_amp, y=y0, width=14, height=150)
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,y1 = 75,75,300
x_delay = x0
for n in (1,2):
y = {1:y0,2:y1}[n]
ptime = "delay%dTime" % n
self.tumbler(ptime,4,0.001,x_delay,y,range_=(0,1000))
for i,p in enumerate(("Lfo","Feedback","XFeedback","Filter","Mix","Pan")):
if p == "Lfo":
param = "delay%dLfo%d" % (n,n)
elif p == "Filter":
if n==1:
param = "delay1Lowpass"
else:
param = "delay2Highpass"
else:
param = "delay%d%s" % (n,p)
x = x_delay+120+(i*60)
if p in ("Feedback","XFeedback","Pan"):
self.linear_slider(param,(-1,1),x,y)
else:
self.norm_slider(param,x,y)
x_reverb = x_delay+530
for i,p in enumerate(("RoomSize","Damping","Env","Lfo2","Mix")):
param = "reverb%s" % p
x = x_reverb+(i*60)
self.norm_slider(param,x,y0)
x_output = x_reverb+120
self.volume_slider("outputGain",x_output,y1)
def __init__(self,editor):
frame = editor.create_tab(self.NAME,self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,848,729,self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self,canvas,editor,self.NAME)
editor.add_child_editor(self.NAME, self)
x0,y0 = 75,75
# LFO
x_lfo = x0
x_wave = x_lfo + 100
x_depth = x_wave+60
x_xdepth = x_depth+60
y_tumbler = y0+50
self.tumbler("scanRate",5,0.001,x_lfo,y_tumbler)
self.norm_slider("wave",x_wave,y0)
#self.norm_slider("modDepth",x_depth,y0)
self.exp_slider("modDepth",1.0,x_depth,y0)
self.norm_slider("xmodDepth",x_xdepth,y0)
# Delay
x_delay = x_xdepth+90
x_feedback = x_delay+60
x_lowpass = x_feedback+60
self.linear_slider("delay",(0.0, 0.05),x_delay,y0)
self.linear_slider("feedback",(-0.99,0.99),x_feedback,y0)
self.exp_slider("lowpass",16000,x_lowpass,y0,degree=4)
# Mixer
x_dry = x_lowpass+90
x_wet1 = x_dry+60
x_wet2 = x_wet1+60
self.volume_slider("dryMix",x_dry,y0)
self.volume_slider("wet1Mix",x_wet1,y0)
self.volume_slider("wet2Mix",x_wet2,y0)
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, 900, 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 = 50
y1 = 250
x0 = 100
x_port = x0
x_lfo = x_port + 90
x_delay = x_lfo
x_vsens = x_delay + 60
x_vdepth = x_vsens + 60
x_extern = x_vdepth + 90
x_xpitch = x_extern
x_xdepth = x_xpitch + 60
x_xscale = x_xdepth + 60
x_xbias = x_xscale + 60
x_amp = x_xbias + 90
self.norm_slider("port", x0, y0)
self.tumbler("lfoFreq", x_lfo, y1)
self.linear_slider("lfoDelay", (0,4), x_delay, y0)
self.norm_slider("vsens", x_vsens, y0)
self.norm_slider("vdepth", x_vdepth, y0)
self.norm_slider("xPitch", x_xpitch, y0)
self.norm_slider("xModDepth", x_xdepth, y0)
self.linear_slider("xScale", (0,4), x_xscale, y0)
self.linear_slider("xBias", (-4,4), x_xbias, y0)
svol = cf.volume_slider(self.canvas, "amp", editor)
self.add_control("amp", svol)
svol.widget().place(x=x_amp, y=y0, width=14, height=150)
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 848, 729, self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
x0, y0 = 75, 75
# LFO
x_lfo = x0
x_wave = x_lfo + 100
x_depth = x_wave + 60
x_xdepth = x_depth + 60
y_tumbler = y0 + 50
self.tumbler("scanRate", 5, 0.001, x_lfo, y_tumbler)
self.norm_slider("wave", x_wave, y0)
self.norm_slider("modDepth", x_depth, y0)
self.norm_slider("xmodDepth", x_xdepth, y0)
# Delay
x_delay = x_xdepth + 90
x_feedback = x_delay + 60
x_lowpass = x_feedback + 60
self.linear_slider("delay", (0.0, 0.05), x_delay, y0)
self.linear_slider("feedback", (-0.99, 0.99), x_feedback, y0)
self.exp_slider("lowpass", 16000, x_lowpass, y0, degree=4)
# Mixer
x_dry = x_lowpass + 90
x_wet1 = x_dry + 60
x_wet2 = x_wet1 + 60
self.volume_slider("dryMix", x_dry, y0)
self.volume_slider("wet1Mix", x_wet1, y0)
self.volume_slider("wet2Mix", x_wet2, y0)
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)
s_lowcut = cf.third_octave_slider(frame, "lowcut", editor)
s_highcut = cf.third_octave_slider(frame, "highcut", editor)
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)
self.add_control("lowcut",s_lowcut)
self.add_control("highcut",s_highcut)
s_lowcut.widget().place(x=x_low, y=y0, height=200)
s_highcut.widget().place(x=x_high, 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, 1000, 650, 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 = 25
x0 = 75
dx = 200
size = (900, dx)
for i, prefix in enumerate(("op2", "efx", "op1")):
paramlist = []
for p in ("Attack", "Decay1", "Decay2", "Release", "Breakpoint",
"Sustain", "GateHold"):
paramlist.append("%s%s" % (prefix, p))
x = x0
y = y0 + (i * dx)
ed = ADDSREditor(canvas, i, (x, y), size, paramlist, editor)
self.add_child_editor(prefix, ed)
ed.sync()
def __init__(self,editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1000, 650, 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 = 25
x0 = 75
dx = 200
size = (900,dx)
for i,prefix in enumerate(("op2","efx","op1")):
paramlist = []
for p in ("Attack","Decay1","Decay2","Release","Breakpoint",
"Sustain","GateHold"):
paramlist.append("%s%s" % (prefix,p))
x = x0
y = y0+(i*dx)
ed = ADDSREditor(canvas,i,(x,y),size,paramlist,editor)
self.add_child_editor(prefix,ed)
ed.sync()
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, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame,1018,663,self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
def ratio_msb(param,x,y):
count = len(HARMONICS)
msb = MSB(canvas,param,editor,count)
for i,p in enumerate(HARMONICS):
v,text = p
d = _msb_aspect(v,text)
msb.define_aspect(i,v,d)
self.add_control(param,msb)
msb.layout((x,y))
msb.update_aspect()
return msb
tumbler = Tumbler(canvas,"lfoFreq",editor, digits=5, scale=0.001)
s_scale = cf.linear_slider(canvas, "lfoScale", editor, range_=(0,4))
s_bias = cf.linear_slider(canvas, "lfoBias", editor, range_=(-4,4))
s_fm = cf.linear_slider(canvas, "lfoFM", editor, range_=(0, 8))
s_am = cf.normalized_slider(canvas, "lfoAM", editor)
s_delay = ExpSlider(canvas, "lfoDelay", editor, range_=8)
s_attack = ExpSlider(canvas, "lfoAttack", editor, range_=8)
s_hold = ExpSlider(canvas, "lfoHold", editor, range_=8)
s_release = ExpSlider(canvas, "lfoRelease", editor, range_=8)
s_env_fm = cf.linear_slider(canvas, "lfoEnvToFreq", editor, range_=(0,8))
s_env_bleed = cf.normalized_slider(canvas, "lfoBleed", editor)
s_amp_a = cf.normalized_slider(canvas, "lfoAmpA", editor)
s_amp_b = cf.normalized_slider(canvas, "lfoAmpB", editor)
s_amp_c = cf.normalized_slider(canvas, "lfoAmpC", editor)
self.add_control("lfoFreq", tumbler)
self.add_control("lfoScale", s_scale)
self.add_control("lfoBias", s_bias)
self.add_control("lfoFM", s_fm)
self.add_control("lfoAM", s_am)
self.add_control("lfoDelay", s_delay)
self.add_control("lfoAttack", s_attack)
self.add_control("lfoHold", s_hold)
self.add_control("lfoRelease", s_release)
self.add_control("lfoEnvToFreq", s_env_fm)
self.add_control("lfoBleed", s_env_bleed)
self.add_control("lfoAmpA", s_amp_a)
self.add_control("lfoAmpB", s_amp_b)
self.add_control("lfoAmpC", s_amp_c)
y0, y1 = 90, 350
x0 = 90
x1 = x0 + 140
x2 = x1 + 60
x_mod = x2 +60
x_fm = x_mod + 75
x_am = x_fm + 60
x_delay = x_am + 90
x_attack = x_delay + 60
x_hold = x_attack + 60
x_release = x_hold + 60
x_env_fm = x_release + 60
x_bleed = x_env_fm + 60
x_a = x0
x_b = x_a + 150
x_c = x_b + 150
ratio_msb("lfoModFreq", x_mod,y0)
ratio_msb("lfoRatioA", x_a, y1)
ratio_msb("lfoRatioB", x_b, y1)
ratio_msb("lfoRatioC", x_c, y1)
tumbler.layout((x0+13,y0+30))
s_scale.widget().place(x=x1, y=y0)
s_bias.widget().place(x=x2, y=y0)
s_fm.widget().place(x=x_fm, y=y0)
s_am.widget().place(x=x_am, y=y0)
s_delay.layout(offset=(x_delay, y0),checkbutton_offset=None)
s_attack.layout(offset=(x_attack, y0),checkbutton_offset=None)
s_hold.layout(offset=(x_hold, y0),checkbutton_offset=None)
s_release.layout(offset=(x_release, y0),checkbutton_offset=None)
s_env_fm.widget().place(x=x_env_fm, y=y0)
s_env_bleed.widget().place(x=x_bleed, y=y0)
s_amp_a.widget().place(x=x_a+75, y=y1)
s_amp_b.widget().place(x=x_b+75, y=y1)
s_amp_c.widget().place(x=x_c+75, y=y1)
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)
cfill = "black"
cforeground = "#c79fa1"
coutline = "blue"
csfill = "#005c56"
csforeground = "white"
y0 = 0
ysliders = y0 + 192
ywave = y0 + 128
yclock = ywave
yfilter = yclock
yrsenable = y0 + 200
x0 = 75
xgain = x0 + 60
xwave = x0 + 143
xclock = xwave + 100
xfilter = xclock + 100
xefx = xgain + 395
xdry = xgain + 455
def volume_slider(param, x, y):
s = cf.volume_slider(canvas, param, editor)
self.add_control(param, s)
s.widget().place(x=x, y=y)
return s
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)
return s
linear_slider("gain", (0, 8), xgain, ysliders)
msb_wave = MSB(canvas, "wave", editor, 5)
for i, tx in enumerate(("Off", "Soft", "Clip", "Fold", "Wrap")):
d = {
"fill": cfill,
"foreground": cforeground,
"outline": coutline,
"value": i,
"text": tx
}
msb_wave.define_aspect(i, i, d)
msb_wave.layout((xwave, ywave))
msb_wave.update_aspect()
msb_clock = MSB(canvas, "clockFreq", editor, len(CLOCK_FREQS))
for i, freq in enumerate(CLOCK_FREQS):
ad = {
"fill": cfill,
"foreground": cforeground,
"outline": coutline,
"text": str(freq),
"value": freq
}
msb_clock.define_aspect(i, freq, ad)
self.add_control("clockFreq", msb_clock)
msb_clock.layout((xclock, yclock))
msb_clock.update_aspect()
msb_filter = MSB(canvas, "low", editor, len(LP_FREQS))
for i, freq in enumerate(LP_FREQS):
ad = {
"fill": cfill,
"foreground": cforeground,
"outline": coutline,
"text": str(freq),
"value": freq
}
msb_filter.define_aspect(i, freq, ad)
self.add_control("low", msb_filter)
msb_filter.layout((xfilter, yfilter))
msb_filter.update_aspect()
volume_slider("wet", xefx, ysliders)
volume_slider("dry", xdry, ysliders)
tog_rs_enable = ToggleButton(canvas,
"resampleEnable",
editor,
fill=cfill,
foreground=cforeground,
outline=coutline,
selected_fill=csfill,
selected_foreground=csforeground,
text=["Off", "On"],
values=[0, 1])
self.add_control("resampleEnable", tog_rs_enable)
tog_rs_enable.layout((xclock, yrsenable))
tog_rs_enable.update_aspect()
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 = [50,275]
x0 = 100
xdelay = x0 + 180
xmod = xdelay+90
xfeedback = xmod+120
xeq = xfeedback+60
xmixer = xeq+150
def add_slider(param,s,x,y,width=14,height=150):
self.add_control(param,s)
s.widget().place(x=x,y=y,width=width,height=height)
def amp_slider(param,x,y):
s = cf.volume_slider(canvas,param,editor)
add_slider(param,s,x,y)
def bipolar_slider(param,x,y, width=14, height=150):
s = cf.bipolar_slider(canvas,param,editor)
add_slider(param,s,x,y,width,height)
def eq_slider(param,x,y):
s = cf.third_octave_slider(canvas,param,editor)
add_slider(param,s,x,y)
def norm_slider(param,x,y):
s = cf.normalized_slider(canvas,param,editor)
add_slider(param,s,x,y)
def linear_slider(param,x,y,range_=(0.0,1.0)):
s = cf.linear_slider(canvas,param,editor,range_=range_)
add_slider(param,s,x,y)
for i in (0,1):
n = i+1
for j, p in enumerate(('d%dDry1In','d%dDry2In')):
x = x0 + j*60
param = p % n
amp_slider(param,x,y[i])
amp_slider('d2Delay1In',x0+60*2, y[1])
param = 'd%dDelayTime' % n
tumbler_delay = Tumbler(canvas, param, editor,
sign=False, digits=4,scale = 0.001,
range_ = (0,2000))
self.add_control(param,tumbler_delay)
tumbler_delay.layout((xdelay, y[i]))
param = 'd%dLfoRatio' % n
msb_lfo_ratio = MSB(canvas,param,editor,len(LFO_RATIOS))
self.add_control(param, msb_lfo_ratio)
for k,pair in enumerate(LFO_RATIOS):
adict = {'text' : pair[0],
'font' : ('Times', 12),
'fill' : 'black',
'foreground' : 'white',
'outline' : 'white',
'active-fill' : 'black',
'active-foreground' : 'yellow',
'active-outline' : 'yellow'}
msb_lfo_ratio.define_aspect(k,pair[1],adict)
msb_lfo_ratio.layout((xdelay, y[i]+75))
msb_lfo_ratio.update_aspect()
norm_slider('d%dLfoModDepth' % n, xmod,y[i])
norm_slider('d%dExternalModDepth' % n, xmod+60,y[i])
bipolar_slider('d%dFeedback' % n, xfeedback,y[i])
eq_slider('d%dLowpass' % n, xeq,y[i])
eq_slider('d%dHighpass' % n, xeq+60,y[i])
# Mixer
amp_slider("dry1Amp", xmixer, y[0])
amp_slider("dry2Amp", xmixer+60, y[0])
amp_slider("d1Amp", xmixer+120, y[0])
amp_slider("d2Amp", xmixer+180, y[0])
bipolar_slider("dry1Pan", xmixer, y[1],height=75)
bipolar_slider("dry2Pan", xmixer+60, y[1],height=75)
bipolar_slider("d1Pan", xmixer+120, y[1],height=75)
bipolar_slider("d2Pan", xmixer+180, y[1],height=75)
msb_lfo_preset = MSB(canvas,"",None,7)
for i in range(len(msb_lfo_preset)):
adict = {'fill' : 'black',
'foreground' : 'white',
'outline' : 'white',
'active-fill' : 'black',
'active-foregeround' : 'yellow',
'active-outline' : 'yellow',
'text' : str(i+1),
'fomt' : ('Times', 8)}
msb_lfo_preset.define_aspect(i,i+1,adict)
msb_lfo_preset.layout((xmixer+160, y[1]+143),width=18,height=18)
msb_lfo_preset.update_aspect()
def lfo_preset_freq(*_):
v = msb_lfo_preset.value()
synth = self.editor.synth
synth.x_param_change("lfoCommonFreq",v)
synth.bank()[None]["lfoCommonFreq"] = float(v)
tumbler_lfo.value(v)
msb_lfo_preset.tag_bind("<Button-1>", lfo_preset_freq)
msb_lfo_preset.tag_bind("<Button-3>", lfo_preset_freq)
tumbler_lfo = Tumbler(canvas,"lfoCommonFreq",editor,
sign=False,digits=5, scale=0.001,
range_=(0,16999))
self.add_control("lfoCommonFreq", tumbler_lfo)
tumbler_lfo.layout((xmixer+60, y[1]+143))
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)
y0 = 75
y1 = y0+60
y2 = y1+60
y3 = y2+70
x0=90
x1 = x0+100
x2 = x1+60
x3 = x2+60
x4 = x3+60
x5 = x4+75
x6 = x5+60
xlfo = x6+75
xmix = x6+196
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)
return s
def bipolar_slider(param, x, y, height=150):
s = cf.bipolar_slider(canvas, param, editor)
self.add_control(param,s)
s.widget().place(x=x,y=y,height=height)
return s
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)
return s
def linear_slider(param, x, y, range_):
s = cf.linear_slider(canvas, param, editor, range_=range_)
self.add_control(param,s)
s.widget().place(x=x,y=y)
return s
msb_xover = MSB(canvas,"xover",editor,len(xcon.CROSSOVER_FREQUENCIES))
for i,v in enumerate(xcon.CROSSOVER_FREQUENCIES):
d = _msb_aspect(v,str(v))
msb_xover.define_aspect(i,v,d)
self.add_control("xover", msb_xover)
msb_xover.layout((x0,y0))
msb_xover.update_aspect()
msb_maxxover = MSB(canvas,"maxXover",editor,len(xcon.CROSSOVER_FREQUENCIES))
for i,v in enumerate(xcon.CROSSOVER_FREQUENCIES):
d = _msb_aspect(v,str(v))
msb_maxxover.define_aspect(i,v,d)
self.add_control("maxXover", msb_maxxover)
msb_maxxover.layout((x0,y1))
msb_maxxover.update_aspect()
msb_minxover = MSB(canvas,"minXover",editor,len(xcon.CROSSOVER_FREQUENCIES))
for i,v in enumerate(xcon.CROSSOVER_FREQUENCIES):
d = _msb_aspect(v,str(v))
msb_minxover.define_aspect(i,v,d)
self.add_control("minXover",msb_minxover)
msb_minxover.layout((x0,y2))
msb_minxover.update_aspect()
norm_slider("lfoToXover", x1,y0)
msb_lforatio = MSB(canvas,"lfo2Ratio",editor,len(xcon.LFO_RATIOS))
for i,p in enumerate(xcon.LFO_RATIOS):
ratio, text = p
d = _msb_aspect(ratio,text)
msb_lforatio.define_aspect(i,ratio,d)
self.add_control("lfo2Ratio", msb_lforatio)
msb_lforatio.layout((x1-22,y3))
msb_lforatio.update_aspect()
norm_slider("lfo2Wave",x2,y0)
norm_slider("externToXover",x3,y0)
norm_slider("res",x4,y0)
norm_slider("filterBMix",x5,y0)
norm_slider("filterBLag",x6,y0)
msb_b_ratio = MSB(canvas,"filterBRatio",editor,len(xcon.FILTER_B_RATIOS))
for i,p in enumerate(xcon.FILTER_B_RATIOS):
ratio,text = p
d = _msb_aspect(ratio,text)
msb_b_ratio.define_aspect(i,ratio,d)
self.add_control("filterBRatio", msb_b_ratio)
msb_b_ratio.layout((x5+6,y3))
msb_b_ratio.update_aspect()
tumbler = Tumbler(canvas,"lfoFreq",editor,digits=4,scale=0.01)
self.add_control("lfoFreq", tumbler)
tumbler.layout((xlfo, y1))
msb_lfo_enable = ToggleButton(canvas,"lfoEnable",editor,
fill='',foreground='#c29378',outline='#c29378',
active_color='yellow',
selected_fill='#825151', selected_foreground='white')
self.add_control("lfoEnable",msb_lfo_enable)
msb_lfo_enable.layout((xlfo, y2))
msb_lfo_enable.update_aspect()
amp_slider("dryAmp", xmix, y0)
amp_slider("filterAAmp", xmix+60, y0)
amp_slider("filterBAmp", xmix+120, y0)
amp_slider("amp", xmix+180,y0)
bipolar_slider("dryPan", xmix, y3)
bipolar_slider("filterAPan", xmix+60, y3)
bipolar_slider("filterBPan", xmix+120, y3)
linear_slider("xscale", xlfo-7, y3, (0,4))
linear_slider("xbias", xlfo+53, y3, (-4,4))
def __init__(self, editor):
name = "Misc"
image_file = "resources/Corvus/editor_misc.png"
tab_file = "resources/Tabs/misc.png"
frame = editor.create_tab(name, tab_file)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1000, 750, image_file)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, name)
editor.add_child_editor(name, self)
self.op = n
y0 = 50
y_msb = 230
x0 = 50
x_port = x0
x_vib = x_port + 90
x_vdelay = x_vib + 90
x_vsens = x_vdelay + 60
x_vdepth = x_vsens + 60
x_xpitch = x_vdepth + 60
x_lfo1 = x_xpitch + 90
x_lfo2 = x_lfo1 + 90
x_amp = x_lfo2 + 90
def norm_slider(param, x, y, height=150):
s = cf.normalized_slider(canvas, param, editor)
self.add_control(param, s)
s.widget().place(x=x, y=y, height=height)
return s
def volume_slider(param, x, y, height=150):
s = cf.volume_slider(canvas, param, editor)
self.add_control(param, s)
s.widget().place(x=x, y=y, height=height)
return s
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)
return s
def tumbler(param, digits, scale, x, y):
t = Tumbler(canvas, param, editor, digits=digits, scale=scale)
self.add_control(param, t)
t.layout((x, y))
t.update_aspect()
return t
def msb_ratio(n, x):
param = "lfo%d_ratio" % n
count = len(LFO_RATIOS)
msb = MSB(canvas, param, editor, count)
for i, pair in enumerate(LFO_RATIOS):
value, txt = pair
d = {
"fill": CFILL,
"foreground": CFOREGROUND,
"outline": COUTLINE,
"value": value,
"text": txt
}
msb.define_aspect(i, value, d)
self.add_control(param, msb)
msb.layout((x, y_msb))
msb.update_aspect()
return msb
norm_slider("port", x_port, y0)
tumbler("vfreq", 5, 0.001, x_vib, y0)
linear_slider("vdelay", (0, 4), x_vdelay, y0)
norm_slider("vsens", x_vsens, y0)
norm_slider("vdepth", x_vdepth, y0)
norm_slider("xpitch", x_xpitch, y0)
linear_slider("lfo1_delay", (0, 4), x_lfo1, y0)
msb_ratio(1, x_lfo1 - 22)
linear_slider("lfo2_delay", (0, 4), x_lfo2, y0)
msb_ratio(2, x_lfo2 - 22)
volume_slider("amp", x_amp, y0)
y_penv = 375
y_buttons = y_penv + 200
x_penv = x0
for a in (0, 1, 2, 3, 4):
x = x_penv + a * 60
linear_slider("pe_a%d" % a, (-1.0, 1.0), x, y_penv)
x += 60
for t in (1, 2, 3, 4):
x = x + 60
linear_slider("pe_t%d" % t, (0, MAX_ENV_SEGMENT), x, y_penv)
x += 60
x_send = x
for i in (1, 2, 3, 4):
x += 60
linear_slider("op%d_pe" % i, (-1, 1), x, y_penv)
count = len(PENV_HOLD_NODES)
msb_loop = MSB(canvas, "pe_loop", editor, count)
for i, v in enumerate(PENV_LOOP_NODES):
d = {
"fill": CFILL,
"foreground": CFOREGROUND,
"outline": COUTLINE,
"value": v,
"text": str(v)
}
msb_loop.define_aspect(i, v, d)
self.add_control("pe_loop", msb_loop)
msb_loop.layout((x_penv, y_buttons))
msb_loop.update_aspect()
def zero_levels():
for a in (0, 1, 2, 3, 4):
p = "pe_a%d" % a
self.set_value(p, 0.0)
self.sync()
def zero_sends():
for a in (1, 2, 3, 4):
p = "op%d_pe" % a
self.set_value(p, 0.0)
self.sync()
b1 = factory.button(canvas, "0", command=zero_levels)
b1.place(x=x_penv + 120, y=y_buttons)
b2 = factory.button(canvas, "0", command=zero_sends)
b2.place(x=x_send + 49, y=y_buttons)
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 770,654, 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_slider = 75
x0 = 75
x_bias_offset = 60
slider_width=14
slider_height = 300
def scale_slider(param, x):
s = cf.linear_slider(canvas,param,self.editor,range_=(-4.0, 4.0))
self.add_control(param,s)
s.widget().place(x=x,y=y_slider,
width=slider_width,
height=slider_height)
return s
def bias_slider(param, x):
s = cf.linear_slider(canvas,param,self.editor,range_=(-4.0,4.0))
self.add_control(param,s)
s.widget().place(x=x+x_bias_offset,y=y_slider,
width=slider_width,
height=slider_height)
return s
def mute_button(param, x):
b = MSB(canvas,param,self.editor,2)
aoff = {'fill' : 'black',
'foreground' : 'gray',
'outline' : 'gray',
'text' : 'Mute'}
aon = {'fill' : '#002e00',
'foreground' : 'white',
'outline' : '#096c00',
'text' : 'Mute'}
b.define_aspect(0, 0, aoff)
b.define_aspect(1, 1, aon)
self.add_control(param,b)
x = x + 8
y = y_slider + slider_height + 40
b.layout(offset = (x,y))
b.update_aspect()
return b
x_diff = 130
for i,p in enumerate("ABCD"):
x = x0 + i*x_diff
scale_slider("scale%s" % p, x)
bias_slider("bias%s" % p, x)
mute_button("mute%s" % p, x)
x_master = 600
scale_slider("masterScale", x_master)
bias_slider("masterBias", x_master)
mute_button("masterMute", x_master)
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 966, 433, self.IMAGE_FILE)
canvas.pack()
TkSubEditor.__init__(self, canvas, editor, self.NAME)
editor.add_child_editor(self.NAME, self)
SLIDER_HEIGHT = 200
y0 = 75
y_tumbler = y0
y_msb = y0 + SLIDER_HEIGHT + 40
x0 = 75
xsine = x0 + 160
xsaw = xsine + 90
xpulse = xsaw + 150
xdelay = xpulse + 150
def tumbler(param, x):
t = Tumbler(canvas,
param,
editor,
digits=5,
scale=0.001,
fill='#140e23',
foreground='#8f94a9',
outline='#8f94a9')
self.add_control(param, t)
t.layout((x, y_tumbler))
return t
def msb(param, x):
b = MSB(canvas, param, editor, len(FREQ_RATIOS))
self.add_control(param, b)
b.layout((x, y_msb))
for i, r in enumerate(FREQ_RATIOS):
value = float(r[0])
txt = r[1]
adict = {
'value': value,
'text': txt,
'fill': '#13302d',
'foreground': '#8f94a9',
'outline': '#8f94a9'
}
b.define_aspect(i, value, adict)
b.update_aspect()
def norm(param, x):
s = cf.normalized_slider(canvas, param, editor)
self.add_control(param, s)
s.widget().place(x=x, y=y0, height=SLIDER_HEIGHT)
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, height=SLIDER_HEIGHT)
return s
tumbler("lfoFreq", x0)
msb("sineRatio", xsine - 23)
norm("sineAmp", xsine)
msb("sawRatio", xsaw + 7)
norm("sawAmp", xsaw)
norm("sawWidth", xsaw + 60)
msb("pulseRatio", xpulse + 7)
norm("pulseAmp", xpulse)
norm("pulseWidth", xpulse + 60)
linear_slider("lfoDelay", xdelay, (0, 4))
linear_slider("lfoHold", xdelay + 60, (0, 4))
norm("lfoBleed", xdelay + 120)
linear_slider("lfoScale", xdelay + 195, (-1, 1))
linear_slider("lfoBias", xdelay + 255, (-4, 4))
def __init__(self, n, editor):
name = "OP%d" % n
image_file = "resources/Corvus/editor_%d.png" % n
tab_file = "resources/Corvus/tab_%d.png" % n
frame = editor.create_tab(name, tab_file)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 1053, 663, image_file)
canvas.pack()
self.canvas = canvas
self.editor = editor
TkSubEditor.__init__(self, canvas, editor, name)
editor.add_child_editor(name, self)
self.op = n
y0 = 50
y_carrier = y0
y_mod = y_carrier
y_env = y0 + 250
x0 = 50
x_fm = x0
x_mod_lfo1 = x_fm + 100
x_mod_lfo2 = x_mod_lfo1 + 60
x_mod_external = x_mod_lfo2 + 60
x_mod_keyscale = x_mod_lfo2 + 100
x_mod_amp = x_mod_keyscale + 87
x_carrier = x_mod_amp + 100
x_ratio = x_carrier
x_velocity = x_ratio + 120
x_lfo1 = x_velocity + 60
x_lfo2 = x_lfo1 + 60
x_external = x_lfo2 + 60
x_keyscale = x_external + 60
x_enable = x_keyscale + 90
x_env = x0 - 22
def norm_slider(param, x, y, height=150):
s = cf.normalized_slider(canvas, param, editor)
self.add_control(param, s)
s.widget().place(x=x, y=y, height=height)
return s
def volume_slider(param, x, y, height=150):
s = cf.volume_slider(canvas, param, editor)
self.add_control(param, s)
s.widget().place(x=x, y=y, height=height)
return s
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)
return s
def tumbler(param, digits, scale, x, y):
t = Tumbler(canvas, param, editor, digits=digits, scale=scale)
self.add_control(param, t)
t.layout((x, y))
t.update_aspect()
return t
def msb_keyscale(param, x, y):
count = len(KEYSCALES)
msb = MSB(canvas, param, editor, count)
for i, s in enumerate(KEYSCALES):
d = {
"fill": CFILL,
"foreground": CFOREGROUND,
"outline": COUTLINE,
"value": s,
"text": "%+d" % s
}
msb.define_aspect(i, s, d)
self.add_control(param, msb)
msb.layout((x, y))
msb.update_aspect()
return msb
def msb_keybreak(param, x, y):
count = len(KEYBREAK)
msb = MSB(canvas, param, editor, count)
for i, s in enumerate(KEYBREAK):
d = {
"fill": CFILL,
"foreground": CFOREGROUND,
"outline": COUTLINE,
"value": s,
"text": "%d" % s
}
msb.define_aspect(i, s, d)
self.add_control(param, msb)
msb.layout((x, y))
msb.update_aspect()
return msb
def msb_modscale(param, x, y):
count = len(MODSCALES)
msb = MSB(canvas, param, editor, count)
for i in MODSCALES:
j = i + 1
value = 10**i
d = {
"fill": CFILL,
"foreground": CFOREGROUND,
"outline": COUTLINE,
"value": value,
"text": "x%d" % j
}
msb.define_aspect(i, value, d)
self.add_control(param, msb)
msb.layout((x, y))
msb.update_aspect()
tumbler("fm%d_ratio" % n, 5, 0.001, x_fm, y_mod)
norm_slider("fm%d_lfo1" % n, x_mod_lfo1, y_mod)
norm_slider("fm%d_lfo2" % n, x_mod_lfo2, y_mod)
norm_slider("fm%d_external" % n, x_mod_external, y_mod)
msb_keyscale("fm%d_left" % n, x_mod_keyscale, y_mod)
msb_keyscale("fm%d_right" % n, x_mod_keyscale, y_mod + 70)
msb_modscale("fm%d_modscale" % n, x_mod_amp, y_mod)
norm_slider("fm%d_moddepth" % n,
x_mod_amp + 24,
y_mod + 50,
height=100)
norm_slider("fm%d_lag" % n, x_fm + 30, y_mod + 75, height=75)
tumbler("op%d_ratio" % n, 5, 0.001, x_ratio + 8, y_carrier)
tumbler("op%d_bias" % n, 6, 0.001, x_ratio, y_carrier + 75)
norm_slider("op%d_velocity" % n, x_velocity, y0)
norm_slider("op%d_lfo1" % n, x_lfo1, y0)
norm_slider("op%d_lfo2" % n, x_lfo2, y0)
norm_slider("op%d_external" % n, x_external, y0)
msb_keyscale("op%d_left" % n, x_keyscale, y0)
msb_keyscale("op%d_right" % n, x_keyscale, y0 + 70)
msb_keybreak("op%d_key" % n, x_keyscale, y0 + 140)
penable = "op%d_enable" % n
msb_enable = ToggleButton(canvas,
penable,
editor,
fill=CFILL,
foreground=CFOREGROUND,
outline=COUTLINE,
text=["Off", "Enabled"])
self.add_control(penable, msb_enable)
msb_enable.layout((x_enable, y0))
msb_enable.update_aspect()
volume_slider("op%d_amp" % n, x_enable + 24, y0 + 50, height=100)
env_parameters = []
for s in ("attack", "decay1", "decay2", "release", "breakpoint",
"sustain", "env_mode"):
p = "op%d_%s" % (n, s)
env_parameters.append(p)
enved = ADDSREditor(canvas, n, (x_env, y_env), (800, 350),
env_parameters, editor, MAX_ENV_SEGMENT)
self.add_child_editor("OP%dENV" % n, enved)
enved.sync()
y_extra = y_env + 30
x_extra = x0 + 800
if n == 3:
# Add exgtra noise controls
count = len(NOISE_BANDWIDTHS)
msb = MSB(canvas, "nse3_bw", editor, count)
for i, v in enumerate(NOISE_BANDWIDTHS):
d = {
"fill": CFILL,
"foreground": CFOREGROUND,
"outline": COUTLINE,
"value": v,
"text": str(v)
}
msb.define_aspect(i, v, d)
self.add_control("nse3_bw", msb)
msb.layout((x_extra, y_extra))
msb.update_aspect()
norm_slider("nse3_mix", x_extra + 24, y_extra + 75)
if n == 4:
# Add buzz controls
x_n = x_extra + 16
x_env = x_n + 60
x_lfo = x_env + 60
x_lag = x_env
x_mix = x_lag + 60
linear_slider("bzz4_n", (1, 128), x_n, y_extra)
linear_slider("bzz4_env", (-128, 128), x_env, y_extra)
linear_slider("bzz4_lfo2", (0, 128), x_lfo, y_extra)
norm_slider("bzz4_lag", x_lag, y_extra + 200, height=100)
norm_slider("bzz4_mix", x_mix, y_extra + 200, height=100)
def __init__(self, editor):
frame = editor.create_tab(self.NAME, self.TAB_FILE)
frame.config(background=factory.bg())
canvas = factory.canvas(frame, 760, 708, 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
xres = x0 + 75
xenv = xres + 90
xattack = xenv + 75
xxmod = xattack + 208
xout = xxmod + 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 volume_slider(param, x): # auto build indent, mover 1->
s = cf.volume_slider(canvas, param, editor)
self.add_control(param, s)
s.widget().place(x=x, y=y0)
return s
def linear_slider(param, range_, x): # auto build indent, mover 1->
s = cf.linear_slider(canvas, param, editor,
range_=range_) # auto build missing closing )
self.add_control(param, s)
s.widget().place(x=x, y=y0)
return s
def bipolar_slider(param, x):
return linear_slider(param, (-1.0, +1.0), x)
cfill = "black"
cforeground = "#aae1aa"
coutline = "blue"
msb_filter = MSB(canvas, "filterFreq", editor, len(FILTER_FREQUENCIES))
for i, ff in enumerate(FILTER_FREQUENCIES):
d = {
"value": int(ff),
"fill": cfill,
"foreground": cforeground,
"outline": coutline,
"text": str(ff)
}
msb_filter.define_aspect(i, ff, d)
self.add_control("filterFreq", msb_filter)
msb_filter.layout((x0, y0))
msb_filter.update_aspect()
msb_gain = MSB(canvas, "pregain", editor, len(GAINS))
for i, g in enumerate(GAINS):
val, tx = g
d = {
"value": float(val),
"fill": cfill,
"foreground": cforeground,
"outline": coutline,
"text": tx
}
msb_gain.define_aspect(i, float(val), d)
self.add_control("pregain", msb_gain)
msb_gain.layout((xenv, y0))
msb_gain.update_aspect()
norm_slider("res", xres)
linear_slider("attack", (0.01, 4.0), xattack)
linear_slider("release", (0.01, 4.0), xattack + 60)
bipolar_slider("modDepth", xattack + 120)
bipolar_slider("xmod", xxmod)
volume_slider("dryamp", xout)
volume_slider("wetamp", xout + 60)
