snappy 3.0.3__cp38-cp38-macosx_11_0_arm64.whl → 3.2__cp38-cp38-macosx_11_0_arm64.whl

snappy/tkterminal.py

@@ -1,35 +1,71 @@
 # -*- coding: utf-8 -*-
-import os, sys, re, signal, IPython
-from builtins import range
-from IPython.utils import io
-from IPython.core.autocall import IPyAutocall
-import snappy
+import os
+import sys
+import re
 from urllib.request import pathname2url
-from .gui import *
+import tkinter as Tk_
+from tkinter import ttk
+from tkinter.font import Font
+from tkinter.font import families as font_families
+from tkinter.messagebox import askyesno
+from IPython.utils import io
 
-snappy_path = os.path.abspath(os.path.dirname(snappy.__file__))
-icon_file = os.path.join(snappy_path, 'info_icon.gif')
-debug_Tk = False
+debug_Tk = True
 ansi_seqs = re.compile(r'(?:\x01*\x1b\[((?:[0-9]*;)*[0-9]*.)\x02*)*([^\x01\x1b]*)',
                        re.MULTILINE)
-ansi_colors =  {'0;30m': 'Black',
-                '0;31m': 'Red',
-                '0;32m': 'Green',
-                '0;33m': 'Brown',
-                '0;34m': 'Blue',
-                '0;35m': 'Purple',
-                '0;36m': 'Cyan',
-                '0;37m': 'LightGray',
-                '1;30m': 'Black', #'DarkGray',
-                '1;31m': 'DarkRed',
-                '1;32m': 'SeaGreen',
-                '1;33m': 'Yellow',
-                '1;34m': 'LightBlue',
-                '1;35m': 'MediumPurple',
-                '1;36m': 'LightCyan',
-                '1;37m': 'White'}
+ansi_colors = {'0;30m': 'Black',
+               '0;31m': 'Red',
+               '0;32m': 'Green',
+               '0;33m': 'Brown',
+               '0;34m': 'Blue',
+               '0;35m': 'Purple',
+               '0;36m': 'Cyan',
+               '0;37m': 'LightGray',
+               '1;30m': 'Black',  # 'DarkGray',
+               '1;31m': 'DarkRed',
+               '1;32m': 'SeaGreen',
+               '1;33m': 'Yellow',
+               '1;34m': 'LightBlue',
+               '1;35m': 'MediumPurple',
+               '1;36m': 'LightCyan',
+               '1;37m': 'White'}
 delims = re.compile(r'[\s\[\]\{\}\(\)\+\-\=\'`~!@#\$\^\&\*]+')
 
+
+class FontChoice:
+    def __init__(self, family, size, weight, slant):
+        self.family = family
+        self.size = size
+        self.weight = weight
+        self.slant = slant
+        self.rest = f'{self.weight} {self.slant}'
+
+    def as_tuple(self):
+        size = self.size
+        if sys.platform == 'darwin' and Tk_.TkVersion >= 9.0:
+            size = int(size/1.3)
+        return (self.family, size, self.rest)
+
+    def __repr__(self):
+        return 'FontChoice' + repr((self.family, self.size, self.weight, self.slant))
+
+    def bold(self):
+        return FontChoice(self.family, self.size, 'bold', self.slant)
+
+
+def default_terminal_font():
+    size = 13 if sys.platform == 'darwin' else 11
+    family = Font(font='TkFixedFont').actual()['family']
+    if sys.platform == 'win32':
+        # Default is Courier New which is ugly and appears blurry.
+        available = font_families()
+        for better in ['Consolas', 'Cascadia Mono SemiLight']:
+            if better in available:
+                family = better
+
+    return FontChoice(family, size, 'normal', 'roman')
+
+
 class Tk(Tk_.Tk):
     def __init__(self, error_handler=None):
         Tk_.Tk.__init__(self, className='snappy')
@@ -37,14 +73,9 @@ class Tk(Tk_.Tk):
         # calls this function to report their occurrence.
         if error_handler:
             self.report_callback_exception = error_handler
-        # In Python 2.7 the _default root does not get set correctly.
-        if not Tk_._default_root:
-            Tk_._default_root = self
 
-#  Some ideas for the TkTerm class were borrowed from code written by
-#  Eitan Isaacson, IBM Corp.
 
