def __add(self, time, value):
print 'add tempo change to', value, 'at', time
time = action.mass_quantity(time)
value = action.mass_quantity(value)
print 'add tempo change to', value, 'at', time
c = TempoChange(self.beatclock)
self.beat_changes.add(c)
c.setup(time, value)
def __del(self, time, value):
time = action.mass_quantity(time)
value = action.mass_quantity(value)
print 'del tempo change to', value, 'at', time
for (i, c) in self.beat_changes.iteritems():
if c.compare(time, value):
del self.beat_changes[i]
c.clear()
return
def __map_channel(self, subject, cfrom, cto):
cfrom = int(action.mass_quantity(cfrom))
cto = int(action.mass_quantity(cto))
if cfrom < 1 or cfrom > 16:
return errors.invalid_thing(str(cfrom), 'map')
if cto < 1 or cto > 16:
return errors.invalid_thing(str(cto), 'map')
new_mapping = []
new_mapping.append((cfrom, cto))
for m in self.__current_channel_mapping():
if m[0] != cfrom:
new_mapping.append(m)
self.__set_channel_mapping(new_mapping)
def __set_course_int(self,subject,course,interval):
(typ,id) = action.crack_ideal(action.arg_objects(course)[0])
course = int(id)
ints = action.mass_quantity(interval)
print 'set course',course,'ints',ints
self.controller.set_course_steps(int(course),ints)
return action.nosync_return()
def __record(self,subject,duration,mode):
duration = action.mass_quantity(duration)
mode = self.__crack_mode(mode)
if not self.__schedready:
print 'no scheduler'
return async.success(errors.state_error1('scheduler','use'))
result,started,done = self.recorder.record_start(duration)
if result==record_err_no_clock:
print 'metronome isnt started'
return async.success(errors.state_error1('metronome','start'))
if result==record_err_in_prog:
print 'recording already in progress'
return async.success(errors.message('recording already in progress'))
id = self.library.nextid()
if not self.__is_overdub_enabled():
self.__unplay_auto()
print 'recording',duration,'bars',id
def trigger_ok(r,trigger):
cookie = self.player.load(id,r,0)
event,status = self.verb_defer(3,(True,trigger,2,mode),trigger,None,self.cookie_arg(id))
self.player.unload(cookie,False)
self[5].update()
print 'trigger created',trigger,'cookie is', cookie
def trigger_failed(msg):
print 'cannot create trigger',msg
def started_ok(r):
start = r.get_tag(3).as_float()
duration = r.get_tag(4).as_float()
desc = "take %s at song beat %g every %g song beat" % (id,start,duration)
self.library.write(recorder_native.recording(),id)
trigger = self.__scheduler.create_trigger('schema("%s",[m(3,%f,%f)])' % (desc,duration,start%duration))
trigger.setCallback(trigger_ok,r).setErrback(trigger_failed)
print 'record started: start=',start,'duration=',duration
def started_failed(msg):
print 'record failed:',msg
def done_ok(r):
print 'record completed: signals=',r.signals(),'wires=',r.wires(),'start=',r.get_tag(2)
self.library.write(r,id)
def done_failed(msg):
print 'record failed:',msg
self.__unplay_auto()
done.setCallback(done_ok).setErrback(done_failed)
started.setCallback(started_ok).setErrback(started_failed)
return action.nosync_return()
def __uncreate_output(self,subj,mass):
id = int(action.mass_quantity(mass))
channel = self[2].get_channel(id)
if channel is None:
thing='output %s' %str(id)
return async.success(errors.invalid_thing(thing,'un create'))
self[2].del_channel(id)
def __create3(self,subj,voice):
id=int(action.mass_quantity(voice))
voice = self[5].get_voice(id)
if voice is not None:
thing='voice %s' %str(id)
return async.success(errors.already_exists(thing,'create'))
self[5].create_voice(id)
def __uncreate_connector(self, subj, mass):
id = int(action.mass_quantity(mass))
connector = self[4].get_connector(id)
if connector is None:
thing = 'connector %s' % str(id)
return async .success(errors.invalid_thing(thing, 'un create'))
self[4].del_connector(id)
def __kadd(self,subject,k,course=None):
k = str(int(action.mass_quantity(k)))
if course:
course = int(action.mass_quantity(course))-1
else:
course = 0
self.controller.ensure(course+1)
coursekeys = self.__getkeys()
while len(coursekeys) <= course:
coursekeys.append([])
for i in range(0,len(coursekeys)):
if k in coursekeys[i]:
coursekeys[i].remove(k)
coursekeys[course].append(k)
self.__setkeys(coursekeys)
def __kclear(self,subject,course):
if course is None:
self.controller.setlist('courselen',[0])
self.__set_mapping(())
return
course = int(action.mass_quantity(course))-1
coursekeys = self.__getkeys()
if len(coursekeys) > course:
coursekeys[course] = []
self.__setkeys(coursekeys)
def __radd(self,subject,f,t,course):
if course:
course = int(action.mass_quantity(course))-1
else:
course = 0
f = int(action.mass_quantity(f))
t = int(action.mass_quantity(t))
r = map(str,range(f,t+1))
self.controller.ensure(course+1)
coursekeys = self.__getkeys()
while len(coursekeys) <= course:
coursekeys.append([])
coursekeys[course] = []
for i in range(0,len(coursekeys)):
coursekeys[i] = removelist(coursekeys[i],r)
coursekeys[course].extend(r)
self.__setkeys(coursekeys)
def __set_midi_control(self, ctx, subj, ctl, val):
c = action.mass_quantity(ctl)
to = action.abstract_wordlist(val)[0]
c_val = int(c)
to_val = int(to)
if c_val < 0 or c_val > 127:
return errors.invalid_thing(c, 'set')
if to_val < 0 or to_val > 127:
return errors.invalid_thing(to, 'set')
return piw.trigger(
self.host.change_cc(),
utils.makedict_nb(
{
'ctl': piw.makelong_nb(c_val, 0),
'val': piw.makelong_nb(to_val, 0)
}, 0)), None
def verb2_20_connect(self, subject, src, dst, dst_chan, src_chan):
"""
connect([],global_connect,role(None,[or([concrete],[composite([descriptor])])]),role(to,[concrete,singular]),option(into,[mass([channel])]),option(from,[abstract]))
"""
if dst_chan is not None:
dst_chan = int(action.mass_quantity(dst_chan))
if src_chan is not None:
src_chan = action.abstract_string(src_chan)
src_match = re.match('^channel\s+([\d\.]+)$', src_chan,
re.IGNORECASE)
if src_match:
src_chan = src_match.group(1)
else:
yield async .Coroutine.failure("%s is not valid" % src_chan)
to_descriptor = (action.concrete_object(dst), None)
to_descriptor = self.database.to_database_term(to_descriptor)
for ff in action.arg_objects(src):
if action.is_concrete(ff):
from_descriptors = [(action.crack_concrete(ff), None)]
else:
from_descriptors = action.crack_composite(
ff, action.crack_descriptor)
from_descriptors = self.database.to_database_term(from_descriptors)
r = plumber.plumber(self.database,
to_descriptor,
from_descriptors,
dst_chan=dst_chan,
src_chan=src_chan)
yield r
if not r.status():
yield async .Coroutine.failure(*r.args(), **r.kwds())
yield async .Coroutine.success()
def __show_blue(self, ctx, subj, b, v, s):
return self.__show_colour(None, None, float(action.mass_quantity(v)),
action.mass_quantity(s))
def __minimise(self, subj, pedal):
pedal = int(action.mass_quantity(pedal))
self.keyboard.learn_pedal_min(pedal)
self.__setpedal(pedal)
def __unset_breath_modulation(self, a, subj, course):
number = int(action.mass_quantity(course))
self.strumconfig.remove_breath_course(number)
self.__update_strumconfig()
def __show_blue(self,ctx,subj,b,v,s):
return self.__show_colour(None,None,float(action.mass_quantity(v)),action.mass_quantity(s))
def __playnvl(self,ctx,subj,note,velocity,s):
note = action.mass_quantity(note)
velocity = action.mass_quantity(velocity)
length = max(1,int(1000000*action.mass_quantity(s)))
print 'play note',note,'velocity',velocity,'sec',s,'us',length
return self.nplayer.play(note,velocity,length),None
def __set_open_course_key(self, a, subj, key, course):
number = int(action.mass_quantity(course))
key = int(action.mass_quantity(key))
self.strumconfig.set_open_course_key(number, key)
self.__update_strumconfig()
def set_time_secs(self, subj, dummy, arg):
time_secs = action.mass_quantity(arg)
print "set time secs", arg, "->", time_secs, self.id()
# time in seconds is -ve for now!
self[1].get_policy().set_value(-time_secs)
return action.nosync_return()
def __create_output(self,subj,mass):
id = int(action.mass_quantity(mass))
e = self[2].create_channel(id)
if not isinstance(e,AudioOutput):
return e
def __set_open_course_physical(self, a, subj, phys, course):
number = int(action.mass_quantity(course))
open_col, open_row = action.coord_value(phys)
self.strumconfig.set_open_course_physical(number, open_col, open_row)
self.__update_strumconfig()
def __add_strum_key(self, a, subj, phys, course):
number = int(action.mass_quantity(course))
strum_col, strum_row = action.coord_value(phys)
self.strumconfig.add_key_course(number, strum_col, strum_row)
self.__update_strumconfig()
def __playnv(self,ctx,subj,note,velocity):
note = action.mass_quantity(note)
velocity = action.mass_quantity(velocity)
print 'play note',note,'velocity',velocity
return self.nplayer.play(note,velocity,500000),None
def __clear_strum_key(self, a, subj, course):
number = int(action.mass_quantity(course))
self.strumconfig.clear_key_course(number)
self.__update_strumconfig()
def set_time_beats(self, subj, dummy, arg):
time_beats = action.mass_quantity(arg)
print "set time beats", arg, "->", time_beats, self.id()
self[1].get_policy().set_value(time_beats)
return action.nosync_return()
def __create_connector(self, subj, mass):
id = int(action.mass_quantity(mass))
e = self[4].create_connector(id)
if not isinstance(e, Connector):
return e
