def dsp_outlet(self, outlet):
try:
return (self.outlet_objects[outlet].dsp_obj, 0)
except IndexError:
log.error("Programming error: asked for outlet '%d' in patch %s but it has %d"
% (outlet, self.name, len(self.outlet_objects)))
return (None, 0)
def clutter_proc(self):
try:
from gi.repository import Clutter, GObject, Gtk, GtkClutter
# explicit init seems to avoid strange thread sync/blocking issues
GObject.threads_init()
GtkClutter.init([])
# create main window
from mfp.gui.patch_window import PatchWindow
self.appwin = PatchWindow()
self.mfp = MFPCommand()
except Exception as e:
log.error("Fatal error during GUI startup")
log.debug_traceback()
return
try:
# direct logging to GUI log console
Gtk.main()
except Exception as e:
log.error("Caught GUI exception:", e)
log.debug_traceback()
sys.stdout.flush()
def dispatch_rpcdata(self, rpc_worker, rpcdata):
try:
json_data, peer_id = rpcdata
obj = json.loads(json_data, object_hook=extended_decoder_hook)
except Exception as e:
log.error("Can't parse JSON for peer:", peer_id, json_data)
log.debug_traceback()
return True
req = Request.from_dict(obj)
# is someone waiting on this response?
rpc_worker.data = "Request %s started" % req.request_id
if req.is_response() and req.request_id in self.pending:
rpc_worker.data = "Request %s processing response" % req.request_id
oldreq = self.pending.get(req.request_id)
del self.pending[req.request_id]
oldreq.result = req.result
oldreq.state = req.state
oldreq.diagnostic = req.diagnostic
with self.lock:
self.condition.notify()
elif req.is_request():
rpc_worker.data = "Request %s calling local %s (%s)" % (
req.request_id, req.method, req.params)
# actually call the local handler
self.handle_request(req, peer_id)
# and send back the response
rpc_worker.data = "Request %s sending response" % req.request_id
if req.request_id is not None:
self.put(req, peer_id)
rpc_worker.data = "Request %s done (%s)" % (req.request_id, req.method)
return True
def dsp_outlet(self, outlet):
try:
return (self.outlet_objects[outlet].dsp_obj, 0)
except IndexError:
log.error("Programming error: asked for outlet '%d' in patch %s but it has %d"
% (outlet, self.name, len(self.outlet_objects)))
return (None, 0)
def remove(self, obj):
try:
if obj.scope is not None and obj.name is not None:
self.unbind(obj.name, obj.scope)
del self.objects[obj.obj_id]
except KeyError:
log.error("Error deleting obj", obj, "can't find key", obj.obj_id)
log.debug_traceback()
try:
self.inlet_objects.remove(obj)
self.dsp_inlets = [ p[0] for p in enumerate(self.inlet_objects)
if p[1] and p[1].init_type == 'inlet~' ]
self.gui_params['dsp_inlets'] = self.dsp_inlets
except ValueError:
pass
try:
self.outlet_objects.remove(obj)
self.dsp_outlets = [ p[0] for p in enumerate(self.outlet_objects)
if p[1] and p[1].init_type == 'outlet~' ]
self.gui_params['dsp_outlets'] = self.dsp_outlets
except ValueError:
pass
try:
self.dispatch_objects.remove(obj)
except ValueError:
pass
def dispatch_rpcdata(self, rpc_worker, rpcdata):
try:
json_data, peer_id = rpcdata
obj = json.loads(json_data, object_hook=extended_decoder_hook)
except Exception as e:
log.error("Can't parse JSON for peer:", peer_id, json_data)
log.debug_traceback()
return True
req = Request.from_dict(obj)
# is someone waiting on this response?
rpc_worker.data = "Request %s started" % req.request_id
if req.is_response() and req.request_id in self.pending:
rpc_worker.data = "Request %s processing response" % req.request_id
oldreq = self.pending.get(req.request_id)
del self.pending[req.request_id]
oldreq.result = req.result
oldreq.state = req.state
oldreq.diagnostic = req.diagnostic
with self.lock:
self.condition.notify()
elif req.is_request():
rpc_worker.data = "Request %s calling local %s (%s)" % (req.request_id, req.method, req.params)
# actually call the local handler
self.handle_request(req, peer_id)
# and send back the response
rpc_worker.data = "Request %s sending response" % req.request_id
if req.request_id is not None:
self.put(req, peer_id)
rpc_worker.data = "Request %s done (%s)" % (req.request_id, req.method)
return True
def remove(self, obj):
try:
if obj.scope is not None and obj.name is not None:
self.unbind(obj.name, obj.scope)
del self.objects[obj.obj_id]
except KeyError:
log.error("Error deleting obj", obj, "can't find key", obj.obj_id)
log.debug_traceback()
try:
self.inlet_objects.remove(obj)
self.dsp_inlets = [ p[0] for p in enumerate(self.inlet_objects)
if p[1] and p[1].init_type == 'inlet~' ]
self.gui_params['dsp_inlets'] = self.dsp_inlets
except ValueError:
pass
try:
self.outlet_objects.remove(obj)
self.dsp_outlets = [ p[0] for p in enumerate(self.outlet_objects)
if p[1] and p[1].init_type == 'outlet~' ]
self.gui_params['dsp_outlets'] = self.dsp_outlets
except ValueError:
pass
try:
self.dispatch_objects.remove(obj)
except ValueError:
pass
def clutter_proc(self):
try:
from gi.repository import Clutter, GObject, Gtk, GtkClutter
# explicit init seems to avoid strange thread sync/blocking issues
GObject.threads_init()
GtkClutter.init([])
# create main window
from mfp.gui.patch_window import PatchWindow
self.appwin = PatchWindow()
self.mfp = MFPCommand()
except Exception as e:
log.error("Fatal error during GUI startup")
log.debug_traceback()
return
try:
# direct logging to GUI log console
Gtk.main()
except Exception as e:
log.error("Caught GUI exception:", e)
log.debug_traceback()
sys.stdout.flush()
def handler(stage, event):
try:
return self.input_mgr.handle_event(stage, event)
except Exception as e:
log.error("Error handling UI event", event)
log.debug(e)
log.debug_traceback()
return False
def handler(stage, event):
try:
return self.input_mgr.handle_event(stage, event)
except Exception as e:
log.error("Error handling UI event", event)
log.debug(e)
log.debug_traceback()
return False
def grab_handler(stage, event):
try:
if not self.embed.has_focus():
self.embed.grab_focus()
return self.input_mgr.handle_event(stage, event)
except Exception, e:
import traceback
log.error("Error handling UI event", event)
log.debug(e)
traceback.print_exc()
return False
def _run_onload(self, objects):
from .mfp_app import MFPApp
for phase in (0,1):
for obj in objects:
try:
if obj.do_onload:
obj.onload(phase)
except Exception as e:
log.error("Problem initializing %s.%s" % (obj.scope.name, obj.name))
log.debug_traceback()
self.update_export_bounds()
if MFPApp().gui_command:
MFPApp().gui_command.load_complete()
return True
def get_color(self, colorspec):
rgba = None
if self.selected:
rgba = self.get_style(colorspec + ':selected')
if not rgba:
rgba = self.get_style(colorspec)
if not rgba:
rgba = self.get_style(colorspec.split(':')[0])
if not rgba:
log.error('Could not find color %s in %s' % (colorspec, self._all_styles))
return ColorDB().find(64, 64, 64, 255)
elif isinstance(rgba, str):
return ColorDB().find(rgba)
else:
return ColorDB().find(rgba[0], rgba[1], rgba[2], rgba[3])
def _run_onload(self, objects):
from .mfp_app import MFPApp
for phase in (0,1):
for obj in objects:
try:
if obj.do_onload:
obj.onload(phase)
except Exception as e:
log.error("Problem initializing %s.%s" % (obj.scope.name, obj.name))
log.debug_traceback()
self.update_export_bounds()
if MFPApp().gui_command:
MFPApp().gui_command.load_complete()
return True
def get_color(self, colorspec):
rgba = None
if self.selected:
rgba = self.get_style(colorspec + ':selected')
if not rgba:
rgba = self.get_style(colorspec)
if not rgba:
rgba = self.get_style(colorspec.split(':')[0])
if not rgba:
log.error('Could not find color %s in %s' %
(colorspec, self._all_styles))
return ColorDB().find(64, 64, 64, 255)
elif isinstance(rgba, str):
return ColorDB().find(rgba)
else:
return ColorDB().find(rgba[0], rgba[1], rgba[2], rgba[3])
def grab_handler(stage, event):
try:
r = self.input_mgr.handle_event(stage, event)
if not self.embed.has_focus():
log.debug("event handler: do not have focus")
if hasattr(event, 'keyval'):
log.debug("keyval was", event.keyval)
else:
log.debug("event was:", event.type)
self.grab_focus()
return False
return r
except Exception, e:
import traceback
log.error("Error handling UI event", event)
log.debug(e)
log.debug_traceback()
return False
def grab_handler(stage, event):
try:
r = self.input_mgr.handle_event(stage, event)
if not self.embed.has_focus():
log.debug("event handler: do not have focus")
if hasattr(event, 'keyval'):
log.debug("keyval was", event.keyval)
else:
log.debug("event was:", event.type)
self.grab_focus()
return False
return r
except Exception as e:
import traceback
log.error("Error handling UI event", event)
log.debug(e)
log.debug_traceback()
return False
def _resize_cb(self, widget, rect):
try:
self.stage.set_size(rect.width, rect.height)
if self.hud_mode_txt:
self.hud_mode_txt.set_position(self.stage.get_width()-80,
self.stage.get_height()-25)
if self.hud_prompt:
self.hud_prompt.set_position(10, self.stage.get_height() - 25)
if self.hud_prompt_input:
self.hud_prompt_input.set_position(15 + self.hud_prompt.get_width(),
self.stage.get_height() - 25)
except Exception as e:
log.error("Error handling UI event", event)
log.debug(e)
log.debug_traceback()
return False
def _resize_cb(self, widget, rect):
try:
self.stage.set_size(rect.width, rect.height)
if self.hud_mode_txt:
self.hud_mode_txt.set_position(self.stage.get_width() - 80,
self.stage.get_height() - 25)
if self.hud_prompt:
self.hud_prompt.set_position(10, self.stage.get_height() - 25)
if self.hud_prompt_input:
self.hud_prompt_input.set_position(
15 + self.hud_prompt.get_width(),
self.stage.get_height() - 25)
except Exception as e:
log.error("Error handling UI event", event)
log.debug(e)
log.debug_traceback()
return False
def run(self):
from mfp import log
while not self.join_req:
try:
if self.process:
fileobj = self.process.stdout
r, w, e = select.select([fileobj], [], [], 0.25)
if fileobj in r:
ll = fileobj.readline().decode()
else:
continue
else:
ll = None
if not ll:
self.join_req = True
else:
ll = ll.strip()
if ll.startswith("[LOG] "):
ll = ll[6:]
if ll.startswith("FATAL:"):
log.error(ll[7:], module=self.log_module)
self.join_req = True
elif ll.startswith("ERROR:"):
log.error(ll[7:], module=self.log_module)
elif ll.startswith("WARNING:"):
log.warning(ll[9:], module=self.log_module)
elif ll.startswith("INFO:"):
log.info(ll[6:], module=self.log_module)
elif ll.startswith("DEBUG:"):
log.debug(ll[7:], module=self.log_module)
elif ll.startswith("JackEngine::XRun"):
log.warning("JACK: " + ll, module=self.log_module)
elif ll.startswith("JackAudioDriver"):
if "Process error" in ll:
log.error("JACK: " + ll, module=self.log_module)
elif self.log_raw and len(ll):
log.debug("%s " % self.log_module, ll)
except Exception as e:
log.debug("RPCExecRemote: exiting with error", e)
self.join_req = True
if self.process:
self.process.terminate()
self.process.wait()
def run(self):
from mfp import log
while not self.join_req:
try:
if self.process:
fileobj = self.process.stdout
r, w, e = select.select([fileobj], [], [], 0.25)
if fileobj in r:
ll = fileobj.readline().decode()
else:
continue
else:
ll = None
if not ll:
self.join_req = True
else:
ll = ll.strip()
if ll.startswith("[LOG] "):
ll = ll[6:]
if ll.startswith("FATAL:"):
log.error(ll[7:], module=self.log_module)
self.join_req = True
elif ll.startswith("ERROR:"):
log.error(ll[7:], module=self.log_module)
elif ll.startswith("WARNING:"):
log.warning(ll[9:], module=self.log_module)
elif ll.startswith("INFO:"):
log.info(ll[6:], module=self.log_module)
elif ll.startswith("DEBUG:"):
log.debug(ll[7:], module=self.log_module)
elif ll.startswith("JackEngine::XRun"):
log.warning("JACK: " + ll, module=self.log_module)
elif ll.startswith("JackAudioDriver"):
if "Process error" in ll:
log.error("JACK: " + ll, module=self.log_module)
elif self.log_raw and len(ll):
log.debug("%s " % self.log_module, ll)
except Exception as e:
log.debug("RPCExecRemote: exiting with error", e)
self.join_req = True
if self.process:
self.process.terminate()
self.process.wait()
def run(self):
from mfp import log
while not self.join_req:
try:
if self.process:
ll = self.process.stdout.readline()
else:
ll = None
if not ll:
self.join_req = True
else:
ll = ll.strip()
if self.log_raw:
log.debug("%s:" % self.log_module, ll.strip())
if ll.startswith("[LOG] "):
ll = ll[6:]
if ll.startswith("FATAL:"):
log.error(ll[7:], module=self.log_module)
self.join_req = True
elif ll.startswith("ERROR:"):
log.error(ll[7:], module=self.log_module)
elif ll.startswith("WARNING:"):
log.warning(ll[9:], module=self.log_module)
elif ll.startswith("INFO:"):
log.info(ll[6:], module=self.log_module)
elif ll.startswith("DEBUG:"):
log.debug(ll[7:], module=self.log_module)
elif ll.startswith("JackEngine::XRun"):
log.warning("JACK: " + ll, module=self.log_module)
elif ll.startswith("JackAudioDriver"):
if "Process error" in ll:
log.error("JACK: " + ll, module=self.log_module)
except Exception, e:
print "RPCExecRemote caught error:", e
log.debug("RPCExecRemote: exiting")
self.join_req = True
def run(self):
'''
RPCHost.run: perform IO on managed sockets, dispatch data
'''
self.read_workers.start()
if RPCWrapper.rpchost is None:
RPCWrapper.rpchost = self
import select
self.fdsockets = {}
while not self.join_req:
rdy = None
for s in self.managed_sockets.values():
if s.fileno() not in self.fdsockets:
self.fdsockets[s.fileno()] = s
try:
sockets = list(self.fdsockets.keys())
if sockets:
rdy, _w, _x = select.select(list(self.fdsockets.keys()),
[], [], 0.1)
else:
time.sleep(0.1)
except Exception as e:
print("select exception:", e)
if not rdy:
continue
syncbytes = 8
sync = b''
for rsock in rdy:
jdata = b''
retry = 1
while retry:
sock = self.fdsockets.get(rsock)
if sock is None:
retry = 0
jdata = None
continue
try:
sync = sync[syncbytes:]
syncbit = sock.recv(syncbytes)
if not syncbit:
raise self.RecvError()
sync += syncbit
if sync != RPCHost.SYNC_MAGIC:
syncbytes = 1
retry = 1
raise self.SyncError()
else:
syncbytes = 8
retry = 0
jlen = sock.recv(8)
jlen = int(jlen)
recvlen = 0
while recvlen < jlen:
jdata += sock.recv(jlen - recvlen)
recvlen = len(jdata)
if recvlen < jlen:
log.warning(
"RPCHost: got short packet (%d of %d)" %
(recvlen, jlen))
except RPCHost.SyncError as e:
log.warning("RPCHost: sync error, resyncing")
pass
except (socket.error, RPCHost.RecvError) as e:
log.warning("RPCHost: communication error")
retry = 0
jdata = None
deadpeer = self.peers_by_socket[sock]
self.unmanage(deadpeer)
except Exception as e:
log.error("RPCHost: unhandled exception", type(e), e)
log.debug(jdata)
log.debug_traceback()
retry = 0
jdata = b""
if jdata is not None and len(jdata) >= jlen:
peer_id = self.peers_by_socket.get(sock)
self.read_workers.submit((jdata, peer_id))
if self.node_id == 0:
peers = list(self.managed_sockets.keys())
for node in peers:
req = Request("exit_request", {})
self.put(req, node)
self.wait(req)
del self.managed_sockets[node]
elif 0 in self.managed_sockets:
req = Request("exit_notify", {})
self.put(req, 0)
self.wait(req)
for clsname, cls in list(self.served_classes.items()):
self.unpublish(cls)
for clsname, cls in RPCWrapper.rpctype.items():
cls.publishers = []
if RPCWrapper.rpchost == self:
RPCWrapper.rpchost = None
self.read_workers.finish()
def run(self):
'''
RPCHost.run: perform IO on managed sockets, dispatch data
'''
self.read_workers.start()
if RPCWrapper.rpchost is None:
RPCWrapper.rpchost = self
import select
self.fdsockets = {}
while not self.join_req:
rdy = None
for s in self.managed_sockets.values():
if s.fileno() not in self.fdsockets:
self.fdsockets[s.fileno()] = s
try:
sockets = list(self.fdsockets.keys())
if sockets:
rdy, _w, _x = select.select(list(self.fdsockets.keys()), [], [], 0.1)
else:
time.sleep(0.1)
except Exception as e:
print("select exception:", e)
if not rdy:
continue
syncbytes = 8
sync = b''
for rsock in rdy:
jdata = b''
retry = 1
while retry:
sock = self.fdsockets.get(rsock)
if sock is None:
retry = 0
jdata = None
continue
try:
sync = sync[syncbytes:]
syncbit = sock.recv(syncbytes)
if not syncbit:
raise self.RecvError()
sync += syncbit
if sync != RPCHost.SYNC_MAGIC:
syncbytes = 1
retry = 1
raise self.SyncError()
else:
syncbytes = 8
retry = 0
jlen = sock.recv(8)
jlen = int(jlen)
recvlen = 0
while recvlen < jlen:
jdata += sock.recv(jlen-recvlen)
recvlen = len(jdata)
if recvlen < jlen:
log.warning("RPCHost: got short packet (%d of %d)"
% (recvlen, jlen))
except RPCHost.SyncError as e:
log.warning("RPCHost: sync error, resyncing")
pass
except (socket.error, RPCHost.RecvError) as e:
log.warning("RPCHost: communication error")
retry = 0
jdata = None
deadpeer = self.peers_by_socket[sock]
self.unmanage(deadpeer)
except Exception as e:
log.error("RPCHost: unhandled exception", type(e), e)
log.debug(jdata)
log.debug_traceback()
retry = 0
jdata = b""
if jdata is not None and len(jdata) >= jlen:
peer_id = self.peers_by_socket.get(sock)
self.read_workers.submit((jdata, peer_id))
if self.node_id == 0:
peers = list(self.managed_sockets.keys())
for node in peers:
req = Request("exit_request", {})
self.put(req, node)
self.wait(req)
del self.managed_sockets[node]
elif 0 in self.managed_sockets:
req = Request("exit_notify", {})
self.put(req, 0)
self.wait(req)
for clsname, cls in list(self.served_classes.items()):
self.unpublish(cls)
for clsname, cls in RPCWrapper.rpctype.items():
cls.publishers = []
if RPCWrapper.rpchost == self:
RPCWrapper.rpchost = None
self.read_workers.finish()
def run(self):
'''
RPCHost.run: perform IO on managed sockets, dispatch data
'''
self.read_workers.start()
if RPCWrapper.rpchost is None:
RPCWrapper.rpchost = self
import select
self.fdsockets = {}
while not self.join_req:
rdy = None
for s in self.managed_sockets.values():
if s.fileno() not in self.fdsockets:
self.fdsockets[s.fileno()] = s
try:
sockets = self.fdsockets.keys()
if sockets:
rdy, _w, _x = select.select(self.fdsockets.keys(), [], [], 0.1)
else:
time.sleep(0.1)
except Exception, e:
print "select exception:", e
if not rdy:
continue
syncbytes = 8
sync = ''
for rsock in rdy:
jdata = ''
retry = 1
while retry:
sock = self.fdsockets.get(rsock)
if sock is None:
retry = 0
jdata = None
continue
try:
sync = sync[syncbytes:]
syncbit = sock.recv(syncbytes)
if not syncbit:
raise self.RecvError()
sync += syncbit
if sync != RPCHost.SYNC_MAGIC:
syncbytes = 1
retry = 1
raise self.SyncError()
else:
syncbytes = 8
retry = 0
jlen = sock.recv(8)
jlen = int(jlen)
recvlen = 0
while recvlen < jlen:
jdata += sock.recv(jlen-recvlen)
recvlen = len(jdata)
if recvlen < jlen:
log.warning("RPCHost: got short packet (%d of %d)"
% (recvlen, jlen))
except RPCHost.SyncError, e:
log.warning("RPCHost: sync error, resyncing")
pass
except (socket.error, RPCHost.RecvError) as e:
log.warning("RPCHost: communication error")
retry = 0
jdata = None
deadpeer = self.peers_by_socket[sock]
self.unmanage(deadpeer)
except Exception, e:
log.error("RPCHost: unhandled exception", type(e), e)
log.debug(jdata)
log.debug_traceback()
retry = 0
jdata = ""
def handle_event(self, stage, event):
from gi.repository import Clutter
from mfp import log
keysym = None
if event.type in (
Clutter.EventType.KEY_PRESS, Clutter.EventType.KEY_RELEASE,
Clutter.EventType.BUTTON_PRESS,
Clutter.EventType.BUTTON_RELEASE, Clutter.EventType.SCROLL):
self.keyseq.process(event)
if len(self.keyseq.sequences):
keysym = self.keyseq.pop()
elif event.type == Clutter.EventType.MOTION:
# FIXME: if the scaling changes so that window.stage_pos would return a
# different value, that should generate a MOTION event. Currently we are
# just kludging pointer_x and pointer_y from the scale callback.
self.pointer_ev_x = event.x
self.pointer_ev_y = event.y
self.pointer_x, self.pointer_y = self.window.stage_pos(event.x, event.y)
self.keyseq.process(event)
if len(self.keyseq.sequences):
keysym = self.keyseq.pop()
elif event.type == Clutter.EventType.ENTER:
src = self.event_sources.get(event.source)
now = datetime.now()
if (self.pointer_leave_time is not None
and (now - self.pointer_leave_time) > timedelta(milliseconds=100)):
self.keyseq.mod_keys = set()
self.window.grab_focus()
if src and self.window.object_visible(src):
self.pointer_obj = src
self.pointer_obj_time = now
elif event.type == Clutter.EventType.LEAVE:
src = self.event_sources.get(event.source)
self.pointer_leave_time = datetime.now()
if src == self.pointer_obj:
self.pointer_lastobj = self.pointer_obj
self.pointer_obj = None
self.pointer_obj_time = None
else:
log.debug("event type not matched:", event.type)
return False
if not keysym:
return True
retry_count = 0
while True:
rv = None
try:
retry_count += 1
rv = self.handle_keysym(keysym)
except self.InputNeedsRequeue, e:
if retry_count < 5:
continue
else:
return False
except Exception, e:
log.error("Exception while handling key command", keysym)
log.debug(e)
log.debug_traceback()
def handle_event(self, stage, event):
from gi.repository import Clutter
keysym = None
if event.type in (Clutter.EventType.KEY_PRESS,
Clutter.EventType.KEY_RELEASE,
Clutter.EventType.BUTTON_PRESS,
Clutter.EventType.BUTTON_RELEASE,
Clutter.EventType.SCROLL):
self.keyseq.process(event)
if len(self.keyseq.sequences):
keysym = self.keyseq.pop()
elif event.type == Clutter.EventType.MOTION:
# FIXME: if the scaling changes so that window.stage_pos would return a
# different value, that should generate a MOTION event. Currently we are
# just kludging pointer_x and pointer_y from the scale callback.
self.pointer_ev_x = event.x
self.pointer_ev_y = event.y
self.pointer_x, self.pointer_y = self.window.stage_pos(
event.x, event.y)
self.keyseq.process(event)
if len(self.keyseq.sequences):
keysym = self.keyseq.pop()
elif event.type == Clutter.EventType.ENTER:
src = self.event_sources.get(event.source)
now = datetime.now()
if (self.pointer_leave_time is not None and
(now - self.pointer_leave_time) > timedelta(milliseconds=100)):
self.keyseq.mod_keys = set()
self.window.embed.grab_focus()
if src and self.window.object_visible(src):
self.pointer_obj = src
self.pointer_obj_time = now
elif event.type == Clutter.EventType.LEAVE:
src = self.event_sources.get(event.source)
self.pointer_leave_time = datetime.now()
if src == self.pointer_obj:
self.pointer_lastobj = self.pointer_obj
self.pointer_obj = None
self.pointer_obj_time = None
else:
return False
retry_count = 0
while True:
rv = None
try:
retry_count += 1
rv = self.handle_keysym(keysym)
except self.InputNeedsRequeue, e:
if retry_count < 5:
continue
else:
return False
except Exception, e:
from mfp import log
import traceback
log.error("Exception while handling key command", keysym)
for l in traceback.format_exc().split("\n"):
log.debug(l)
log.debug(e)