-class TkTerm:
+class TkTerminalBase:
     """
     A Tkinter terminal window that runs an IPython shell.  This class
     supports the IOStream interface, and can function as a replacement
@@ -56,8 +87,6 @@ class TkTerm:
             io.stdout = sys.stdout = self
         else:
             self.window = window = Tk(self.report_callback_exception)
-            self.encoding = sys.stdout.encoding
-            self.saved_io = (sys.stdout, sys.stderr)
             io.stdout = io.stderr = sys.stdout = sys.stderr = self
         self._input_buffer = ''
         self._current_indent = 0
@@ -65,7 +94,6 @@ class TkTerm:
         window.option_add('*Menu.tearOff', 0)
         window.title(name)
         window.protocol("WM_DELETE_WINDOW", self.close)
-        self.icon = Tk_.PhotoImage(file=icon_file)
         self.frame = frame = Tk_.Frame(window)
         self.text = text = Tk_.Text(frame,
                                     width=85,
@@ -77,7 +105,7 @@ class TkTerm:
                                     highlightthickness=0,
                                     relief=Tk_.FLAT
                                 )
-        self.set_font(Font(text, text.cget('font')))
+        self.set_font(default_terminal_font())
         self.scroller = scroller = Tk_.Scrollbar(frame, command=text.yview)
         text.config(yscrollcommand=scroller.set)
         scroller.pack(side=Tk_.RIGHT, fill=Tk_.Y, pady=10)
@@ -85,19 +113,16 @@ class TkTerm:
         frame.pack(fill=Tk_.BOTH, expand=Tk_.YES)
         text.focus_set()
         window.bind('<FocusIn>', lambda event=None: text.focus_set())
+        text.bind('<Control-c>', self.handle_control_c)
         text.bind('<KeyPress>', self.handle_keypress)
         text.bind('<KeyRelease>', self.handle_keyrelease)
-        if not sys.platform == 'darwin':
-            text.bind('<Control-c>', self.handle_keypress)
         text.bind('<Return>', self.handle_return)
         text.bind('<Shift-Return>', self.handle_shift_return)
         text.bind('<BackSpace>', self.handle_backspace)
         text.bind('<Delete>', self.handle_backspace)
         text.bind('<Tab>', self.handle_tab)
         text.bind('<Up>', self.handle_up)
-        text.bind('<Shift-Up>', lambda event : None)
         text.bind('<Down>', self.handle_down)
-        text.bind('<Shift-Down>', lambda event : None)
         text.bind('<Home>', self.go_to_beginning)
         text.bind('<<Cut>>', self.protect_text)
         text.bind('<<Copy>>', self.edit_copy)
@@ -113,12 +138,14 @@ class TkTerm:
         if sys.platform == 'darwin':
             self.window.bind_all('<Command-Key-q>', self.close)
             self.window.bind_all('<Command-Key-Left>', self.go_to_beginning)
+            self.text.bind('<Command-Key-Up>', self.jump_up)
         elif sys.platform == 'linux2' or sys.platform == 'linux':
             self.window.bind_all('<Alt-Key-q>', self.close)
         self.add_bindings()
         # 'output_end' marks the end of the text written by us.
         # Everything above this position should be
         # immutable, and tagged with the "output" style.
+        # Normally it is set at the end of the input prompt.
         self.text.mark_set('output_end', Tk_.INSERT)
         self.text.mark_gravity('output_end', Tk_.LEFT)
         text.tag_config('output')
@@ -157,7 +184,7 @@ class TkTerm:
             self.banner = shell.banner1
         else:
             cprt = 'Type "copyright", "credits" or "license" for more information.'
-            self.banner = "Python %s on %s\n%s\n(%s)\n" %(
+            self.banner = "Python %s on %s\n%s\n(%s)\n" % (
                 sys.version, sys.platform, cprt,
                 self.__class__.__name__)
         self.quiet = False
@@ -171,6 +198,10 @@ class TkTerm:
         self.showing_traceback = False
         self.closed = False
         self._saved_index = Tk_.END
+        # This flag is set to prevent quitting the app.
+        self.blockers = {}
+        self.can_quit = True
+        self.close_callback = lambda :None
 
     # Emulate a ListedWindow.  We are listed, even though we are unique.
     def bring_to_front(self):
@@ -194,12 +225,12 @@ class TkTerm:
         traceback = '\n' + self.IP.InteractiveTB.stb2text(stb)
         if etype == KeyboardInterrupt:
             self.write('KeyboardInterrupt: ', style='msg')
-            self.write('%s'%evalue)
+            self.write('%s' % evalue)
         else:
             self.write(traceback)
         self.reset()
         self.showing_traceback = True
-        self.send_code('\n')
+        self.process_return('\n')
 
     def SnapPea_callback(self, interrupted=False):
         """
