2
2
# -*- mode: python; coding: utf-8 -*-
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2009-2014 Teddy Hogeborn
7
# Copyright © 2009-2014 Björn Påhlsson
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
11
# the Free Software Foundation, either version 3 of the License, or
12
# (at your option) any later version.
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
# GNU General Public License for more details.
19
# You should have received a copy of the GNU General Public License
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
23
# Contact the authors at <mandos@recompile.se>.
4
from __future__ import division, absolute_import, with_statement
26
from __future__ import (division, absolute_import, print_function,
29
from future_builtins import *
15
41
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GObject as gobject
24
locale.setlocale(locale.LC_ALL, u'')
51
if sys.version_info[0] == 2:
54
locale.setlocale(locale.LC_ALL, '')
27
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
29
59
# Some useful constants
30
domain = 'se.bsnet.fukt'
60
domain = 'se.recompile'
31
61
server_interface = domain + '.Mandos'
32
62
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)
43
65
def isoformat_to_datetime(iso):
44
66
"Parse an ISO 8601 date string to a datetime.datetime()"
47
d, t = iso.split(u"T", 1)
48
year, month, day = d.split(u"-", 2)
49
hour, minute, second = t.split(u":", 2)
69
d, t = iso.split("T", 1)
70
year, month, day = d.split("-", 2)
71
hour, minute, second = t.split(":", 2)
50
72
second, fraction = divmod(float(second), 1)
51
73
return datetime.datetime(int(year),
61
83
properties and calls a hook function when any of them are
64
def __init__(self, proxy_object=None, *args, **kwargs):
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
65
87
self.proxy = proxy_object # Mandos Client proxy object
67
self.properties = dict()
68
self.proxy.connect_to_signal(u"PropertyChanged",
69
self.property_changed,
73
self.properties.update(
74
self.proxy.GetAll(client_interface,
75
dbus_interface = dbus.PROPERTIES_IFACE))
77
#XXX This break good super behaviour!
78
# super(MandosClientPropertyCache, self).__init__(
88
self.properties = dict() if properties is None else properties
89
self.property_changed_match = (
90
self.proxy.connect_to_signal("PropertyChanged",
91
self._property_changed,
95
if properties is None:
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
99
= dbus.PROPERTIES_IFACE))
101
super(MandosClientPropertyCache, self).__init__(**kwargs)
103
def _property_changed(self, property, value):
104
"""Helper which takes positional arguments"""
105
return self.property_changed(property=property, value=value)
81
107
def property_changed(self, property=None, value=None):
82
108
"""This is called whenever we get a PropertyChanged signal
102
131
self.logger = logger
104
133
self._update_timer_callback_tag = None
105
self._update_timer_callback_lock = 0
106
self.last_checker_failed = False
108
135
# The widget shown normally
109
self._text_widget = urwid.Text(u"")
136
self._text_widget = urwid.Text("")
110
137
# The widget shown when we have focus
111
self._focus_text_widget = urwid.Text(u"")
112
super(MandosClientWidget, self).__init__(
113
update_hook=update_hook, delete_hook=delete_hook,
138
self._focus_text_widget = urwid.Text("")
139
super(MandosClientWidget, self).__init__(**kwargs)
116
141
self.opened = False
118
last_checked_ok = isoformat_to_datetime(self.properties
120
if last_checked_ok is None:
121
self.last_checker_failed = True
123
self.last_checker_failed = ((datetime.datetime.utcnow()
130
if self.last_checker_failed:
131
self.using_timer(True)
133
if self.need_approval:
134
self.using_timer(True)
136
self.proxy.connect_to_signal(u"CheckerCompleted",
137
self.checker_completed,
140
self.proxy.connect_to_signal(u"CheckerStarted",
141
self.checker_started,
144
self.proxy.connect_to_signal(u"GotSecret",
148
self.proxy.connect_to_signal(u"NeedApproval",
152
self.proxy.connect_to_signal(u"Rejected",
143
self.match_objects = (
144
self.proxy.connect_to_signal("CheckerCompleted",
145
self.checker_completed,
148
self.proxy.connect_to_signal("CheckerStarted",
149
self.checker_started,
152
self.proxy.connect_to_signal("GotSecret",
156
self.proxy.connect_to_signal("NeedApproval",
160
self.proxy.connect_to_signal("Rejected",
164
self.logger('Created client {0}'
165
.format(self.properties["Name"]), level=0)
157
def property_changed(self, property=None, value=None):
158
super(self, MandosClientWidget).property_changed(property,
160
if property == u"ApprovalPending":
161
using_timer(bool(value))
163
167
def using_timer(self, flag):
164
168
"""Call this method with True or False when timer should be
165
169
activated or deactivated.
167
old = self._update_timer_callback_lock
169
self._update_timer_callback_lock += 1
171
self._update_timer_callback_lock -= 1
172
if old == 0 and self._update_timer_callback_lock:
171
if flag and self._update_timer_callback_tag is None:
172
# Will update the shown timer value every second
173
173
self._update_timer_callback_tag = (gobject.timeout_add
175
175
self.update_timer))
176
elif old and self._update_timer_callback_lock == 0:
176
elif not (flag or self._update_timer_callback_tag is None):
177
177
gobject.source_remove(self._update_timer_callback_tag)
178
178
self._update_timer_callback_tag = None
180
180
def checker_completed(self, exitstatus, condition, command):
181
181
if exitstatus == 0:
182
if self.last_checker_failed:
183
self.last_checker_failed = False
184
self.using_timer(False)
185
#self.logger(u'Checker for client %s (command "%s")'
187
# % (self.properties[u"Name"], command))
182
self.logger('Checker for client {0} (command "{1}")'
183
' succeeded'.format(self.properties["Name"],
191
if not self.last_checker_failed:
192
self.last_checker_failed = True
193
self.using_timer(True)
194
188
if os.WIFEXITED(condition):
195
self.logger(u'Checker for client %s (command "%s")'
196
u' failed with exit code %s'
197
% (self.properties[u"Name"], command,
198
os.WEXITSTATUS(condition)))
189
self.logger('Checker for client {0} (command "{1}")'
190
' failed with exit code {2}'
191
.format(self.properties["Name"], command,
192
os.WEXITSTATUS(condition)))
199
193
elif os.WIFSIGNALED(condition):
200
self.logger(u'Checker for client %s (command "%s")'
201
u' was killed by signal %s'
202
% (self.properties[u"Name"], command,
203
os.WTERMSIG(condition)))
194
self.logger('Checker for client {0} (command "{1}") was'
195
' killed by signal {2}'
196
.format(self.properties["Name"], command,
197
os.WTERMSIG(condition)))
204
198
elif os.WCOREDUMP(condition):
205
self.logger(u'Checker for client %s (command "%s")'
207
% (self.properties[u"Name"], command))
199
self.logger('Checker for client {0} (command "{1}")'
201
.format(self.properties["Name"], command))
209
self.logger(u'Checker for client %s completed'
203
self.logger('Checker for client {0} completed'
205
.format(self.properties["Name"]))
213
208
def checker_started(self, command):
214
#self.logger(u'Client %s started checker "%s"'
215
# % (self.properties[u"Name"], unicode(command)))
209
"""Server signals that a checker started."""
210
self.logger('Client {0} started checker "{1}"'
211
.format(self.properties["Name"],
218
214
def got_secret(self):
219
self.last_checker_failed = False
220
self.logger(u'Client %s received its secret'
221
% self.properties[u"Name"])
215
self.logger('Client {0} received its secret'
216
.format(self.properties["Name"]))
223
218
def need_approval(self, timeout, default):
225
message = u'Client %s needs approval within %s seconds'
220
message = 'Client {0} needs approval within {1} seconds'
227
message = u'Client %s will get its secret in %s seconds'
229
% (self.properties[u"Name"], timeout/1000))
230
self.using_timer(True)
222
message = 'Client {0} will get its secret in {1} seconds'
223
self.logger(message.format(self.properties["Name"],
232
226
def rejected(self, reason):
233
self.logger(u'Client %s was rejected; reason: %s'
234
% (self.properties[u"Name"], reason))
227
self.logger('Client {0} was rejected; reason: {1}'
228
.format(self.properties["Name"], reason))
236
230
def selectable(self):
237
231
"""Make this a "selectable" widget.
238
232
This overrides the method from urwid.FlowWidget."""
241
def rows(self, (maxcol,), focus=False):
235
def rows(self, maxcolrow, focus=False):
242
236
"""How many rows this widget will occupy might depend on
243
237
whether we have focus or not.
244
238
This overrides the method from urwid.FlowWidget"""
245
return self.current_widget(focus).rows((maxcol,), focus=focus)
239
return self.current_widget(focus).rows(maxcolrow, focus=focus)
247
241
def current_widget(self, focus=False):
248
242
if focus or self.opened:
252
246
def update(self):
253
247
"Called when what is visible on the screen should be updated."
254
248
# How to add standout mode to a style
255
with_standout = { u"normal": u"standout",
256
u"bold": u"bold-standout",
258
u"underline-blink-standout",
259
u"bold-underline-blink":
260
u"bold-underline-blink-standout",
249
with_standout = { "normal": "standout",
250
"bold": "bold-standout",
252
"underline-blink-standout",
253
"bold-underline-blink":
254
"bold-underline-blink-standout",
263
257
# Rebuild focus and non-focus widgets using current properties
265
259
# Base part of a client. Name!
266
base = (u'%(name)s: '
267
% {u"name": self.properties[u"Name"]})
268
if not self.properties[u"Enabled"]:
269
message = u"DISABLED"
270
elif self.properties[u"ApprovalPending"]:
260
base = '{name}: '.format(name=self.properties["Name"])
261
if not self.properties["Enabled"]:
263
self.using_timer(False)
264
elif self.properties["ApprovalPending"]:
271
265
timeout = datetime.timedelta(milliseconds
272
266
= self.properties
274
268
last_approval_request = isoformat_to_datetime(
275
self.properties[u"LastApprovalRequest"])
269
self.properties["LastApprovalRequest"])
276
270
if last_approval_request is not None:
277
timer = timeout - (datetime.datetime.utcnow()
278
- last_approval_request)
271
timer = max(timeout - (datetime.datetime.utcnow()
272
- last_approval_request),
273
datetime.timedelta())
280
275
timer = datetime.timedelta()
281
if self.properties[u"ApprovedByDefault"]:
282
message = u"Approval in %s. (d)eny?"
284
message = u"Denial in %s. (a)pprove?"
285
message = message % unicode(timer).rsplit(".", 1)[0]
286
elif self.last_checker_failed:
287
timeout = datetime.timedelta(milliseconds
290
last_ok = isoformat_to_datetime(
291
max((self.properties[u"LastCheckedOK"]
292
or self.properties[u"Created"]),
293
self.properties[u"LastEnabled"]))
294
timer = timeout - (datetime.datetime.utcnow() - last_ok)
295
message = (u'A checker has failed! Time until client'
296
u' gets disabled: %s'
297
% unicode(timer).rsplit(".", 1)[0])
276
if self.properties["ApprovedByDefault"]:
277
message = "Approval in {0}. (d)eny?"
279
message = "Denial in {0}. (a)pprove?"
280
message = message.format(str(timer).rsplit(".", 1)[0])
281
self.using_timer(True)
282
elif self.properties["LastCheckerStatus"] != 0:
283
# When checker has failed, show timer until client expires
284
expires = self.properties["Expires"]
286
timer = datetime.timedelta(0)
288
expires = (datetime.datetime.strptime
289
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
290
timer = max(expires - datetime.datetime.utcnow(),
291
datetime.timedelta())
292
message = ('A checker has failed! Time until client'
293
' gets disabled: {0}'
294
.format(str(timer).rsplit(".", 1)[0]))
295
self.using_timer(True)
300
self._text = "%s%s" % (base, message)
298
self.using_timer(False)
299
self._text = "{0}{1}".format(base, message)
302
301
if not urwid.supports_unicode():
303
302
self._text = self._text.encode("ascii", "replace")
304
textlist = [(u"normal", self._text)]
303
textlist = [("normal", self._text)]
305
304
self._text_widget.set_text(textlist)
306
305
self._focus_text_widget.set_text([(with_standout[text[0]],
316
315
self.update_hook()
318
317
def update_timer(self):
318
"""called by gobject. Will indefinitely loop until
319
gobject.source_remove() on tag is called"""
321
321
return True # Keep calling this
323
def delete(self, **kwargs):
324
324
if self._update_timer_callback_tag is not None:
325
325
gobject.source_remove(self._update_timer_callback_tag)
326
326
self._update_timer_callback_tag = None
327
for match in self.match_objects:
329
self.match_objects = ()
327
330
if self.delete_hook is not None:
328
331
self.delete_hook(self)
332
return super(MandosClientWidget, self).delete(**kwargs)
330
def render(self, (maxcol,), focus=False):
334
def render(self, maxcolrow, focus=False):
331
335
"""Render differently if we have focus.
332
336
This overrides the method from urwid.FlowWidget"""
333
return self.current_widget(focus).render((maxcol,),
337
return self.current_widget(focus).render(maxcolrow,
336
def keypress(self, (maxcol,), key):
340
def keypress(self, maxcolrow, key):
338
342
This overrides the method from urwid.FlowWidget"""
340
self.proxy.Enable(dbus_interface = client_interface)
342
self.proxy.Disable(dbus_interface = client_interface)
344
self.proxy.Enable(dbus_interface = client_interface,
347
self.proxy.Disable(dbus_interface = client_interface,
344
350
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
345
dbus_interface = client_interface)
351
dbus_interface = client_interface,
347
354
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
348
dbus_interface = client_interface)
349
elif key == u"r" or key == u"_" or key == u"ctrl k":
355
dbus_interface = client_interface,
357
elif key == "R" or key == "_" or key == "ctrl k":
350
358
self.server_proxy_object.RemoveClient(self.proxy
353
self.proxy.StartChecker(dbus_interface = client_interface)
355
self.proxy.StopChecker(dbus_interface = client_interface)
357
self.proxy.CheckedOK(dbus_interface = client_interface)
362
self.proxy.StartChecker(dbus_interface = client_interface,
365
self.proxy.StopChecker(dbus_interface = client_interface,
368
self.proxy.CheckedOK(dbus_interface = client_interface,
359
# elif key == u"p" or key == "=":
371
# elif key == "p" or key == "=":
360
372
# self.proxy.pause()
361
# elif key == u"u" or key == ":":
373
# elif key == "u" or key == ":":
362
374
# self.proxy.unpause()
363
# elif key == u"RET":
368
def property_changed(self, property=None, value=None,
380
def property_changed(self, property=None, **kwargs):
370
381
"""Call self.update() if old value is not new value.
371
382
This overrides the method from MandosClientPropertyCache"""
372
property_name = unicode(property)
383
property_name = str(property)
373
384
old_value = self.properties.get(property_name)
374
385
super(MandosClientWidget, self).property_changed(
375
property=property, value=value, *args, **kwargs)
386
property=property, **kwargs)
376
387
if self.properties.get(property_name) != old_value:
394
404
"""This is the entire user interface - the whole screen
395
405
with boxes, lists of client widgets, etc.
397
def __init__(self, max_log_length=1000):
407
def __init__(self, max_log_length=1000, log_level=1):
398
408
DBusGMainLoop(set_as_default=True)
400
410
self.screen = urwid.curses_display.Screen()
402
412
self.screen.register_palette((
404
u"default", u"default", None),
406
u"default", u"default", u"bold"),
408
u"default", u"default", u"underline"),
410
u"default", u"default", u"standout"),
411
(u"bold-underline-blink",
412
u"default", u"default", (u"bold", u"underline")),
414
u"default", u"default", (u"bold", u"standout")),
415
(u"underline-blink-standout",
416
u"default", u"default", (u"underline", u"standout")),
417
(u"bold-underline-blink-standout",
418
u"default", u"default", (u"bold", u"underline",
414
"default", "default", None),
416
"bold", "default", "bold"),
418
"underline,blink", "default", "underline,blink"),
420
"standout", "default", "standout"),
421
("bold-underline-blink",
422
"bold,underline,blink", "default", "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"),
422
433
if urwid.supports_unicode():
423
self.divider = u"─" # \u2500
424
#self.divider = u"━" # \u2501
434
self.divider = "─" # \u2500
435
#self.divider = "━" # \u2501
426
#self.divider = u"-" # \u002d
427
self.divider = u"_" # \u005f
437
#self.divider = "-" # \u002d
438
self.divider = "_" # \u005f
429
440
self.screen.start()
444
457
# This keeps track of whether self.uilist currently has
445
458
# self.logbox in it or not
446
459
self.log_visible = True
447
self.log_wrap = u"any"
460
self.log_wrap = "any"
450
self.log_message_raw((u"bold",
451
u"Mandos Monitor version " + version))
452
self.log_message_raw((u"bold",
463
self.log_message_raw(("bold",
464
"Mandos Monitor version " + version))
465
self.log_message_raw(("bold",
455
468
self.busname = domain + '.Mandos'
456
469
self.main_loop = gobject.MainLoop()
457
self.bus = dbus.SystemBus()
458
mandos_dbus_objc = self.bus.get_object(
459
self.busname, u"/", follow_name_owner_changes=True)
460
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
464
mandos_clients = (self.mandos_serv
465
.GetAllClientsWithProperties())
466
except dbus.exceptions.DBusException:
467
mandos_clients = dbus.Dictionary()
470
.connect_to_signal(u"ClientRemoved",
471
self.find_and_remove_client,
472
dbus_interface=server_interface,
475
.connect_to_signal(u"ClientAdded",
477
dbus_interface=server_interface,
480
.connect_to_signal(u"ClientNotFound",
481
self.client_not_found,
482
dbus_interface=server_interface,
484
for path, client in mandos_clients.iteritems():
485
client_proxy_object = self.bus.get_object(self.busname,
487
self.add_client(MandosClientWidget(server_proxy_object
490
=client_proxy_object,
500
471
def client_not_found(self, fingerprint, address):
501
self.log_message((u"Client with address %s and fingerprint %s"
502
u" could not be found" % (address,
472
self.log_message("Client with address {0} and fingerprint"
473
" {1} could not be found"
474
.format(address, fingerprint))
505
476
def rebuild(self):
506
477
"""This rebuilds the User Interface.
517
488
if self.log_visible:
518
489
self.uilist.append(self.logbox)
520
490
self.topwidget = urwid.Pile(self.uilist)
522
def log_message(self, message):
492
def log_message(self, message, level=1):
493
"""Log message formatted with timestamp"""
494
if level < self.log_level:
523
496
timestamp = datetime.datetime.now().isoformat()
524
self.log_message_raw(timestamp + u": " + message)
497
self.log_message_raw("{0}: {1}".format(timestamp, message),
526
def log_message_raw(self, markup):
500
def log_message_raw(self, markup, level=1):
527
501
"""Add a log message to the log buffer."""
502
if level < self.log_level:
528
504
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
529
505
if (self.max_log_length
530
506
and len(self.log) > self.max_log_length):
531
507
del self.log[0:len(self.log)-self.max_log_length-1]
532
508
self.logbox.set_focus(len(self.logbox.body.contents),
533
coming_from=u"above")
536
512
def toggle_log_display(self):
537
513
"""Toggle visibility of the log buffer."""
538
514
self.log_visible = not self.log_visible
540
#self.log_message(u"Log visibility changed to: "
541
# + unicode(self.log_visible))
516
self.log_message("Log visibility changed to: {0}"
517
.format(self.log_visible), level=0)
543
519
def change_log_display(self):
544
520
"""Change type of log display.
545
521
Currently, this toggles wrapping of text lines."""
546
if self.log_wrap == u"clip":
547
self.log_wrap = u"any"
522
if self.log_wrap == "clip":
523
self.log_wrap = "any"
549
self.log_wrap = u"clip"
525
self.log_wrap = "clip"
550
526
for textwidget in self.log:
551
527
textwidget.set_wrap_mode(self.log_wrap)
552
#self.log_message(u"Wrap mode: " + self.log_wrap)
528
self.log_message("Wrap mode: {0}".format(self.log_wrap),
554
531
def find_and_remove_client(self, path, name):
555
"""Find an client from its object path and remove it.
532
"""Find a client by its object path and remove it.
557
534
This is connected to the ClientRemoved signal from the
558
535
Mandos server object."""
606
580
"""Start the main loop and exit when it's done."""
581
self.bus = dbus.SystemBus()
582
mandos_dbus_objc = self.bus.get_object(
583
self.busname, "/", follow_name_owner_changes=True)
584
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
588
mandos_clients = (self.mandos_serv
589
.GetAllClientsWithProperties())
590
if not mandos_clients:
591
self.log_message_raw(("bold", "Note: Server has no clients."))
592
except dbus.exceptions.DBusException:
593
self.log_message_raw(("bold", "Note: No Mandos server running."))
594
mandos_clients = dbus.Dictionary()
597
.connect_to_signal("ClientRemoved",
598
self.find_and_remove_client,
599
dbus_interface=server_interface,
602
.connect_to_signal("ClientAdded",
604
dbus_interface=server_interface,
607
.connect_to_signal("ClientNotFound",
608
self.client_not_found,
609
dbus_interface=server_interface,
611
for path, client in mandos_clients.items():
612
client_proxy_object = self.bus.get_object(self.busname,
614
self.add_client(MandosClientWidget(server_proxy_object
617
=client_proxy_object,
608
628
self._input_callback_tag = (gobject.io_add_watch
609
629
(sys.stdin.fileno(),
635
655
except KeyError: # :-)
638
if key == u"q" or key == u"Q":
658
if key == "q" or key == "Q":
641
elif key == u"window resize":
661
elif key == "window resize":
642
662
self.size = self.screen.get_cols_rows()
644
elif key == u"\f": # Ctrl-L
664
elif key == "ctrl l":
646
elif key == u"l" or key == u"D":
667
elif key == "l" or key == "D":
647
668
self.toggle_log_display()
649
elif key == u"w" or key == u"i":
670
elif key == "w" or key == "i":
650
671
self.change_log_display()
652
elif key == u"?" or key == u"f1" or key == u"esc":
673
elif key == "?" or key == "f1" or key == "esc":
653
674
if not self.log_visible:
654
675
self.log_visible = True
656
self.log_message_raw((u"bold",
660
u"l: Log window toggle",
661
u"TAB: Switch window",
663
self.log_message_raw((u"bold",
669
u"s: Start new checker",
677
self.log_message_raw(("bold",
681
"l: Log window toggle",
682
"TAB: Switch window",
683
"w: Wrap (log lines)",
684
"v: Toggle verbose log",
686
self.log_message_raw(("bold",
692
"s: Start new checker",
676
699
if self.topwidget.get_focus() is self.logbox:
677
700
self.topwidget.set_focus(0)
679
702
self.topwidget.set_focus(self.logbox)
681
#elif (key == u"end" or key == u"meta >" or key == u"G"
705
if self.log_level == 0:
707
self.log_message("Verbose mode: Off")
710
self.log_message("Verbose mode: On")
711
#elif (key == "end" or key == "meta >" or key == "G"
683
713
# pass # xxx end-of-buffer
684
#elif (key == u"home" or key == u"meta <" or key == u"g"
714
#elif (key == "home" or key == "meta <" or key == "g"
686
716
# pass # xxx beginning-of-buffer
687
#elif key == u"ctrl e" or key == u"$":
717
#elif key == "ctrl e" or key == "$":
688
718
# pass # xxx move-end-of-line
689
#elif key == u"ctrl a" or key == u"^":
719
#elif key == "ctrl a" or key == "^":
690
720
# pass # xxx move-beginning-of-line
691
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
721
#elif key == "ctrl b" or key == "meta (" or key == "h":
692
722
# pass # xxx left
693
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
723
#elif key == "ctrl f" or key == "meta )" or key == "l":
694
724
# pass # xxx right
696
726
# pass # scroll up log
698
728
# pass # scroll down log
699
729
elif self.topwidget.selectable():
700
730
self.topwidget.keypress(self.size, key)