766 lines
25 KiB
Python
766 lines
25 KiB
Python
#
|
|
# pyconsole.py
|
|
#
|
|
# Copyright (C) 2004-2006 by Yevgen Muntyan <muntyan@math.tamu.edu>
|
|
# Portions of code by Geoffrey French.
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Lesser General Public version 2.1 as
|
|
# published by the Free Software Foundation.
|
|
#
|
|
# See COPYING.lib file that comes with this distribution for full text
|
|
# of the license.
|
|
#
|
|
|
|
# This module 'runs' python interpreter in a TextView widget.
|
|
# The main class is Console, usage is:
|
|
# Console(locals=None, banner=None, completer=None, use_rlcompleter=True, start_script='') -
|
|
# it creates the widget and 'starts' interactive session; see the end
|
|
# of this file. If start_script is not empty, it pastes it as it was
|
|
# entered from keyboard.
|
|
#
|
|
# Console has "command" signal which is emitted when code is about to
|
|
# be executed. You may connect to it using console.connect or
|
|
# console.connect_after to get your callback ran before or after the
|
|
# code is executed.
|
|
#
|
|
# To modify output appearance, set attributes of console.stdout_tag and
|
|
# console.stderr_tag.
|
|
#
|
|
# Console may subclass a type other than gtk.TextView, to allow syntax
|
|
# highlighting and stuff,
|
|
# e.g.:
|
|
# console_type = pyconsole.ConsoleType(moo.edit.TextView)
|
|
# console = console_type(use_rlcompleter=False, start_script="import moo\nimport gtk\n")
|
|
#
|
|
# This widget is not a replacement for real terminal with python running
|
|
# inside: GtkTextView is not a terminal.
|
|
# The use case is: you have a python program, you create this widget,
|
|
# and inspect your program interiors.
|
|
|
|
import gi
|
|
gi.require_version('Gtk', '3.0')
|
|
from gi.repository import Gtk
|
|
gi.require_version('Gdk', '3.0')
|
|
from gi.repository import Gdk
|
|
from gi.repository import GObject
|
|
from gi.repository import Pango
|
|
import code
|
|
import sys
|
|
import keyword
|
|
import re
|
|
|
|
def pango_pixels(value):
|
|
# The PANGO_PIXELS macro is not accessible through GObject
|
|
# Introspection. Just reimplement it:
|
|
# #define PANGO_PIXELS(d) (((int)(d) + 512) >> 10)
|
|
return (value + 512) >> 10
|
|
|
|
# commonprefix() from posixpath
|
|
def _commonprefix(m):
|
|
"Given a list of pathnames, returns the longest common leading component"
|
|
if not m: return ''
|
|
prefix = m[0]
|
|
for item in m:
|
|
for i in range(len(prefix)):
|
|
if prefix[:i+1] != item[:i+1]:
|
|
prefix = prefix[:i]
|
|
if i == 0:
|
|
return ''
|
|
break
|
|
return prefix
|
|
|
|
class _ReadLine(object):
|
|
|
|
class Output(object):
|
|
def __init__(self, console, tag_name):
|
|
object.__init__(self)
|
|
self.buffer = console.get_buffer()
|
|
self.tag_name = tag_name
|
|
def write(self, text):
|
|
pos = self.buffer.get_iter_at_mark(self.buffer.get_insert())
|
|
self.buffer.insert_with_tags_by_name(pos, text, self.tag_name)
|
|
def flush(self):
|
|
# The output is just a GtkTextBuffer inside a GtkTexView so I
|
|
# believe it should be always in-sync without needing to be flushed.
|
|
# Nevertheless someone might be just copy-pasting plug-in code to
|
|
# test it, for instance. So let's just add a no-op flush() method to
|
|
# get a similar interface as the real sys.stdout which we overrode.
|
|
# It avoids useless and unexpected code failure.
|
|
pass
|
|
|
|
class History(object):
|
|
def __init__(self):
|
|
object.__init__(self)
|
|
self.items = ['']
|
|
self.ptr = 0
|
|
self.edited = {}
|
|
|
|
def commit(self, text):
|
|
if text and self.items[-1] != text:
|
|
self.items.append(text)
|
|
self.ptr = 0
|
|
self.edited = {}
|
|
|
|
def get(self, dir, text):
|
|
if len(self.items) == 1:
|
|
return None
|
|
|
|
if text != self.items[self.ptr]:
|
|
self.edited[self.ptr] = text
|
|
elif self.ptr in self.edited:
|
|
del self.edited[self.ptr]
|
|
|
|
self.ptr = self.ptr + dir
|
|
if self.ptr >= len(self.items):
|
|
self.ptr = 0
|
|
elif self.ptr < 0:
|
|
self.ptr = len(self.items) - 1
|
|
|
|
try:
|
|
return self.edited[self.ptr]
|
|
except KeyError:
|
|
return self.items[self.ptr]
|
|
|
|
def __init__(self, quit_func=None):
|
|
object.__init__(self)
|
|
|
|
self.quit_func = quit_func
|
|
|
|
self.set_wrap_mode(Gtk.WrapMode.CHAR)
|
|
self.modify_font(Pango.FontDescription("Monospace"))
|
|
|
|
self.buffer = self.get_buffer()
|
|
self.buffer.connect("insert-text", self.on_buf_insert)
|
|
self.buffer.connect("delete-range", self.on_buf_delete)
|
|
self.buffer.connect("mark-set", self.on_buf_mark_set)
|
|
self.do_insert = False
|
|
self.do_delete = False
|
|
|
|
self.stdout_tag = self.buffer.create_tag("stdout", foreground="#006000")
|
|
self.stderr_tag = self.buffer.create_tag("stderr", foreground="#B00000")
|
|
self._stdout = _ReadLine.Output(self, "stdout")
|
|
self._stderr = _ReadLine.Output(self, "stderr")
|
|
|
|
self.cursor = self.buffer.create_mark("cursor",
|
|
self.buffer.get_start_iter(),
|
|
False)
|
|
insert = self.buffer.get_insert()
|
|
self.cursor.set_visible(True)
|
|
insert.set_visible(False)
|
|
|
|
self.ps = ''
|
|
self.in_raw_input = False
|
|
self.in_modal_raw_input = False
|
|
self.run_on_raw_input = None
|
|
self.tab_pressed = 0
|
|
self.history = _ReadLine.History()
|
|
self.nonword_re = re.compile("[^\w\._]")
|
|
|
|
def freeze_undo(self):
|
|
try: self.begin_not_undoable_action()
|
|
except: pass
|
|
|
|
def thaw_undo(self):
|
|
try: self.end_not_undoable_action()
|
|
except: pass
|
|
|
|
def raw_input(self, ps=None):
|
|
'''Show prompt 'ps' and enter input mode until the current input
|
|
is committed.'''
|
|
|
|
if ps:
|
|
self.ps = ps
|
|
else:
|
|
self.ps = ''
|
|
|
|
iter = self.buffer.get_iter_at_mark(self.buffer.get_insert())
|
|
|
|
if ps:
|
|
self.freeze_undo()
|
|
self.buffer.insert(iter, self.ps)
|
|
self.thaw_undo()
|
|
|
|
self.__move_cursor_to(iter)
|
|
self.scroll_to_mark(self.cursor, 0.2, False, 0.0, 0.0)
|
|
|
|
self.in_raw_input = True
|
|
|
|
if self.run_on_raw_input:
|
|
run_now = self.run_on_raw_input
|
|
self.run_on_raw_input = None
|
|
self.buffer.insert_at_cursor(run_now + '\n')
|
|
|
|
def modal_raw_input(self, text):
|
|
'''Starts raw input in modal mode. The event loop is spinned until
|
|
the input is committed. Returns the text entered after the prompt.'''
|
|
orig_ps = self.ps
|
|
|
|
self.raw_input(text)
|
|
self.in_modal_raw_input = True
|
|
|
|
while self.in_modal_raw_input:
|
|
Gtk.main_iteration()
|
|
|
|
self.ps = orig_ps
|
|
self.in_modal_raw_input = False
|
|
self.in_raw_input = False
|
|
|
|
return self.modal_raw_input_result
|
|
|
|
def modal_input(self, text):
|
|
return eval(self.modal_raw_input(text))
|
|
|
|
# Each time the insert mark is modified, move the cursor to it.
|
|
def on_buf_mark_set(self, buffer, iter, mark):
|
|
if mark is not buffer.get_insert():
|
|
return
|
|
start = self.__get_start()
|
|
end = self.__get_end()
|
|
if iter.compare(self.__get_start()) >= 0 and \
|
|
iter.compare(self.__get_end()) <= 0:
|
|
buffer.move_mark_by_name("cursor", iter)
|
|
self.scroll_to_mark(self.cursor, 0.2, False, 0.0, 0.0)
|
|
|
|
def __insert(self, iter, text):
|
|
self.do_insert = True
|
|
self.buffer.insert(iter, text)
|
|
self.do_insert = False
|
|
|
|
# Make sure that text insertions while in text input mode are properly
|
|
# committed to the history.
|
|
def on_buf_insert(self, buf, iter, text, len):
|
|
# Bail out if not in input mode.
|
|
if not self.in_raw_input or self.do_insert or not len:
|
|
return
|
|
|
|
buf.stop_emission("insert-text")
|
|
lines = text.splitlines()
|
|
need_eol = False
|
|
for l in lines:
|
|
if need_eol:
|
|
self._commit()
|
|
iter = self.__get_cursor()
|
|
else:
|
|
cursor = self.__get_cursor()
|
|
if iter.compare(self.__get_start()) < 0:
|
|
iter = cursor
|
|
elif iter.compare(self.__get_end()) > 0:
|
|
iter = cursor
|
|
else:
|
|
self.__move_cursor_to(iter)
|
|
need_eol = True
|
|
self.__insert(iter, l)
|
|
self.__move_cursor(0)
|
|
|
|
def __delete(self, start, end):
|
|
self.do_delete = True
|
|
self.buffer.delete(start, end)
|
|
self.do_delete = False
|
|
|
|
def on_buf_delete(self, buf, start, end):
|
|
if not self.in_raw_input or self.do_delete:
|
|
return
|
|
|
|
buf.stop_emission("delete-range")
|
|
|
|
start.order(end)
|
|
line_start = self.__get_start()
|
|
line_end = self.__get_end()
|
|
|
|
if start.compare(line_end) > 0:
|
|
return
|
|
if end.compare(line_start) < 0:
|
|
return
|
|
|
|
self.__move_cursor(0)
|
|
|
|
if start.compare(line_start) < 0:
|
|
start = line_start
|
|
if end.compare(line_end) > 0:
|
|
end = line_end
|
|
self.__delete(start, end)
|
|
|
|
# We overload the key press event handler to handle "special keys"
|
|
# when in input mode to make history browsing, completions, etc. work.
|
|
def do_key_press_event(self, event):
|
|
if not self.in_raw_input:
|
|
return Gtk.TextView.do_key_press_event(self, event)
|
|
|
|
tab_pressed = self.tab_pressed
|
|
self.tab_pressed = 0
|
|
handled = True
|
|
|
|
state = event.state & (Gdk.ModifierType.SHIFT_MASK |
|
|
Gdk.ModifierType.CONTROL_MASK |
|
|
Gdk.ModifierType.MOD1_MASK)
|
|
keyval = event.keyval
|
|
|
|
if not state:
|
|
if keyval == Gdk.KEY_Escape:
|
|
pass
|
|
elif keyval == Gdk.KEY_Return:
|
|
self._commit()
|
|
elif keyval == Gdk.KEY_Up:
|
|
self.__history(-1)
|
|
elif keyval == Gdk.KEY_Down:
|
|
self.__history(1)
|
|
elif keyval == Gdk.KEY_Left:
|
|
self.__move_cursor(-1)
|
|
elif keyval == Gdk.KEY_Right:
|
|
self.__move_cursor(1)
|
|
elif keyval == Gdk.KEY_Home:
|
|
self.__move_cursor(-10000)
|
|
elif keyval == Gdk.KEY_End:
|
|
self.__move_cursor(10000)
|
|
elif keyval == Gdk.KEY_Tab:
|
|
cursor = self.__get_cursor()
|
|
if cursor.starts_line():
|
|
handled = False
|
|
else:
|
|
cursor.backward_char()
|
|
if cursor.get_char().isspace():
|
|
handled = False
|
|
else:
|
|
self.tab_pressed = tab_pressed + 1
|
|
self.__complete()
|
|
else:
|
|
handled = False
|
|
elif state == Gdk.ModifierType.CONTROL_MASK:
|
|
if keyval == Gdk.KEY_u:
|
|
start = self.__get_start()
|
|
end = self.__get_cursor()
|
|
self.__delete(start, end)
|
|
elif keyval == Gdk.KEY_d:
|
|
if self.quit_func:
|
|
self.quit_func()
|
|
else:
|
|
handled = False
|
|
else:
|
|
handled = False
|
|
|
|
# Handle ordinary keys
|
|
if not handled:
|
|
return Gtk.TextView.do_key_press_event(self, event)
|
|
else:
|
|
return True
|
|
|
|
def __history(self, dir):
|
|
text = self._get_line()
|
|
new_text = self.history.get(dir, text)
|
|
if not new_text is None:
|
|
self.__replace_line(new_text)
|
|
self.__move_cursor(0)
|
|
self.scroll_to_mark(self.cursor, 0.2, False, 0.0, 0.0)
|
|
|
|
def __get_cursor(self):
|
|
'''Returns an iterator at the current cursor position.'''
|
|
return self.buffer.get_iter_at_mark(self.cursor)
|
|
|
|
def __get_start(self):
|
|
'''Returns an iterator at the start of the input on the current
|
|
cursor line.'''
|
|
|
|
iter = self.__get_cursor()
|
|
iter.set_line(iter.get_line())
|
|
iter.forward_chars(len(self.ps))
|
|
return iter
|
|
|
|
def __get_end(self):
|
|
'''Returns an iterator at the end of the cursor line.'''
|
|
iter = self.__get_cursor()
|
|
if not iter.ends_line():
|
|
iter.forward_to_line_end()
|
|
return iter
|
|
|
|
def __get_text(self, start, end):
|
|
'''Get text between 'start' and 'end' markers.'''
|
|
return self.buffer.get_text(start, end, False)
|
|
|
|
def __move_cursor_to(self, iter):
|
|
self.buffer.place_cursor(iter)
|
|
self.buffer.move_mark_by_name("cursor", iter)
|
|
|
|
def __move_cursor(self, howmany):
|
|
iter = self.__get_cursor()
|
|
end = self.__get_cursor()
|
|
if not end.ends_line():
|
|
end.forward_to_line_end()
|
|
line_len = end.get_line_offset()
|
|
move_to = iter.get_line_offset() + howmany
|
|
move_to = min(max(move_to, len(self.ps)), line_len)
|
|
iter.set_line_offset(move_to)
|
|
self.__move_cursor_to(iter)
|
|
|
|
def __delete_at_cursor(self, howmany):
|
|
iter = self.__get_cursor()
|
|
end = self.__get_cursor()
|
|
if not end.ends_line():
|
|
end.forward_to_line_end()
|
|
line_len = end.get_line_offset()
|
|
erase_to = iter.get_line_offset() + howmany
|
|
if erase_to > line_len:
|
|
erase_to = line_len
|
|
elif erase_to < len(self.ps):
|
|
erase_to = len(self.ps)
|
|
end.set_line_offset(erase_to)
|
|
self.__delete(iter, end)
|
|
|
|
def __get_width(self):
|
|
'''Estimate the number of characters that will fit in the area
|
|
currently allocated to this widget.'''
|
|
|
|
if not self.get_realized():
|
|
return 80
|
|
|
|
context = self.get_pango_context()
|
|
metrics = context.get_metrics(context.get_font_description(),
|
|
context.get_language())
|
|
pix_width = metrics.get_approximate_char_width()
|
|
allocation = Gtk.Widget.get_allocation(self)
|
|
return allocation.width * Pango.SCALE / pix_width
|
|
|
|
def __print_completions(self, completions):
|
|
line_start = self.__get_text(self.__get_start(), self.__get_cursor())
|
|
line_end = self.__get_text(self.__get_cursor(), self.__get_end())
|
|
iter = self.buffer.get_end_iter()
|
|
self.__move_cursor_to(iter)
|
|
self.__insert(iter, "\n")
|
|
|
|
width = max(self.__get_width(), 4)
|
|
max_width = max(len(s) for s in completions)
|
|
n_columns = max(int(width / (max_width + 1)), 1)
|
|
col_width = int(width / n_columns)
|
|
total = len(completions)
|
|
col_length = total / n_columns
|
|
if total % n_columns:
|
|
col_length = col_length + 1
|
|
col_length = max(col_length, 1)
|
|
|
|
if col_length == 1:
|
|
n_columns = total
|
|
col_width = width / total
|
|
|
|
for i in range(int(col_length)):
|
|
for j in range(n_columns):
|
|
ind = i + j*col_length
|
|
if ind < total:
|
|
if j == n_columns - 1:
|
|
n_spaces = 0
|
|
else:
|
|
n_spaces = int(col_width - len(completions[int(ind)]))
|
|
self.__insert(iter, completions[int(ind)] + " " * n_spaces)
|
|
self.__insert(iter, "\n")
|
|
|
|
self.__insert(iter, "%s%s%s" % (self.ps, line_start, line_end))
|
|
iter.set_line_offset(len(self.ps) + len(line_start))
|
|
self.__move_cursor_to(iter)
|
|
self.scroll_to_mark(self.cursor, 0.2, False, 0.0, 0.0)
|
|
|
|
def __complete(self):
|
|
text = self.__get_text(self.__get_start(), self.__get_cursor())
|
|
start = ''
|
|
word = text
|
|
nonwords = self.nonword_re.findall(text)
|
|
if nonwords:
|
|
last = text.rfind(nonwords[-1]) + len(nonwords[-1])
|
|
start = text[:last]
|
|
word = text[last:]
|
|
|
|
completions = self.complete(word)
|
|
|
|
if completions:
|
|
prefix = _commonprefix(completions)
|
|
if prefix != word:
|
|
start_iter = self.__get_start()
|
|
start_iter.forward_chars(len(start))
|
|
end_iter = start_iter.copy()
|
|
end_iter.forward_chars(len(word))
|
|
self.__delete(start_iter, end_iter)
|
|
self.__insert(end_iter, prefix)
|
|
elif self.tab_pressed > 1:
|
|
self.freeze_undo()
|
|
self.__print_completions(completions)
|
|
self.thaw_undo()
|
|
self.tab_pressed = 0
|
|
|
|
def complete(self, text):
|
|
return None
|
|
|
|
def _get_line(self):
|
|
'''Return the current input behind the prompt.'''
|
|
start = self.__get_start()
|
|
end = self.__get_end()
|
|
return self.buffer.get_text(start, end, False)
|
|
|
|
def __replace_line(self, new_text):
|
|
'''Replace the current input with 'new_text' '''
|
|
start = self.__get_start()
|
|
end = self.__get_end()
|
|
self.__delete(start, end)
|
|
self.__insert(end, new_text)
|
|
|
|
def _commit(self):
|
|
'''Commit the input entered on the current line.'''
|
|
|
|
# Find iterator and end of cursor line.
|
|
end = self.__get_cursor()
|
|
if not end.ends_line():
|
|
end.forward_to_line_end()
|
|
|
|
# Get text at current line.
|
|
text = self._get_line()
|
|
|
|
# Move cursor to the end of the line, insert new line.
|
|
self.__move_cursor_to(end)
|
|
self.freeze_undo()
|
|
self.__insert(end, "\n")
|
|
|
|
self.history.commit(text)
|
|
if self.in_modal_raw_input:
|
|
self.in_modal_raw_input = False
|
|
self.modal_raw_input_result = text
|
|
else:
|
|
self.in_raw_input = False
|
|
self.do_raw_input(text)
|
|
|
|
self.thaw_undo()
|
|
|
|
def do_raw_input(self, text):
|
|
pass
|
|
|
|
|
|
class _Console(_ReadLine, code.InteractiveInterpreter):
|
|
def __init__(self, locals=None, banner=None,
|
|
completer=None, use_rlcompleter=True,
|
|
start_script=None, quit_func=None):
|
|
_ReadLine.__init__(self, quit_func)
|
|
|
|
code.InteractiveInterpreter.__init__(self, locals)
|
|
self.locals["__console__"] = self
|
|
|
|
# The builtin raw_input function reads from stdin, we don't want
|
|
# this. Therefore, replace this function with our own modal raw
|
|
# input function.
|
|
exec ("import builtins", self.locals)
|
|
#self.locals['builtins'].__dict__['raw_input'] = lambda text='': self.modal_raw_input(text)
|
|
self.locals['builtins'].__dict__['input'] = lambda text='': self.modal_input(text)
|
|
|
|
self.start_script = start_script
|
|
self.completer = completer
|
|
self.banner = banner
|
|
|
|
if not self.completer and use_rlcompleter:
|
|
try:
|
|
import rlcompleter
|
|
self.completer = rlcompleter.Completer()
|
|
except ImportError:
|
|
pass
|
|
|
|
self.ps1 = ">>> "
|
|
self.ps2 = "... "
|
|
self.__start()
|
|
self.run_on_raw_input = start_script
|
|
self.raw_input(self.ps1)
|
|
|
|
def __start(self):
|
|
self.cmd_buffer = ""
|
|
|
|
self.freeze_undo()
|
|
self.thaw_undo()
|
|
|
|
self.do_delete = True
|
|
self.buffer.set_text("")
|
|
self.do_delete = False
|
|
|
|
if self.banner:
|
|
iter = self.buffer.get_start_iter()
|
|
self.buffer.insert_with_tags_by_name(iter, self.banner, "stdout")
|
|
if not iter.starts_line():
|
|
self.buffer.insert(iter, "\n")
|
|
|
|
def clear(self, start_script=None):
|
|
if start_script is None:
|
|
start_script = self.start_script
|
|
else:
|
|
self.start_script = start_script
|
|
|
|
self.__start()
|
|
self.run_on_raw_input = start_script
|
|
self.raw_input(self.ps1)
|
|
|
|
def do_raw_input(self, text):
|
|
if self.cmd_buffer:
|
|
cmd = self.cmd_buffer + "\n" + text
|
|
else:
|
|
cmd = text
|
|
|
|
saved_stdout, saved_stderr = sys.stdout, sys.stderr
|
|
sys.stdout, sys.stderr = self._stdout, self._stderr
|
|
|
|
if self.runsource(cmd):
|
|
self.cmd_buffer = cmd
|
|
ps = self.ps2
|
|
else:
|
|
self.cmd_buffer = ''
|
|
ps = self.ps1
|
|
|
|
sys.stdout, sys.stderr = saved_stdout, saved_stderr
|
|
self.raw_input(ps)
|
|
|
|
def do_command(self, code):
|
|
try:
|
|
eval(code, self.locals)
|
|
except SystemExit:
|
|
if self.quit_func:
|
|
self.quit_func()
|
|
else:
|
|
raise
|
|
except:
|
|
self.showtraceback()
|
|
|
|
def runcode(self, code):
|
|
#if gtk.pygtk_version[1] < 8:
|
|
self.do_command(code)
|
|
#else:
|
|
#self.emit("command", code)
|
|
|
|
def complete_attr(self, start, end):
|
|
try:
|
|
obj = eval(start, self.locals)
|
|
strings = dir(obj)
|
|
|
|
if end:
|
|
completions = {}
|
|
for s in strings:
|
|
if s.startswith(end):
|
|
completions[s] = None
|
|
completions = completions.keys()
|
|
else:
|
|
completions = strings
|
|
|
|
completions.sort()
|
|
return [start + "." + s for s in completions]
|
|
except:
|
|
return None
|
|
|
|
def complete(self, text):
|
|
if self.completer:
|
|
completions = []
|
|
i = 0
|
|
try:
|
|
while 1:
|
|
s = self.completer.complete(text, i)
|
|
if s:
|
|
completions.append(s)
|
|
i += 1
|
|
else:
|
|
completions.sort()
|
|
return completions
|
|
except NameError:
|
|
return None
|
|
|
|
dot = text.rfind(".")
|
|
if dot >= 0:
|
|
return self.complete_attr(text[:dot], text[dot+1:])
|
|
|
|
completions = {}
|
|
strings = keyword.kwlist
|
|
|
|
if self.locals:
|
|
strings.extend(self.locals.keys())
|
|
|
|
try: strings.extend(eval("globals()", self.locals).keys())
|
|
except: pass
|
|
|
|
try:
|
|
exec("import __builtin__", self.locals)
|
|
strings.extend(eval("dir(__builtin__)", self.locals))
|
|
except:
|
|
pass
|
|
|
|
for s in strings:
|
|
if s.startswith(text):
|
|
completions[s] = None
|
|
completions = completions.keys()
|
|
completions.sort()
|
|
return completions
|
|
|
|
|
|
def ReadLineType(t=Gtk.TextView):
|
|
class readline(t, _ReadLine):
|
|
def __init__(self, *args, **kwargs):
|
|
t.__init__(self)
|
|
_ReadLine.__init__(self, *args, **kwargs)
|
|
def do_key_press_event(self, event):
|
|
return _ReadLine.do_key_press_event(self, event)
|
|
GObject.type_register(readline)
|
|
return readline
|
|
|
|
def ConsoleType(t=Gtk.TextView):
|
|
class console_type(t, _Console):
|
|
__gsignals__ = {
|
|
'command' : (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (object,)),
|
|
}
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
#if gtk.pygtk_version[1] < 8:
|
|
GObject.GObject.__init__(self)
|
|
#else:
|
|
#t.__init__(self)
|
|
_Console.__init__(self, *args, **kwargs)
|
|
|
|
def do_command(self, code):
|
|
return _Console.do_command(self, code)
|
|
|
|
def do_key_press_event(self, event):
|
|
return _Console.do_key_press_event(self, event)
|
|
|
|
def get_default_size(self):
|
|
context = self.get_pango_context()
|
|
metrics = context.get_metrics(context.get_font_description(),
|
|
context.get_language())
|
|
width = metrics.get_approximate_char_width()
|
|
height = metrics.get_ascent() + metrics.get_descent()
|
|
|
|
# Default to a 80x40 console
|
|
width = pango_pixels(int(width * 80 * 1.05))
|
|
height = pango_pixels(height * 40)
|
|
|
|
return width, height
|
|
|
|
#if gtk.pygtk_version[1] < 8:
|
|
GObject.type_register(console_type)
|
|
|
|
return console_type
|
|
|
|
ReadLine = ReadLineType()
|
|
Console = ConsoleType()
|
|
|
|
def _make_window():
|
|
window = Gtk.Window()
|
|
window.set_title("pyconsole.py")
|
|
swin = Gtk.ScrolledWindow()
|
|
swin.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS)
|
|
window.add(swin)
|
|
console = Console(banner="Hello there!",
|
|
use_rlcompleter=False,
|
|
start_script="gi.require_version('Pika', '3.0')\nfrom gi.repository import Pika\n")
|
|
swin.add(console)
|
|
|
|
width, height = console.get_default_size()
|
|
sb_width, sb_height = swin.get_vscrollbar().size_request()
|
|
|
|
window.set_default_size(width + sb_width, height)
|
|
window.show_all()
|
|
|
|
if not Gtk.main_level():
|
|
window.connect("destroy", Gtk.main_quit)
|
|
Gtk.main()
|
|
|
|
return console
|
|
|
|
if __name__ == '__main__':
|
|
if len(sys.argv) < 2 or sys.argv[1] != '-pika':
|
|
_make_window()
|