@@ -224,12 +255,14 @@ class TkTerm:
             source_raw = self.reset()
             self.IP.history_manager.store_inputs(self.IP.execution_count, source_raw)
             self.IP.execution_count += 1
-            raise KeyboardInterrupt('Halted')
         else:
             self.interrupted = True
             # Inform the SnapPea kernel about the interrupt.
             snappy.SnapPy.SnapPea_interrupt()
             snappy.SnapPyHP.SnapPea_interrupt()
+        # For some reason we need to raise a KeyboardInterrupt here.  Otherwise
+        # the call to KeyboardInterrupt('Halted') will be ignored.
+        raise KeyboardInterrupt('Interrupted')
 
     def report_callback_exception(self, exc, value, traceback):
         """
@@ -240,22 +273,49 @@ class TkTerm:
         sys.last_traceback = traceback
         self.IP.showtraceback()
 
-    def set_font(self, fontdesc):
-        self.text.config(font=fontdesc)
-        normal_font = Font(self.text, self.text.cget('font'))
-        self.bold_font = bold_font = Font(self.text, self.text.cget('font'))
-        self.bold_font.config(weight='bold')
+    def set_font(self, font_choice):
+        normal_tuple = font_choice.as_tuple()
+        bold_tuple = font_choice.bold().as_tuple()
+        normal_font = Font(font=font_choice.as_tuple())
         self.char_size = normal_font.measure('M')
+        self.text.config(font=normal_tuple)
         text = self.text
-        text.tag_config('output', font=normal_font)
-        text.tag_config('Prompt', foreground='#0000cc', font=normal_font)
-        text.tag_config('PromptNum', foreground='#0000bb', font=bold_font)
-        text.tag_config('OutPrompt', foreground='#cc0000', font=normal_font)
-        text.tag_config('OutPromptNum', foreground='#bb0000', font=bold_font)
+        text.tag_config('output', font=normal_tuple)
+        text.tag_config('Prompt', foreground='#0000cc', font=normal_tuple)
+        text.tag_config('PromptNum', foreground='#0000bb', font=bold_tuple)
+        text.tag_config('OutPrompt', foreground='#cc0000', font=normal_tuple)
+        text.tag_config('OutPromptNum', foreground='#bb0000', font=bold_tuple)
+
+    def add_blocker(self, window, message):
+        self.blockers[window] = message
+
+    def remove_blocker(self, window):
+        self.blockers.pop(window)
 
     def close(self, event=None):
-        self.window.quit()
-        self.closed = True
+        can_quit = True
+        topmost = None
+        for blocker in self.blockers:
+            if blocker.attributes('-topmost'):
+                topmost = blocker
+                blocker.attributes('-topmost', False)
+            message = self.blockers[blocker]
+            answer  = askyesno('Quit',
+                message + '\nDo you want to quit anyway?')
+            if not answer:
+                can_quit = False
+                break;
+        if topmost:
+            topmost.attributes('-topmost', True)
+        if can_quit:
+            for blocker in self.blockers:
+                blocker.destroy()
+            self.window.quit()
+            self.closed = True
+
+    def handle_control_c(self, event):
+        self.interrupt()
+        self.interrupted = False
 
     def handle_keypress(self, event):
         self.clear_completions()
@@ -265,8 +325,27 @@ class TkTerm:
             return
         keysym = event.keysym
         if keysym == 'Left':
-            # Don't go past the prompt
-            if self.text.compare(Tk_.INSERT, '<', 'output_end+1c'):
+            # Don't go into the prompt or continuation prompt
+            line, pos = map(int, self.text.index(Tk_.INSERT).split('.'))
+            if pos <= self._prompt_size:
+                prompt_line = int(self.text.index('output_end').split('.')[0])
+                insert_line = int(self.text.index(Tk_.INSERT).split('.')[0])
+                if line > prompt_line:
+                    self.text.mark_set(Tk_.INSERT, '%s.0-1c' % insert_line)
+                else:
+                    self.window.bell()
+                return 'break'
+            return
+        if keysym == 'Right':
+            # Don't go into a continuation prompt or past the end
+            insert_pos = int(self.text.index('%s+1c' % Tk_.INSERT).split('.')[1])
+            if insert_pos < self._prompt_size:
+                insert_line = int(self.text.index(Tk_.INSERT).split('.')[0])
+                if self.text.compare(Tk_.INSERT, '>=', '%s-2c' % Tk_.END):
+                    self.window.bell()
+                else:
+                    self.text.mark_set(Tk_.INSERT, '%d.%d' % (
+                        insert_line + 1, self._prompt_size))
                 return 'break'
             return
         # Check for a control character
@@ -307,59 +386,62 @@ class TkTerm:
         if self.editing_hist and self.multiline:
             self.text.tag_add('history', 'output_end', Tk_.INSERT)
 
-    def handle_return(self, event):
+    def handle_return(self, event=None):
+        # If the input consists of one complete line of code we run it,
+        # regardless of where the insert cursor is located.  Otherwise we only
+        # run the code if the cursor is at the end of the input
         self.clear_completions()
-        line = self.text.get('output_end', Tk_.END)
-        if self.editing_hist:
-            insert = self.text.index(Tk_.INSERT)
-            newline = self.text.index('output_end')
-            tail = self.text.get('%s.0'%insert.split('.')[0], Tk_.END)
-            if tail.strip() != '':
-                    return
-            prompt_size = self.text.index('output_end-1c').split('.')[1]
-            first = self.text.index('output_end').split('.')[0]
-            last = self.text.index(Tk_.END).split('.')[0]
-            prompt = self._continuation_prompt(int(prompt_size)).pop()
-            for line_number in range(int(first) + 1, int(last) - 1):
-                self.write(prompt[1], style=prompt[0], advance=False,
-                           mark='%s.0'%line_number)
-            self.text.delete(newline+'-1c', newline)
-        else:
-            self.text.insert(Tk_.END, '\n')
-        self.text.tag_add('output', 'output_end', Tk_.END)
-        self.text.mark_set('output_end', Tk_.END)
-        if not self.running_code:
-            self.send_code(line)
+        if self.running_code:
+            return 'break'
+        cursor = int(self.text.index(Tk_.INSERT).split('.')[0])
+        last = int(self.text.index(Tk_.END).split('.')[0])
+        first = int(self.text.index('output_end').split('.')[0])
+        if cursor == first == last - 1:  # single line input
+            self.text.mark_set(Tk_.INSERT, Tk_.END)
+        self.text.insert(Tk_.INSERT, '\n')
+        cell = self.text.get('output_end', Tk_.INSERT)
+        try:
+            self.interact_handle_input(cell)
+        except KeyboardInterrupt:
+            self.write('(IP) Keyboard Interrupt: ')
+            self.reset()
+            self.hist_pointer = 0
+            self.hist_stem = ''
+        self.interact_prompt()
+        self.text.see(Tk_.INSERT)
+        if self.IP.more:
+            self.text.insert(Tk_.INSERT, ' '*self._current_indent, ())
+        self.hist_pointer = 0
+        self.hist_stem = ''
         return 'break'
 
     def handle_shift_return(self, event):
-        if self.editing_hist or self.hist_pointer == 0:
-            return 'break'
-        l1, c1 = map(int, self.text.index('output_end').split('.'))
-        l2, c2 = map(int, self.text.index(Tk_.INSERT).split('.'))
-        index = '%d.%d'%(l1 + 1, c2 - c1)
-        self.text.delete('output_end', Tk_.END)
-        self.write_history(force_multiline=True)
-        self.text.mark_set(Tk_.INSERT, index)
+        self.text.mark_set(Tk_.INSERT, Tk_.END)
+        return self.handle_return()
 
-    def handle_up(self, event):
+    def jump_up(self, event):
+        return self.handle_up(event, jump=True)
+
+    def handle_up(self, event, jump=False):
         if self.text.compare(Tk_.INSERT, '<', 'output_end'):
             return
-        insert_line = str(self.text.index(Tk_.INSERT)).split('.')[0]
-        prompt_line = str(self.text.index('output_end')).split('.')[0]
-        if insert_line != prompt_line:
+        insert_line_number = str(self.text.index(Tk_.INSERT)).split('.')[0]
+        prompt_line_number = str(self.text.index('output_end')).split('.')[0]
+        if insert_line_number != prompt_line_number:
             return
         if self.hist_pointer == 0:
             input_history = self.IP.history_manager.input_hist_raw
             self.hist_stem = self.text.get('output_end', Tk_.END).strip()
             self.filtered_hist = [x for x in input_history
-                                  if x.startswith(self.hist_stem)]
+                                  if x and x.startswith(self.hist_stem)]
         if self.hist_pointer >= len(self.filtered_hist):
             self.window.bell()
             return 'break'
         self.text.delete('output_end', Tk_.END)
         self.hist_pointer += 1
         self.write_history()
+        if jump:
+            self.text.mark_set(Tk_.INSERT, 'output_end')
         return 'break'
 
     def handle_down(self, event):
@@ -368,11 +450,10 @@ class TkTerm:
         if self.editing_hist:
             insert_line = int(str(self.text.index(Tk_.INSERT)).split('.')[0])
             bottom_line = int(str(self.text.index('history_end')).split('.')[0])
-            if insert_line < bottom_line - 1:
+            if insert_line < bottom_line:
                 return
         if self.hist_pointer == 0:
-            self.window.bell()
-            return 'break'
+            return
         self.text.delete('output_end', Tk_.END)
         self.hist_pointer -= 1
         if self.hist_pointer == 0:
@@ -388,6 +469,14 @@ class TkTerm:
         if self.text.compare(Tk_.INSERT, '<=', 'output_end'):
             self.window.bell()
             return 'break'
+        line, pos = map(int, self.text.index(Tk_.INSERT).split('.'))
+        first_line = int(self.text.index('output_end').split('.')[0])
+        if pos <= self._prompt_size + 1 and line != first_line:
+            start = '%d.end' % (line - 1)
+            end = '%d.end' % (line)
+            self.text.mark_set(Tk_.INSERT, start)
+            self.text.delete(start, '%s.%s' % (line, self._prompt_size))
+            return 'break'
         if self._current_indent >= 4:
             if self.text.get(Tk_.INSERT+'-4c', Tk_.INSERT) == '    ':
                 self.text.delete(Tk_.INSERT+'-4c', Tk_.INSERT)
@@ -404,23 +493,35 @@ class TkTerm:
         line = self.text.get('output_end', self.tab_index).strip('\n')
         word = delims.split(line)[-1]
         try:
-            completions = self.IP.complete(word)[1]
+            stem, completions = self.IP.complete(word)
         except TypeError:
             completions = []
         if word.find('_') == -1:
             completions = [x for x in completions
                            if x.find('__') == -1 and x.find('._') == -1]
-        if len(completions) == 0:
+        # No meaningful completions.  Ring the bell.
+        if len(completions) == 0 or len(completions) == 1 and completions[0] == stem:
             self.window.bell()
             self.tab_count = 0
             return 'break'
-        stem = self.stem(completions)
-        if len(stem) > len(word):
-            self.do_completion(word, stem)
-        elif len(completions) > 60 and self.tab_count == 1:
-            self.show_completions(['%s possibilities -- hit tab again to view them all'%len(completions)])
+        # Only one completion.  Use it.
+        if len(completions) == 1:
+            self.do_completion(stem, completions[0])
+            self.tab_count = 0
+            return 'break'
+        max_stem = self.max_stem(stem, completions)
+        # Add the maximal stem of all completions if it extends the word,
+        if len(max_stem) > len(word):
+            self.do_completion(stem, max_stem)
+            self.tab_count = 0
+            return 'break'
+        # Show the possible completions, with a warning if there are lots.
+        if len(completions) > 60 and self.tab_count == 1:
+            self.show_completions('', '',
+                ['%s possibilities -- hit tab again to view them all' %
+                len(completions)])
         else:
-            self.show_completions(completions)
+            self.show_completions(word, stem, completions)
             if len(completions) <= 60:
                 self.tab_count += 1
         return 'break'
@@ -429,24 +530,25 @@ class TkTerm:
         self.text.mark_set(Tk_.INSERT, 'output_end')
         return 'break'
 
-    def do_completion(self, word, completion):
-        tail = completion[len(word):]
+    def do_completion(self, stem, completion):
+        tail = completion[len(stem):]
         self.text.insert(self.tab_index, tail)
         self.tab_index = Tk_.END
         self.tab_count = 0
 
-    def show_completions(self, comps):
+    def show_completions(self, word, stem, comps):
+        n = len(stem)
+        comps = [word + c[n:] for c in comps]
         self.text.delete(self.tab_index, Tk_.END)
         width = self.text.winfo_width()
-        font = Font(self.text, self.text.cget('font'))
-        charwidth = width//self.char_size
+        charwidth = width // self.char_size
         biggest = 2 + max([len(x) for x in comps])
-        num_cols = charwidth//biggest
-        num_rows = (len(comps) + num_cols -1)//num_cols
+        num_cols = max(charwidth // biggest, 1)
+        num_rows = (len(comps) + num_cols - 1) // num_cols
         rows = []
-        format = '%%-%ds'%biggest
-        for n in range(0, num_rows):
-            rows.append(''.join([format%x for x in comps[n:len(comps):num_rows]]))
+        format = '%%-%ds' % biggest
+        for n in range(num_rows):
+            rows.append(''.join(format % x for x in comps[n:len(comps):num_rows]))
         view = '\n'.join(rows)
         self.text.insert(self.tab_index, '\n'+view)
         self.text.mark_set(Tk_.INSERT, self.tab_index)
@@ -458,33 +560,40 @@ class TkTerm:
             self.tab_index = None
             self.tab_count = 0
 
-    def stem(self, wordlist):
-        if len(wordlist) == 1:
-            return wordlist[0]
-        result = ''
-        for n in range(1,100):
-            heads = set(w[:n] for w in wordlist)
+    def max_stem(self, stem, completions):
+        if len(completions) == 1:
+            return completions[0]
+        result = stem
+        for n in range(len(stem) + 1, 100):
+            heads = {w[:n] for w in completions}
             if len(heads) > 1:
                 return result
             elif len(heads) == 1:
                 result = heads.pop()
-        return wordlist[0][:100]
+        return result
+
+    def write_continuation_prompt(self):
+        prompt_tokens = self._continuation_prompt(self._prompt_size)
+        for style, text in prompt_tokens:
+            self.write(text, style, mark=Tk_.INSERT, advance=True)
 
     def write_history(self, force_multiline=False):
         self.text.see('output_end')
         input = self.filtered_hist[-self.hist_pointer]
         input = re.sub('\n+', '\n', input).rstrip()
-        if input.find('\n') > 0 or force_multiline:
+        lines = input.split('\n')
+        if len(lines) > 1 or force_multiline:
             self.editing_hist = True
             self.multiline = True
-            # Add a newline to place the editing box below the prompt.
-            self.write('\n')
-            self.text.tag_config('history',
-                                 background='White')
-            self.text.tag_lower('history')
-            self.write(input + '\n\n', style=('history',), advance=False)
+            self.text.delete('output_end', Tk_.END)
+            self.write(lines[0] + '\n', mark=Tk_.INSERT, advance=True)
+            prompt_tokens = self._continuation_prompt(self._prompt_size)
+            for line in lines[1:-1]:
+                self.write_continuation_prompt()
+                self.write(line + '\n', mark=Tk_.INSERT)
+            self.write_continuation_prompt()
+            self.write(lines[-1], mark=Tk_.INSERT)
             self.text.mark_set('history_end', Tk_.INSERT)
-            self.text.mark_set(Tk_.INSERT, 'output_end')
         else:
             self.multiline = False
             self.write(input, style=(), advance=False)
@@ -605,33 +714,20 @@ class TkTerm:
 
     def start_interaction(self):
         """
