def next(self): self.__scan() c = self.get_value() if not c: return action.nosync_return() f,b,p = c.split('|',2) if self.__files: if f in self.__files: all=[] for ps in self.__scanpresets(f): all.append(ps[0]) i=all.index(c)+1 if i<len(all): self.__setcurrent(all[i]) return action.nosync_return() else: findex=(self.__files.index(f))+1 if findex>=len(self.__files): findex=0 f=self.__files[findex] for ps in self.__scanpresets(f): self.__setcurrent(ps[0]) return action.nosync_return() else: ps=self.__scanpresets(self.__files[0]) self.__setcurrent(ps[0]) return action.nosync_return() return async.failure('no files')
def __add(self,subj,arg): if arg is None: return action.nosync_return() (type,id) = action.crack_ideal(action.arg_objects(arg)[0]) if id >= self.loopdb.size(): return async.success(errors.doesnt_exist('loop %s' % str(id),'add')) file = self.loopdb.basename(id) voice = self[5].new_voice() voice.set_current(id,file) return action.nosync_return()
def unname(self,cookie): self.__scan() n = self.__c2n.get(cookie) if n is None: return action.nosync_return() n = '%s.name' % n.replace(' ','_') path = os.path.join(self.userdir,n) try: resource.os_unlink(path) except: pass self.__scan() self.__update() return action.nosync_return()
def __tune_tonic(self,subj,dummy,arg): print 'tune tonic',arg type,thing = action.crack_ideal(action.arg_objects(arg)[0]) tonic = int(thing) self[2][3].get_policy().set_value(tonic) self.illuminator.reference_tonic(tonic); return action.nosync_return()
def __tune_tonic(self, subj, dummy, arg): print 'tune tonic', arg type, thing = action.crack_ideal(action.arg_objects(arg)[0]) tonic = int(thing) self[2][3].get_policy().set_value(tonic) self.illuminator.reference_tonic(tonic) return action.nosync_return()
def __tune_scale(self, subj, dummy, arg): print 'tune scale', arg type, thing = action.crack_ideal(action.arg_objects(arg)[0]) scale = action.marshal(thing) self[2][2].get_policy().set_value(scale) self.illuminator.reference_scale(scale) return action.nosync_return()
def first(self): self.__scan() p = self.__scanpresets(self.__files[0]) if p: self.__setcurrent(p[0][0]) return action.nosync_return() return async.failure('first failed')
def __tune_scale(self,subj,dummy,arg): print 'tune scale',arg type,thing = action.crack_ideal(action.arg_objects(arg)[0]) scale = action.marshal(thing) self[2][2].get_policy().set_value(scale) self.illuminator.reference_scale(scale); return action.nosync_return()
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 __delete(self,subj,thing): self.__unplay(subj,thing) cookie = self.__crack_arg(thing) try: self.library.delete(cookie) return action.nosync_return() except: return async.success(errors.invalid_value(cookie,'delete'))
def __select(self,subj,voice): id = self.crack_voice(voice) if self[5].choose_voice(id): return action.nosync_return() thing='voice %s' %str(id) return async.success(errors.invalid_thing(thing,'select'))
def __next(self,subj): v = self[5].current_voice() if not v: return async.success(errors.no_current_voice('','next')) v.next() return action.nosync_return()
def __unplay(self,subj,arg): #print 'unplaying',arg if arg is None: latest_cookie=0 latest_ctx=None latest_id=None for (id,ctx,cookie) in self.verb_events(lambda l,i: i==3): if cookie>latest_cookie: latest_cookie=cookie latest_ctx=ctx latest_id=id if latest_cookie: (autor,trigger,poly,mode) = latest_ctx self.__scheduler.delete_trigger(trigger) self.verb_cancel(latest_id) self[5].update() self.player.abortcookie(latest_cookie) #self.set_all_status(const.status_inactive) return action.nosync_return() arg = self.__crack_arg(arg) if arg: c = self.player.getcookie(arg) while c: #print 'clearing cookie',c for (id,ctx,cookie) in self.verb_events(lambda l,i: i==3): if c==cookie: (autor,trigger,poly,mode) = ctx #print 'tear down',id,trigger,cookie self.__scheduler.delete_trigger(trigger) self.verb_cancel(id) self[5].update() c = self.player.getcookie(arg) self.player.abort(arg) return action.nosync_return()
def __name(self,subj,thing,name): thing = self.__crack_arg(thing) name = action.abstract_string(name) try: self.library.rename(thing,name) self[5].update() return action.nosync_return() except: utils.log_exception() return async.success(errors.invalid_value(thing,'name'))
def rename(self,cookie,name): n = '%s.name' % name.replace(' ','_') path = os.path.join(self.userdir,n) try: resource.os_unlink(path) except: pass f = resource.file_open(path,'w') f.write(cookie) f.close() self.__update() return action.nosync_return()
def __do_play_now(self,arg,mode): cookie = self.__load(arg,1) if not cookie: thing= 'take %s' %str(arg) return async.success(errors.invalid_thing(thing,'play')) f = self.player.player(cookie,mode) ff = piw.fastchange(f) ff(piw.makefloat_bounded_nb(1,0,0,1,0)) self.player.unload(cookie,False) return action.nosync_return()
def __choose(self,subj,arg): (type,id) = action.crack_ideal(action.arg_objects(arg)[0]) if id >= self.loopdb.size(): return async.success(errors.doesnt_exist('loop %s' % id,'choose')) file = self.loopdb.basename(id) voice = self[5].current_voice() if not voice: return async.success(errors.no_current_voice('','choose')) voice.set_current(id,file) return action.nosync_return()
def __remove(self,subj,voice): if voice is None: voice = self[5].current_voice() if not voice: return async.success(errors.no_current_voice('','remove')) id = voice.voice else: id = self.crack_voice(voice) if self[5].remove_voice(id): return action.nosync_return() thing='voice %s' %str(id) return async.success(errors.invalid_thing(thing,'remove'))
def __copy(self,sub,take): type,thing = action.crack_ideal(action.arg_objects(take)[0]) id = self.library.nextid() fn = self.library.perm_path(id,None) print 'copy',type,thing,'to',self.id(),fn r = files.copy_file(logic.render_term(thing),fn) yield r if not r.status(): yield async.Coroutine.failure(*r.args()) print 'transfer complete' self.library.add_file(fn) self[5].update() yield async.Coroutine.success(action.nosync_return())
def choose_cookie(self,c): if self.__setcurrent(c): return action.nosync_return() return async.failure('choose_cookie failed %s' % c)
def set_time_beats_default(self, subj, dummy, arg): time_beats = float(action.abstract_string(arg)) print "set time beats default", arg, "->", time_beats, self.id() self[1].get_policy().set_value(time_beats) return action.nosync_return()
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 save(self,name): dir = resource.user_resource_dir(resource.instrument_dir) file = os.path.join(dir,name) if os.path.exists(file): os.unlink(file) agg = async.Aggregate() map = state.create_mapping(True) ctl = [] ssctl=[] id =self.id() all=[id] for a in self.iterall(): all.append(a) if isrig(a): rr=self.__get_rig_agents(a) yield rr if not rr.status(): yield async.Coroutine.failure('error getting agents in rig') rigall=rr.args()[0] all.extend(rigall) subs={} for a in all: r=rpc.invoke_rpc(a,'subsystems',logic.render_term(self.id())) yield r if not r.status(): yield async.Coroutine.failure('rpc error') if r.args()[0]: ss=logic.parse_clause(r.args()[0]) print 'subsystems of %s' %a,ss subs[a]=ss for i,a in enumerate(all): c = Controller(a) ctl.append(c) agg.add(c,c.add_sync()) map.add(a,'|rig-%d-rig|' % i) print 'adding to map',a,'|rig-%d-rig|' % i if a in subs: for s in subs[a]: ss=getssid(s,a) c = Controller(ss) #ctl.append(c) agg.add(c,c.add_sync()) ssname=self.__getssname(ss) ssctl.append((c,str(i) +'/'+ ssname)) map.add(ss,'|rig-%d/%s-rig|' % (i,ssname)) print 'adding to map',ss,'|rig-%d/%s-rig|' % (i,ssname) agg.enable() yield agg db = state.open_database(file,True) snap = db.get_trunk() for i,c in enumerate(ctl): a = snap.get_agent_address(0,str(i),True) c.save_template(a.get_root(),map) a.set_checkpoint() for c,name in ssctl: a = snap.get_agent_address(0,name,True) c.save_template(a.get_root(),map) a.set_checkpoint() snap.save(0,'') db.flush() db.close() yield async.Coroutine.success(action.nosync_return())
def __unbypass(self,*arg): self.__host.set_bypassed(False) self.set_light(1,False) return action.nosync_return()
def __bypass(self,*arg): self.__host.set_bypassed(True) self.set_light(1,True) return action.nosync_return()
def __tog_show(self,*arg): self.__host.set_showing(not self.__host.is_showing()) self.set_light(2,self.__host.is_showing()) return action.nosync_return()
def __unshow(self,*arg): self.__host.set_showing(False) self.set_light(2,False) return action.nosync_return()
def __show(self,*arg): self.__host.set_showing(True) self.set_light(2,True) return action.nosync_return()
def __tog_bypass(self,*arg): self.__host.set_bypassed(not self.__host.is_bypassed()) self.set_light(1,self.__host.is_bypassed()) return action.nosync_return()
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 __calibrate(self, *arg): self.cv_calibration.calibrate() return action.nosync_return()
def __calibrate(self,*arg): self.cv_calibration.calibrate() return action.nosync_return()