def __resolve1(self, id, path, ordinal, asTerm=False):
a = logic.render_term((tuple(path), ordinal - 1))
r = (yield rpc.invoke_rpc(id, 'finfo', a))
if not r.status():
print 'rpc error, finfo'
yield async .Coroutine.failure(*r.args(), **r.kwds())
flist = logic.parse_clause(r.args()[0])
if not flist:
yield async .Coroutine.failure('no selection %d' % ordinal)
print 'flist=', flist
(cookie, desc, name) = flist[0][:3]
if len(flist[0]) > 3:
aux = flist[0][3]
a = logic.render_term((tuple(path), cookie))
r = (yield rpc.invoke_rpc(id, 'fideal', a))
if not r.status():
print 'rpc error, fideal'
yield async .Coroutine.failure(*r.args(), **r.kwds())
try:
ideal = logic.parse_clause(r.args()[0], paths.make_subst(id))
except:
print 'cant parse:', r.args()[0]
raise
print 'converted', ordinal, 'to ideal', ideal
yield async .Coroutine.success(self.__render(ideal, asTerm))
def rpc_finfo(self,a):
(path,idx) = logic.parse_clause(a)
if len(path) == 1:
p = self.__plugin_list.plugins_by_manufacturer.get(path[0])
if p:
return render_list(p,idx,lambda i,t: logic.render_term((plugin_id_escaped(t),t.name(),t.description())))
return logic.render_term(())
def rpc_cinfo(self,a):
(path,idx) = logic.parse_clause(a)
self.__scan()
if len(path) == 0:
return render_list(self.__files,idx,lambda i,t: logic.render_term((t)))
return logic.render_term(())
def rpc_enumerate(self, arg):
path = logic.parse_clause(arg)
if len(path) > 0:
if path[0] == factory_cat:
return logic.render_term((len(self.__factory_fingerings), 0))
if path[0] == user_cat:
return logic.render_term((len(self.__user_fingerings), 0))
return logic.render_term((0, 2))
def rpc_finfo(self,a):
(path,idx) = logic.parse_clause(a)
if len(path) == 1:
self.__scan()
presets = self.__scanpresets(path[0])
#return render_list(presets,idx,lambda i,t: logic.render_term((t[0],t[1],t[2],'autoload')))
return render_list(presets,idx,lambda i,t: logic.render_term((t[0],t[1],t[2])))
return logic.render_term(())
def rpc_finfo(self, a):
(path, idx) = logic.parse_clause(a)
if len(path) == 1:
p = self.__plugin_list.plugins_by_manufacturer.get(path[0])
if p:
return render_list(
p, idx, lambda i, t: logic.render_term(
(plugin_id_escaped(t), t.name() + ' (' + t.format()
+ prepad_not_empty(t.category()) + ')', t.description(
))))
return logic.render_term(())
def rpc_dinfo(self,a):
c=self.get_value()
l=[]
if c:
l.append(('dinfo_id',c))
l.append(('Current sample',c.split('|')[0]))
return logic.render_term(T('keyval',tuple(l) ))
else:
n=self.get_description()
l.append(('dinfo_id',n))
return logic.render_term(T('keyval',tuple(l) ))
def rpc_finfo(self, a):
(path, idx) = logic.parse_clause(a)
self.__scan()
if len(path) == 0:
# list of tuples for the browser window, [(cookie,textcolumn1,textcolumn2),...]
map = tuple([(files, files, self.__c2n.get(files))
for files in self.__files[idx:]])
mapstr = logic.render_term(map)
return mapstr
return logic.render_term(())
def rpc_activated(self, arg):
(path, selected) = logic.parse_clause(arg)
if self.__selected == selected and self.__armed == self.__selected:
self.__run()
return logic.render_term(('', ''))
self.__selected = selected
self.__armed = selected
self.__status = 'armed'
print 'arming', self.__armed
self.update()
return logic.render_term(('', ''))
def rpc_enumerate(self,a):
path = logic.parse_clause(a)
self.__scan()
if len(path) == 0:
return logic.render_term((0, len(self.__f2p)))
if len(path) == 1:
p = self.__scanpresets(path[0])
return logic.render_term((len(p), 0))
return logic.render_term((0,0))
def rpc_enumerate(self,a):
path=logic.parse_clause(a)
if len(path)==0:
r = logic.render_term((0,len(self.__plugin_list.plugins_by_manufacturer)))
return r
if len(path)==1:
p = self.__plugin_list.plugins_by_manufacturer.get(path[0])
if p:
r = logic.render_term((len(p),0))
return r
r = logic.render_term((0,0))
return r
def __mode(self,text,k,u):
row = int(action.abstract_string(k))-1
for v in self[5].itervalues():
d = v.target.get_data()
if d.is_long() and d.as_long()==row:
v.addref()
return logic.render_term((v.id(),('transient',)))
i = self[5].find_hole()
if i:
self[5][i] = RowTarget(self,row)
return logic.render_term((self[5][i].id(),('transient',)))
return None
def rpc_dinfo(self, a):
print 'scale __dinfo:'
activated = self.__activated_name
l = []
if activated is not None:
print 'scale dinfo', activated
l.append(('dinfo_id', activated))
l.append(('Selected scale', self.__describe(activated)))
l.append(('Definition',
' '.join([str(f) for f in self.__activated_scale])))
return logic.render_term(T('keyval', tuple(l)))
else:
l.append(('dinfo_id', 'scale'))
return logic.render_term(T('keyval', tuple(l)))
def disconnect(self, srcid, dstid, u, f, c):
proxy = self.__database.find_item(dstid)
if proxy:
if u == 0:
u = None
if f == '':
f = None
if c == '':
c = None
r = proxy.invoke_rpc(
'disconnect',
logic.render_term(logic.make_term('conn', u, None, srcid, f,
c)))
yield (r)
if not r.status():
print 'disconnect failed', srcid, dstid, u, f, c
self.__frontend.report_error(
'eigenD could not disconnect wire ' + srcid + ':' + dstid,
r.args()[0])
yield async .Coroutine.failure('rpc_disconnect failed')
yield async .Coroutine.success()
else:
print 'proxy not found'
def rpc_dinfo(self, a):
path = logic.parse_clause(a)
l = []
l.append(('dinfo_id', self.__selected or path))
if self.__selected:
x = self.read_script(self.__selected)
if x:
(n, d, sc, rn) = x
if rn:
l.append(('name', "%s (%s)" % (n, rn)))
else:
l.append(('name', n))
l.append(('', ''))
for (i, di) in enumerate(d):
l.append(('description' if i == 0 else '', di))
if self.__status:
l.append(('', ''))
l.append(('status', self.__status))
return logic.render_term(logic.make_term('keyval', tuple(l)))
def unload(self):
ss = ''
if self.open():
ss = logic.render_term(
tuple([ss.id() for ss in self.__subsystems.values()]))
self.close_server()
return ss
def rpc_dinfo(self,arg):
l=[]
dsc=self.get_description()
l.append(('dinfo_id',dsc))
l.append(('Headphone enabled','Yes' if self[103][100].get_value() else 'No'))
l.append(('Headphone gain',self[103][101].get_value()))
return logic.render_term(T('keyval',tuple(l) ))
def find_conn(aproxy, id):
r = []
for cnx in cnxs:
if logic.is_pred_arity(cnx, 'conn', 5) and cnx.args[2] == id:
r.append(logic.render_term(cnx))
return r
def rpc_get_test_data(self,arg):
print 'getting test data',self.__filename
f = files.get_ideal(self.id(),'audio',files.FileSystemFile(self.__filename,'audio'),0) if resource.os_path_exists(self.__filename) else '[]'
print 'got recording',f
d = self.audio.get_dropout_count()
print 'got dropouts',d
return logic.render_term((f,d))
def rpc_fideal(self, arg):
(path, cookie) = logic.parse_clause(arg)
for id, n in self.__midi_port.sinks:
if id == cookie:
return 'ideal([~server,midiport],%s)' % logic.render_term(
cookie)
return async .failure('invalid cookie')
def verb2_19_unconnect_from(self, subject, t, f):
"""
connect([un],global_unconnect_from,role(None,[concrete]),role(from,[concrete,singular]))
"""
f = self.database.to_database_id(action.concrete_object(f))
for o in action.concrete_objects(t):
t2 = self.database.to_database_id(o)
print 'un connect', t2, 'from', f
tproxy = self.database.find_item(t2)
objs = self.database.search_any_key(
'W', T('unconnect_from_list', t2, f, V('W')))
for (s, m) in objs:
sproxy = self.database.find_item(s)
cnxs = logic.parse_clauselist(sproxy.get_master())
for cnx in cnxs:
if logic.is_pred_arity(cnx, 'conn',
5) and self.database.to_database_id(
cnx.args[2]) == m:
print 'disconnect', cnx, 'from', s
yield interpreter.RpcAdapter(
sproxy.invoke_rpc('disconnect',
logic.render_term(cnx)))
yield async .Coroutine.success()
def rpc_finfo(self, a):
(dlist, cnum) = logic.parse_clause(a)
all = list(
enumerate(
[e for k in self.__keylist() for e in self.__eventlist(k)]))
map = tuple([(i, e.describe(), None) for (i, e) in all[cnum:]])
return logic.render_term(map)
def setSelectedFile(self, selected):
if selected > 0 and selected <= len(self.finfo):
print 'browseModel:setSelectedFile: No. in browser list=', selected, 'uid=', self.finfo[
selected - 1]
self.selected_file = self.finfo[selected - 1][0]
args = logic.render_term((tuple(self.path), self.selected_file))
rpc.invoke_rpc(self.getTargetId(), 'setselected', args)
def upgrade_5_0_to_6_0(self, tools, address):
root = tools.root(address)
root.ensure_node(2, 253, 254).set_long(2)
root.ensure_node(2, 253, 255.1)
root.ensure_node(2, 253, 255.3)
root.ensure_node(2, 253, 255.4).set_string('channel')
root.ensure_node(2, 253, 255.8).set_string('count')
root.ensure_node(2, 1, 255, 8).set_string('')
root.ensure_node(3, 253, 254).set_long(2)
root.ensure_node(3, 253, 255.1)
root.ensure_node(3, 253, 255.3)
root.ensure_node(3, 253, 255.4).set_string('channel')
root.ensure_node(3, 253, 255.8).set_string('count')
root.ensure_node(3, 1, 255, 8).set_string('')
pmap = []
for p in range(1, 17):
pnode = root.ensure_node(4, p)
for n in pnode.iter():
pbits = n.get_string().split(',')
pmap.append(logic.make_term('m', p, int(pbits[2]), 1.0))
pnode.ensure_node(255, 17)
# replace 0 tail time (meaning, plugin value) with a sensible default
n = root.ensure_node(10, 254)
if n.get_data().is_float() and n.get_data().as_float() == 0.0:
n.set_data(piw.makefloat(30.0, 0))
root.ensure_node(14, 255.1)
root.ensure_node(14, 255.3)
root.ensure_node(14, 255.8).set_string('midi input')
root.ensure_node(15, 255.1)
root.ensure_node(15, 255.3)
root.ensure_node(15, 255.8).set_string('midi output')
id_bits = root.ensure_node(255, 6).get_string().split('|')
plug_id = id_bits[0]
plug_name = id_bits[1] if len(id_bits) > 1 else ''
au_bits = plug_id[0:4], plug_id[4:8], plug_id[8:12]
what = ''
if au_bits[0] == 'aumu': what = 'Synths'
if au_bits[0] == 'aumf' or au_bits[0] == 'aufx': what = 'Effects'
if what:
desc = host_native.plugin_description(
'AudioUnit:%s/%s' % (what, ','.join(au_bits)), plug_name)
root.ensure_node(255, 6, 3).set_string(urllib.quote(desc.to_xml()))
root.ensure_node(255, 6,
4).set_data(root.get_node(9, 254).get_data())
root.ensure_node(255, 6, 5).set_string(
logic.render_term(logic.make_term('mapping', *tuple(pmap))))
root.remove(99)
return True
def __add(self,subject,agent):
id = action.concrete_object(agent)
if self.__state.find(lambda v,s: s==id):
print id,'already in',self.id()
return
print 'adding',id, 'to',self.id()
rpc.invoke_rpc(id,'notify_delete',logic.render_term(self.id()))
self.__state.assert_state(id)
def activate(self, selection):
print 'activate', selection
if selection > 0 and selection <= len(self.finfo):
uid = self.finfo[selection - 1][0]
print 'Activate: No. in browser list=', selection, 'uid=', uid
args = logic.render_term((tuple(self.path), uid))
self.__do_activate(self.getTargetId(), args)
def destroy(self):
# remove this widget from the targets controllers
address = self.get_property_string('target-id')
myrid = paths.to_relative(self.id(), scope=paths.id2scope(address))
cs = logic.render_term(
logic.make_term('conn', None, None, myrid, None, 'ctl'))
if address != '':
rpc.invoke_rpc(address, 'disconnect', cs)
def rpc_finfo(self, a):
print 'finfo', a
(dlist, cnum) = logic.parse_clause(a)
# XXX
#map = tuple([(i+cnum,e.describe(),None) for (i,e) in enumerate(self.__eventlist()[cnum:])])
map = tuple([(e.ordinal(), e.describe(), None)
for (i, e) in enumerate(self.__eventlist()[cnum:])])
return logic.render_term(map)
def set_boolvalue(self, id, val):
print 'backend set_boolvalue', id, val
proxy = self.__database.find_item(id)
if (not proxy == None):
if val:
proxy.invoke_rpc('set_value', logic.render_term(val))
else:
proxy.invoke_rpc('set_value', '')
def rpc_enumerate(self,a):
path=logic.parse_clause(a)
if len(path)==0:
k=reduce(operator.add,[len(self.__eventlist(k)) for k in self.__keylist()],0)
c=0
else:
k=0
c=0
return logic.render_term((k,c))
