#+TITLE: GTK-3 Textview interactions
#+DATE: 2014-04-18 12:00:00 UTC
#+DESCRIPTION: Load a glade file displaying a textview widget which runs python code on carriage return.
#+FILETAGS: GTK-3:python:widgets
#+CATEGORY: python
#+SLUG: 11-interactive-python-textview
#+THUMBNAIL: ../../../images/gtk/tut11-interactive-python-textview.png
#+BEGIN_COMMENT
.. 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
#+END_COMMENT

#+CAPTION: Textview widget
[[../../../images/gtk/tut11-interactive-python-textview.png]]

        
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.

#+BEGIN_SRC 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()
#+END_SRC