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>.
26
from __future__ import (division, absolute_import, print_function,
29
from future_builtins import *
4
from __future__ import division, absolute_import, with_statement
41
15
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GObject as gobject
51
if sys.version_info.major == 2:
54
locale.setlocale(locale.LC_ALL, '')
24
locale.setlocale(locale.LC_ALL, u'')
57
27
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
59
29
# Some useful constants
60
domain = 'se.recompile'
30
domain = 'se.bsnet.fukt'
61
31
server_interface = domain + '.Mandos'
62
32
client_interface = domain + '.Mandos.Client'
65
def isoformat_to_datetime(iso):
66
"Parse an ISO 8601 date string to a datetime.datetime()"
69
d, t = iso.split("T", 1)
70
year, month, day = d.split("-", 2)
71
hour, minute, second = t.split(":", 2)
72
second, fraction = divmod(float(second), 1)
73
return datetime.datetime(int(year),
78
int(second), # Whole seconds
79
int(fraction*1000000)) # Microseconds
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)
81
43
class MandosClientPropertyCache(object):
82
44
"""This wraps a Mandos Client D-Bus proxy object, caches the
83
45
properties and calls a hook function when any of them are
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
48
def __init__(self, proxy_object=None, *args, **kwargs):
87
49
self.proxy = proxy_object # Mandos Client proxy object
88
self.properties = dict() if properties is None else properties
89
self.property_changed_match = (
90
self.proxy.connect_to_signal("PropertiesChanged",
91
self.properties_changed,
92
dbus.PROPERTIES_IFACE,
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)
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))
61
#XXX This break good super behaviour!
62
# super(MandosClientPropertyCache, self).__init__(
103
def properties_changed(self, interface, properties, invalidated):
104
"""This is called whenever we get a PropertiesChanged signal
105
It updates the changed properties in the "properties" dict.
65
def property_changed(self, property=None, value=None):
66
"""This is called whenever we get a PropertyChanged signal
67
It updates the changed property in the "properties" dict.
107
69
# Update properties dict with new value
108
self.properties.update(properties)
111
self.property_changed_match.remove()
70
self.properties[property] = value
114
73
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
127
86
self.logger = logger
129
self._update_timer_callback_tag = None
131
88
# The widget shown normally
132
self._text_widget = urwid.Text("")
89
self._text_widget = urwid.Text(u"")
133
90
# The widget shown when we have focus
134
self._focus_text_widget = urwid.Text("")
135
super(MandosClientWidget, self).__init__(**kwargs)
91
self._focus_text_widget = urwid.Text(u"")
92
super(MandosClientWidget, self).__init__(
93
update_hook=update_hook, delete_hook=delete_hook,
137
96
self.opened = False
139
self.match_objects = (
140
self.proxy.connect_to_signal("CheckerCompleted",
141
self.checker_completed,
144
self.proxy.connect_to_signal("CheckerStarted",
145
self.checker_started,
148
self.proxy.connect_to_signal("GotSecret",
152
self.proxy.connect_to_signal("NeedApproval",
156
self.proxy.connect_to_signal("Rejected",
160
self.logger('Created client {}'
161
.format(self.properties["Name"]), level=0)
163
def using_timer(self, flag):
164
"""Call this method with True or False when timer should be
165
activated or deactivated.
167
if flag and self._update_timer_callback_tag is None:
168
# Will update the shown timer value every second
169
self._update_timer_callback_tag = (gobject.timeout_add
172
elif not (flag or self._update_timer_callback_tag is None):
173
gobject.source_remove(self._update_timer_callback_tag)
174
self._update_timer_callback_tag = None
97
self.proxy.connect_to_signal(u"CheckerCompleted",
98
self.checker_completed,
101
self.proxy.connect_to_signal(u"CheckerStarted",
102
self.checker_started,
105
self.proxy.connect_to_signal(u"GotSecret",
109
self.proxy.connect_to_signal(u"NeedApproval",
113
self.proxy.connect_to_signal(u"Rejected",
176
118
def checker_completed(self, exitstatus, condition, command):
177
119
if exitstatus == 0:
178
self.logger('Checker for client {} (command "{}")'
179
' succeeded'.format(self.properties["Name"],
120
#self.logger(u'Checker for client %s (command "%s")'
122
# % (self.properties[u"name"], command))
184
124
if os.WIFEXITED(condition):
185
self.logger('Checker for client {} (command "{}") failed'
187
.format(self.properties["Name"], command,
188
os.WEXITSTATUS(condition)))
189
elif os.WIFSIGNALED(condition):
190
self.logger('Checker for client {} (command "{}") was'
191
' killed by signal {}'
192
.format(self.properties["Name"], command,
193
os.WTERMSIG(condition)))
194
elif os.WCOREDUMP(condition):
195
self.logger('Checker for client {} (command "{}") dumped'
196
' core'.format(self.properties["Name"],
199
self.logger('Checker for client {} completed'
201
.format(self.properties["Name"]))
125
self.logger(u'Checker for client %s (command "%s")'
126
u' failed with exit code %s'
127
% (self.properties[u"name"], command,
128
os.WEXITSTATUS(condition)))
130
if os.WIFSIGNALED(condition):
131
self.logger(u'Checker for client %s (command "%s")'
132
u' was killed by signal %s'
133
% (self.properties[u"name"], command,
134
os.WTERMSIG(condition)))
136
if os.WCOREDUMP(condition):
137
self.logger(u'Checker for client %s (command "%s")'
139
% (self.properties[u"name"], command))
140
self.logger(u'Checker for client %s completed mysteriously')
204
142
def checker_started(self, command):
205
"""Server signals that a checker started."""
206
self.logger('Client {} started checker "{}"'
207
.format(self.properties["Name"],
143
#self.logger(u'Client %s started checker "%s"'
144
# % (self.properties[u"name"], unicode(command)))
210
147
def got_secret(self):
211
self.logger('Client {} received its secret'
212
.format(self.properties["Name"]))
148
self.logger(u'Client %s received its secret'
149
% self.properties[u"name"])
214
151
def need_approval(self, timeout, default):
216
message = 'Client {} needs approval within {} seconds'
153
message = u'Client %s needs approval within %s seconds'
218
message = 'Client {} will get its secret in {} seconds'
219
self.logger(message.format(self.properties["Name"],
155
message = u'Client %s will get its secret in %s seconds'
157
% (self.properties[u"name"], timeout/1000))
222
159
def rejected(self, reason):
223
self.logger('Client {} was rejected; reason: {}'
224
.format(self.properties["Name"], reason))
160
self.logger(u'Client %s was rejected; reason: %s'
161
% (self.properties[u"name"], reason))
226
163
def selectable(self):
227
164
"""Make this a "selectable" widget.
228
165
This overrides the method from urwid.FlowWidget."""
231
def rows(self, maxcolrow, focus=False):
168
def rows(self, (maxcol,), focus=False):
232
169
"""How many rows this widget will occupy might depend on
233
170
whether we have focus or not.
234
171
This overrides the method from urwid.FlowWidget"""
235
return self.current_widget(focus).rows(maxcolrow, focus=focus)
172
return self.current_widget(focus).rows((maxcol,), focus=focus)
237
174
def current_widget(self, focus=False):
238
175
if focus or self.opened:
242
179
def update(self):
243
180
"Called when what is visible on the screen should be updated."
244
181
# How to add standout mode to a style
245
with_standout = { "normal": "standout",
246
"bold": "bold-standout",
248
"underline-blink-standout",
249
"bold-underline-blink":
250
"bold-underline-blink-standout",
182
with_standout = { u"normal": u"standout",
183
u"bold": u"bold-standout",
185
u"underline-blink-standout",
186
u"bold-underline-blink":
187
u"bold-underline-blink-standout",
253
190
# Rebuild focus and non-focus widgets using current properties
255
192
# Base part of a client. Name!
256
base = '{name}: '.format(name=self.properties["Name"])
257
if not self.properties["Enabled"]:
259
self.using_timer(False)
260
elif self.properties["ApprovalPending"]:
261
timeout = datetime.timedelta(milliseconds
264
last_approval_request = isoformat_to_datetime(
265
self.properties["LastApprovalRequest"])
266
if last_approval_request is not None:
267
timer = max(timeout - (datetime.datetime.utcnow()
268
- last_approval_request),
269
datetime.timedelta())
271
timer = datetime.timedelta()
272
if self.properties["ApprovedByDefault"]:
273
message = "Approval in {}. (d)eny?"
275
message = "Denial in {}. (a)pprove?"
276
message = message.format(str(timer).rsplit(".", 1)[0])
277
self.using_timer(True)
278
elif self.properties["LastCheckerStatus"] != 0:
279
# When checker has failed, show timer until client expires
280
expires = self.properties["Expires"]
282
timer = datetime.timedelta(0)
284
expires = (datetime.datetime.strptime
285
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
286
timer = max(expires - datetime.datetime.utcnow(),
287
datetime.timedelta())
288
message = ('A checker has failed! Time until client'
290
.format(str(timer).rsplit(".", 1)[0]))
291
self.using_timer(True)
193
self._text = (u'%(name)s: '
194
% {u"name": self.properties[u"name"]})
196
if self.properties[u"approved_pending"]:
197
if self.properties[u"approved_by_default"]:
198
self._text += u"Connection established to client. (d)eny?"
200
self._text += u"Seeks approval to send secret. (a)pprove?"
294
self.using_timer(False)
295
self._text = "{}{}".format(base, message)
202
self._text += (u'%(enabled)s'
205
if self.properties[u"enabled"]
297
207
if not urwid.supports_unicode():
298
208
self._text = self._text.encode("ascii", "replace")
299
textlist = [("normal", self._text)]
209
textlist = [(u"normal", self._text)]
300
210
self._text_widget.set_text(textlist)
301
211
self._focus_text_widget.set_text([(with_standout[text[0]],
310
220
if self.update_hook is not None:
311
221
self.update_hook()
313
def update_timer(self):
314
"""called by gobject. Will indefinitely loop until
315
gobject.source_remove() on tag is called"""
317
return True # Keep calling this
319
def delete(self, **kwargs):
320
if self._update_timer_callback_tag is not None:
321
gobject.source_remove(self._update_timer_callback_tag)
322
self._update_timer_callback_tag = None
323
for match in self.match_objects:
325
self.match_objects = ()
326
224
if self.delete_hook is not None:
327
225
self.delete_hook(self)
328
return super(MandosClientWidget, self).delete(**kwargs)
330
def render(self, maxcolrow, focus=False):
227
def render(self, (maxcol,), focus=False):
331
228
"""Render differently if we have focus.
332
229
This overrides the method from urwid.FlowWidget"""
333
return self.current_widget(focus).render(maxcolrow,
230
return self.current_widget(focus).render((maxcol,),
336
def keypress(self, maxcolrow, key):
233
def keypress(self, (maxcol,), key):
338
235
This overrides the method from urwid.FlowWidget"""
340
self.proxy.Enable(dbus_interface = client_interface,
343
self.proxy.Disable(dbus_interface = client_interface,
237
self.proxy.Enable(dbus_interface = client_interface)
239
self.proxy.Disable(dbus_interface = client_interface)
346
241
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
347
dbus_interface = client_interface,
242
dbus_interface = client_interface)
350
244
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
351
dbus_interface = client_interface,
353
elif key == "R" or key == "_" or key == "ctrl k":
245
dbus_interface = client_interface)
246
elif key == u"r" or key == u"_" or key == u"ctrl k":
354
247
self.server_proxy_object.RemoveClient(self.proxy
358
self.proxy.StartChecker(dbus_interface = client_interface,
361
self.proxy.StopChecker(dbus_interface = client_interface,
364
self.proxy.CheckedOK(dbus_interface = client_interface,
250
self.proxy.StartChecker(dbus_interface = client_interface)
252
self.proxy.StopChecker(dbus_interface = client_interface)
254
self.proxy.CheckedOK(dbus_interface = client_interface)
367
# elif key == "p" or key == "=":
256
# elif key == u"p" or key == "=":
368
257
# self.proxy.pause()
369
# elif key == "u" or key == ":":
258
# elif key == u"u" or key == ":":
370
259
# self.proxy.unpause()
260
# elif key == u"RET":
263
# self.proxy.Approve(True)
265
# self.proxy.Approve(False)
376
def properties_changed(self, interface, properties, invalidated):
377
"""Call self.update() if any properties changed.
269
def property_changed(self, property=None, value=None,
271
"""Call self.update() if old value is not new value.
378
272
This overrides the method from MandosClientPropertyCache"""
379
old_values = { key: self.properties.get(key)
380
for key in properties.keys() }
381
super(MandosClientWidget, self).properties_changed(
382
interface, properties, invalidated)
383
if any(old_values[key] != self.properties.get(key)
384
for key in old_values):
273
property_name = unicode(property)
274
old_value = self.properties.get(property_name)
275
super(MandosClientWidget, self).property_changed(
276
property=property, value=value, *args, **kwargs)
277
if self.properties.get(property_name) != old_value:
401
294
"""This is the entire user interface - the whole screen
402
295
with boxes, lists of client widgets, etc.
404
def __init__(self, max_log_length=1000, log_level=1):
297
def __init__(self, max_log_length=1000):
405
298
DBusGMainLoop(set_as_default=True)
407
300
self.screen = urwid.curses_display.Screen()
409
302
self.screen.register_palette((
411
"default", "default", None),
413
"bold", "default", "bold"),
415
"underline,blink", "default", "underline,blink"),
417
"standout", "default", "standout"),
418
("bold-underline-blink",
419
"bold,underline,blink", "default", "bold,underline,blink"),
421
"bold,standout", "default", "bold,standout"),
422
("underline-blink-standout",
423
"underline,blink,standout", "default",
424
"underline,blink,standout"),
425
("bold-underline-blink-standout",
426
"bold,underline,blink,standout", "default",
427
"bold,underline,blink,standout"),
304
u"default", u"default", None),
306
u"default", u"default", u"bold"),
308
u"default", u"default", u"underline"),
310
u"default", u"default", u"standout"),
311
(u"bold-underline-blink",
312
u"default", u"default", (u"bold", u"underline")),
314
u"default", u"default", (u"bold", u"standout")),
315
(u"underline-blink-standout",
316
u"default", u"default", (u"underline", u"standout")),
317
(u"bold-underline-blink-standout",
318
u"default", u"default", (u"bold", u"underline",
430
322
if urwid.supports_unicode():
431
self.divider = "─" # \u2500
432
#self.divider = "━" # \u2501
323
self.divider = u"─" # \u2500
324
#self.divider = u"━" # \u2501
434
#self.divider = "-" # \u002d
435
self.divider = "_" # \u005f
326
#self.divider = u"-" # \u002d
327
self.divider = u"_" # \u005f
437
329
self.screen.start()
454
344
# This keeps track of whether self.uilist currently has
455
345
# self.logbox in it or not
456
346
self.log_visible = True
457
self.log_wrap = "any"
347
self.log_wrap = u"any"
460
self.log_message_raw(("bold",
461
"Mandos Monitor version " + version))
462
self.log_message_raw(("bold",
350
self.log_message_raw((u"bold",
351
u"Mandos Monitor version " + version))
352
self.log_message_raw((u"bold",
465
355
self.busname = domain + '.Mandos'
466
356
self.main_loop = gobject.MainLoop()
357
self.bus = dbus.SystemBus()
358
mandos_dbus_objc = self.bus.get_object(
359
self.busname, u"/", follow_name_owner_changes=True)
360
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
364
mandos_clients = (self.mandos_serv
365
.GetAllClientsWithProperties())
366
except dbus.exceptions.DBusException:
367
mandos_clients = dbus.Dictionary()
370
.connect_to_signal(u"ClientRemoved",
371
self.find_and_remove_client,
372
dbus_interface=server_interface,
375
.connect_to_signal(u"ClientAdded",
377
dbus_interface=server_interface,
380
.connect_to_signal(u"ClientNotFound",
381
self.client_not_found,
382
dbus_interface=server_interface,
384
for path, client in mandos_clients.iteritems():
385
client_proxy_object = self.bus.get_object(self.busname,
387
self.add_client(MandosClientWidget(server_proxy_object
390
=client_proxy_object,
468
400
def client_not_found(self, fingerprint, address):
469
self.log_message("Client with address {} and fingerprint {}"
470
" could not be found"
471
.format(address, fingerprint))
401
self.log_message((u"Client with address %s and fingerprint %s"
402
u" could not be found" % (address,
473
405
def rebuild(self):
474
406
"""This rebuilds the User Interface.
475
407
Call this when the widget layout needs to change"""
477
409
#self.uilist.append(urwid.ListBox(self.clients))
478
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
410
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
480
411
#header=urwid.Divider(),
483
urwid.Divider(div_char=
413
footer=urwid.Divider(div_char=self.divider)))
485
414
if self.log_visible:
486
415
self.uilist.append(self.logbox)
487
417
self.topwidget = urwid.Pile(self.uilist)
489
def log_message(self, message, level=1):
490
"""Log message formatted with timestamp"""
491
if level < self.log_level:
419
def log_message(self, message):
493
420
timestamp = datetime.datetime.now().isoformat()
494
self.log_message_raw("{}: {}".format(timestamp, message),
421
self.log_message_raw(timestamp + u": " + message)
497
def log_message_raw(self, markup, level=1):
423
def log_message_raw(self, markup):
498
424
"""Add a log message to the log buffer."""
499
if level < self.log_level:
501
425
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
502
426
if (self.max_log_length
503
427
and len(self.log) > self.max_log_length):
504
428
del self.log[0:len(self.log)-self.max_log_length-1]
505
429
self.logbox.set_focus(len(self.logbox.body.contents),
430
coming_from=u"above")
509
433
def toggle_log_display(self):
510
434
"""Toggle visibility of the log buffer."""
511
435
self.log_visible = not self.log_visible
513
self.log_message("Log visibility changed to: {}"
514
.format(self.log_visible), level=0)
437
self.log_message(u"Log visibility changed to: "
438
+ unicode(self.log_visible))
516
440
def change_log_display(self):
517
441
"""Change type of log display.
518
442
Currently, this toggles wrapping of text lines."""
519
if self.log_wrap == "clip":
520
self.log_wrap = "any"
443
if self.log_wrap == u"clip":
444
self.log_wrap = u"any"
522
self.log_wrap = "clip"
446
self.log_wrap = u"clip"
523
447
for textwidget in self.log:
524
448
textwidget.set_wrap_mode(self.log_wrap)
525
self.log_message("Wrap mode: {}".format(self.log_wrap),
449
self.log_message(u"Wrap mode: " + self.log_wrap)
528
451
def find_and_remove_client(self, path, name):
529
"""Find a client by its object path and remove it.
452
"""Find an client from its object path and remove it.
531
454
This is connected to the ClientRemoved signal from the
532
455
Mandos server object."""
577
503
"""Start the main loop and exit when it's done."""
578
self.bus = dbus.SystemBus()
579
mandos_dbus_objc = self.bus.get_object(
580
self.busname, "/", follow_name_owner_changes=True)
581
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
585
mandos_clients = (self.mandos_serv
586
.GetAllClientsWithProperties())
587
if not mandos_clients:
588
self.log_message_raw(("bold", "Note: Server has no clients."))
589
except dbus.exceptions.DBusException:
590
self.log_message_raw(("bold", "Note: No Mandos server running."))
591
mandos_clients = dbus.Dictionary()
594
.connect_to_signal("ClientRemoved",
595
self.find_and_remove_client,
596
dbus_interface=server_interface,
599
.connect_to_signal("ClientAdded",
601
dbus_interface=server_interface,
604
.connect_to_signal("ClientNotFound",
605
self.client_not_found,
606
dbus_interface=server_interface,
608
for path, client in mandos_clients.items():
609
client_proxy_object = self.bus.get_object(self.busname,
611
self.add_client(MandosClientWidget(server_proxy_object
614
=client_proxy_object,
625
505
self._input_callback_tag = (gobject.io_add_watch
626
506
(sys.stdin.fileno(),
652
532
except KeyError: # :-)
655
if key == "q" or key == "Q":
535
if key == u"q" or key == u"Q":
658
elif key == "window resize":
538
elif key == u"window resize":
659
539
self.size = self.screen.get_cols_rows()
661
elif key == "ctrl l":
541
elif key == u"\f": # Ctrl-L
664
elif key == "l" or key == "D":
543
elif key == u"l" or key == u"D":
665
544
self.toggle_log_display()
667
elif key == "w" or key == "i":
546
elif key == u"w" or key == u"i":
668
547
self.change_log_display()
670
elif key == "?" or key == "f1" or key == "esc":
549
elif key == u"?" or key == u"f1" or key == u"esc":
671
550
if not self.log_visible:
672
551
self.log_visible = True
674
self.log_message_raw(("bold",
678
"l: Log window toggle",
679
"TAB: Switch window",
680
"w: Wrap (log lines)",
681
"v: Toggle verbose log",
683
self.log_message_raw(("bold",
689
"s: Start new checker",
553
self.log_message_raw((u"bold",
557
u"l: Log window toggle",
558
u"TAB: Switch window",
560
self.log_message_raw((u"bold",
566
u"s: Start new checker",
696
573
if self.topwidget.get_focus() is self.logbox:
697
574
self.topwidget.set_focus(0)
699
576
self.topwidget.set_focus(self.logbox)
702
if self.log_level == 0:
704
self.log_message("Verbose mode: Off")
707
self.log_message("Verbose mode: On")
708
#elif (key == "end" or key == "meta >" or key == "G"
578
#elif (key == u"end" or key == u"meta >" or key == u"G"
710
580
# pass # xxx end-of-buffer
711
#elif (key == "home" or key == "meta <" or key == "g"
581
#elif (key == u"home" or key == u"meta <" or key == u"g"
713
583
# pass # xxx beginning-of-buffer
714
#elif key == "ctrl e" or key == "$":
584
#elif key == u"ctrl e" or key == u"$":
715
585
# pass # xxx move-end-of-line
716
#elif key == "ctrl a" or key == "^":
586
#elif key == u"ctrl a" or key == u"^":
717
587
# pass # xxx move-beginning-of-line
718
#elif key == "ctrl b" or key == "meta (" or key == "h":
588
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
719
589
# pass # xxx left
720
#elif key == "ctrl f" or key == "meta )" or key == "l":
590
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
721
591
# pass # xxx right
723
593
# pass # scroll up log
725
595
# pass # scroll down log
726
596
elif self.topwidget.selectable():
727
597
self.topwidget.keypress(self.size, key)