-        Print the banner and issue the first prompt.
+        Display a banner and prepare to begin interaction.
         """
-        self.text.image_create(Tk_.END, image=self.icon)
-        banner_label = Tk_.Label(self.text, text=self.banner,
-                                 background='#ec0fffec0',
-                                 foreground='DarkGreen',
-                                 anchor=Tk_.W,
-                                 justify=Tk_.LEFT,
-                                 font=self.prefs['font'])
+        # Subclasses should override this method
+        banner_label = Tk_.Label(self.text,
+            text="Please override the start_interaction method.",
+            anchor=Tk_.W,
+            justify=Tk_.LEFT)
         self.text.window_create(Tk_.END, window=banner_label)
         self.text.insert(Tk_.END, '\n')
         self.text.mark_set('output_end', '2.0')
-         # Set a reasonable default directory for files to be saved to.
-        try:
-            home = os.environ['HOME']
-        except KeyError:
-            home = os.path.expanduser("~")
-        desktop = os.path.join(home, "Desktop")
-        default_save_dir = desktop if os.path.exists(desktop) else home
-        self.IP.magics_manager.magics['line']['cd']("-q " + default_save_dir)
-        # Create the prompt and go!
-        self.interact_prompt()
-        self.text.mark_set('output_end',Tk_.INSERT)
 
     def _input_prompt(self):
         result = [('Prompt', 'In['),
-                  ('PromptNum', '%d'%self.IP.execution_count),
+                  ('PromptNum', '%d' % self.IP.execution_count),
                   ('Prompt', ']: ')]
         self._prompt_size = sum(len(token[1]) for token in result)
         return result
@@ -642,57 +738,90 @@ class TkTerm:
 
     def interact_prompt(self):
         """
