15
41
from dbus.mainloop.glib import DBusGMainLoop
42
from gi.repository import GLib
24
locale.setlocale(locale.LC_ALL, u'')
50
if sys.version_info.major == 2:
53
locale.setlocale(locale.LC_ALL, '')
27
55
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
29
57
# Some useful constants
30
domain = 'se.bsnet.fukt'
58
domain = 'se.recompile'
31
59
server_interface = domain + '.Mandos'
32
60
client_interface = domain + '.Mandos.Client'
35
# Always run in monochrome mode
36
urwid.curses_display.curses.has_colors = lambda : False
38
# Urwid doesn't support blinking, but we want it. Since we have no
39
# use for underline on its own, we make underline also always blink.
40
urwid.curses_display.curses.A_UNDERLINE |= (
41
urwid.curses_display.curses.A_BLINK)
64
dbus.OBJECT_MANAGER_IFACE
65
except AttributeError:
66
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
69
def isoformat_to_datetime(iso):
70
"Parse an ISO 8601 date string to a datetime.datetime()"
73
d, t = iso.split("T", 1)
74
year, month, day = d.split("-", 2)
75
hour, minute, second = t.split(":", 2)
76
second, fraction = divmod(float(second), 1)
77
return datetime.datetime(int(year),
82
int(second), # Whole seconds
83
int(fraction*1000000)) # Microseconds
43
86
class MandosClientPropertyCache(object):
44
87
"""This wraps a Mandos Client D-Bus proxy object, caches the
45
88
properties and calls a hook function when any of them are
48
def __init__(self, proxy_object=None, *args, **kwargs):
49
self.proxy = proxy_object # Mandos Client proxy object
51
self.properties = dict()
52
self.proxy.connect_to_signal(u"PropertyChanged",
53
self.property_changed,
57
self.properties.update(
58
self.proxy.GetAll(client_interface,
59
dbus_interface = dbus.PROPERTIES_IFACE))
60
super(MandosClientPropertyCache, self).__init__(
63
def property_changed(self, property=None, value=None):
64
"""This is called whenever we get a PropertyChanged signal
65
It updates the changed property in the "properties" dict.
91
def __init__(self, proxy_object=None, properties=None, **kwargs):
92
self.proxy = proxy_object # Mandos Client proxy object
93
self.properties = dict() if properties is None else properties
94
self.property_changed_match = (
95
self.proxy.connect_to_signal("PropertiesChanged",
96
self.properties_changed,
97
dbus.PROPERTIES_IFACE,
100
if properties is None:
101
self.properties.update(self.proxy.GetAll(
103
dbus_interface=dbus.PROPERTIES_IFACE))
105
super(MandosClientPropertyCache, self).__init__(**kwargs)
107
def properties_changed(self, interface, properties, invalidated):
108
"""This is called whenever we get a PropertiesChanged signal
109
It updates the changed properties in the "properties" dict.
67
111
# Update properties dict with new value
68
self.properties[property] = value
112
if interface == client_interface:
113
self.properties.update(properties)
116
self.property_changed_match.remove()
71
119
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
72
120
"""A Mandos Client which is visible on the screen.
75
123
def __init__(self, server_proxy_object=None, update_hook=None,
76
delete_hook=None, logger=None, *args, **kwargs):
124
delete_hook=None, logger=None, **kwargs):
77
125
# Called on update
78
126
self.update_hook = update_hook
79
127
# Called on delete
82
130
self.server_proxy_object = server_proxy_object
84
132
self.logger = logger
134
self._update_timer_callback_tag = None
86
136
# The widget shown normally
87
self._text_widget = urwid.Text(u"")
137
self._text_widget = urwid.Text("")
88
138
# The widget shown when we have focus
89
self._focus_text_widget = urwid.Text(u"")
90
super(MandosClientWidget, self).__init__(
91
update_hook=update_hook, delete_hook=delete_hook,
139
self._focus_text_widget = urwid.Text("")
140
super(MandosClientWidget, self).__init__(**kwargs)
94
142
self.opened = False
95
self.proxy.connect_to_signal(u"CheckerCompleted",
96
self.checker_completed,
99
self.proxy.connect_to_signal(u"CheckerStarted",
100
self.checker_started,
103
self.proxy.connect_to_signal(u"GotSecret",
107
self.proxy.connect_to_signal(u"NeedApproval",
111
self.proxy.connect_to_signal(u"Rejected",
144
self.match_objects = (
145
self.proxy.connect_to_signal("CheckerCompleted",
146
self.checker_completed,
149
self.proxy.connect_to_signal("CheckerStarted",
150
self.checker_started,
153
self.proxy.connect_to_signal("GotSecret",
157
self.proxy.connect_to_signal("NeedApproval",
161
self.proxy.connect_to_signal("Rejected",
165
self.logger('Created client {}'
166
.format(self.properties["Name"]), level=0)
168
def using_timer(self, flag):
169
"""Call this method with True or False when timer should be
170
activated or deactivated.
172
if flag and self._update_timer_callback_tag is None:
173
# Will update the shown timer value every second
174
self._update_timer_callback_tag = (GLib.timeout_add
177
elif not (flag or self._update_timer_callback_tag is None):
178
GLib.source_remove(self._update_timer_callback_tag)
179
self._update_timer_callback_tag = None
116
181
def checker_completed(self, exitstatus, condition, command):
117
182
if exitstatus == 0:
118
#self.logger(u'Checker for client %s (command "%s")'
120
# % (self.properties[u"name"], command))
183
self.logger('Checker for client {} (command "{}")'
184
' succeeded'.format(self.properties["Name"],
122
189
if os.WIFEXITED(condition):
123
self.logger(u'Checker for client %s (command "%s")'
124
u' failed with exit code %s'
125
% (self.properties[u"name"], command,
126
os.WEXITSTATUS(condition)))
128
if os.WIFSIGNALED(condition):
129
self.logger(u'Checker for client %s (command "%s")'
130
u' was killed by signal %s'
131
% (self.properties[u"name"], command,
132
os.WTERMSIG(condition)))
134
if os.WCOREDUMP(condition):
135
self.logger(u'Checker for client %s (command "%s")'
137
% (self.properties[u"name"], command))
138
self.logger(u'Checker for client %s completed mysteriously')
190
self.logger('Checker for client {} (command "{}") failed'
192
.format(self.properties["Name"], command,
193
os.WEXITSTATUS(condition)))
194
elif os.WIFSIGNALED(condition):
195
self.logger('Checker for client {} (command "{}") was'
196
' killed by signal {}'
197
.format(self.properties["Name"], command,
198
os.WTERMSIG(condition)))
140
201
def checker_started(self, command):
141
#self.logger(u'Client %s started checker "%s"'
142
# % (self.properties[u"name"], unicode(command)))
202
"""Server signals that a checker started."""
203
self.logger('Client {} started checker "{}"'
204
.format(self.properties["Name"],
145
207
def got_secret(self):
146
self.logger(u'Client %s received its secret'
147
% self.properties[u"name"])
208
self.logger('Client {} received its secret'
209
.format(self.properties["Name"]))
149
211
def need_approval(self, timeout, default):
151
message = u'Client %s needs approval within %s seconds'
213
message = 'Client {} needs approval within {} seconds'
153
message = u'Client %s will get its secret in %s seconds'
155
% (self.properties[u"name"], timeout/1000))
215
message = 'Client {} will get its secret in {} seconds'
216
self.logger(message.format(self.properties["Name"],
157
219
def rejected(self, reason):
158
self.logger(u'Client %s was rejected; reason: %s'
159
% (self.properties[u"name"], reason))
220
self.logger('Client {} was rejected; reason: {}'
221
.format(self.properties["Name"], reason))
161
223
def selectable(self):
162
224
"""Make this a "selectable" widget.
163
225
This overrides the method from urwid.FlowWidget."""
166
def rows(self, (maxcol,), focus=False):
228
def rows(self, maxcolrow, focus=False):
167
229
"""How many rows this widget will occupy might depend on
168
230
whether we have focus or not.
169
231
This overrides the method from urwid.FlowWidget"""
170
return self.current_widget(focus).rows((maxcol,), focus=focus)
232
return self.current_widget(focus).rows(maxcolrow, focus=focus)
172
234
def current_widget(self, focus=False):
173
235
if focus or self.opened:
174
236
return self._focus_widget
175
237
return self._widget
177
239
def update(self):
178
240
"Called when what is visible on the screen should be updated."
179
241
# How to add standout mode to a style
180
with_standout = { u"normal": u"standout",
181
u"bold": u"bold-standout",
183
u"underline-blink-standout",
184
u"bold-underline-blink":
185
u"bold-underline-blink-standout",
242
with_standout = {"normal": "standout",
243
"bold": "bold-standout",
245
"underline-blink-standout",
246
"bold-underline-blink":
247
"bold-underline-blink-standout",
188
250
# Rebuild focus and non-focus widgets using current properties
189
self._text = (u'%(name)s: %(enabled)s'
190
% { u"name": self.properties[u"name"],
193
if self.properties[u"enabled"]
252
# Base part of a client. Name!
253
base = '{name}: '.format(name=self.properties["Name"])
254
if not self.properties["Enabled"]:
256
self.using_timer(False)
257
elif self.properties["ApprovalPending"]:
258
timeout = datetime.timedelta(
259
milliseconds=self.properties["ApprovalDelay"])
260
last_approval_request = isoformat_to_datetime(
261
self.properties["LastApprovalRequest"])
262
if last_approval_request is not None:
263
timer = max(timeout - (datetime.datetime.utcnow()
264
- last_approval_request),
265
datetime.timedelta())
267
timer = datetime.timedelta()
268
if self.properties["ApprovedByDefault"]:
269
message = "Approval in {}. (d)eny?"
271
message = "Denial in {}. (a)pprove?"
272
message = message.format(str(timer).rsplit(".", 1)[0])
273
self.using_timer(True)
274
elif self.properties["LastCheckerStatus"] != 0:
275
# When checker has failed, show timer until client expires
276
expires = self.properties["Expires"]
278
timer = datetime.timedelta(0)
280
expires = (datetime.datetime.strptime
281
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
282
timer = max(expires - datetime.datetime.utcnow(),
283
datetime.timedelta())
284
message = ('A checker has failed! Time until client'
286
.format(str(timer).rsplit(".", 1)[0]))
287
self.using_timer(True)
290
self.using_timer(False)
291
self._text = "{}{}".format(base, message)
195
293
if not urwid.supports_unicode():
196
294
self._text = self._text.encode("ascii", "replace")
197
textlist = [(u"normal", self._text)]
295
textlist = [("normal", self._text)]
198
296
self._text_widget.set_text(textlist)
199
297
self._focus_text_widget.set_text([(with_standout[text[0]],
207
305
# Run update hook, if any
208
306
if self.update_hook is not None:
209
307
self.update_hook()
309
def update_timer(self):
310
"""called by GLib. Will indefinitely loop until
311
GLib.source_remove() on tag is called
314
return True # Keep calling this
316
def delete(self, **kwargs):
317
if self._update_timer_callback_tag is not None:
318
GLib.source_remove(self._update_timer_callback_tag)
319
self._update_timer_callback_tag = None
320
for match in self.match_objects:
322
self.match_objects = ()
212
323
if self.delete_hook is not None:
213
324
self.delete_hook(self)
215
def render(self, (maxcol,), focus=False):
325
return super(MandosClientWidget, self).delete(**kwargs)
327
def render(self, maxcolrow, focus=False):
216
328
"""Render differently if we have focus.
217
329
This overrides the method from urwid.FlowWidget"""
218
return self.current_widget(focus).render((maxcol,),
330
return self.current_widget(focus).render(maxcolrow,
221
def keypress(self, (maxcol,), key):
333
def keypress(self, maxcolrow, key):
223
335
This overrides the method from urwid.FlowWidget"""
224
if key == u"e" or key == u"+":
226
elif key == u"d" or key == u"-":
228
elif key == u"r" or key == u"_" or key == u"ctrl k":
337
self.proxy.Set(client_interface, "Enabled",
338
dbus.Boolean(True), ignore_reply=True,
339
dbus_interface=dbus.PROPERTIES_IFACE)
341
self.proxy.Set(client_interface, "Enabled", False,
343
dbus_interface=dbus.PROPERTIES_IFACE)
345
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
346
dbus_interface=client_interface,
349
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
350
dbus_interface=client_interface,
352
elif key == "R" or key == "_" or key == "ctrl k":
229
353
self.server_proxy_object.RemoveClient(self.proxy
232
self.proxy.StartChecker()
234
self.proxy.StopChecker()
236
self.proxy.CheckedOK()
357
self.proxy.Set(client_interface, "CheckerRunning",
358
dbus.Boolean(True), ignore_reply=True,
359
dbus_interface=dbus.PROPERTIES_IFACE)
361
self.proxy.Set(client_interface, "CheckerRunning",
362
dbus.Boolean(False), ignore_reply=True,
363
dbus_interface=dbus.PROPERTIES_IFACE)
365
self.proxy.CheckedOK(dbus_interface=client_interface,
238
# elif key == u"p" or key == "=":
368
# elif key == "p" or key == "=":
239
369
# self.proxy.pause()
240
# elif key == u"u" or key == ":":
370
# elif key == "u" or key == ":":
241
371
# self.proxy.unpause()
242
# elif key == u"RET":
245
self.proxy.Approve(True)
247
self.proxy.Approve(False)
251
def property_changed(self, property=None, value=None,
253
"""Call self.update() if old value is not new value.
377
def properties_changed(self, interface, properties, invalidated):
378
"""Call self.update() if any properties changed.
254
379
This overrides the method from MandosClientPropertyCache"""
255
property_name = unicode(property)
256
old_value = self.properties.get(property_name)
257
super(MandosClientWidget, self).property_changed(
258
property=property, value=value, *args, **kwargs)
259
if self.properties.get(property_name) != old_value:
380
old_values = {key: self.properties.get(key)
381
for key in properties.keys()}
382
super(MandosClientWidget, self).properties_changed(
383
interface, properties, invalidated)
384
if any(old_values[key] != self.properties.get(key)
385
for key in old_values):
276
403
"""This is the entire user interface - the whole screen
277
404
with boxes, lists of client widgets, etc.
279
def __init__(self, max_log_length=1000):
406
def __init__(self, max_log_length=1000, log_level=1):
280
407
DBusGMainLoop(set_as_default=True)
282
409
self.screen = urwid.curses_display.Screen()
284
411
self.screen.register_palette((
286
u"default", u"default", None),
288
u"default", u"default", u"bold"),
290
u"default", u"default", u"underline"),
292
u"default", u"default", u"standout"),
293
(u"bold-underline-blink",
294
u"default", u"default", (u"bold", u"underline")),
296
u"default", u"default", (u"bold", u"standout")),
297
(u"underline-blink-standout",
298
u"default", u"default", (u"underline", u"standout")),
299
(u"bold-underline-blink-standout",
300
u"default", u"default", (u"bold", u"underline",
413
"default", "default", None),
415
"bold", "default", "bold"),
417
"underline,blink", "default", "underline,blink"),
419
"standout", "default", "standout"),
420
("bold-underline-blink",
421
"bold,underline,blink", "default",
422
"bold,underline,blink"),
424
"bold,standout", "default", "bold,standout"),
425
("underline-blink-standout",
426
"underline,blink,standout", "default",
427
"underline,blink,standout"),
428
("bold-underline-blink-standout",
429
"bold,underline,blink,standout", "default",
430
"bold,underline,blink,standout"),
304
433
if urwid.supports_unicode():
305
self.divider = u"─" # \u2500
306
#self.divider = u"━" # \u2501
434
self.divider = "─" # \u2500
308
#self.divider = u"-" # \u002d
309
self.divider = u"_" # \u005f
436
self.divider = "_" # \u005f
311
438
self.screen.start()
313
440
self.size = self.screen.get_cols_rows()
315
442
self.clients = urwid.SimpleListWalker([])
316
443
self.clients_dict = {}
318
445
# We will add Text widgets to this list
320
447
self.max_log_length = max_log_length
449
self.log_level = log_level
322
451
# We keep a reference to the log widget so we can remove it
323
452
# from the ListWalker without it getting destroyed
324
453
self.logbox = ConstrainedListBox(self.log)
326
455
# This keeps track of whether self.uilist currently has
327
456
# self.logbox in it or not
328
457
self.log_visible = True
329
self.log_wrap = u"any"
458
self.log_wrap = "any"
332
self.log_message_raw((u"bold",
333
u"Mandos Monitor version " + version))
334
self.log_message_raw((u"bold",
461
self.log_message_raw(("bold",
462
"Mandos Monitor version " + version))
463
self.log_message_raw(("bold",
337
466
self.busname = domain + '.Mandos'
338
self.main_loop = gobject.MainLoop()
339
self.bus = dbus.SystemBus()
340
mandos_dbus_objc = self.bus.get_object(
341
self.busname, u"/", follow_name_owner_changes=True)
342
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
346
mandos_clients = (self.mandos_serv
347
.GetAllClientsWithProperties())
348
except dbus.exceptions.DBusException:
349
mandos_clients = dbus.Dictionary()
352
.connect_to_signal(u"ClientRemoved",
353
self.find_and_remove_client,
354
dbus_interface=server_interface,
357
.connect_to_signal(u"ClientAdded",
359
dbus_interface=server_interface,
362
.connect_to_signal(u"ClientNotFound",
363
self.client_not_found,
364
dbus_interface=server_interface,
366
for path, client in mandos_clients.iteritems():
367
client_proxy_object = self.bus.get_object(self.busname,
369
self.add_client(MandosClientWidget(server_proxy_object
372
=client_proxy_object,
467
self.main_loop = GLib.MainLoop()
382
469
def client_not_found(self, fingerprint, address):
383
self.log_message((u"Client with address %s and fingerprint %s"
384
u" could not be found" % (address,
470
self.log_message("Client with address {} and fingerprint {}"
471
" could not be found"
472
.format(address, fingerprint))
387
474
def rebuild(self):
388
475
"""This rebuilds the User Interface.
389
476
Call this when the widget layout needs to change"""
391
#self.uilist.append(urwid.ListBox(self.clients))
392
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
393
#header=urwid.Divider(),
478
# self.uilist.append(urwid.ListBox(self.clients))
479
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
481
# header=urwid.Divider(),
395
footer=urwid.Divider(div_char=self.divider)))
483
footer=urwid.Divider(
484
div_char=self.divider)))
396
485
if self.log_visible:
397
486
self.uilist.append(self.logbox)
399
487
self.topwidget = urwid.Pile(self.uilist)
401
def log_message(self, message):
489
def log_message(self, message, level=1):
490
"""Log message formatted with timestamp"""
491
if level < self.log_level:
402
493
timestamp = datetime.datetime.now().isoformat()
403
self.log_message_raw(timestamp + u": " + message)
405
def log_message_raw(self, markup):
494
self.log_message_raw("{}: {}".format(timestamp, message),
497
def log_message_raw(self, markup, level=1):
406
498
"""Add a log message to the log buffer."""
499
if level < self.log_level:
407
501
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
408
if (self.max_log_length
409
and len(self.log) > self.max_log_length):
410
del self.log[0:len(self.log)-self.max_log_length-1]
502
if self.max_log_length:
503
if len(self.log) > self.max_log_length:
504
del self.log[0:len(self.log)-self.max_log_length-1]
411
505
self.logbox.set_focus(len(self.logbox.body.contents),
412
coming_from=u"above")
415
509
def toggle_log_display(self):
416
510
"""Toggle visibility of the log buffer."""
417
511
self.log_visible = not self.log_visible
419
self.log_message(u"Log visibility changed to: "
420
+ unicode(self.log_visible))
513
self.log_message("Log visibility changed to: {}"
514
.format(self.log_visible), level=0)
422
516
def change_log_display(self):
423
517
"""Change type of log display.
424
518
Currently, this toggles wrapping of text lines."""
425
if self.log_wrap == u"clip":
426
self.log_wrap = u"any"
519
if self.log_wrap == "clip":
520
self.log_wrap = "any"
428
self.log_wrap = u"clip"
522
self.log_wrap = "clip"
429
523
for textwidget in self.log:
430
524
textwidget.set_wrap_mode(self.log_wrap)
431
self.log_message(u"Wrap mode: " + self.log_wrap)
433
def find_and_remove_client(self, path, name):
434
"""Find an client from its object path and remove it.
436
This is connected to the ClientRemoved signal from the
525
self.log_message("Wrap mode: {}".format(self.log_wrap),
528
def find_and_remove_client(self, path, interfaces):
529
"""Find a client by its object path and remove it.
531
This is connected to the InterfacesRemoved signal from the
437
532
Mandos server object."""
533
if client_interface not in interfaces:
534
# Not a Mandos client object; ignore
439
537
client = self.clients_dict[path]
443
self.remove_client(client, path)
445
def add_new_client(self, path):
540
self.log_message("Unknown client {!r} removed"
545
def add_new_client(self, path, ifs_and_props):
546
"""Find a client by its object path and remove it.
548
This is connected to the InterfacesAdded signal from the
549
Mandos server object.
551
if client_interface not in ifs_and_props:
552
# Not a Mandos client object; ignore
446
554
client_proxy_object = self.bus.get_object(self.busname, path)
447
self.add_client(MandosClientWidget(server_proxy_object
450
=client_proxy_object,
555
self.add_client(MandosClientWidget(
556
server_proxy_object=self.mandos_serv,
557
proxy_object=client_proxy_object,
558
update_hook=self.refresh,
559
delete_hook=self.remove_client,
560
logger=self.log_message,
561
properties=dict(ifs_and_props[client_interface])),
459
564
def add_client(self, client, path=None):
460
565
self.clients.append(client)
462
567
path = client.proxy.object_path
463
568
self.clients_dict[path] = client
464
self.clients.sort(None, lambda c: c.properties[u"name"])
569
self.clients.sort(key=lambda c: c.properties["Name"])
467
572
def remove_client(self, client, path=None):
468
573
self.clients.remove(client)
470
575
path = client.proxy.object_path
471
576
del self.clients_dict[path]
472
if not self.clients_dict:
473
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
474
# is completely emptied, we need to recreate it.
475
self.clients = urwid.SimpleListWalker([])
479
579
def refresh(self):
480
580
"""Redraw the screen"""
481
581
canvas = self.topwidget.render(self.size, focus=True)
482
582
self.screen.draw_screen(self.size, canvas)
485
585
"""Start the main loop and exit when it's done."""
586
self.bus = dbus.SystemBus()
587
mandos_dbus_objc = self.bus.get_object(
588
self.busname, "/", follow_name_owner_changes=True)
589
self.mandos_serv = dbus.Interface(
590
mandos_dbus_objc, dbus_interface=server_interface)
592
mandos_clients = (self.mandos_serv
593
.GetAllClientsWithProperties())
594
if not mandos_clients:
595
self.log_message_raw(("bold",
596
"Note: Server has no clients."))
597
except dbus.exceptions.DBusException:
598
self.log_message_raw(("bold",
599
"Note: No Mandos server running."))
600
mandos_clients = dbus.Dictionary()
603
.connect_to_signal("InterfacesRemoved",
604
self.find_and_remove_client,
605
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
608
.connect_to_signal("InterfacesAdded",
610
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
613
.connect_to_signal("ClientNotFound",
614
self.client_not_found,
615
dbus_interface=server_interface,
617
for path, client in mandos_clients.items():
618
client_proxy_object = self.bus.get_object(self.busname,
620
self.add_client(MandosClientWidget(
621
server_proxy_object=self.mandos_serv,
622
proxy_object=client_proxy_object,
624
update_hook=self.refresh,
625
delete_hook=self.remove_client,
626
logger=self.log_message),
487
self._input_callback_tag = (gobject.io_add_watch
630
self._input_callback_tag = (GLib.io_add_watch
488
631
(sys.stdin.fileno(),
490
633
self.process_input))
491
634
self.main_loop.run()
492
635
# Main loop has finished, we should close everything now
493
gobject.source_remove(self._input_callback_tag)
636
GLib.source_remove(self._input_callback_tag)
494
637
self.screen.stop()
497
640
self.main_loop.quit()
499
642
def process_input(self, source, condition):
500
643
keys = self.screen.get_input()
501
translations = { u"ctrl n": u"down", # Emacs
502
u"ctrl p": u"up", # Emacs
503
u"ctrl v": u"page down", # Emacs
504
u"meta v": u"page up", # Emacs
505
u" ": u"page down", # less
506
u"f": u"page down", # less
507
u"b": u"page up", # less
644
translations = {"ctrl n": "down", # Emacs
645
"ctrl p": "up", # Emacs
646
"ctrl v": "page down", # Emacs
647
"meta v": "page up", # Emacs
648
" ": "page down", # less
649
"f": "page down", # less
650
"b": "page up", # less
513
656
key = translations[key]
514
657
except KeyError: # :-)
517
if key == u"q" or key == u"Q":
660
if key == "q" or key == "Q":
520
elif key == u"window resize":
663
elif key == "window resize":
521
664
self.size = self.screen.get_cols_rows()
523
elif key == u"\f": # Ctrl-L
666
elif key == "ctrl l":
525
elif key == u"l" or key == u"D":
669
elif key == "l" or key == "D":
526
670
self.toggle_log_display()
528
elif key == u"w" or key == u"i":
672
elif key == "w" or key == "i":
529
673
self.change_log_display()
531
elif key == u"?" or key == u"f1" or key == u"esc":
675
elif key == "?" or key == "f1" or key == "esc":
532
676
if not self.log_visible:
533
677
self.log_visible = True
535
self.log_message_raw((u"bold",
539
u"l: Log window toggle",
540
u"TAB: Switch window",
542
self.log_message_raw((u"bold",
548
u"s: Start new checker",
679
self.log_message_raw(("bold",
683
"l: Log window toggle",
684
"TAB: Switch window",
685
"w: Wrap (log lines)",
686
"v: Toggle verbose log",
688
self.log_message_raw(("bold",
694
"s: Start new checker",
553
701
if self.topwidget.get_focus() is self.logbox:
554
702
self.topwidget.set_focus(0)
556
704
self.topwidget.set_focus(self.logbox)
558
#elif (key == u"end" or key == u"meta >" or key == u"G"
560
# pass # xxx end-of-buffer
561
#elif (key == u"home" or key == u"meta <" or key == u"g"
563
# pass # xxx beginning-of-buffer
564
#elif key == u"ctrl e" or key == u"$":
565
# pass # xxx move-end-of-line
566
#elif key == u"ctrl a" or key == u"^":
567
# pass # xxx move-beginning-of-line
568
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
570
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
573
# pass # scroll up log
575
# pass # scroll down log
707
if self.log_level == 0:
709
self.log_message("Verbose mode: Off")
712
self.log_message("Verbose mode: On")
713
# elif (key == "end" or key == "meta >" or key == "G"
715
# pass # xxx end-of-buffer
716
# elif (key == "home" or key == "meta <" or key == "g"
718
# pass # xxx beginning-of-buffer
719
# elif key == "ctrl e" or key == "$":
720
# pass # xxx move-end-of-line
721
# elif key == "ctrl a" or key == "^":
722
# pass # xxx move-beginning-of-line
723
# elif key == "ctrl b" or key == "meta (" or key == "h":
725
# elif key == "ctrl f" or key == "meta )" or key == "l":
728
# pass # scroll up log
730
# pass # scroll down log
576
731
elif self.topwidget.selectable():
577
732
self.topwidget.keypress(self.size, key)