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_gate_button(self):
msb = ToggleButton(self.canvas, self.params['gate-mode'],
self.parent,
text=["Gate", "Trig"],
values=[0,1])
x, y = self.xi0, self.y1-50
msb.layout((x,y))
msb.update_aspect()
self.msb_gate_mode = msb
def msb_enable(self,param,x,y):
msb = ToggleButton(self.canvas,param,self.editor,
text = ["Off","On"],
fill=acon.CFILL,
foreground=acon.CFOREGROUND,
outline=acon.COUTLINE)
self.add_control(param,msb)
msb.layout((x,y))
msb.update_aspect()
return msb
def __init__(self,canvas,param,editor,
sign=False,digits=4,scale=1.0,
range_ = None,
fill = 'black',
foreground = 'white',
outline = 'white',
active_color = 'yellow',
font = ('Times',10)):
'''
Tumbler combines several MSB buttons into a single compost control
for numeric values.
'''
self.canvas = canvas
self.param=param
self.editor = editor
#self._range = range_ or (0,10**digits-1)
if not range_:
mag = 10**digits-1
if sign:
range_ = (-mag,mag)
else:
range_ = (0,mag)
self._range = range_
self._common_aspect = {"fill" : fill,
"foreground" : foreground,
"outline" : outline,
"active-fill" : fill,
"active-foreground" : active_color,
"active-outline" : active_color,
"font" : font}
self.scale = float(scale)
self.has_sign = sign
self._msb_sign = ToggleButton(canvas,"",None,
text=["-","+"],
values=[-1,1])
self._msb_sign.tag_bind("<Button-1>", self._callback)
self._msb_sign.tag_bind("<Button-3>", self._callback)
acc = []
for i in range(digits):
msb = MSB.digit_msb(canvas,"",None,
font = self._common_aspect['font'],
fill = self._common_aspect['fill'],
foreground = self._common_aspect['foreground'],
outline = self._common_aspect['outline'],
active_fill = self._common_aspect['fill'],
active_foreground = self._common_aspect['active-foreground'],
active_outline = self._common_aspect['active-outline'])
msb.tag_bind("<Button-1>", self._callback)
msb.tag_bind("<Button-3>", self._callback)
msb.weight = (10**i)
acc.append(msb)
acc.reverse()
self._digits = acc
def toggle(param,x,y):
b = ToggleButton(canvas,param,editor,
fill=cfill,
foreground=cforeground,
outline=cforeground,
selected_fill = cfill,
selected_foreground = cselected)
self.add_control(param,b)
b.layout((x,y))
b.update_aspect()
return b
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, 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, 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_gate_button(self):
msb = ToggleButton(self.canvas,
self.params['gate-mode'],
self.parent,
text=["Gate", "Trig"],
values=[0, 1])
x, y = self.xi0, self.y1 - 50
msb.layout((x, y))
msb.update_aspect()
self.msb_gate_mode = msb
def msb_enable(self, param, x, y):
msb = ToggleButton(self.canvas,
param,
self.editor,
text=["Off", "On"],
fill=acon.CFILL,
foreground=acon.CFOREGROUND,
outline=acon.COUTLINE)
self.add_control(param, msb)
msb.layout((x, y))
msb.update_aspect()
return msb
def toggle(param, x, y):
b = ToggleButton(canvas,
param,
editor,
fill=cfill,
foreground=cforeground,
outline=cforeground,
selected_fill=cfill,
selected_foreground=cselected)
self.add_control(param, b)
b.layout((x, y))
b.update_aspect()
return b
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, 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, 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()
class Tumbler(object):
def __init__(self,canvas,param,editor,
sign=False,digits=4,scale=1.0,
range_ = None,
fill = 'black',
foreground = 'white',
outline = 'white',
active_color = 'yellow',
font = ('Times',10)):
'''
Tumbler combines several MSB buttons into a single compost control
for numeric values.
'''
self.canvas = canvas
self.param=param
self.editor = editor
#self._range = range_ or (0,10**digits-1)
if not range_:
mag = 10**digits-1
if sign:
range_ = (-mag,mag)
else:
range_ = (0,mag)
self._range = range_
self._common_aspect = {"fill" : fill,
"foreground" : foreground,
"outline" : outline,
"active-fill" : fill,
"active-foreground" : active_color,
"active-outline" : active_color,
"font" : font}
self.scale = float(scale)
self.has_sign = sign
self._msb_sign = ToggleButton(canvas,"",None,
text=["-","+"],
values=[-1,1])
self._msb_sign.tag_bind("<Button-1>", self._callback)
self._msb_sign.tag_bind("<Button-3>", self._callback)
acc = []
for i in range(digits):
msb = MSB.digit_msb(canvas,"",None,
font = self._common_aspect['font'],
fill = self._common_aspect['fill'],
foreground = self._common_aspect['foreground'],
outline = self._common_aspect['outline'],
active_fill = self._common_aspect['fill'],
active_foreground = self._common_aspect['active-foreground'],
active_outline = self._common_aspect['active-outline'])
msb.tag_bind("<Button-1>", self._callback)
msb.tag_bind("<Button-3>", self._callback)
msb.weight = (10**i)
acc.append(msb)
acc.reverse()
self._digits = acc
def widget(self, key=None):
msg = "Tumbler does not implement widget method"
raise NotImplementedError(msg)
def widget_keys(self):
return []
def has_widget(self, key):
return False
def _get_value(self):
acc = 0
for b in self._digits:
w = b.weight
digit = b.value()
acc += digit*w
acc *= self._msb_sign.value()
mn,mx = self._range
acc = min(max(acc,mn),mx)
return acc*self.scale
def _set_value(self, v):
mn,mx = self._range
v = int(v/self.scale)
v = min(max(v,mn),mx)
if v < 0:
s = -1
else:
s = 1
v = abs(v)
dcount = len(self._digits)
for i in range(dcount):
j = dcount-i-1
b = self._digits[j]
lsd = int(v % 10)
b.value(lsd)
v /= 10
self._msb_sign.value(s)
self._update_synths()
def _callback(self, *_):
mn,mx = self._range
v = min(max(self._get_value(),mn),mx)
self._set_value(v)
def _update_synths(self, *_):
if self.editor:
v = self._get_value()
synth = self.editor.synth
synth.x_param_change(self.param,v)
program = synth.bank()[None]
program[self.param] = v
msg = '[%s] -> %s' % (self.param, v)
self.editor.status(msg)
def update_aspect(self):
for b in self._digits:
b.update_aspect()
self._msb_sign.update_aspect()
# No range test, no scaling
def aspect(self, new_aspect=None):
if new_aspect is not None:
a = new_aspect
if a < 0:
s = -1
a = abs(a)
else:
s = 1
for b in self._digits:
lsd = int(a % 10)
b.value(lsd)
self._msb_sign.value(s)
acc = 0
s = self._msb_sign.value()
for b in self._digits:
w = b.weight
acc += w*b.value()
return int(acc*s)
def value(self, new_value=None):
if new_value is not None:
self._set_value(new_value)
self.update_aspect()
return self._get_value()
def layout(self, offset=(0,0),bwidth=15,height=20):
x,y= offset
if self.has_sign:
self._msb_sign.layout((x,y),width=bwidth,height=height)
x += bwidth
self._msb_sign.update_aspect()
for b in self._digits:
b.layout((x,y),width=bwidth,height=height)
x += bwidth
b.update_aspect()
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, 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, 741,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
xfilter = x0+130
xmod = xfilter+90
xattack = xmod + 90
xrelease = xattack + 60
xdry = xrelease+90
xwet = xdry+60
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):
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):
s = cf.linear_slider(canvas,param,editor,range_=range_)
self.add_control(param,s)
s.widget().place(x=x,y=y0)
return s
t_freq = Tumbler(canvas,"fixedFrequency",editor,
digits = 4, scale=0.01)
t_track = Tumbler(canvas,"keyTrack",editor,
digits=2, scale=1, range_=(0,16))
self.add_control("fixedFrequency",t_freq)
self.add_control("keyTrack",t_track)
t_freq.layout((x0+25,y0+25))
t_track.layout((x0+40,y0+100))
cfill = 'black'
cforeground = 'white'
coutline = 'white'
msb_filter = MSB(canvas,"inputFilter",editor,len(FILTER_VALUES))
for i,v in enumerate(FILTER_VALUES):
k = v/1000
tx = "%dk" % k
d = {"fill" : cfill,
"foreground" : cforeground,
"outline" : coutline,
"value" : v,
"text" : tx}
msb_filter.define_aspect(i,v,d)
self.add_control("inputFilter",msb_filter)
msb_filter.layout((xfilter,y0+25))
msb_filter.update_aspect()
msb_gain = MSB(canvas,"inputGain",editor,MAX_INPUT_GAIN_MAGNITUDE)
for i in range(MAX_INPUT_GAIN_MAGNITUDE):
j = i+1
v = 10**i
tx = "x%d" % j
d = {"fill" : cfill,
"foreground" : cforeground,
"outline" : coutline,
"value" : v,
"text" : tx}
msb_gain.define_aspect(i,v,d)
self.add_control("inputGain",msb_gain)
msb_gain.layout((xfilter,y0+100))
msb_gain.update_aspect()
norm_slider("modDepth",xmod)
linear_slider("attack",(0,4),xattack)
linear_slider("release",(0,4),xrelease)
msb_env = ToggleButton(canvas,"envelopeSelect",editor,
text=("Follow","ASR"),
values = (0,1),
fill=cfill,
selected_fill = cfill,
foreground=cforeground,
selected_foreground=cforeground,
outline=coutline)
self.add_control("envelopeSelect",msb_env)
msb_env.layout((xattack+8,y0+200))
msb_env.update_aspect()
volume_slider("dryAmp",xdry)
volume_slider("wetAmp",xwet)