-        Print an input prompt or a continuation prompt.
+        Print an input prompt or a continuation prompt.  For an input
+        prompt set the output_end mark at the end of the prompt.
         """
         if self.showing_traceback:
             self.showing_traceback = False
             return
         try:
-            if self.IP.more:
-                prompt_tokens = self._continuation_prompt(self._prompt_size)
+            if self.IP.more or self.editing_hist:
+                self.write_continuation_prompt()
             else:
-                self.write(self.IP.separate_in)
+                if int(self.text.index('output_end').split('.')[1]) != 0:
+                    self.write('\n\n', mark='output_end')
                 prompt_tokens = self._input_prompt()
+                for style, text in prompt_tokens:
+                    self.write(text, style, mark='output_end')
         except:
             self.IP.showtraceback()
-        for style, text in prompt_tokens:
-            self.write(text, style)
-
-    def interact_handle_input(self, code, script=False):
-        transformer = self.IP.input_transformer_manager
-        assert code.endswith('\n')
-        code = re.sub('\n+', '\n', code).rstrip() + '\n'
-        self._input_buffer += code
-        status, indent = transformer.check_complete(self._input_buffer)
+
+    def clean_code(self, code):
+        """
+        Remove blank lines and continuation prompts.
+        """
+        if not code.strip():
+            return '\n'
+        lines = list(code.split('\n'))
+        clean_lines = [lines[0].lstrip()]
+        for line in lines[1:]:
+            try:
+                clean_lines.append(line.split(': ', 1)[1])
+            except IndexError:
+                pass
+        return '\n'.join(clean_lines)
+
+    def interact_handle_input(self, cell, script=False):
+        """
+        Validate the code in the cell.  If the code is valid but
+        incomplete, set the indent that should follow a continuation
+        prompt and set the 'more' flag.  If the code is valid and
+        complete then run the code.
+        """
+        assert cell.endswith('\n')
+        if not cell.strip():
+            self._current_indent = 0
+            return
         if script:
-            # We are running a script.  If adding a newline would make the
-            # buffer complete and the indent 0 then we want to run the code.
-            # So add the newline to force the buffer to be run.
-            Xstatus, Xindent = transformer.check_complete(self._input_buffer + '\n')
-            if Xstatus == 'complete' and Xindent is None:
-                self._input_buffer += '\n'
-                status, indent = Xstatus, Xindent
+            self._input_buffer += cell
+        else:
+            self._input_buffer = self.clean_code(cell)
+        transformed_cell = self.IP.transform_cell(self._input_buffer)
+        status, indent = self.IP.check_complete(transformed_cell)
+        self._current_indent = indent or 0
         if status == 'incomplete':
             self.IP.more = True
-            self._current_indent = indent or 0
             return
         if status == 'invalid':
             # Force display of the SyntaxError
+            self.text.mark_set(Tk_.INSERT, self.text.index('output_end-1line'))
             self.IP.run_cell(self._input_buffer, store_history=True)
+            self.text.insert('output_end-1line', '\n')
             self.reset()
+            self.text.delete('output_end', Tk_.END)
             return
-        # The code is complete, but we only run it if the indent level is 0 or
-        # if there is an empty line at the end.
-        if self._current_indent == 0 or self._input_buffer.endswith('\n\n'):
-            self.editing_hist = False
-            self.multiline = False
+        # The code is complete, but we only run it if the cursor is on the
+        # last line of the input and that line is blank.
+        insert_line = int(self.text.index(Tk_.INSERT).split('.')[0])
+        prompt_line = int(self.text.index('output_end').split('.')[0])
+        tail = self.text.get('%d.%d' % (insert_line, self._prompt_size), Tk_.END)
+        if not tail.strip():
             self.text.tag_delete('history')
             self._input_buffer = self._input_buffer.rstrip() + '\n'
-            if self._input_buffer.count('\n') > 1:
-                self.write('\n')
+            self.text.delete(Tk_.INSERT, Tk_.END)
+            self.text.insert(Tk_.INSERT, '\n')
+            self.text.mark_set('output_end', Tk_.INSERT)
+            self.multiline = False
             self.running_code = True
-            result = self.IP.run_cell(self._input_buffer, store_history=True)
+            self.editing_hist = False
+            last_line = insert_line - 1
+            if last_line > prompt_line:
+                # Delete the last continuation prompt.
+                self.text.delete('%d.0' % last_line, '%d.0 lineend' % last_line)
+            self.IP.run_cell(self._input_buffer, store_history=True)
+            # Add a newline after the output.
             self.write('\n')
+            self.text.tag_add('output', 'output_end', Tk_.END)
             self.reset()
         else:
             self.IP.more = True
@@ -706,29 +835,9 @@ class TkTerm:
         self.multiline = False
         self.running_code = False
         self.IP.more = False
-
         self.text.tag_delete('history')
         return result
 
-    def send_code(self, code):
-        """
-        Accumulate some lines of code and either issue a continuation
-        prompt or execute the code, print the result and issue a new
-        input prompt.
-        """
-        try:
-            self.interact_handle_input(code)
-        except KeyboardInterrupt:
-            self.write('(IP) Keyboard Interrupt: ')
-            self.reset()
-        self.interact_prompt()
-        self.text.see(Tk_.INSERT)
-        self.text.mark_set('output_end',Tk_.INSERT)
-        if self.IP.more:
-            self.text.insert(Tk_.INSERT, ' '*self._current_indent, ())
-        self.hist_pointer = 0
-        self.hist_stem = ''
-
     def write(self, string, style=('output',), advance=True,
               mark='output_end', see=True):
         """
