8.7 KiB
Executable File
8.7 KiB
Executable File
GTK-3 Textview interactions
.. title: GTK-3 Textview interactions .. slug: 11-interactive-python-textview .. date: 2014-04-18 12:00:00 UTC .. tags: GTK-3, python, widgets .. category: python .. description: Load a glade file displaying a textview widget which runs python code on carriage return. .. type: text
This example shows using the text view widget to get text entered by a use, it makes use of marked text blocks so that only some text can be edited and will dynamically read the current line and run it in python interactively.
You can type app.test() or app.show_drawing(True) as examples of the interaction between the widget and python.
#!/usr/bin/env python
import sys
from StringIO import StringIO
from gi.repository import Gtk, Gdk
import code
import math
class interactiveGtk:
def __init__(self):
window = Gtk.Window()
window.set_default_size(380, 300)
window.connect("destroy", lambda w: Gtk.main_quit())
box = Gtk.VBox()
self.drawingarea = Gtk.DrawingArea()
#python console using a textview
console = interactive_console(Gtk.TextView())
self.drawingarea.connect("draw", self.area_expose_cb)
box.add(self.drawingarea)
box.add(console.textarea)
window.add(box)
window.show_all()
self.drawarea = False
def show_drawing(self, state):
"""self.show_drawing(True) to enable showing the lines"""
self.drawarea = state
def test(self):
"""run app.test() when program is running to print this message"""
print ('hello world')
def area_expose_cb(self, widget, context):
"""expose event lets draw, lines will only display if we run self.show_lines first.
demonstrating running state change of our program"""
self.style = self.drawingarea.get_style()
if self.drawarea is True:
self.drawing(context, 210, 10)
def drawing(self, cr, x, y):
""" draw a circle in the drawing area """
cr.set_line_width(10)
cr.set_source_rgb(0.5, 0.8, 0.0)
cr.translate(20 / 2, 20 / 2)
cr.arc(50, 50, 50, 0, 2 * math.pi)
cr.stroke_preserve()
cr.set_source_rgb(0.3, 0.4, 0.4)
cr.fill()
class interactive_console:
editor_chars = '>>>'
editor_chars_other = '...'
editor_history = []
editor_history_position = 0
def __init__(self, textview):
#the python editor window
self.textarea = textview
self.textarea.connect('key-press-event', self.key_pressed)
self.console_buffer = self.textarea.get_buffer()
#setup some characters which can not be changed
self.console_buffer.set_text(self.editor_chars + 'app.show_drawing(True)')
self.console_buffer.create_tag("uneditable", editable=False, editable_set=True)
self.console_buffer.create_mark("input_position", self.console_buffer.get_end_iter(), True)
self.console_buffer.create_mark("end_position", self.console_buffer.get_end_iter(), False)
self.console_buffer.apply_tag_by_name("uneditable", self.console_buffer.get_start_iter(), self.console_buffer.get_iter_at_offset(len(self.editor_chars)))
#interactive mode interpreter,
#pass locals() or globals() so we can access our programs functions and variables
#using global here so we have access to the app object in the global scope
self.interpreter = code.InteractiveInterpreter(globals())
def key_pressed(self, widget, event):
"""
grab key presses, run code from textview on return
navigate history if arrow keys are pressed
"""
if event.keyval == Gdk.keyval_from_name('Return'):
self.execute_line()
return True
if event.keyval == Gdk.keyval_from_name('Up'):
self.console_history(-1)
return True
if event.keyval == Gdk.keyval_from_name('Down'):
self.console_history(1)
return True
return False
def execute_line(self):
"""
carriage return was captured so lets process the textview contents for code to run
"""
text = self.console_buffer.get_text(self.console_buffer.get_start_iter(), self.console_buffer.get_end_iter(), False)
source = ''
block = False
indent = 0
#work out code to run if its not a block or a blank line then run what we have,
#if its a block of code like a for loop or if condition dont run it yet unless the block has finished.
last_line = ''
for line in text.split("\n"):
line = line[3:].strip('')
if line.strip() == '':
block = False
indent = 0
else:
if line.endswith(':'):
if block is True:
source += line + "\n\t"
else:
source = line + "\n\t"
block = True
indent += 1
else:
if line.startswith("\t"):
source += line + "\n"
else:
block = False
source = line + "\n"
indent = 0
last_line = line
if last_line.strip() != '':
self.append_history(last_line)
chars = self.editor_chars
# run the code grabbed from the text buffer and execute it if its not a block
results = ''
if block is True:
chars = self.editor_chars_other
else:
chars = self.editor_chars
results = self.execute_code(source)
#build text for the editor, and workout which part of the text should be locked
text_output = text + '\n' + results + chars
text_output_length = len(text_output)
if block is True:
text_output += "\t" * indent
self.update_editor(text_output, text_output_length)
def execute_code(self, source):
"""
run any code sent here and capture output and return the results
"""
# capture output from stdio so we can display the errors in our editor
result = StringIO()
sys.stdout = result
sys.stderr = result
#run code output will be put into result because we are capturing stdout
self.interpreter.runsource(source, "<<console>>")
# restore stdout so future output is capture to the terminal again
sys.stdout = sys.__stdout__
sys.stdout = sys.__stderr__
return result.getvalue()
def update_editor(self, text, uneditable_end=0):
"""
pass in text to put in the editor and portion to be locked from editing
"""
self.console_buffer.set_text(text)
self.console_buffer.create_mark("input_position", self.console_buffer.get_end_iter(), True)
self.console_buffer.create_mark("end_position", self.console_buffer.get_end_iter(), False)
self.console_buffer.apply_tag_by_name("uneditable", self.console_buffer.get_start_iter(), self.console_buffer.get_iter_at_offset(uneditable_end))
def append_history(self, line):
"""
Store command in history drop command if limit has been reached
"""
if len(self.editor_history) > 10:
self.editor_history.pop()
self.editor_history.append(line)
self.editor_history_position = len(self.editor_history)
def console_history(self, direction=-1):
"""
drop any text on last line and insert text from history based on position
"""
# get current text excluding last line as we will update from our history
text = self.console_buffer.get_text(
self.console_buffer.get_start_iter(),
self.console_buffer.get_iter_at_line_index(
self.console_buffer.get_line_count(), 0),
False)
#work out position in history and what should be displayed
linenumber = self.editor_history_position + direction
if linenumber >= 0 and linenumber < len(self.editor_history):
self.editor_history_position += direction
self.console_buffer.set_text(text + self.editor_chars + self.editor_history[self.editor_history_position])
app = interactiveGtk()
Gtk.main()