def __init__(self, address, ordinal):
agent.Agent.__init__(self,
signature=version,
names='cycler',
container=10,
ordinal=ordinal)
self.set_private(node.Server())
self.get_private()[1] = node.Server(change=self.__cycle_set,
value=piw.makebool(True, 0))
self.get_private()[2] = node.Server(change=self.__invert_set,
value=piw.makebool(False, 0))
self[2] = atom.Atom()
self[2][1] = bundles.Output(1, False, names='activation output')
self[2][2] = bundles.Output(2, False, names='pressure output')
self[2][3] = bundles.Output(3, False, names='roll output')
self[2][4] = bundles.Output(4, False, names='yaw output')
self[2][5] = bundles.Output(5, False, names='scale note output')
self[2][6] = bundles.Output(6, False, names='frequency output')
self[2][7] = bundles.Output(16, False, names='damper output')
self.add_verb2(1, 'cycle([],None)', self.__cycle_on)
self.add_verb2(2, 'cycle([un],None)', self.__cycle_off)
self.domain = piw.clockdomain_ctl()
self.domain.set_source(piw.makestring('*', 0))
self.main_output = bundles.Splitter(self.domain, self[2][1],
self[2][2], self[2][3], self[2][4],
self[2][5], self[2][6])
self.damp_output = bundles.Splitter(self.domain, self[2][7])
self.cycler = piw.cycler(self.domain, 32, self.main_output.cookie(),
self.damp_output.cookie(), False)
self.input = bundles.VectorInput(self.cycler.main_cookie(),
self.domain,
signals=(1, 2, 3, 4, 5, 6, 16, 17),
threshold=5)
self.feedback = bundles.VectorInput(self.cycler.feedback_cookie(),
self.domain,
signals=(1, ),
threshold=5)
self.cycler.set_cycle(True)
self.cycler.set_maxdamp(1.0)
self.cycler.set_invert(False)
self.cycler.set_curve(1.0)
self[1] = atom.Atom()
self[1][1] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.input.vector_policy(1, False),
names='activation input')
self[1][2] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.input.vector_policy(2, False),
names='pressure input')
self[1][3] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.input.vector_policy(3, False),
names='roll input')
self[1][4] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.input.vector_policy(4, False),
names='yaw input')
self[1][5] = atom.Atom(domain=domain.BoundedFloat(0, 1000),
policy=self.input.vector_policy(5, False),
names='scale note input')
self[1][6] = atom.Atom(domain=domain.BoundedFloat(0, 96000),
policy=self.input.vector_policy(6, False),
names='frequency input')
self[1][7] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.feedback.vector_policy(
1, False, clocked=False),
names='feedback input')
self[1][8] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0.0,
policy=self.input.linger_policy(16, False),
names='damper pedal input',
container=(None, 'damper',
self.verb_container()))
self[1][10] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=1.0,
policy=atom.default_policy(self.__setmaxdamp),
names='damper maximum input')
self[1][12] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.input.latch_policy(17, False),
names='hold pedal input')
self[1][13] = atom.Atom(domain=domain.BoundedFloat(0.1, 10),
init=1,
names="damper curve",
policy=atom.default_policy(self.__setdcurve))
self[1][8].add_verb2(1, 'invert([],None)', self.__invert_on)
self[1][8].add_verb2(2, 'invert([un],None)', self.__invert_off)
def __init__(self, address, ordinal):
agent.Agent.__init__(self, signature=version, names='kmapper', icon='plg_simple/kgroup.png',container=17,ordinal=ordinal)
self.__cur_size = 0
self.__choices=[]
self.__coursekeys=[]
self.__course=1
self.__private = node.Server(value=piw.makestring('[]',0),change=self.__set_members)
self.set_private(self.__private)
self.domain = piw.clockdomain_ctl()
self.domain.set_source(piw.makestring('*',0))
self.mapper = piw.kgroup_mapper()
self[1] = bundles.Output(1,False, names='light output',protocols='revconnect')
self.loutput = bundles.Splitter(self.domain,self[1])
self.lmapper = piw.clone(True)
self.lmapper.set_filtered_output(1,self.loutput.cookie(),self.mapper.light_filter())
self.lmux = piw.multiplexer(self.lmapper.cookie(),self.domain)
self.linput = bundles.VectorInput(self.lmux.get_input(1),self.domain,signals=(1,))
self[2] = atom.Atom(names='light input',protocols='revconnect',policy=self.linput.vector_policy(1,False,False),domain=domain.Aniso())
self[3] = bundles.Output(1,False, names='strip position output',ordinal=1)
self[4] = bundles.Output(2,False, names='strip position output',ordinal=2)
self[5] = bundles.Output(3,False, names='breath output')
self.soutput = bundles.Splitter(self.domain,self[3],self[4],self[5])
self.sgate = piw.gate(self.soutput.cookie(),True)
self.sinput = bundles.VectorInput(self.sgate.cookie(),self.domain,signals=(1,2,3))
self[6] = atom.Atom(domain=domain.BoundedFloat(-1,1),policy=self.sinput.vector_policy(1,False),names='strip position input',ordinal=1)
self[7] = atom.Atom(domain=domain.BoundedFloat(-1,1),policy=self.sinput.vector_policy(2,False),names='strip position input',ordinal=2)
self[8] = atom.Atom(domain=domain.BoundedFloat(0,1),policy=self.sinput.vector_policy(3,False),names='breath input')
self[9] = bundles.Output(1,False, names='activation output')
self[10] = bundles.Output(2,False, names='pressure output')
self[11] = bundles.Output(3,False, names='roll output')
self[12] = bundles.Output(4,False, names='yaw output')
self.koutput = bundles.Splitter(self.domain,self[9],self[10],self[11],self[12])
self.kpoly = piw.polyctl(10,self.koutput.cookie(),False,5)
self.kclone = piw.clone(True)
self.kclone.set_policy(False)
self.kinput = bundles.VectorInput(self.kclone.cookie(),self.domain,signals=(1,2,3,4),filter=self.mapper.key_filter())
self[13] = atom.Atom(domain=domain.BoundedFloat(0,1), policy=self.kinput.vector_policy(1,False), names='activation input')
self[14] = atom.Atom(domain=domain.BoundedFloat(0,1), policy=self.kinput.vector_policy(2,False), names='pressure input')
self[15] = atom.Atom(domain=domain.BoundedFloat(-1,1), policy=self.kinput.vector_policy(3,False), names='roll input')
self[16] = atom.Atom(domain=domain.BoundedFloat(-1,1), policy=self.kinput.vector_policy(4,False), names='yaw input')
self.kclone.set_output(1,self.kpoly.cookie())
#self.add_verb2(2,'choose([],None,role(None,[matches([k])]),option(from,[numeric,singular]))',self.__choose2)
#self.add_verb2(3,'choose([],None,role(None,[mass([k])]))',self.__choose3)
#self.add_verb2(4,'clear([],None)',self.__clear)
#self.add_verb2(5,'add([],None,role(None,[mass([k])]))',self.__add)
self.add_verb2(7,'choose([],None,role(None,[matches([k])]),option(as,[numeric]))',self.__choose)
self.add_verb2(8,'set([],None,role(None,[tagged_ideal([~server,course],[offset])]),role(to,[mass([semitone])]))',callback=self.__set_course_semi)
self.add_verb2(9,'set([],None,role(None,[tagged_ideal([~server,course],[offset])]),role(to,[mass([interval])]))',callback=self.__set_course_int)
self.add_verb2(12,'clear([],None,option(None,[mass([course])]))',self.__kclear)
self.add_verb2(13,'add([],None,role(None,[mass([k])]),option(to,[mass([course])]))',self.__kadd)
self.add_verb2(14,'add([],None,role(None,[mass([k])]),role(to,[mass([k])]),option(as,[mass([course])]))',self.__radd)
self[20] = VirtualKey(lambda: self.__cur_size)
self.statusbuffer = piw.statusbuffer(self.lmux.gate_input(),2,self.lmux.get_input(2))
self.selgate = piw.functor_backend(1,True)
self.kclone.set_output(2,self.selgate.cookie())
self.statusbuffer.enable(1)
self.kclone.enable(1,True)
self.sgate.enable(True)
self.__upstream_size = 0
self.__set_poly()
self[21] = atom.Atom(domain=domain.Aniso(),policy=atom.default_policy(self.__upstream),names='controller input')
self[22] = VirtualChannel()
self[23] = bundles.Output(1,False, names='controller output', continuous=True)
self.coutput = bundles.Splitter(self.domain,self[23])
self.controller = Controller(self.coutput.cookie())
self.__private[2]=self.controller.state()
self.cgate = piw.gate(self.controller.cookie(),True)
self.cinput = bundles.ScalarInput(self.cgate.cookie(),self.domain,signals=(1,))
self[24] = atom.Atom(domain=domain.Aniso(), policy=self.cinput.nodefault_policy(1,False),names='controller input')
self[25] = VirtualCourse(self.controller)
def __init__(self, address, ordinal):
agent.Agent.__init__(self, signature=version,names='ahdsr',ordinal=ordinal)
self[2] = atom.Atom(names='outputs')
self[2][1] = bundles.Output(1,True,names='volume output')
self[2][2] = bundles.Output(2,False,names='activation output')
self[2][3] = bundles.Output(8,False,names='pressure output')
self.domain = piw.clockdomain_ctl()
self.output = bundles.Splitter(self.domain,self[2][1],self[2][2],self[2][3])
self.adsr = synth_native.adsr2(self.output.cookie(),self.domain)
self.vdetect = piw.velocitydetect(self.adsr.cookie(),8,1)
vel=(T('stageinc',0.1),T('inc',0.1),T('biginc',1),T('control','updown'))
self[3] = atom.Atom(domain=domain.BoundedInt(1,1000),init=4,names="velocity sample",policy=atom.default_policy(self.__set_samples))
self[4] = atom.Atom(domain=domain.BoundedFloat(0.1,10,hints=vel),init=4,names="velocity curve",policy=atom.default_policy(self.__set_curve))
self[5] = atom.Atom(domain=domain.BoundedFloat(0.1,10,hints=vel),init=4,names="velocity scale",policy=atom.default_policy(self.__set_scale))
self.input = bundles.VectorInput(self.vdetect.cookie(), self.domain,signals=(2,3,4,5,6,7,8,9,10,11,12,13,14),threshold=5)
time=(T('stageinc',0.01),T('inc',0.01),T('biginc',0.2),T('control','updown'))
self[1] = atom.Atom(names='inputs')
self[1][1]=atom.Atom(domain=domain.BoundedFloat(0,1), init=1.0, names="activation input", policy=self.input.merge_policy(13,False), protocols="nostage")
self[1][2]=atom.Atom(domain=domain.BoundedFloat(0,60,hints=time),init=0, names="delay input", policy=self.input.merge_policy(2,False))
self[1][3]=atom.Atom(domain=domain.BoundedFloat(0,60,hints=time),init=0.01, names="attack input", policy=self.input.merge_policy(3,False))
self[1][4]=atom.Atom(domain=domain.BoundedFloat(0,60,hints=time),init=0, names="hold input", policy=self.input.merge_policy(4,False))
self[1][5]=atom.Atom(domain=domain.BoundedFloat(0,60,hints=time),init=0.05, names="decay input", policy=self.input.merge_policy(5,False))
self[1][6]=atom.Atom(domain=domain.BoundedFloat(0,1), init=1.0, names="sustain input", policy=self.input.merge_policy(6,False))
self[1][7]=atom.Atom(domain=domain.BoundedFloat(0,60,hints=time),init=0.5, names="release input", policy=self.input.merge_policy(7,False))
self[1][8]=atom.Atom(domain=domain.BoundedFloat(0,1), init=0, names="pressure input", ordinal=1, policy=self.input.vector_policy(8,False))
self[1][9]=atom.Atom(domain=domain.BoundedFloat(0,1), init=0, names="pressure input", ordinal=2, policy=self.input.vector_policy(9,policy.IsoStreamPolicy(1,0,0)))
self[1][10]=atom.Atom(domain=domain.BoundedFloat(0,1), init=0, names="velocity sensitivity input", policy=self.input.merge_policy(10,False))
self[1][11]=atom.Atom(domain=domain.BoundedFloat(0,1), init=0, names="aftertouch input", policy=self.input.merge_policy(11,False))
self[1][12]=atom.Atom(domain=domain.BoundedFloat(0,1), init=0, names="pedal input", policy=self.input.latch_policy(12,False))
self[1][13]=atom.Atom(domain=domain.BoundedFloat(0,1), init=0.5, names="damper input", policy=self.input.linger_policy(14,False))
self.__set_samples(4)
self.__set_curve(4)
self.__set_scale(4)
def __init__(self, address, ordinal):
agent.Agent.__init__(self,
signature=version,
names='metronome',
container=4,
protocols='browse metronome',
ordinal=ordinal)
self[1] = atom.Atom(names='outputs')
self[1][1] = bundles.Output(1, False, names='bar beat output')
self[1][2] = bundles.Output(2, False, names='song beat output')
self[1][3] = bundles.Output(3, False, names='running output')
self[1][4] = bundles.Output(4, False, names='bar output')
self[1][5] = bundles.Output(5, False, names='tempo output')
self[14] = bundles.Output(1, False, names='status output')
self.domain = piw.clockdomain_ctl()
self.domain.set_source(piw.makestring('*', 0))
self.clk_output = bundles.Splitter(self.domain, self[1][1], self[1][2],
self[1][3], self[1][4])
self.tempo_output = bundles.Splitter(self.domain, self[1][5])
self.status_output = bundles.Splitter(self.domain, self[14])
self.pinger = loop_native.pinger(self.clk_output.cookie(),
self.tempo_output.cookie(),
self.status_output.cookie(),
self.domain, sc(self.__tempo_set),
sc(self.__beats_set),
sc(self.__preroll_set))
self.aggregator = piw.aggregator(self.pinger.cookie(), self.domain)
self.tap_input = bundles.ScalarInput(self.aggregator.get_output(1),
self.domain,
signals=(1, 2))
self.midi_clock_input = bundles.ScalarInput(
self.aggregator.get_output(2), self.domain, signals=(1, ))
self[2] = atom.Atom(domain=domain.BoundedFloat(
0,
500,
hints=(T('stageinc',
1), T('inc', 1), T('biginc', 10), T('control',
'updown'))),
init=120,
names='tempo input',
policy=atom.default_policy(self.__set_tempo))
self[3] = atom.Atom(domain=domain.BoundedFloat(0,
100,
rest=4,
hints=(
T('stageinc', 1),
T('inc', 1),
)),
names='beat input',
policy=atom.default_policy(self.__set_beats))
# self[4] is the verb container
self[5] = atom.Atom(domain=domain.BoundedFloat(0,
1,
rest=0,
hints=(T(
'control',
'trigger'), )),
policy=self.tap_input.nodefault_policy(
1, policy.ImpulseStreamPolicy()),
names='beat trigger',
transient=True)
self[6] = atom.Atom(domain=domain.BoundedFloat(0,
1,
rest=0,
hints=(T(
'control',
'trigger'), )),
policy=self.tap_input.nodefault_policy(
2, policy.ImpulseStreamPolicy()),
names='bar trigger',
transient=True)
self[7] = atom.Atom(domain=domain.BoundedFloat(1, 500),
init=30,
names='tap tempo minimum',
policy=atom.default_policy(
self.__set_tempo_lbound))
self[8] = atom.Atom(domain=domain.BoundedFloat(1, 500),
init=240,
names='tap tempo maximum',
policy=atom.default_policy(
self.__set_tempo_ubound))
self[9] = atom.Atom(
domain=domain.Bool(hints=(T('control', 'toggle'), )),
policy=atom.default_policy(self.__preroll),
names='preroll trigger',
transient=True)
self[10] = atom.Atom(domain=domain.BoundedInt(1, 32),
init=4,
names='preroll',
policy=atom.default_policy(
self.__set_preroll_count))
self[15] = atom.Atom(domain=domain.Aniso(),
policy=self.midi_clock_input.nodefault_policy(
1, False),
names='midi clock input')
self[16] = toggle.Toggle(self.__set_midi_clock_enable,
self.domain,
container=(None, 'midi clock enable',
self.verb_container()),
names='midi clock enable')
self[17] = atom.Atom(
domain=domain.BoundedFloat(-1000,
1000,
hints=(T('inc',
1), T('control', 'updown'))),
init=0,
names='midi clock latency',
policy=atom.default_policy(self.__midi_clock_set_latency))
self[18] = atom.Atom(domain=domain.BoundedIntOrNull(0, 2000),
init=0,
names='beat flash persistence',
policy=atom.default_policy(
self.__set_beat_flash_persistence))
self.add_verb2(1,
'start([],None)',
self.__start,
status_action=self.__status)
self.add_verb2(2,
'stop([],None)',
self.__stop,
status_action=self.__status)
self.add_verb2(3,
'start([toggle],None)',
self.__toggle,
status_action=self.__status)
print 'init tempo=', self[2].get_value()
self.pinger.set_tempo(self[2].get_value())
self.pinger.set_beats(self[3].get_value())
self.pinger.set_range(self[8].get_value(), self[7].get_value())
self.__playing = False
self.__timestamp = piw.tsd_time()
self.__selected = None
self.update()
def __init__(self, address, ordinal):
#
# Agents are constructed with the address and ordinal. Each
# agent will have a unique address and an ordinal unique for
# that type of agent.
#
# We also pass in the automatically generated version to go into
# the metadata.
#
agent.Agent.__init__(self,
signature=version,
names='osc output',
ordinal=ordinal)
#
# Create a clock domain. A clock domain is a collection of clock
# sinks all of which share common properties. Domains can be isochronous
# or anisochronous. Currently, sinks in iso domains can be connected
# only to other iso domains using the same source.
#
self.domain = piw.clockdomain_ctl()
#
# Make our domain anisochronous (aniso is used for everything except audio)
#
self.domain.set_source(piw.makestring('*', 0))
#
# Create an OSC server, implemented in our C++ library, imported through
# the osc_plg_native module.
#
self.osc = osc_server(self.domain, "keyboard_%d" % ordinal)
#
# Create an OSC output within the OSC server, which will correlate 4
# streams. These will be used for keyboard data. We group like this
# so that we can send all the keyboard parameters together.
# these will be under the /key OSC path
#
# The return value from create_output is a piw.cookie, which represents
# a connection endpoint. This can be used by another component to send
# events for OSC output. The OSC output will place the first 4 signals
# into each OSC output packet.
#
self.key_output = self.osc.create_output("key", True, 4)
#
# Create an input. An input does the work of correlating the events on a
# number of signals, grouping them together.
#
# A Vector input is a proper multiple channel input. This one is being
# constructed to handle 4 signals, numbered 1,2,3 and 4. The events will
# be sent to the OSC output stage through the use of the key_output cookie.
#
self.key_input = bundles.VectorInput(self.key_output,
self.domain,
signals=(1, 2, 3, 4))
#
# Create a null atom just to group our inputs. We still name this atom so that it
# shows up with a meaningful name through introspection by tools like Workbench.
#
self[1] = atom.Atom(names="inputs")
#
# Now create our inputs. The data policy for the atom is created by our vector input.
# There are lots of corner cases when we invert our model from signal-contains-events
# to event-contains-signals. In particular, this happens when events on individual
# signals dont start and and stop together.
#
# Any input with a vector_policy will create or join an existing event.
# merge_policy will never create events, just join onto existing events created by
# a vector policy.
#
# We create 4 inputs, with vector policies routing them to signals 1,2,3 and 4 on
# our bundle. These are all non-iso inputs.
#
self[1][1] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.key_input.vector_policy(1, False),
names='activation input')
self[1][2] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.key_input.vector_policy(2, False),
names='pressure input')
self[1][3] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.key_input.vector_policy(3, False),
names='roll input')
self[1][4] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.key_input.vector_policy(4, False),
names='yaw input')
#
# Create another OSC output for the breath pipe.
#
self.breath_output = self.osc.create_output("breath", False, 1)
#
# And another input. We use separate inputs for breath and keys, because we want
# all the key signals to be correlated together (so we can output pressure roll and
# yaw as 1 packet), the breath pipe is completely independent from the keys though.
#
# Using the breath_output cookie, the input data will be send to the breath output created
# in the native OSC transport.
#
self.breath_input = bundles.VectorInput(self.breath_output,
self.domain,
signals=(1, ))
self[1][5] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.breath_input.vector_policy(
1, False),
names='breath input')
#
# Lastly, create an atom called 'decimation' to store our current decimation rate.
# This will appear in Stage and can be set using Belcanto. When it changes, our
# __decimation method will be called with a Python numeric argument (because its a
# numeric domain).
#
self[3] = atom.Atom(domain=domain.BoundedInt(0, 100),
policy=atom.default_policy(self.__decimation),
names='decimation')
def __init__(self, address, ordinal):
agent.Agent.__init__(self,
signature=version,
names='audio unit',
container=100,
ordinal=ordinal)
self.__state = PluginState(self.__plugin_state_loaded)
self.set_private(self.__state)
self.__browser = PluginBrowser(self)
self.__domain = piw.clockdomain_ctl()
self.__audio_output = audio.AudioOutput(bundles.Splitter(
self.__domain),
1,
2,
names='channels')
self.__audio_output_channels = audio.AudioChannels(self.__audio_output)
self.__midi_output = bundles.Splitter(self.__domain)
self.__observer = PluginObserver(self.__state, self)
self.host = host_native.plugin_instance(
self.__observer, self.__domain, self.__audio_output.cookie(),
self.__midi_output.cookie(),
utils.statusify(self.__window_state_changed))
self.parameter_list = inputparameter.List(self.host,
self.host.clock_domain(),
self.verb_container())
self.__audio_input = audio.AudioInput(bundles.ScalarInput(
self.host.audio_input_cookie(),
self.__domain,
signals=range(1, 65)),
1,
2,
names='channels')
self.__audio_input_channels = audio.AudioChannels(self.__audio_input)
self.__key_input = bundles.VectorInput(
self.host.midi_from_belcanto_cookie(),
self.__domain,
signals=(1, 2))
self.__midi_input = bundles.ScalarInput(
self.host.midi_aggregator_cookie(), self.__domain, signals=(1, ))
self.__metronome_input = bundles.ScalarInput(
self.host.metronome_input_cookie(),
self.__domain,
signals=(1, 2, 3, 4))
self.host.set_bypassed(True)
# plugin browser
self[1] = self.__browser
# audio output
self[2] = atom.Atom(names='audio outputs')
self[2][1] = self.__audio_output
self[2][2] = self.__audio_output_channels
# audio input
self[3] = atom.Atom(names='audio inputs')
self[3][1] = self.__audio_input
self[3][2] = self.__audio_input_channels
# parameter mapping
self[4] = self.parameter_list
# metronome input
self[5] = atom.Atom(names='metronome inputs')
self[5][1] = atom.Atom(domain=domain.Aniso(),
policy=self.__metronome_input.nodefault_policy(
1, False),
names='song beat input')
self[5][2] = atom.Atom(domain=domain.Aniso(),
policy=self.__metronome_input.nodefault_policy(
2, False),
names='running input')
self[5][3] = atom.Atom(domain=domain.Aniso(),
policy=self.__metronome_input.nodefault_policy(
3, False),
names='tempo input')
self[5][4] = atom.Atom(domain=domain.Aniso(),
policy=self.__metronome_input.nodefault_policy(
4, False),
names='bar beat input')
# kbd/controller inputs
self[6] = atom.Atom(names='musical inputs')
self[6][1] = atom.Atom(domain=domain.Aniso(),
policy=self.__key_input.vector_policy(1, False),
names='pressure input')
self[6][2] = atom.Atom(domain=domain.Aniso(),
policy=self.__key_input.merge_nodefault_policy(
2, False),
names='frequency input')
# midi channel
self[7] = atom.Atom(domain=domain.BoundedInt(0, 20),
init=0,
names='midi channel',
policy=atom.default_policy(self.set_midi_channel))
# velocity curve control
vel = (T('stageinc', 0.1), T('inc', 0.1), T('biginc',
1), T('control', 'updown'))
self[8] = atom.Atom(names='velocity curve controls')
self[8][1] = atom.Atom(domain=domain.BoundedInt(1, 1000),
init=4,
names='velocity sample',
policy=atom.default_policy(
self.__set_velocity_samples))
self[8][2] = atom.Atom(domain=domain.BoundedFloat(0.1, 10, hints=vel),
init=4,
names='velocity curve',
policy=atom.default_policy(
self.__set_velocity_curve))
self[8][3] = atom.Atom(domain=domain.BoundedFloat(0.1, 10, hints=vel),
init=4,
names='velocity scale',
policy=atom.default_policy(
self.__set_velocity_scale))
self[9] = atom.Atom(domain=domain.Bool(),
init=True,
names='tail time enable',
policy=atom.default_policy(
self.__set_tail_time_enabled))
self[10] = atom.Atom(domain=domain.BoundedFloatOrNull(0, 100000),
init=10,
names='tail time',
policy=atom.default_policy(self.__set_tail_time))
self[11] = atom.Atom(domain=domain.BoundedInt(1, 16),
init=1,
names='minimum channel',
policy=atom.default_policy(self.set_min_channel))
self[12] = atom.Atom(domain=domain.BoundedInt(1, 16),
init=16,
names='maximum channel',
policy=atom.default_policy(self.set_max_channel))
# other global settings inputs
self[20] = atom.Atom(domain=domain.BoundedInt(0, 100),
init=0,
names="minimum decimation",
policy=atom.default_policy(
self.set_min_decimation))
self[21] = atom.Atom(domain=domain.Bool(),
init=True,
names="notes enable",
policy=atom.default_policy(self.set_midi_notes))
self[22] = atom.Atom(domain=domain.Bool(),
init=True,
names="pitch bend enable",
policy=atom.default_policy(
self.set_midi_pitchbend))
self[23] = atom.Atom(domain=domain.Bool(),
init=False,
names="high resolution velocity enable",
policy=atom.default_policy(
self.set_midi_hires_velocity))
self[24] = atom.Atom(domain=domain.BoundedInt(0, 96),
init=1,
names="pitch bend range upper",
policy=atom.default_policy(self.set_pitchbend_up))
self[25] = atom.Atom(domain=domain.BoundedInt(0, 96),
init=1,
names="pitch bend range lower",
policy=atom.default_policy(
self.set_pitchbend_down))
# status output to drive the talker lights
self[13] = bundles.Output(1, False, names='status output')
self.light_output = bundles.Splitter(self.__domain, self[13])
self.lights = piw.lightsource(piw.change_nb(), 0,
self.light_output.cookie())
self.lights.set_size(2)
self.set_light(1, True)
self.set_light(2, False)
# midi I/O
# midi input
self[14] = atom.Atom(domain=domain.Aniso(),
policy=self.__midi_input.nodefault_policy(
1, False),
names='midi input')
# midi output
self[15] = self.__midi_output.add_output(
bundles.Output(1, False, names='midi output'))
# controller input/output to add labels
self[16] = atom.Atom(
domain=domain.Aniso(hints=(logic.make_term('continuous'), )),
names='controller output',
policy=atom.readonly_policy())
self[17] = atom.Atom(domain=domain.String(),
init='Plugin',
names='label category',
policy=atom.default_policy(self.__set_category))
self[18] = atom.Atom(domain=domain.String(),
init='',
names='label',
policy=atom.default_policy(self.__set_label))
self.ctl_functor = piw.functor_backend(1, True)
self.ctl_input = bundles.VectorInput(self.ctl_functor.cookie(),
self.__domain,
signals=(1, ))
self[19] = atom.Atom(domain=domain.Aniso(),
policy=self.ctl_input.vector_policy(1, False),
names='controller input')
self.ctl_functor.set_functor(
piw.pathnull(0),
utils.make_change_nb(
piw.slowchange(utils.changify(self.__controller_input))))
self.__ctl = []
# verbs
self.add_verb2(1, 'show([],None)', callback=self.__show)
self.add_verb2(2, 'show([un],None)', callback=self.__unshow)
self.add_verb2(3, 'close([],None)', callback=self.__close)
self.add_verb2(4,
'bypass([toggle],None)',
callback=self.__tog_bypass,
status_action=self.__status_bypass)
self.add_verb2(5,
'show([toggle],None)',
callback=self.__tog_show,
status_action=self.__status_show)
self.add_verb2(6,
'open([],None,role(None,[abstract]))',
callback=self.__open)
self.add_verb2(7,
'scan([],None)',
callback=self.__browser.refresh_plugin_list)
self.add_verb2(8, 'bypass([],None)', callback=self.__bypass)
self.add_verb2(9, 'bypass([un],None)', callback=self.__unbypass)
# control change
self.add_verb2(
10,
'set([],~a,role(None,[matches([midi,program])]),role(to,[numeric]))',
create_action=self.__set_program_change)
self.add_verb2(
11,
'set([],~a,role(None,[matches([midi,bank])]),role(to,[numeric]))',
create_action=self.__set_bank_change)
self.add_verb2(
12,
'set([],~a,role(None,[mass([midi,controller])]),role(to,[numeric]))',
create_action=self.__set_midi_control)
self.set_ordinal(ordinal)
def __init__(self, address, ordinal):
self.domain = piw.clockdomain_ctl()
self.domain.set_source(piw.makestring('*', 0))
agent.Agent.__init__(self,
signature=version,
names='strummer',
protocols='',
ordinal=ordinal)
self[1] = atom.Atom()
self[1][1] = bundles.Output(1,
False,
names='pressure output',
protocols='')
self.output = bundles.Splitter(self.domain, *self[1].values())
self.strummer = piw.strummer(self.output.cookie(), self.domain)
self.ctl_input = bundles.VectorInput(self.strummer.ctl_cookie(),
self.domain,
signals=(1, ))
self.data_input = bundles.VectorInput(self.strummer.data_cookie(),
self.domain,
signals=(1, ))
self[4] = atom.Atom()
self[4][1] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.ctl_input.vector_policy(1, False),
names='controller input')
self[4][2] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.data_input.vector_policy(1, False),
names='pressure input')
self[2] = atom.Atom()
self[2][1] = atom.Atom(domain=domain.Bool(),
init=False,
names='enable',
policy=atom.default_policy(
self.strummer.enable))
self[2][2] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0.01,
names='on threshold',
policy=atom.default_policy(
self.strummer.set_on_threshold))
self[2][3] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0.08,
names='off threshold',
policy=atom.default_policy(
self.strummer.set_off_threshold))
self[2][4] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0.0,
names='k mix',
policy=atom.default_policy(
self.strummer.set_key_mix))
self[2][5] = atom.Atom(domain=domain.BoundedInt(0, 2000),
init=400,
names='trigger window',
policy=atom.default_policy(
self.strummer.set_trigger_window))
self.strummer.enable(False)
self.strummer.set_on_threshold(0.2)
self.strummer.set_off_threshold(0.1)
self.strummer.set_key_mix(0.0)
self.strummer.set_trigger_window(400)
def __init__(self, address, ordinal):
self.domain = piw.clockdomain_ctl()
agent.Agent.__init__(self, signature=version, names='recorder', protocols='bind',icon='plg_recorder/recorder.png',container=(3,'agent',atom.VerbContainer(clock_domain=self.domain)),ordinal=ordinal)
self[2] = atom.Atom()
self[2][1] = bundles.Output(1,False,names='activation output', protocols='')
self[2][2] = bundles.Output(2,False,names='pressure output', protocols='')
self[2][3] = bundles.Output(3,False,names='roll output', protocols='')
self[2][4] = bundles.Output(4,False,names='yaw output', protocols='')
self[2][5] = bundles.Output(1,False,names='auxilliary output', ordinal=1, protocols='')
self[2][6] = bundles.Output(1,False,names='auxilliary output', ordinal=2, protocols='')
self[2][7] = bundles.Output(1,False,names='auxilliary output', ordinal=3, protocols='')
self[2][8] = bundles.Output(1,False,names='auxilliary output', ordinal=4, protocols='')
self[2][9] = bundles.Output(1,False,names='auxilliary output', ordinal=5, protocols='')
self[2][10] = bundles.Output(1,False,names='auxilliary output', ordinal=6, protocols='')
self[2][11] = bundles.Output(1,False,names='auxilliary output', ordinal=7, protocols='')
self[2][12] = bundles.Output(1,False,names='auxilliary output', ordinal=8, protocols='')
self[2][13] = bundles.Output(1,False,names='auxilliary output', ordinal=9, protocols='')
self[2][14] = bundles.Output(1,False,names='auxilliary output', ordinal=10, protocols='')
self.output_data = bundles.Splitter(self.domain,self[2][1],self[2][2],self[2][3],self[2][4])
self.output_aux1 = bundles.Splitter(self.domain,self[2][5])
self.output_aux2 = bundles.Splitter(self.domain,self[2][6])
self.output_aux3 = bundles.Splitter(self.domain,self[2][7])
self.output_aux4 = bundles.Splitter(self.domain,self[2][8])
self.output_aux5 = bundles.Splitter(self.domain,self[2][9])
self.output_aux6 = bundles.Splitter(self.domain,self[2][10])
self.output_aux7 = bundles.Splitter(self.domain,self[2][11])
self.output_aux8 = bundles.Splitter(self.domain,self[2][12])
self.output_aux9 = bundles.Splitter(self.domain,self[2][13])
self.output_aux10 = bundles.Splitter(self.domain,self[2][14])
self.poly_data = piw.polyctl(poly_data_initial,self.output_data.cookie(),False,poly_data_headroom)
self.poly_aux1 = piw.polyctl(poly_aux_initial,self.output_aux1.cookie(),False,poly_aux_headroom)
self.poly_aux2 = piw.polyctl(poly_aux_initial,self.output_aux2.cookie(),False,poly_aux_headroom)
self.poly_aux3 = piw.polyctl(poly_aux_initial,self.output_aux3.cookie(),False,poly_aux_headroom)
self.poly_aux4 = piw.polyctl(poly_aux_initial,self.output_aux4.cookie(),False,poly_aux_headroom)
self.poly_aux5 = piw.polyctl(poly_aux_initial,self.output_aux5.cookie(),False,poly_aux_headroom)
self.poly_aux6 = piw.polyctl(poly_aux_initial,self.output_aux6.cookie(),False,poly_aux_headroom)
self.poly_aux7 = piw.polyctl(poly_aux_initial,self.output_aux7.cookie(),False,poly_aux_headroom)
self.poly_aux8 = piw.polyctl(poly_aux_initial,self.output_aux8.cookie(),False,poly_aux_headroom)
self.poly_aux9 = piw.polyctl(poly_aux_initial,self.output_aux9.cookie(),False,poly_aux_headroom)
self.poly_aux10 = piw.polyctl(poly_aux_initial,self.output_aux10.cookie(),False,poly_aux_headroom)
self.output_clone = piw.clone(True)
self.output_clone.set_filtered_output(2,self.poly_data.cookie(),piw.grist_deaggregation_filter2(2,100))
self.output_clone.set_filtered_output(3,self.poly_aux1.cookie(),piw.grist_deaggregation_filter(3))
self.output_clone.set_filtered_output(4,self.poly_aux2.cookie(),piw.grist_deaggregation_filter(4))
self.output_clone.set_filtered_output(5,self.poly_aux3.cookie(),piw.grist_deaggregation_filter(5))
self.output_clone.set_filtered_output(6,self.poly_aux4.cookie(),piw.grist_deaggregation_filter(6))
self.output_clone.set_filtered_output(7,self.poly_aux5.cookie(),piw.grist_deaggregation_filter(7))
self.output_clone.set_filtered_output(8,self.poly_aux6.cookie(),piw.grist_deaggregation_filter(8))
self.output_clone.set_filtered_output(9,self.poly_aux7.cookie(),piw.grist_deaggregation_filter(9))
self.output_clone.set_filtered_output(10,self.poly_aux8.cookie(),piw.grist_deaggregation_filter(10))
self.output_clone.set_filtered_output(11,self.poly_aux9.cookie(),piw.grist_deaggregation_filter(11))
self.output_clone.set_filtered_output(12,self.poly_aux10.cookie(),piw.grist_deaggregation_filter(12))
self.output_aggregator = piw.aggregator(self.output_clone.cookie(), self.domain)
self.player = recorder_native.kplayer(self.domain, 16, 9, self.output_aggregator.get_output(2))
self.recorder = Recorder(self.domain,9)
self.input_clone = piw.clone(True)
self.input_clone.set_output(1,self.output_aggregator.get_output(1))
self.input_clone.set_output(2,self.player.cookie())
self.input_clone.set_output(3,self.recorder.cookie())
self.input_aggregator = piw.aggregator(self.input_clone.cookie(), self.domain)
self.input_clock = bundles.ScalarInput(self.input_aggregator.get_filtered_output(1,piw.grist_aggregation_filter(1)), self.domain, signals=(1,2,3))
self.input_clock.add_upstream(self.verb_container().clock)
self.input_poly = piw.polyctl(10,self.input_aggregator.get_filtered_output(2,piw.grist_aggregation_filter(2)), False,5)
self.input_data = bundles.VectorInput(self.input_poly.cookie(), self.domain, signals=(1,2,3,4))
self.input_aux1 = bundles.VectorInput(self.input_aggregator.get_filtered_output(3,piw.grist_aggregation_filter(3)), self.domain, signals=(1,))
self.input_aux2 = bundles.VectorInput(self.input_aggregator.get_filtered_output(4,piw.grist_aggregation_filter(4)), self.domain, signals=(1,))
self.input_aux3 = bundles.VectorInput(self.input_aggregator.get_filtered_output(5,piw.grist_aggregation_filter(5)), self.domain, signals=(1,))
self.input_aux4 = bundles.VectorInput(self.input_aggregator.get_filtered_output(6,piw.grist_aggregation_filter(6)), self.domain, signals=(1,))
self.input_aux5 = bundles.VectorInput(self.input_aggregator.get_filtered_output(7,piw.grist_aggregation_filter(7)), self.domain, signals=(1,))
self.input_aux6 = bundles.VectorInput(self.input_aggregator.get_filtered_output(8,piw.grist_aggregation_filter(8)), self.domain, signals=(1,))
self.input_aux7 = bundles.VectorInput(self.input_aggregator.get_filtered_output(9,piw.grist_aggregation_filter(9)), self.domain, signals=(1,))
self.input_aux8 = bundles.VectorInput(self.input_aggregator.get_filtered_output(10,piw.grist_aggregation_filter(10)), self.domain, signals=(1,))
self.input_aux9 = bundles.VectorInput(self.input_aggregator.get_filtered_output(11,piw.grist_aggregation_filter(11)), self.domain, signals=(1,))
self.input_aux10 = bundles.VectorInput(self.input_aggregator.get_filtered_output(12,piw.grist_aggregation_filter(12)), self.domain, signals=(1,))
self.nplayer = recorder_native.nplayer(self.output_aggregator.get_filtered_output(3,piw.gristchaff_aggregation_filter(100,3)),16,2,self.domain)
self.input_clock.add_upstream(self.nplayer.get_clock())
self[1] = atom.Atom()
self[1][1]=atom.Atom(domain=domain.BoundedFloat(0,1), policy=self.input_data.vector_policy(1,False),names='activation input')
self[1][2]=atom.Atom(domain=domain.BoundedFloat(0,1), policy=self.input_data.vector_policy(2,False),names='pressure input')
self[1][3]=atom.Atom(domain=domain.BoundedFloat(-1,1), policy=self.input_data.vector_policy(3,False),names='roll input')
self[1][4]=atom.Atom(domain=domain.BoundedFloat(-1,1), policy=self.input_data.vector_policy(4,False),names='yaw input')
self[1][5]=atom.Atom(domain=domain.Aniso(), policy=self.input_aux1.vector_policy(1,False),names='auxilliary input', ordinal=1)
self[1][6]=atom.Atom(domain=domain.Aniso(), policy=self.input_aux2.vector_policy(1,False),names='auxilliary input', ordinal=2)
self[1][7]=atom.Atom(domain=domain.Aniso(), policy=self.input_aux3.vector_policy(1,False),names='auxilliary input', ordinal=3)
self[1][8]=atom.Atom(domain=domain.Aniso(), policy=self.input_aux4.vector_policy(1,False),names='auxilliary input', ordinal=4)
self[1][9]=atom.Atom(domain=domain.Aniso(), policy=self.input_aux5.vector_policy(1,False),names='auxilliary input', ordinal=5)
self[1][10]=atom.Atom(domain=domain.Aniso(), policy=self.input_aux6.vector_policy(1,False),names='auxilliary input', ordinal=6)
self[1][11]=atom.Atom(domain=domain.Aniso(), policy=self.input_aux7.vector_policy(1,False),names='auxilliary input', ordinal=7)
self[1][12]=atom.Atom(domain=domain.Aniso(), policy=self.input_aux8.vector_policy(1,False),names='auxilliary input', ordinal=8)
self[1][13]=atom.Atom(domain=domain.Aniso(), policy=self.input_aux9.vector_policy(1,False),names='auxilliary input', ordinal=9)
self[1][14]=atom.Atom(domain=domain.Aniso(), policy=self.input_aux10.vector_policy(1,False),names='auxilliary input', ordinal=10)
self[1][16]=atom.Atom(domain=domain.BoundedFloat(0,10000000), policy=self.input_clock.nodefault_policy(1,False),names='song beat input')
self[1][17]=atom.Atom(domain=domain.BoundedFloat(0,100), policy=self.input_clock.nodefault_policy(2,False),names='bar beat input')
self[1][18]=atom.Atom(domain=domain.Bool(), init=False, policy=self.input_clock.nodefault_policy(3,False),names='running input')
c = dict(c=schedproxy.get_constraints(),
x='[ideal([~server,take]),singular]',
o='option(with,[or([[matches([stretch],stretch)],[matches([un,stretch],unstretch)],[matches([chop],chop)]])])'
)
a = dict(create_action=self.__create_deferred, destroy_action=self.__destroy_deferred,clock=True)
self.add_verb2(1,'record([],None,role(None,[mass([bar])]),%(o)s)'%c,self.__record)
self.add_verb2(2,'play([un],None,option(None,%(x)s))'%c,self.__unplay)
self.add_verb2(3,'play([],None,role(None,%(x)s),%(o)s)'%c,callback=self.__play_now,**a)
self.add_verb2(4,'play([],None,role(None,%(x)s),role(at,%(c)s),option(until,%(c)s),option(every,%(c)s),%(o)s)'%c,callback=self.__play_aue,**a)
self.add_verb2(5,'play([],None,role(None,%(x)s),role(until,%(c)s),option(every,%(c)s),%(o)s)'%c,callback=self.__play_ue,**a)
self.add_verb2(6,'play([],None,role(None,%(x)s),role(every,%(c)s),%(o)s)'%c,callback=self.__play_e,**a)
self.add_verb2(7,'play([dont],None,option(None,%(x)s))'%c,self.__unplay)
self.add_verb2(8,'repeat([],None,role(None,%(x)s),%(o)s)'%c,callback=self.__repeat,**a)
self.add_verb2(9,'name([],None,role(None,[ideal([~server,take]),singular]),role(to,[abstract]))',self.__name)
self.add_verb2(10,'copy([],None,role(None,[gideal(take),singular]))',callback=self.__copy)
self.add_verb2(11,'use([],None,role(None,[concrete,proto(scheduler),singular]))',callback=self.__usesched)
self.add_verb2(12,'delete([],None,role(None,[ideal([~server,take]),singular]))',self.__delete)
self.add_verb2(13,'play([],None,role(None,[mass([note])]),role(with,[mass([velocity])]))',create_action=self.__playnv,clock=True)
self.add_verb2(14,'play([],None,role(None,[mass([note])]),role(with,[mass([velocity])]),role(for,[mass([second])]))',create_action=self.__playnvl,clock=True)
self.add_verb2(15,'play([toggle],None,role(None,%(x)s),%(o)s)'%c,callback=self.__tog_play_now,**a)
self.add_verb2(16,'play([toggle],None,role(None,%(x)s),role(at,%(c)s),option(until,%(c)s),option(every,%(c)s),%(o)s)'%c,callback=self.__tog_play_aue,**a)
self.add_verb2(17,'play([toggle],None,role(None,%(x)s),role(until,%(c)s),option(every,%(c)s),%(o)s)'%c,callback=self.__tog_play_ue,**a)
self.add_verb2(18,'play([toggle],None,role(None,%(x)s),role(every,%(c)s),%(o)s)'%c,callback=self.__tog_play_e,**a)
self.add_verb2(19,'repeat([toggle],None,role(None,%(x)s),%(o)s)'%c,callback=self.__tog_repeat,**a)
self.add_verb2(20,'cancel([],None)',self.__cancel)
self[4] = TakeBrowser(self)
self.library = TakeLibrary(self)
self.__scheduler = schedproxy.SchedProxy(delegate=self)
self.set_private(node.server(value=piw.makestring('',0),change=self.__schedchange))
self.__schedready = False
self[5] = Voice(self)
# don't use self[6], it was previously used by a legacy status output that was removed in 1.2
self[7]=toggle.Toggle(None,self.domain,container=(None,'overdub',self.verb_container()),init=False,names='overdub',transient=True)
def __init__(self, address, ordinal):
self.domain = piw.clockdomain_ctl()
agent.Agent.__init__(
self,
signature=version,
names='synth filter',
container=(10, 'agent',
atom.VerbContainer(clock_domain=self.domain)),
ordinal=ordinal)
self[1] = bundles.Output(1, True, names="low pass output")
self[2] = bundles.Output(2, True, names="high pass output")
self[3] = bundles.Output(3, True, names="band pass output")
self.output = bundles.Splitter(self.domain, self[1], self[2], self[3])
self.filter = synth_native.synthfilter(self.output.cookie(),
self.domain)
self.bend_filter = piw.function2(
True, 3, 4, 1, piw.makefloat_bounded(96000, 0, 0, 440, 0),
piw.makefloat_bounded(1, -1, 0, 0, 0), self.filter.cookie())
self.bender = piw.fast_pitchbender()
self.bend_filter.set_functor(self.bender.bend_functor())
self.input = bundles.VectorInput(self.bend_filter.cookie(),
self.domain,
signals=(5, 2, 3, 4),
threshold=5)
self.input.add_upstream(self.verb_container().clock)
self[4] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names="audio input",
policy=self.input.vector_policy(5, True))
self[5] = atom.Atom(domain=domain.BoundedFloat(
0,
1,
rest=0.5,
hints=(T('control',
'updown'), T('stageinc',
0.01), T('inc', 0.01), T('biginc', 0.05))),
names="resonance input",
policy=self.input.merge_policy(2, False))
self[6] = atom.Atom(domain=domain.BoundedFloat(0, 96000),
init=5000,
names="cutoff frequency input",
policy=self.input.merge_policy(3, False))
self[7] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names="bend input",
policy=self.input.merge_policy(4, False))
self[8] = atom.Atom(domain=domain.BoundedFloat(0, 72),
init=24,
policy=atom.default_policy(self.__rchange),
names='frequency range',
protocols='bind set',
container=(None, 'range', self.verb_container()))
self[8].add_verb2(
1,
'set([],None,role(None,[instance(~self)]),role(to,[]))',
create_action=self.__rcreate,
clock=True)
self[9] = atom.Atom(domain=domain.BoundedFloat(-144, 144, rest=0),
init=24,
policy=atom.default_policy(self.__ochange),
names='frequency offset',
protocols='bind set',
container=(None, 'offset', self.verb_container()))
self[9].add_verb2(
2,
'set([],None,role(None,[instance(~self)]),role(to,[]))',
create_action=self.__ocreate,
clock=True)
self.__rchange(24)
self.__ochange(24)
def __init__(self, address, ordinal):
agent.Agent.__init__(self,
signature=version,
names='system input events',
ordinal=ordinal)
self.domain = piw.clockdomain_ctl()
self.sysin_events = sysin_events_native.sysin_events(self.domain)
self.__input = bundles.VectorInput(self.sysin_events.mouse_input(),
self.domain,
signals=(1, 2, 3, 4))
self[1] = atom.Atom(names='mouse inputs')
self[1][1] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names="mouse horizontal input",
policy=self.__input.vector_policy(1, True))
self[1][2] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names="mouse vertical input",
policy=self.__input.vector_policy(2, True))
self[1][3] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names="left mouse button input",
policy=self.__input.vector_policy(3, True))
self[1][4] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names="right mouse button input",
policy=self.__input.vector_policy(4, True))
self[2] = KeyPresses(self)
self[3] = atom.Atom(names='velocity curve controls')
self[3][1] = atom.Atom(domain=domain.BoundedInt(1, 1000),
init=4,
names="velocity sample",
policy=atom.default_policy(self.__set_samples))
self[3][2] = atom.Atom(domain=domain.BoundedFloat(0.1, 10),
init=4,
names="velocity curve",
policy=atom.default_policy(self.__set_curve))
self[3][3] = atom.Atom(domain=domain.BoundedFloat(0.1, 10),
init=4,
names="velocity scale",
policy=atom.default_policy(self.__set_scale))
self[4] = atom.Atom(names='mouse controls')
self[4][1] = atom.Atom(domain=domain.BoundedFloat(-10, 10),
init=2.0,
policy=atom.default_policy(
self.__set_mouse_x_scale),
names='mouse horizontal scale')
self[4][2] = atom.Atom(domain=domain.BoundedFloat(-10, 10),
init=-1.0,
policy=atom.default_policy(
self.__set_mouse_y_scale),
names='mouse vertical scale')
self[4][3] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0.1,
policy=atom.default_policy(
self.__set_mouse_x_deadband),
names='mouse horizontal deadband')
self[4][4] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0.1,
policy=atom.default_policy(
self.__set_mouse_y_deadband),
names='mouse vertical deadband')
self[4][5] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names='mouse button threshold 1',
init=0.0,
policy=atom.default_policy(
self.__set_mouse_button_threshold1))
self[4][6] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names='mouse button threshold 2',
init=0.0,
policy=atom.default_policy(
self.__set_mouse_button_threshold2))
self[4][7] = atom.Atom(domain=domain.Bool(),
names='mouse button velocity 1',
init=False,
policy=atom.default_policy(
self.__set_mouse_button_velocity1))
self[4][8] = atom.Atom(domain=domain.Bool(),
names='mouse button velocity 2',
init=False,
policy=atom.default_policy(
self.__set_mouse_button_velocity2))
self.add_verb2(
1,
'press([],~a,role(None,[matches([key])]),role(as,[numeric]))',
create_action=self.__press_key)
self.add_verb2(
2,
'press([],~a,role(None,[matches([character])]),role(as,[abstract]))',
create_action=self.__press_character)
self.add_verb2(
3,
'move([],~a,role(None,[matches([mouse])]),role(to,[numeric]),role(with,[numeric]))',
create_action=self.__move_mouse)
def __init__(self,agent,index):
atom.Atom.__init__(self,domain=domain.BoundedFloat(-1,1),names='audio input',policy=agent.input.nodefault_policy(index,True),ordinal=index,protocols='remove nostage')
def __init__(self, address, ordinal):
self.domain = piw.clockdomain_ctl()
self.domain.set_source(piw.makestring('*', 0))
agent.Agent.__init__(self,
signature=version,
names='strummer',
protocols='',
ordinal=ordinal)
self[1] = atom.Atom(names='outputs')
self[1][1] = bundles.Output(1, False, names='key output')
self[1][2] = bundles.Output(2, False, names='pressure output')
self[1][3] = bundles.Output(3, False, names='roll output')
self[1][4] = bundles.Output(4, False, names='yaw output')
self.output = bundles.Splitter(self.domain, *self[1].values())
self.strummer = strummer_native.cstrummer(self.output.cookie(),
self.domain)
self.aggregator = piw.aggregator(self.strummer.cookie(), self.domain)
self.strum_input = bundles.VectorInput(
self.aggregator.get_filtered_output(1, piw.null_filter()),
self.domain,
signals=(
1,
2,
3,
4,
5,
))
self.data_input = bundles.VectorInput(
self.aggregator.get_filtered_output(2, piw.null_filter()),
self.domain,
signals=(
1,
2,
3,
4,
))
self[4] = atom.Atom(names='inputs')
self[4][1] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.strum_input.vector_policy(1, False),
names='strum breath input',
protocols='nostage')
self[4][2] = atom.Atom(domain=domain.Aniso(),
policy=self.strum_input.vector_policy(2, False),
names='strum key input',
protocols='nostage')
self[4][3] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.strum_input.merge_policy(3, False),
names='strum pressure input',
protocols='nostage')
self[4][4] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.strum_input.merge_policy(4, False),
names='strum roll input',
protocols='nostage')
self[4][5] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.strum_input.merge_policy(5, False),
names='strum yaw input',
protocols='nostage')
self[4][6] = atom.Atom(domain=domain.Aniso(),
policy=self.data_input.vector_policy(1, False),
names='course key input',
protocols='nostage')
self[4][7] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.data_input.merge_policy(2, False),
names='course pressure input',
protocols='nostage')
self[4][8] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.data_input.merge_policy(3, False),
names='course roll input',
protocols='nostage')
self[4][9] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.data_input.merge_policy(4, False),
names='course yaw input',
protocols='nostage')
self[2] = atom.Atom(names='controls')
self[2][1] = atom.Atom(domain=domain.Bool(),
init=True,
names='enable',
policy=atom.default_policy(self.__enable))
self[2][2] = atom.Atom(domain=domain.BoundedInt(0, 2000),
init=0,
names='trigger window',
policy=atom.default_policy(
self.__set_trigger_window))
self[2][3] = atom.Atom(domain=domain.BoundedFloat(0, 10),
init=0.0,
names='course pressure scale',
policy=atom.default_policy(
self.__set_course_pressure_scale))
self[2][4] = atom.Atom(domain=domain.BoundedFloat(0, 10),
init=1.0,
names='course roll scale',
policy=atom.default_policy(
self.__set_course_roll_scale))
self[2][5] = atom.Atom(domain=domain.BoundedFloat(0, 10),
init=1.0,
names='course yaw scale',
policy=atom.default_policy(
self.__set_course_yaw_scale))
self[2][6] = atom.Atom(domain=domain.BoundedFloat(0, 10),
init=1.0,
names='strum breath scale',
policy=atom.default_policy(
self.__set_strum_breath_scale))
self[2][7] = atom.Atom(domain=domain.BoundedFloat(0, 10),
init=1.0,
names='strum pressure scale',
policy=atom.default_policy(
self.__set_strum_pressure_scale))
self[2][8] = atom.Atom(domain=domain.BoundedFloat(0, 10),
init=0.0,
names='strum roll scale',
policy=atom.default_policy(
self.__set_strum_roll_scale))
self[2][9] = atom.Atom(domain=domain.BoundedFloat(0, 10),
init=0.0,
names='strum yaw scale',
policy=atom.default_policy(
self.__set_strum_yaw_scale))
self[2][10] = atom.Atom(domain=domain.Bool(),
init=True,
names='strum note end',
policy=atom.default_policy(
self.__set_strum_note_end))
self[2][11] = atom.Atom(domain=domain.Bool(),
init=False,
names='open course enable',
policy=atom.default_policy(
self.__open_course_enable))
self[2][12] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0.0,
names='open course pressure default',
policy=atom.default_policy(
self.__open_course_pressure_default))
self[2][13] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
init=0.0,
names='open course roll default',
policy=atom.default_policy(
self.__open_course_roll_default))
self[2][14] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
init=0.0,
names='open course yaw default',
policy=atom.default_policy(
self.__open_course_yaw_default))
self[2][15] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0.0,
names='strum roll pressure mix',
policy=atom.default_policy(
self.__set_strum_roll_pressure_mix))
self[2][16] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0.0,
names='strum yaw pressure mix',
policy=atom.default_policy(
self.__set_strum_yaw_pressure_mix))
self[2][17] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0.1,
names='course mute threshold',
policy=atom.default_policy(
self.__set_course_mute_threshold))
self[2][18] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0.1,
names='strum mute threshold',
policy=atom.default_policy(
self.__set_strum_mute_threshold))
self[2][19] = atom.Atom(domain=domain.BoundedInt(0, 1000),
init=20,
names='course mute interval',
policy=atom.default_policy(
self.__set_course_mute_interval))
self[2][20] = atom.Atom(domain=domain.BoundedInt(0, 1000),
init=20,
names='strum mute interval',
policy=atom.default_policy(
self.__set_strum_mute_interval))
self[2][21] = atom.Atom(domain=domain.Bool(),
init=True,
names='polyphonic courses enable',
policy=atom.default_policy(
self.__set_poly_courses_enable))
self[2][22] = atom.Atom(domain=domain.Bool(),
init=True,
names='course mute enable',
policy=atom.default_policy(
self.__set_course_mute_enable))
self[2][23] = atom.Atom(domain=domain.Bool(),
init=True,
names='strum mute enable',
policy=atom.default_policy(
self.__set_strum_mute_enable))
self[2][24] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0.6,
names='pulloff threshold',
policy=atom.default_policy(
self.__set_pulloff_threshold))
self[2][25] = atom.Atom(domain=domain.BoundedInt(0, 1000),
init=10,
names='pulloff interval',
policy=atom.default_policy(
self.__set_pulloff_interval))
self[2][26] = atom.Atom(domain=domain.Bool(),
init=True,
names='pulloff enable',
policy=atom.default_policy(
self.__set_pulloff_enable))
self[3] = atom.Atom(domain=domain.String(),
init='[]',
names='courses',
policy=atom.default_policy(self.__set_courses),
protocols='course_editor')
self.add_verb2(
1,
'set([],~a,role(None,[matches([breath,modulation])]),role(for,[mass([course])]))',
callback=self.__set_breath_modulation)
self.add_verb2(
2,
'set([un],~a,role(None,[matches([breath,modulation])]),role(for,[mass([course])]))',
callback=self.__unset_breath_modulation)
self.add_verb2(
3,
'set([],~a,role(None,[matches([open])]),role(as,[mass([key])]),role(for,[mass([course])]))',
callback=self.__set_open_course_key)
self.add_verb2(
4,
'set([],~a,role(None,[matches([open])]),role(as,[coord(physical,[column],[row])]),role(for,[mass([course])]))',
callback=self.__set_open_course_physical)
self.add_verb2(
5,
'add([],~a,role(None,[matches([strum,key])]),role(with,[coord(physical,[column],[row])]),role(for,[mass([course])]))',
callback=self.__add_strum_key)
self.add_verb2(
6,
'clear([],~a,role(None,[matches([all,strum,key])]),role(for,[mass([course])]))',
callback=self.__clear_strum_key)
self.strumconfig = strummer_native.strumconfig()
def __init__(self, address, ordinal):
self.domain = piw.clockdomain_ctl()
self.domain.set_source(piw.makestring('*', 0))
agent.Agent.__init__(
self,
signature=version,
names='stringer',
protocols='bind set',
container=(5, 'stringer',
atom.VerbContainer(clock_domain=self.domain)),
ordinal=ordinal)
self[1] = atom.Atom()
self[1][1] = bundles.Output(1,
False,
names='activation output',
protocols='')
self[1][2] = bundles.Output(2,
False,
names='pressure output',
protocols='')
self[1][3] = bundles.Output(3,
False,
names='roll output',
protocols='')
self[1][4] = bundles.Output(4, False, names='yaw output', protocols='')
self[1][5] = bundles.Output(5, False, names='key output', protocols='')
self[2] = bundles.Output(1,
False,
names='controller output',
continuous=True)
self.output = bundles.Splitter(self.domain, *self[1].values())
self.coutput = bundles.Splitter(self.domain, self[2])
# stringer
self.stringer = piw.stringer(self.output.cookie())
# clone controller input to copy it to an output and the stringer
self.cclone = piw.clone(True)
self.cclone.set_output(1, self.coutput.cookie())
self.cclone.set_output(2, self.stringer.ctl_cookie())
self.ctl_input = bundles.VectorInput(self.cclone.cookie(),
self.domain,
signals=(1, ))
self.data_input = bundles.VectorInput(self.stringer.data_cookie(),
self.domain,
signals=(1, 2, 3, 4))
self[4] = atom.Atom()
self[4][1] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.data_input.merge_policy(1, False),
names='activation input',
protocols='nostage')
self[4][2] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.data_input.vector_policy(2, False),
names='pressure input',
protocols='nostage')
self[4][3] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.data_input.merge_policy(3, False),
names='roll input',
protocols='nostage')
self[4][4] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.data_input.merge_policy(4, False),
names='yaw input',
protocols='nostage')
self[4][5] = atom.Atom(domain=domain.Aniso(),
policy=self.ctl_input.vector_policy(1, False),
names='controller input')
# self[5] is the verb container
# enable, to deactivate the stringer
self[6] = atom.Atom(domain=domain.Bool(),
init=True,
names="enable",
policy=atom.default_policy(self.__enable))
# status output to drive the talker lights
self[7] = bundles.Output(1, False, names='status output')
self.light_output = bundles.Splitter(self.domain, self[7])
self.lights = piw.lightsource(piw.change_nb(), 0,
self.light_output.cookie())
self.lights.set_size(1)
self.__set_lights(self[6].get_value())
# toggle enable verb, has status action to ensure the status output will be connected to a talker
self.add_verb2(1,
'enable([toggle],None)',
callback=self.__toggle_enable,
status_action=self.__status)
def __init__(self, address, ordinal):
agent.Agent.__init__(self,
signature=version,
names='interpreter',
protocols='langagent has_subsys',
container=10,
ordinal=ordinal)
self.__transcript = resource.open_logfile('transcript')
self.database = database.Database()
self.help_manager = help_manager.HelpManager()
self.__plumber = builtin_conn.Plumber(self, self.database, ordinal)
self.__builtin = builtin_misc.Builtins(self, self.database)
self[12] = script.ScriptManager(self, self.__runner)
self.__ctxmgr = context.ContextManager(self)
self.__statemgr = node.Server(value=piw.makestring('', 0),
change=self.__setstatemgr)
self.__state = node.Server()
self.__state[1] = self.__statemgr
self.__state[2] = container.PersistentFactory(
asserted=self.__ctlassert, retracted=self.__ctlretract)
self.__state[3] = self.__ctxmgr
self.set_private(self.__state)
self.__interpreters = {}
self.interpreter = interpreter.Interpreter(
self, self.database, self, ctx=self.__ctxmgr.default_context())
self.register_interpreter(self.interpreter)
self.queue = interpreter.Queue(self.interpreter)
self[11] = atom.Atom(rtransient=True)
self.__history = feedback.History(self)
self[11].set_private(self.__history)
self.domain = piw.clockdomain_ctl()
self.domain.set_source(piw.makestring('*', 0))
self.cloner = piw.clone(True)
self.input = bundles.VectorInput(self.cloner.cookie(),
self.domain,
signals=(1, 2, 3, 4),
filter=piw.last_filter())
self[1] = atom.Atom()
self[1][1] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.input.vector_policy(1, False),
names='activation input')
self[1][2] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.input.vector_policy(2, False),
names='roll input')
self[1][3] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.input.vector_policy(3, False),
names='yaw input')
self[1][4] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.input.vector_policy(4, False),
names='pressure input')
self.cloner.set_output(1, self.__history.cookie())
self[2] = atom.Atom(init='',
names='word output',
domain=domain.String())
self[5] = atom.Atom(names='main kgroup')
self[5][1] = bundles.Output(1, False, names='activation output')
self[5][2] = bundles.Output(2, False, names='roll output')
self[5][3] = bundles.Output(3, False, names='yaw output')
self[5][4] = bundles.Output(4, False, names='pressure output')
self[9] = atom.Atom(names='auxilliary kgroup')
self[9][1] = bundles.Output(1, False, names='activation output')
self[9][2] = bundles.Output(2, False, names='roll output')
self[9][3] = bundles.Output(3, False, names='yaw output')
self[9][4] = bundles.Output(4, False, names='pressure output')
self.output1 = bundles.Splitter(self.domain, *self[5].values())
self.output2 = bundles.Splitter(self.domain, *self[9].values())
self.cloner.set_filtered_output(3, self.output1.cookie(),
piw.last_lt_filter(9))
self.cloner.set_filtered_output(4, self.output2.cookie(),
piw.last_gt_filter(10))
self.add_verb2(100,
'create([],None,role(None,[matches([controller])]))',
self.__ctlcreate)
self.add_verb2(
101,
'create([un],None,role(None,[concrete,singular,issubject(create,[role(by,[cnc(~self)])])]))',
self.__ctluncreate)
self.add_verb2(30, 'message([],None,role(None,[abstract]))',
self.__message)
self.add_verb2(150, 'execute([],None,role(None,[abstract]))',
self.__runscript)
self.add_verb2(151, 'load([],None,role(None,[matches([help])]))',
self.__loadhelp)
self.add_builtins(self.__builtin)
self.add_builtins(self.__ctxmgr)
self.database.add_module(builtin_conn)
self.database.add_module(context)
self.database.add_module(controller)
self.__messages_on = True
self[4] = atom.Atom(names='messages',
policy=atom.default_policy(self.__messages),
domain=domain.Bool(),
init=True)
self[3] = variable.VariableManager(self)
self.add_builtins(self[3])
self.add_subsystem('plumber', self.__plumber)
# TODO: how should the port number be chosen to avoid clashes with multiple eigenDs?
# perhaps could get a free socket like this:
# import socket
#s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#s.bind(('',0))
#port = s.getsockname()[1]
#s.close()
self.xmlrpc_server_port = 55553
self.widgets = widget.WidgetManager(self, self.xmlrpc_server_port)
self.database.set_widget_manager(self.widgets)
# Stage tab data
self[14] = stage_server.TabList(self)
self.tabs = self[14]
self[15] = self.widgets
self.add_verb2(
102,
'create([],None,role(None,[matches([widget])]),role(for,[concrete,singular]))',
callback=self.__add_widget)
self.add_verb2(
103,
'create([un],None,role(None,[matches([widget])]),role(for,[concrete,singular]))',
callback=self.__del_widget)
def __init__(self, address, ordinal):
self.domain = piw.clockdomain_ctl()
agent.Agent.__init__(
self,
signature=version,
names='ladder filter',
container=(2, 'agent',
atom.VerbContainer(clock_domain=self.domain)),
ordinal=ordinal)
self[1] = bundles.Output(1, True, names="low pass output")
self.output = bundles.Splitter(self.domain, self[1])
self.filter = synth_native.synthfilter2(self.output.cookie(),
self.domain)
self.bend_filter = piw.function2(
True, 3, 4, 1, piw.makefloat_bounded(96000, 0, 0, 440, 0),
piw.makefloat_bounded(1, -1, 0, 0, 0), self.filter.cookie())
self.bender = piw.fast_pitchbender()
self.bend_filter.set_functor(self.bender.bend_functor())
self.input = bundles.VectorInput(self.bend_filter.cookie(),
self.domain,
signals=(2, 3, 4, 5, 6),
threshold=5)
self.input.add_upstream(self.verb_container().clock)
self[4] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names="audio input",
policy=self.input.vector_policy(5, True))
self[5] = atom.Atom(domain=domain.BoundedFloat(
0,
1,
rest=0.5,
hints=(T('control', 'updown'), T('inc', 0.01), T('biginc', 0.05))),
init=0.8,
names="resonance input",
policy=self.input.merge_policy(2, False))
self[6] = atom.Atom(domain=domain.BoundedFloat(0, 96000),
init=5000,
names="cutoff frequency input",
policy=self.input.merge_policy(3, False))
self[7] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names="bend input",
policy=self.input.merge_policy(4, False))
self[8] = atom.Atom(domain=domain.BoundedFloat(0, 72),
init=24,
policy=atom.default_policy(self.__rchange),
names='frequency range',
protocols='bind',
container=(None, 'range', self.verb_container()))
self[9] = atom.Atom(domain=domain.BoundedFloat(-72, 72, rest=0),
init=24,
policy=atom.default_policy(self.__ochange),
names='frequency offset',
protocols='bind',
container=(None, 'offset', self.verb_container()))
self[10] = atom.Atom(domain=domain.BoundedFloat(1, 100),
init=50,
policy=self.input.merge_policy(6, False),
names='temperature')
self.__rchange(24)
self.__ochange(24)
def __init__(self, address, ordinal):
agent.Agent.__init__(self,
names='midi converter',
signature=version,
container=100,
ordinal=ordinal)
self.__domain = piw.clockdomain_ctl()
self.__state = AgentState(self.__agent_state_loaded)
self.set_private(self.__state)
# the MIDI stream output
self[1] = bundles.Output(1, False, names="midi output")
self.__output = bundles.Splitter(self.__domain, self[1])
self.__observer = MappingObserver(self.__state, self)
self.__channel_delegate = MidiChannelDelegate(self)
self.__midi_from_belcanto = piw.midi_from_belcanto(
self.__output.cookie(), self.__domain)
self.__midi_converter = piw.midi_converter(self.__observer,
self.__channel_delegate,
self.__domain,
self.__midi_from_belcanto,
self.__get_title())
self.parameter_list = inputparameter.List(
self.__midi_converter, self.__midi_converter.clock_domain(),
self.verb_container())
# velocity detector, reads pressure input (signal 1) and generates a note on velocity (signal 4), passes thru all other signals in bundle
self.__kvelo = piw.velocitydetect(self.__midi_from_belcanto.cookie(),
1, 4)
# Inputs for generating keyboard driven MIDI signals
# MIDI controllers are merged down with signals from keys (driven by pressure)
self.__kinpt = bundles.VectorInput(self.__kvelo.cookie(),
self.__domain,
signals=(1, 2, 3, 5, 6, 7, 8, 9, 10,
11, 12, 13))
self[2] = atom.Atom()
self[2][1] = atom.Atom(domain=domain.Aniso(),
policy=self.__kinpt.vector_policy(1, False),
names='pressure input')
self[2][2] = atom.Atom(domain=domain.Aniso(),
policy=self.__kinpt.merge_nodefault_policy(
2, False),
names='frequency input')
# input to set the MIDI channel
self[3] = atom.Atom(domain=domain.BoundedInt(0, 16),
init=0,
names="midi channel",
policy=atom.default_policy(self.set_midi_channel))
# inputs to control the velocity curve
self[4] = atom.Atom()
self[4][1] = atom.Atom(domain=domain.BoundedInt(1, 1000),
init=4,
names="velocity sample",
policy=atom.default_policy(self.__set_samples))
self[4][2] = atom.Atom(domain=domain.BoundedFloat(0.1, 10),
init=4,
names="velocity curve",
policy=atom.default_policy(self.__set_curve))
self[4][3] = atom.Atom(domain=domain.BoundedFloat(0.1, 10),
init=4,
names="velocity scale",
policy=atom.default_policy(self.__set_scale))
# inputs to set the minimum and maximum MIDI channel when in poly mode
self[7] = atom.Atom(domain=domain.BoundedInt(1, 16),
init=1,
names="minimum channel",
policy=atom.default_policy(self.set_min_channel))
self[8] = atom.Atom(domain=domain.BoundedInt(1, 16),
init=16,
names="maximum channel",
policy=atom.default_policy(self.set_max_channel))
# parameter mapping
self[12] = self.parameter_list
# control change
self.add_verb2(
1,
'set([],~a,role(None,[matches([midi,program])]),role(to,[numeric]))',
create_action=self.__set_program_change)
self.add_verb2(
2,
'set([],~a,role(None,[matches([midi,bank])]),role(to,[numeric]))',
create_action=self.__set_bank_change)
self.add_verb2(
3,
'set([],~a,role(None,[mass([midi,controller])]),role(to,[numeric]))',
create_action=self.__set_midi_control)
self.set_midi_channel(0)
def __init__(self, min, max, init, **kwd):
Atom.__init__(self,
init=init,
domain=domain.BoundedFloat(min, max),
**kwd)
def __init__(self, address, ordinal):
agent.Agent.__init__(self,
signature=version,
names='cello oscillator',
ordinal=ordinal)
self.domain = piw.clockdomain_ctl()
self[1] = bundles.Output(1, True, names="audio output")
self.output = bundles.Splitter(self.domain, self[1])
self.inst = stk_native.cello(self.output.cookie(), self.domain)
self.input = bundles.VectorInput(self.inst.cookie(),
self.domain,
signals=(2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24))
#self.bow_input = bundles.ScalarInput(self.inst.bow_cookie(), self.domain, signals=(1,2))
self[2] = atom.Atom(names='inputs')
# playing inputs
# frequency
self[2][2] = atom.Atom(names='frequency input',
domain=domain.BoundedFloat(1, 96000),
policy=self.input.vector_policy(2, False))
# bow pressure
self[2][3] = atom.Atom(names='pressure input',
domain=domain.BoundedFloat(0, 1),
policy=self.input.merge_policy(3, False),
protocols='nostage')
# bow position, tranverse position of bow relative to string
self[2][4] = atom.Atom(names='bow position input',
domain=domain.BoundedFloat(-1, 1),
policy=self.input.merge_nodefault_policy(
22, False))
# bow velocity
self[2][5] = atom.Atom(names='bow velocity input',
domain=domain.BoundedFloat(-1, 1),
policy=self.input.merge_nodefault_policy(
23, False))
# pitch sweep time (portomento) for mono mode
self[2][6] = atom.Atom(names='pitch time input',
domain=domain.BoundedFloat(
0,
100000,
hints=(T('stageinc', 10), T('inc', 10),
T('biginc',
1000), T('control', 'updown'))),
init=10,
policy=self.input.merge_policy(4, False))
# TODO: remove
# bow width
#self[2][7] = atom.Atom(names='bow width input', domain=domain.BoundedFloat(0,1), init=0, policy=self.input.merge_policy(5,False))
# minimum frequency limit
self[2][8] = atom.Atom(names='minimum frequency',
domain=domain.BoundedFloat(
0.1,
20,
hints=(T('stageinc', 0.1), T('inc', 0.1),
T('biginc',
0.2), T('control', 'updown'))),
init=20,
policy=self.input.merge_policy(6, False))
# TODO: remove
# string junction mode
#self[2][9] = atom.Atom(names="mode", domain=domain.BoundedFloat(1,2), init=1, policy=self.input.merge_policy(7,False))
# string to body filter parameters
fh = (T('stageinc', 100), T('inc',
100), T('biginc',
10000), T('control', 'updown'))
gh = (T('stageinc', 1), T('inc', 1), T('biginc',
10), T('control', 'updown'))
wh = (T('stageinc', 1), T('inc', 1), T('biginc',
10), T('control', 'updown'))
self[2][10] = atom.Atom(names="low filter frequency",
domain=domain.BoundedFloat(0, 96000, hints=fh),
init=400,
policy=self.input.merge_policy(8, False))
self[2][11] = atom.Atom(names="low filter gain",
domain=domain.BoundedFloat(-96, 24, hints=gh),
init=0,
policy=self.input.merge_policy(9, False))
self[2][12] = atom.Atom(names="low filter width",
domain=domain.BoundedFloat(0.01,
100,
1,
hints=wh),
init=1,
policy=self.input.merge_policy(10, False))
self[2][13] = atom.Atom(names="mid filter frequency",
domain=domain.BoundedFloat(0, 96000, hints=fh),
init=1000,
policy=self.input.merge_policy(11, False))
self[2][14] = atom.Atom(names="mid filter gain",
domain=domain.BoundedFloat(-96, 24, hints=gh),
init=-24,
policy=self.input.merge_policy(12, False))
self[2][15] = atom.Atom(names="mid filter width",
domain=domain.BoundedFloat(0.01,
100,
1,
hints=wh),
init=1,
policy=self.input.merge_policy(13, False))
self[2][16] = atom.Atom(names="high filter frequency",
domain=domain.BoundedFloat(0, 96000, hints=fh),
init=10000,
policy=self.input.merge_policy(14, False))
self[2][17] = atom.Atom(names="high filter gain",
domain=domain.BoundedFloat(-96, 24, hints=gh),
init=-40,
policy=self.input.merge_policy(15, False))
self[2][18] = atom.Atom(names="high filter width",
domain=domain.BoundedFloat(0.01,
100,
1,
hints=wh),
init=1,
policy=self.input.merge_policy(16, False))
# string filter parameters
# TODO: remove
#self[2][19] = atom.Atom(names="string filter frequency", domain=domain.BoundedFloat(0,96000,1), init=800, policy=self.input.merge_policy(17,False))
# TODO: remove
#self[2][20] = atom.Atom(names="string filter width", domain=domain.BoundedFloat(0.01,100,1), init=0.8, policy=self.input.merge_policy(18,False))
# polyphonic bow velocity, to bow independently with keys
# TODO: remove
#self[2][21] = atom.Atom(names='poly bow velocity input', domain=domain.BoundedFloat(-1,1,0), policy=self.input.merge_policy(19,False))
# TODO: remove
#self[2][22] = atom.Atom(names='poly bow enable', domain=domain.Bool(), init=False, policy=self.input.merge_policy(20,False))
# velocity factor, determines velocity of bow from position difference
self[2][23] = atom.Atom(names='bow velocity factor',
domain=domain.BoundedFloat(
0,
100,
1,
hints=(T('stageinc',
1), T('inc', 1), T('biginc', 10),
T('control', 'updown'))),
init=1,
policy=self.input.merge_policy(21, False))
def __init__(self, address, ordinal):
agent.Agent.__init__(self,
signature=version,
names='audio',
icon='plg_macosx/audio.png',
container=9,
ordinal=ordinal)
self.domain = piw.clockdomain_ctl()
self.clone = piw.clone(True)
self.audio = AudioDelegate(self, self.domain)
self.recorder = piw.wavrecorder(self.domain)
self.clone.set_output(1, self.audio.cookie())
self.clone.set_output(2, self.recorder.cookie())
self.input = bundles.ScalarInput(self.clone.cookie(),
self.domain,
signals=(1, 2),
threshold=0)
self.__loading = False
self[1] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names='left input',
policy=self.input.nodefault_policy(1, True))
self[2] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names='right input',
policy=self.input.nodefault_policy(2, True))
self[3] = atom.Atom(
domain=domain.EnumOrNull(44100, 48000, 96000),
names='sample rate',
protocols='bind set',
policy=atom.default_policy(self.__change_sample_rate),
container=(None, 'sample rate', self.verb_container()))
self[3].add_verb2(
1,
'set([],~a,role(None,[instance(~self)]),role(to,[numeric]))',
callback=self.__set_sample_rate)
self[3].add_verb2(2,
'set([un],~a,role(None,[instance(~self)]))',
callback=self.__unset_sample_rate)
self[7] = Port(self)
self[8] = atom.Atom(
domain=domain.BoundedIntOrNull(0, 3072, 0),
names='buffer size',
protocols='bind set',
policy=atom.default_policy(self.__change_buffer_size),
container=(None, 'buffer size', self.verb_container()))
self[8].add_verb2(
1,
'set([],~a,role(None,[instance(~self)]),role(to,[numeric]))',
callback=self.__set_buffer_size)
self[8].add_verb2(2,
'set([un],~a,role(None,[instance(~self)]))',
callback=self.__unset_buffer_size)
self.add_verb2(1, 'mute([],None)', self.__mute)
self.add_verb2(2, 'mute([un],None)', self.__unmute)
self.add_verb2(
3, 'choose([],None,role(None,[ideal([~server,port]),singular]))',
self.__choose)
self.enum()
self.__filename = resource.new_resource_file('audio', 'audio.wav')
self.recorder.setfile(self.__filename)
self[10] = atom.Atom(domain=domain.Bool(),
init=False,
transient=True,
policy=policy.FastPolicy(
self.recorder.record(),
policy.TriggerStreamPolicy()),
names='recorder running input')
def __init__(self, address, ordinal):
agent.Agent.__init__(self,signature=version, names='interpreter',protocols='langagent has_subsys',container=10,ordinal=ordinal)
self.__transcript = resource.open_logfile('transcript')
self.database = database.Database(lexicon_changed=self.__lexicon_changed)
self.help_manager = help_manager.HelpManager()
self.__db_started = False
self.set_property_string('timestamp',self.database.get_lexicon().get_timestamp())
self.__builtin = builtin_misc.Builtins(self,self.database)
self[12] = script.ScriptManager(self,self.__runner)
self.__plumber = plumber.Plumber(self,self.database)
self.__ctxmgr = context.ContextManager(self)
self.__statemgr = node.Server(value=piw.makestring('',0), change=self.__setstatemgr)
self.__state = node.Server()
self.__state[1] = self.__statemgr
self.__state[3] = self.__ctxmgr
self.set_private(self.__state)
self.__interpreters = {}
self.interpreter = interpreter.Interpreter(self, self.database, self, ctx=self.__ctxmgr.default_context())
self.register_interpreter(self.interpreter)
self.queue = interpreter.Queue(self.interpreter)
self[11] = atom.Atom(rtransient=True)
self.__history = feedback.History(self)
self[11].set_private(self.__history)
self.domain = piw.clockdomain_ctl()
self.domain.set_source(piw.makestring('*',0))
self.cloner = piw.clone(True)
self.input = bundles.VectorInput(self.cloner.cookie(),self.domain,signals=(1,2,3,4),filter=piw.last_filter())
self[1] = atom.Atom(names='inputs')
self[1][1] = atom.Atom(domain=domain.BoundedFloat(0,1),policy=self.input.vector_policy(1,False),names='key input')
self[1][2] = atom.Atom(domain=domain.BoundedFloat(-1,1),policy=self.input.vector_policy(2,False),names='roll input')
self[1][3] = atom.Atom(domain=domain.BoundedFloat(-1,1),policy=self.input.vector_policy(3,False),names='yaw input')
self[1][4] = atom.Atom(domain=domain.BoundedFloat(0,1),policy=self.input.vector_policy(4,False),names='pressure input')
self.cloner.set_output(1,self.__history.cookie())
self[2] = atom.Atom(init='',names='word output',domain=domain.String())
self[5] = atom.Atom(names='outputs')
self[5][1] = bundles.Output(1,False, names='key output')
self[5][2] = bundles.Output(2,False, names='roll output')
self[5][3] = bundles.Output(3,False, names='yaw output')
self[5][4] = bundles.Output(4,False, names='pressure output')
self.output1 = bundles.Splitter(self.domain,*self[5].values())
self.cloner.set_output(2,self.output1.cookie())
self.add_verb2(30,'message([],None,role(None,[abstract]))', self.__message)
self.add_verb2(150,'execute([],None,role(None,[abstract]))',self.__runscript)
self.add_verb2(151,'load([],None,role(None,[matches([help])]))',self.__loadhelp)
self.add_verb2(152,'identify([],None,role(None,[concrete]))',self.__identify)
self.add_builtins(self.__builtin)
self.add_builtins(self.__ctxmgr)
self.add_builtins(self.__plumber)
self.__messages_on = True
self[4] = atom.Atom(names='messages',policy=atom.default_policy(self.__messages),domain=domain.Bool(),init=True)
self[3] = variable.VariableManager(self)
self.add_builtins(self[3])
# TODO: how should the port number be chosen to avoid clashes with multiple eigenDs?
# perhaps could get a free socket like this:
# import socket
#s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#s.bind(('',0))
#port = s.getsockname()[1]
#s.close()
self.xmlrpc_server_port = 55553;
self.widgets = widget.WidgetManager(self, self.xmlrpc_server_port)
self.database.set_widget_manager(self.widgets)
# Stage tab data
self[14] = stage_server.TabList(self)
self.tabs = self[14]
self[15] = self.widgets
def __init__(self, address, ordinal):
agent.Agent.__init__(self,
signature=version,
names='scaler',
protocols='bind set',
container=5,
ordinal=ordinal)
self.domain = piw.clockdomain_ctl()
self.domain.set_source(piw.makestring('*', 0))
self.__fixed = False
self.set_private(
node.Server(value=piw.makebool(False, 0), change=self.__changefix))
self[1] = atom.Atom(names='outputs')
self[1][2] = bundles.Output(2, False, names='pressure output')
self[1][3] = bundles.Output(3, False, names='roll output')
self[1][4] = bundles.Output(4, False, names='yaw output')
self[1][7] = bundles.Output(5, False, names='key output')
self[1][5] = bundles.Output(6, False, names='scale note output')
self[1][6] = bundles.Output(7, False, names='frequency output')
self[2] = bundles.Output(1,
False,
names='light output',
protocols='revconnect')
self.lights = bundles.Splitter(self.domain, self[2])
self.ctl = piw.scaler_controller(self.lights.cookie())
self.ctl_input = bundles.VectorInput(self.ctl.cookie(),
self.domain,
signals=(1, ))
self.output = bundles.Splitter(self.domain, *self[1].values())
self.filter = piw.scaler(self.ctl, self.output.cookie(), cubic())
self.input = bundles.VectorInput(self.filter.cookie(),
self.domain,
signals=(2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17,
18))
self.input.correlator.clocksink().add_upstream(
self.ctl_input.correlator.clocksink())
self[4] = atom.Atom(names='inputs')
self[4][2] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.input.merge_policy(2, False),
names='pressure input',
protocols='nostage')
self[4][3] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.input.merge_policy(3, False),
names='roll input',
protocols='nostage')
self[4][4] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.input.merge_policy(4, False),
names='yaw input',
protocols='nostage')
self[4][22] = atom.Atom(domain=domain.Aniso(),
policy=self.input.vector_policy(5, False),
names='key input')
th = (T('stageinc', 1), T('inc', 1), T('biginc',
1), T('control', 'updown'))
bh = (T('stageinc', 0.5), T('inc', 0.5), T('biginc',
12), T('control', 'updown'))
sh = (T('choices', '[0,2,4,5,7,9,11,12]',
'[0,1,2,3,4,5,6,7,8,9,10,11,12]', '[0,2,4,6,8,10,12]',
'[0,2,3,5,7,8,10,12]', '[0,3,5,6,7,10,12]',
'[0,2,3,6,7,8,11,12]', '[0,3,5,7,10,12]', '[0,2,4,7,9,12]'),
T('control', 'selector'))
self[4][5] = atom.Atom(domain=domain.BoundedFloat(0, 12, hints=th),
policy=self.input.merge_policy(6, False),
names='tonic input',
protocols='bind set',
container=(None, 'tonic',
self.verb_container()))
self[4][6] = atom.Atom(domain=domain.BoundedFloat(-20, 20, hints=th),
policy=self.input.merge_policy(7, False),
names='base note input',
protocols='bind')
self[4][7] = atom.Atom(domain=domain.String(hints=sh),
init='[0,2,4,5,7,9,11,12]',
policy=self.input.merge_policy(8, False),
names='scale input',
protocols='bind set',
container=(None, 'scale',
self.verb_container()))
self[4][8] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.input.merge_policy(
9, policy.LopassStreamPolicy(200, 0.6)),
names='key pitch bend input',
protocols='explicit')
self[4][9] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.input.merge_policy(10, False),
names='global pitch bend input')
self[4][10] = atom.Atom(domain=domain.BoundedFloat(0, 72, hints=bh),
init=1,
policy=self.input.merge_policy(11, False),
names='key bend range input',
protocols='bind explicit')
self[4][11] = atom.Atom(domain=domain.BoundedFloat(0, 72, hints=bh),
init=12,
policy=self.input.merge_policy(12, False),
names='global bend range input',
protocols='bind')
self[4][12] = atom.Atom(domain=domain.Aniso(),
policy=self.ctl_input.vector_policy(1, False),
names='controller input')
self[4][13] = atom.Atom(domain=domain.Bool(),
policy=self.input.merge_policy(14, False),
names='override',
protocols='bind')
self[4][14] = atom.Atom(domain=domain.BoundedFloat(-1, 9, hints=th),
init=3,
policy=self.input.merge_policy(15, False),
names='octave input',
protocols='bind',
container=(None, 'octave',
self.verb_container()))
self[4][15] = atom.Atom(domain=domain.BoundedInt(1, 4),
init=2,
policy=atom.default_policy(self.__set_curve),
names='curve',
protocols='bind')
self[4][17] = atom.Atom(domain=domain.BoundedFloat(-10, 10, hints=th),
init=0,
policy=self.input.merge_policy(17, False),
names='relative octave input',
protocols='bind')
self[4][18] = atom.Atom(domain=domain.BoundedFloat(-96, 96, hints=th),
policy=self.input.merge_policy(18, False),
names='modifier input')
self.add_verb2(
3,
'choose([],None,role(none,[ideal([None,scale]),singular]))',
callback=self.__tune_scale)
self.add_verb2(5, 'fix([],None)', callback=self.__fix)
self.add_verb2(6, 'fix([un],None)', callback=self.__unfix)
self[4][5].add_verb2(
1,
'set([],~a,role(None,[instance(~self)]),role(to,[ideal([None,note]),singular]))',
callback=self.__tune_tonic)
self[4][7].add_verb2(
2,
'set([],~a,role(None,[instance(~self)]),role(to,[ideal([None,scale]),singular]))',
callback=self.__tune_scale)
def __init__(self, address, ordinal):
agent.Agent.__init__(self,
signature=version,
names='talker',
container=5,
ordinal=ordinal)
self.add_mode2(
4,
'mode([],role(when,[singular,numeric]),option(using,[instance(~server)]))',
self.__mode, self.__query, self.__cancel_mode, self.__attach_mode)
self.add_mode2(
7,
'mode([],role(when,[singular,numeric]),role(called,[singular,numeric]),option(using,[instance(~server)]))',
self.__cmode, self.__cquery, self.__cancel_mode,
self.__attach_mode)
self.add_verb2(1,
'cancel([],None,role(None,[ideal([~server,event])]))',
self.__cancel_verb)
self.add_verb2(
8,
'cancel([],None,role(None,[singular,numeric]),role(called,[singular,numeric]))',
self.__cancel_verb_called)
self.add_verb2(
5,
'colour([],None,role(None,[singular,numeric]),role(to,[singular,numeric]))',
self.__color_verb)
self.add_verb2(
6,
'colour([],None,role(None,[singular,numeric]),role(to,[singular,numeric]),role(from,[singular,numeric]))',
self.__all_color_verb)
self.add_mode2(
10,
'mode([silent],role(when,[singular,numeric]),option(using,[instance(~server)]))',
self.__mode_silent, self.__query, self.__cancel_mode,
self.__attach_mode)
self.domain = piw.clockdomain_ctl()
self.domain.set_source(piw.makestring('*', 0))
self.__size = 0
self[1] = bundles.Output(1,
False,
names='light output',
protocols='revconnect')
self.light_output = bundles.Splitter(self.domain, self[1])
self.light_convertor = piw.lightconvertor(self.light_output.cookie())
self.light_aggregator = piw.aggregator(self.light_convertor.cookie(),
self.domain)
self.controller = piw.controller(self.light_aggregator.get_output(1),
utils.pack_str(1))
self.activation_input = bundles.VectorInput(self.controller.cookie(),
self.domain,
signals=(1, ))
self[2] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.activation_input.local_policy(
1, False),
names='activation input',
protocols='nostage')
self[3] = atom.Atom(creator=self.__create, wrecker=self.__wreck)
self[4] = PhraseBrowser(self.__eventbykey, self.__keylist)
def __init__(self, address, ordinal):
#
# Agents are constructed with the address and ordinal. Each
# agent will have a unique address and an ordinal unique for
# that type of agent.
#
# We also pass in the automatically generated version to go into
# the metadata.
#
agent.Agent.__init__(self, signature=version, names='latch', ordinal=ordinal)
#
# Create a clock domain. A clock domain is a collection of clock
# sinks all of which share common properties. Domains can be isochronous
# or anisochronous. Currently, sinks in iso domains can be connected
# only to other iso domains using the same source.
#
self.domain = piw.clockdomain_ctl()
#
# Make our domain anisochronous (aniso is used for everything except audio)
#
self.domain.set_source(piw.makestring('*',0))
#
# Create an atom to bundle the outputs also create sub-atoms that correspond to
# each of the input streams.
# An output is created on each sub-atom with a dedicated signal number and name.
# Setting the second argument to false means that they're not isochronous data streams.
#
self[2] = atom.Atom(names="outputs")
self[2][1] = bundles.Output(1, False, names='activation output')
self[2][2] = bundles.Output(2, False, names='pressure output')
self[2][3] = bundles.Output(3, False, names='roll output')
self[2][4] = bundles.Output(4, False, names='yaw output')
#
# bundles.Splitter is a bundle component which demultiplexes the events onto separate
# Outputs, 1 output per signal. The bundle, which carries events containing signals,
# is represented on the output as signals containing events.
#
self.output = bundles.Splitter(self.domain,*self[2].values())
#
# Create an instance of the native Latch implementation and pass it the clock domain
# and the upstream cookie for the output data.
#
self.native = latch(self.domain, self.output.cookie())
#
# Create an input. An input does the work of correlating the events on a
# number of signals, grouping them together.
#
# A Vector input is a proper multiple channel input. This one is being
# constructed to handle 4 signals, numbered 1,2,3 and 4. The events will
# be sent to the output stage through the use of the native implementation's cookie.
#
self.key_input = bundles.VectorInput(self.native.cookie(), self.domain, signals=(1,2,3,4))
#
# Create a null atom just to group our inputs. We still name this atom so that it
# shows up with a meaningful name through introspection by tools like Workbench.
#
self[1] = atom.Atom(names="inputs")
#
# Now create our inputs. The data policy for the atom is created by our vector input.
# There are lots of corner cases when we invert our model from signal-contains-events
# to event-contains-signals. In particular, this happens when events on individual
# signals dont start and and stop together.
#
# Any input with a vector_policy will create or join an existing event.
# merge_policy will never create events, just join onto existing events created by
# a vector policy.
#
# We create 4 inputs, with vector policies routing them to signals 1,2,3 and 4 on
# our bundle. These are all non-iso inputs.
#
self[1][1] = atom.Atom(domain=domain.BoundedFloat(0,1), policy=self.key_input.vector_policy(1,False), names='activation input')
self[1][2] = atom.Atom(domain=domain.BoundedFloat(0,1), policy=self.key_input.vector_policy(2,False), names='pressure input')
self[1][3] = atom.Atom(domain=domain.BoundedFloat(-1,1), policy=self.key_input.vector_policy(3,False), names='roll input')
self[1][4] = atom.Atom(domain=domain.BoundedFloat(-1,1), policy=self.key_input.vector_policy(4,False), names='yaw input')
#
# Lastly, create atoms called 'minimum' and 'controller' to store values for those.
# These will appear in Stage and can be set using Belcanto. When they changes, the
# methods __minimum and __controller will be called with a Python numeric argument
# (because its a numeric domain).
#
self[3] = atom.Atom(domain=domain.BoundedFloat(0,1), init=0.5, policy=atom.default_policy(self.__minimum), names='minimum')
self[4] = atom.Atom(domain=domain.BoundedInt(2,4), init=2, policy=atom.default_policy(self.__controller), names='controller')
def __init__(self, name):
agent.Agent.__init__(self,
signature=upgrade.Signature(),
volatile=True,
names='eigencommander',
ordinal=1)
self.name = name
self.node = random.randrange(0, 1 << 48L) | 0x010000000000L
self.langModel = gui.call_bg_sync(self.__create_lang)
self.historyModel = history.HistoryModel(self.langModel)
self.commandModel = command.CommandModel(self.langModel)
self.dictionaryModel = dictionary.DictionaryModel(self.langModel)
self.cdomain = piw.clockdomain_ctl()
self.cdomain.set_source(piw.makestring('*', 0))
self[25] = scroller.Scroller(self.__scroll1,
self.__tap1,
names="scroller",
ordinal=1) # scrolls the dictionary pane
self[26] = scroller.Scroller(self.__scroll2,
self.__tap2,
names="scroller",
ordinal=2) # scrolls the history pane
self.scroller_clone = piw.clone(True)
self.scroller_clone.set_output(1, self[25].cookie())
self.scroller_clone.set_output(2, self[26].cookie())
self.scroller_in = bundles.VectorInput(self.scroller_clone.cookie(),
self.cdomain,
signals=(1, 2, 3, 4))
self[28] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
init=0,
names='roll',
policy=self.scroller_in.merge_policy(2, False))
self[29] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
init=0,
names='yaw',
policy=self.scroller_in.merge_policy(1, False))
self[30] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
init=0,
names='key',
policy=self.scroller_in.vector_policy(3, False))
self[31] = atom.Atom(domain=domain.Aniso(),
names='controller',
policy=self.scroller_in.merge_policy(4, False))
self[9] = dictionary.DictionaryAgent(self, dictionary.getName())
self.add_verb2(2, 'minimise([],None)', callback=self.__minimise)
self.add_verb2(3, 'maximise([],None)', callback=self.__maximise)
self.font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
self.font.SetPointSize(fonts.DEFAULT_PTS)
self[12] = atom.Atom(domain=domain.BoundedInt(5, 20, rest=11),
names='text',
protocols='nostage',
policy=atom.default_policy(self.__set_fontsize))
self.__size = node.Server(change=self.__size_changed)
self.set_private(node.Server())
self.get_private()[1] = self.__size
self.__x = 100
self.__y = 100
self.__setup_size()
self.__minX = 60
self.__minY = 80
self.__maxX = 100
self.__maxY = 100
self.__rootFrame = None
self.__createRootFrame()
self[25].reset(1, -1)
self[26].reset(-1, 1)
self[25].enable()
self[26].enable()
def __init__(self, address, ordinal):
# the agent event clock
self.domain = piw.clockdomain_ctl()
# verb container, used by all taps
agent.Agent.__init__(self,
signature=version,
names='convolver',
container=3,
ordinal=ordinal)
self.vol = piw.make_f2f_table(
-24, 24, 1000, picross.make_f2f_functor(volume_function))
# outputs
self[1] = bundles.Output(1, True, names="left audio output")
self[2] = bundles.Output(2, True, names="right audio output")
self.output = bundles.Splitter(self.domain, self[1], self[2])
# the convolver class
self.convolver = convolver_native.convolver(self.vol,
self.output.cookie(),
self.domain)
# input has the correlator and a bundle style output
self.input = bundles.ScalarInput(self.convolver.cookie(),
self.domain,
signals=(1, 2, 3, 4))
# self[3] = verb container
self[4] = ImpulseBrowser(self)
# audio inputs
# use vector policy inputs
self[5] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names="left audio input",
policy=self.input.nodefault_policy(1, True))
self[6] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
names="right audio input",
policy=self.input.nodefault_policy(2, True))
# wet/dry mix
self[7] = atom.Atom(domain=domain.BoundedFloat(
-24,
24,
hints=(T('stageinc', 0.1), T('inc',
0.1), T('biginc',
1), T('control', 'updown'))),
init=0,
names="dry gain",
protocols='input',
policy=self.input.merge_policy(3, False))
self[11] = atom.Atom(domain=domain.BoundedFloat(
-24,
24,
hints=(T('stageinc', 0.1), T('inc',
0.1), T('biginc',
1), T('control', 'updown'))),
init=0,
names="wet gain",
protocols='input',
policy=self.input.merge_policy(4, False))
# effect enable
self[8] = atom.Atom(domain=domain.Bool(),
init=True,
names="enable",
protocols='input',
policy=atom.default_policy(self.__set_enable))
# mono processing mode
self[9] = atom.Atom(domain=domain.Bool(),
init=False,
names="mono",
policy=atom.default_policy(
self.__set_mono_processing))
# enable time, time to fade in and out when enabling in ms
self[10] = atom.Atom(
names='enable time input',
domain=domain.BoundedFloat(0,
100000,
hints=(T('stageinc', 1), T('inc', 1),
T('biginc',
10), T('control', 'updown'))),
init=100,
policy=atom.default_policy(self.__set_enable_time))
self.__set_enable(self[8].get_value())
self.__set_mono_processing(self[9].get_value())
self.__set_enable_time(self[10].get_value())
self.add_verb2(
1,
'choose([],None,role(None,[ideal([~server,impulse]),singular]))',
self.__choose)
def __init__(self, usbname, ordinal, dom, remove):
agent.Agent.__init__(self,
names='keyboard pico',
ordinal=ordinal,
signature=version,
subsystem='kbd',
volatile=True,
container=102,
protocols='is_subsys')
self.usbname = usbname
self.remover = remove
self.domain = piw.clockdomain_ctl()
self.domain.set_source(piw.makestring('*', 0))
self[1] = bundles.Output(1, False, names='activation output')
self[2] = bundles.Output(2, False, names='pressure output')
self[3] = bundles.Output(3, False, names='roll output')
self[4] = bundles.Output(4, False, names='yaw output')
self[5] = bundles.Output(1, False, names='strip position output')
self[6] = bundles.Output(1, False, names='breath output')
self[8] = bundles.Output(2, False, names='absolute strip output')
self.led_backend = piw.functor_backend(1, True)
self.status_mixer = piw.statusmixer(self.led_backend.cookie())
self.led_input = bundles.VectorInput(self.status_mixer.cookie(),
self.domain,
signals=(1, ))
self[7] = atom.Atom(names='light input',
protocols='revconnect',
policy=self.led_input.vector_policy(
1, False, False, auto_slot=True),
domain=domain.Aniso())
self.koutput = bundles.Splitter(self.domain, self[1], self[2], self[3],
self[4])
self.kpoly = piw.polyctl(10, self.koutput.cookie(), False, 5)
self.soutput = bundles.Splitter(self.domain, self[5], self[8])
self.boutput = bundles.Splitter(self.domain, self[6])
self.kclone = piw.sclone()
self.kclone.set_filtered_output(1, self.kpoly.cookie(),
piw.first_filter(1))
self.kclone.set_filtered_output(2, self.soutput.cookie(),
piw.first_filter(2))
self.kclone.set_filtered_output(3, self.boutput.cookie(),
piw.first_filter(3))
self.keyboard = pkbd_native.bundle(usbname, self.kclone.cookie(),
utils.notify(self.dead),
utils.changify(self.signal))
self[100] = VirtualKey()
#self[102] = vc
self[251] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=self.keyboard.get_threshold1(),
protocols='input output',
names='soft threshold',
policy=atom.default_policy(
self.keyboard.set_threshold1))
self[249] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=self.keyboard.get_threshold2(),
protocols='input output',
names='hard threshold',
policy=atom.default_policy(
self.keyboard.set_threshold2))
self[240] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=self.keyboard.get_roll_axis_window(),
protocols='input output',
names='roll axis window',
policy=atom.default_policy(
self.keyboard.set_roll_axis_window))
self[241] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=self.keyboard.get_yaw_axis_window(),
protocols='input output',
names='yaw axis window',
policy=atom.default_policy(
self.keyboard.set_yaw_axis_window))
self[242] = atom.Atom(domain=domain.Bool(),
init=False,
protocols='input output',
names='k logging',
policy=atom.default_policy(
self.keyboard.enable_key_logging))
f = self.keyboard.led_functor()
self.led_backend.set_functor(piw.pathnull(0), f)
self[9] = atom.Atom(names='controller output',
domain=domain.Aniso(),
init=self.__courses())
def __init__(self, address, ordinal):
agent.Agent.__init__(self,signature=version,names='audio unit',container=100)
self.set_property_long('cordinal',ordinal)
self.__state = PluginState(self.__plugin_state_loaded)
self.set_private(self.__state)
self.__browser = PluginBrowser(self)
self.__domain = piw.clockdomain_ctl()
self.__audio_output = audio.AudioOutput(bundles.Splitter(self.__domain),1,2)
self.__audio_output_channels = audio.AudioChannels(self.__audio_output)
self.__midi_output = bundles.Splitter(self.__domain)
self.__observer = PluginObserver(self.__state,self)
self.__channel_delegate = MidiChannelDelegate(self)
self.__host = host_native.plugin_instance(
self.__observer, self.__channel_delegate,
self.__domain,self.__audio_output.cookie(),self.__midi_output.cookie(),
utils.statusify(self.__window_state_changed))
self.parameter_list = inputparameter.List(self.__host,self.__host.clock_domain(),self.verb_container())
self.__audio_input = audio.AudioInput(bundles.ScalarInput(self.__host.audio_input(),self.__domain,signals=range(1,65)),1,2)
self.__audio_input_channels = audio.AudioChannels(self.__audio_input)
self.__velocity_detector = piw.velocitydetect(self.__host.midi_from_belcanto(),1,4)
self.__key_input = bundles.VectorInput(self.__velocity_detector.cookie(),self.__domain,signals=(1,2))
self.__midi_input = bundles.ScalarInput(self.__host.midi_aggregator(),self.__domain,signals=(1,))
self.__metronome_input = bundles.ScalarInput(self.__host.metronome_input(),self.__domain,signals=(1,2,3,4))
self.__host.set_bypassed(True)
# plugin browser
self[1] = self.__browser
# audio output
self[2] = atom.Atom()
self[2][1] = self.__audio_output
self[2][2] = self.__audio_output_channels
# audio input
self[3] = atom.Atom()
self[3][1] = self.__audio_input
self[3][2] = self.__audio_input_channels
# parameter mapping
self[4] = self.parameter_list
# metronome input
self[5] = atom.Atom()
self[5][1] = atom.Atom(domain=domain.Aniso(),policy=self.__metronome_input.nodefault_policy(1,False),names='song beat input')
self[5][2] = atom.Atom(domain=domain.Aniso(),policy=self.__metronome_input.nodefault_policy(2,False),names='running input')
self[5][3] = atom.Atom(domain=domain.Aniso(),policy=self.__metronome_input.nodefault_policy(3,False),names='tempo input')
self[5][4] = atom.Atom(domain=domain.Aniso(),policy=self.__metronome_input.nodefault_policy(4,False),names='bar beat input')
# kbd/controller inputs
self[6] = atom.Atom()
self[6][1] = atom.Atom(domain=domain.Aniso(),policy=self.__key_input.vector_policy(1,False),names='pressure input')
self[6][2] = atom.Atom(domain=domain.Aniso(),policy=self.__key_input.merge_nodefault_policy(2,False),names='frequency input')
# midi channel
self[7] = atom.Atom(domain=domain.BoundedInt(0,16),init=0,names='midi channel',policy=atom.default_policy(self.set_midi_channel))
# velocity curve control
self[8] = atom.Atom()
self[8][1] = atom.Atom(domain=domain.BoundedInt(1,1000),init=4,names='velocity sample',policy=atom.default_policy(self.__set_velocity_samples))
self[8][2] = atom.Atom(domain=domain.BoundedFloat(0.1,10),init=4,names='velocity curve',policy=atom.default_policy(self.__set_velocity_curve))
self[8][3] = atom.Atom(domain=domain.BoundedFloat(0.1,10),init=4,names='velocity scale',policy=atom.default_policy(self.__set_velocity_scale))
self[10] = atom.Atom(domain=domain.BoundedFloatOrNull(0,100000),init=None,names='tail time',policy=atom.default_policy(self.__set_tail_time))
self[11] = atom.Atom(domain=domain.BoundedInt(1,16),init=1,names='minimum channel',policy=atom.default_policy(self.set_min_channel))
self[12] = atom.Atom(domain=domain.BoundedInt(1,16),init=16,names='maximum channel',policy=atom.default_policy(self.set_max_channel))
# status output to drive the talker lights
self[13] = bundles.Output(1,False,names='status output')
self.light_output = bundles.Splitter(self.__domain,self[13])
self.lights = piw.lightsource(piw.change_nb(),0,self.light_output.cookie())
self.lights.set_size(2)
self.set_light(1,True)
self.set_light(2,False)
# midi I/O
# midi input
self[14] = atom.Atom(domain=domain.Aniso(),policy=self.__midi_input.nodefault_policy(1,False),names='midi input')
# midi output
self[15] = self.__midi_output.add_output(bundles.Output(1,False,names='midi output'))
self.add_verb2(1,'show([],None)',callback=self.__show)
self.add_verb2(2,'show([un],None)',callback=self.__unshow)
self.add_verb2(3,'close([],None)',callback=self.__close)
self.add_verb2(4,'bypass([toggle],None)',callback=self.__tog_bypass,status_action=self.__status_bypass)
self.add_verb2(5,'show([toggle],None)',callback=self.__tog_show,status_action=self.__status_show)
self.add_verb2(6,'open([],None,role(None,[abstract]))',callback=self.__open)
self.add_verb2(7,'scan([],None)',callback=self.__browser.refresh_plugin_list)
self.add_verb2(8,'bypass([],None)',callback=self.__bypass)
self.add_verb2(9,'bypass([un],None)',callback=self.__unbypass)
self.set_ordinal(ordinal)
def set_threshhold(self):
self[241] = atom.Atom(
domain=domain.BoundedInt(0, 4095),
init=self.keyboard.get_pedal_min(1),
protocols='input output explicit',
names='pedal minimum threshold',
ordinal=1,
policy=atom.default_policy(lambda v: self.__set_min(1, v)))
self[242] = atom.Atom(
domain=domain.BoundedInt(0, 4095),
init=self.keyboard.get_pedal_max(1),
protocols='input output explicit',
names='pedal maximum threshold',
ordinal=1,
policy=atom.default_policy(lambda v: self.__set_max(1, v)))
self[243] = atom.Atom(
domain=domain.BoundedInt(0, 4095),
init=self.keyboard.get_pedal_min(2),
protocols='input output explicit',
names='pedal minimum threshold',
ordinal=2,
policy=atom.default_policy(lambda v: self.__set_min(2, v)))
self[244] = atom.Atom(
domain=domain.BoundedInt(0, 4095),
init=self.keyboard.get_pedal_max(2),
protocols='input output explicit',
names='pedal maximum threshold',
ordinal=2,
policy=atom.default_policy(lambda v: self.__set_max(2, v)))
self[245] = atom.Atom(
domain=domain.BoundedInt(0, 4095),
init=self.keyboard.get_pedal_min(3),
protocols='input output explicit',
names='pedal minimum threshold',
ordinal=3,
policy=atom.default_policy(lambda v: self.__set_min(3, v)))
self[246] = atom.Atom(
domain=domain.BoundedInt(0, 4095),
init=self.keyboard.get_pedal_max(3),
protocols='input output explicit',
names='pedal maximum threshold',
ordinal=3,
policy=atom.default_policy(lambda v: self.__set_max(3, v)))
self[247] = atom.Atom(
domain=domain.BoundedInt(0, 4095),
init=self.keyboard.get_pedal_min(4),
protocols='input output explicit',
names='pedal minimum threshold',
ordinal=4,
policy=atom.default_policy(lambda v: self.__set_min(4, v)))
self[248] = atom.Atom(
domain=domain.BoundedInt(0, 4095),
init=self.keyboard.get_pedal_max(4),
protocols='input output explicit',
names='pedal maximum threshold',
ordinal=4,
policy=atom.default_policy(lambda v: self.__set_max(4, v)))
self[251] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=self.keyboard.get_threshold1(),
protocols='input output',
names='soft threshold',
policy=atom.default_policy(
self.keyboard.set_threshold1))
self[249] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=self.keyboard.get_threshold2(),
protocols='input output',
names='hard threshold',
policy=atom.default_policy(
self.keyboard.set_threshold2))
self[252] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=self.keyboard.get_roll_axis_window(),
protocols='input output',
names='roll axis window',
policy=atom.default_policy(
self.keyboard.set_roll_axis_window))
self[253] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=self.keyboard.get_yaw_axis_window(),
protocols='input output',
names='yaw axis window',
policy=atom.default_policy(
self.keyboard.set_yaw_axis_window))
def __init__(self, name):
agent.Agent.__init__(self,
signature=upgrade.Signature(),
names='eigenbrowser',
volatile=True)
self.name = name
self.node = random.randrange(0, 1 << 48L) | 0x010000000000L
self.langModel = gui.call_bg_sync(self.__create_lang)
self.historyModel = history.HistoryModel(self.langModel)
self.cdomain = piw.clockdomain_ctl()
self.cdomain.set_source(piw.makestring('*', 0))
self.scroller1 = Scroller2(
self.__scroll1) # scrolls the left hand pane
self.scroller2 = Scroller(
self.__scroll2, self.__tap2) # scrolls the right hand (dinfo) pane
self.scroller3 = Scroller(self.__scroll3,
self.__tap3) # scrolls the path pane
self.scroller_in1 = bundles.VectorInput(self.scroller1.cookie(),
self.cdomain,
signals=(1, 2, 3))
self.scroller_in2 = bundles.VectorInput(self.scroller2.cookie(),
self.cdomain,
signals=(1, 2, 3))
self.scroller_in3 = bundles.VectorInput(self.scroller3.cookie(),
self.cdomain,
signals=(1, 2, 3))
nudge = (T('inc', 0.1), )
self[1] = atom.Atom(domain=domain.BoundedFloat(-1, 1, hints=nudge),
init=0,
names='sideways nudger',
ordinal=1,
policy=self.scroller_in1.vector_policy(1, False))
#self[2] = atom.Atom(domain=domain.BoundedFloat(-1,1,hints=nudge), init=0, names='vertical nudger', ordinal=1, policy=self.scroller_in1.vector_policy(2,False),rtransient=True)
self[2] = atom.Atom(domain=domain.BoundedFloat(-1, 1, hints=nudge),
init=0,
names='vertical nudger',
ordinal=1,
policy=self.scroller_in1.vector_policy(2, False))
self[3] = atom.Atom(domain=domain.BoundedFloat(-1, 1, hints=nudge),
init=0,
names='sideways nudger',
ordinal=2,
policy=self.scroller_in2.vector_policy(1, False))
self[4] = atom.Atom(domain=domain.BoundedFloat(-1, 1, hints=nudge),
init=0,
names='vertical nudger',
ordinal=2,
policy=self.scroller_in2.vector_policy(2, False))
self[8] = browse.BrowseAgent(self, browse.getName())
self.add_verb2(1,
'browse([],None,role(None,[proto(browse),singular]))',
callback=self.__do_browse)
self.add_verb2(2, 'minimise([],None)', callback=self.__minimise)
self.add_verb2(3, 'maximise([],None)', callback=self.__maximise)
self.font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
self.font.SetPointSize(fonts.DEFAULT_PTS)
self[12] = atom.Atom(domain=domain.BoundedInt(5, 20, rest=11),
names='text',
policy=atom.default_policy(self.__set_fontsize))
self[15] = atom.Atom(domain=domain.BoundedFloat(-1, 1, hints=nudge),
init=-1,
names='sideways nudger',
ordinal=3,
policy=self.scroller_in3.vector_policy(1, False))
self[16] = atom.Atom(domain=domain.BoundedFloat(-1, 1, hints=nudge),
init=-1,
names='vertical nudger',
ordinal=3,
policy=self.scroller_in3.vector_policy(2, False))
self[17] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0,
names='tapper',
ordinal=1,
policy=self.scroller_in1.vector_policy(3, False))
self[18] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0,
names='tapper',
ordinal=2,
policy=self.scroller_in2.vector_policy(3, False))
self[19] = atom.Atom(domain=domain.BoundedFloat(0, 1),
init=0,
names='tapper',
ordinal=3,
policy=self.scroller_in3.vector_policy(3, False))
self.__size = node.Server(change=self.__size_changed)
self.set_private(node.Server())
self.get_private()[1] = self.__size
self.__x = 100
self.__y = 100
self.__setup_size()
self.__minX = 60
self.__minY = 80
self.__maxX = 100
self.__maxY = 100
self.__rootFrame = None
self.__createRootFrame()
# self.scroller2.reset(-1,-1)
self.scroller3.reset(-1, 1)
self.scroller1.set_scheme(1)
self.scroller1.enable()
self.scroller2.enable()
self.scroller3.enable()
def __init__(self, address, ordinal):
self.domain = piw.clockdomain_ctl()
vc = atom.VerbContainer(clock_domain=self.domain)
agent.Agent.__init__(self,
signature=version,
names='arranger',
protocols='bind',
container=(9, 'agent', vc),
ordinal=ordinal)
self[1] = self.verb_container()
self.model = arranger_native.model(self.domain)
self.light_output = bundles.Output(1,
False,
names='light output',
protocols='revconnect')
self.light_splitter = bundles.Splitter(self.domain, self.light_output)
self.light_convertor = piw.lightconvertor(self.light_splitter.cookie())
self.view = arranger_native.view(self.model,
self.light_convertor.cookie())
self.ctlr_fb = piw.functor_backend(1, True)
self.ctlr_fb.set_functor(piw.pathnull(0), self.view.control())
self.ctlr_input = bundles.ScalarInput(self.ctlr_fb.cookie(),
self.domain,
signals=(1, ))
self[2] = atom.Atom(domain=domain.Aniso(),
policy=self.ctlr_input.policy(1, False),
names='controller input')
self.kinput = bundles.VectorInput(self.view.cookie(),
self.domain,
signals=(1, 2, 3))
self[3] = atom.Atom()
self[3][1] = atom.Atom(domain=domain.BoundedFloat(0, 1),
policy=self.kinput.vector_policy(1, False),
names='pressure input',
protocols='nostage')
self[3][2] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.kinput.merge_policy(2, False),
names='roll input',
protocols='nostage')
self[3][3] = atom.Atom(domain=domain.BoundedFloat(-1, 1),
policy=self.kinput.merge_policy(3, False),
names='yaw input',
protocols='nostage')
self[3][4] = self.light_output
self.cinput = bundles.ScalarInput(self.model.cookie(),
self.domain,
signals=(1, 2))
self.cinput.add_upstream(self.verb_container().clock)
self[4] = atom.Atom()
self[4][1] = atom.Atom(domain=domain.Aniso(),
policy=self.cinput.nodefault_policy(1, False),
names='song beat input')
self[4][2] = atom.Atom(domain=domain.Aniso(),
policy=self.cinput.nodefault_policy(2, False),
names='running input')
self[5] = atom.Atom(creator=self.__createtarget,
wrecker=self.__wrecktarget)
self.add_mode2(
1,
'mode([],role(when,[numeric,singular]),option(using,[instance(~server)]))',
self.__mode, self.__query, self.__cancel_mode)
self[7] = Parameters(self)
self.__eventlist = EventList(self)
self.__playstop = node.Server(change=self.__play_change)
self.__playstop[1] = self.__eventlist
self.set_private(self.__playstop)
self.add_verb2(1,
'play([],~self)',
create_action=self.__play,
clock=True)
self.add_verb2(2,
'play([un],~self)',
create_action=self.__unplay,
clock=True)
self.add_verb2(3, 'cancel([],~self,role(None,[numeric,singular]))',
self.__cancel_verb)
self.add_verb2(4, 'clear([],~self)', self.__clear_verb)
self.model.playstop_set(
piw.make_change_nb(utils.slowchange(self.__play_set)))