@@ -738,10 +847,11 @@ class TkTerm:
         """
         if self.quiet:
             return
-        #if self.interrupted:
+        # if self.interrupted:
         #    self.interrupted = False
         #    raise KeyboardInterrupt('Writing')
-        self.text.mark_set(Tk_.INSERT, mark)
+        if mark != Tk_.INSERT:
+            self.text.mark_set(Tk_.INSERT, mark)
         pairs = ansi_seqs.findall(string)
         for pair in pairs:
             code, text = pair
@@ -754,13 +864,14 @@ class TkTerm:
         if see:
             self.text.see(Tk_.INSERT)
         # Give the Text widget a chance to update itself every
-        # so often (but let's not overdo it!)
+        # so often.  In order to force processing of key events
+        # we have to call the evil update method, unfortunately.
         if self.output_count > 2000:
             self.output_count = 0
-            self.text.update_idletasks()
+            self.text.update()
             if self.interrupted:
                 self.interrupted = False
-                self.interrupt()
+                raise KeyboardInterrupt('Halted')
 
     def write2(self, string):
         """
@@ -802,7 +913,6 @@ class TkTerm:
         # else:
         #     self.text.mark_set(Tk_.INSERT, '%s.0'%(insert_line + scroll_amount))
 
-
     def flush(self):
         """
         Required for a stdout / stderr proxy.