Merged Gael's ipython-sync-frontend branch with important mods.

This branch showed conflicts with recent changes I made to:

IPython.kernel.core.interpreter
IPython.kernel.core.tests.test_interpreter

I resolved these conflicts and closed a ticket that Gael fixed in his
branch.  BUT, there is a related ticket that I opened.  Furthermore,
Gael was using nose in test_interpreter, but we need to keep things in
IPython.kernel free of nose!

IPython/frontend/tests/test_linefrontend.py

@@ -0,0 +1,37 b''
+# encoding: utf-8
+"""
+Test the LineFrontEnd 
+"""
+
+__docformat__ = "restructuredtext en"
+
+#-------------------------------------------------------------------------------
+#  Copyright (C) 2008  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is
+#  in the file COPYING, distributed as part of this software.
+#-------------------------------------------------------------------------------
+
+from IPython.frontend.linefrontendbase import LineFrontEndBase
+from copy import deepcopy
+import nose.tools as nt
+
+class ConcreteLineFrontEnd(LineFrontEndBase):
+    """ A concrete class to test the LineFrontEndBase.
+    """
+    def capture_output(self):
+        pass
+
+    def release_output(self):
+        pass
+
+
+def test_is_complete():
+    """ Tests line completion heuristic.
+    """
+    frontend = ConcreteLineFrontEnd()
+    yield nt.assert_true, not frontend.is_complete('for x in \\')
+    yield nt.assert_true, not frontend.is_complete('for x in (1, ):')
+    yield nt.assert_true, frontend.is_complete('for x in (1, ):\n  pass')
+
+

IPython/frontend/linefrontendbase.py

@@ -18,10 +18,8 b' __docformat__ = "restructuredtext en"'
 #-------------------------------------------------------------------------------
 import re
 
-import IPython
 import sys
 import codeop
-import traceback
 
 from frontendbase import FrontEndBase
 from IPython.kernel.core.interpreter import Interpreter
@@ -58,6 +56,9 b' class LineFrontEndBase(FrontEndBase):'
     # programatic control of the frontend. 
     last_result = dict(number=0)
 
+    # The last prompt displayed. Useful for continuation prompts.
+    last_prompt = ''
+
     # The input buffer being edited
     input_buffer = ''
 
@@ -151,8 +152,12 b' class LineFrontEndBase(FrontEndBase):'
             self.capture_output()
             try:
                 # Add line returns here, to make sure that the statement is
-                # complete.
-                is_complete = codeop.compile_command(string.rstrip() + '\n\n',
+                # complete (except if '\' was used).
+                # This should probably be done in a different place (like
+                # maybe 'prefilter_input' method? For now, this works.
+                clean_string = string.rstrip('\n')
+                if not clean_string.endswith('\\'): clean_string +='\n\n' 
+                is_complete = codeop.compile_command(clean_string,
                             "<string>", "exec")
                 self.release_output()
             except Exception, e:
@@ -183,16 +188,6 b' class LineFrontEndBase(FrontEndBase):'
         # Create a false result, in case there is an exception
         self.last_result = dict(number=self.prompt_number)
 
-        ## try:
-        ##     self.history.input_cache[-1] = raw_string.rstrip()
-        ##     result = self.shell.execute(python_string)
-        ##     self.last_result = result
-        ##     self.render_result(result)
-        ## except:
-        ##     self.show_traceback()
-        ## finally:
-        ##     self.after_execute()
-
         try:
             try:
                 self.history.input_cache[-1] = raw_string.rstrip()
@@ -272,15 +267,15 b' class LineFrontEndBase(FrontEndBase):'
         symbols_per_line = max(1, chars_per_line/max_len)
 
         pos = 1
-        buf = []
+        completion_string = []
         for symbol in possibilities:
             if pos < symbols_per_line:
-                buf.append(symbol.ljust(max_len))
+                completion_string.append(symbol.ljust(max_len))
                 pos += 1
             else:
-                buf.append(symbol.rstrip() + '\n')
+                completion_string.append(symbol.rstrip() + '\n')
                 pos = 1
-        self.write(''.join(buf))
+        self.write(''.join(completion_string))
         self.new_prompt(self.input_prompt_template.substitute(
                             number=self.last_result['number'] + 1))
         self.input_buffer = new_line
@@ -297,26 +292,70 b' class LineFrontEndBase(FrontEndBase):'
         self.write(prompt)
 
 
+    def continuation_prompt(self):
+        """Returns the current continuation prompt.
+        """
+        return ("."*(len(self.last_prompt)-2) + ': ')
+ 
+
+    def execute_command(self, command, hidden=False):
+        """ Execute a command, not only in the model, but also in the
+            view, if any.
+        """
+        return self.shell.execute(command)
+
     #--------------------------------------------------------------------------
     # Private API
     #--------------------------------------------------------------------------
  
-    def _on_enter(self):
+    def _on_enter(self, new_line_pos=0):
         """ Called when the return key is pressed in a line editing
             buffer.
+
+            Parameters
+            ----------
+            new_line_pos : integer, optional
+                Position of the new line to add, starting from the
+                end (0 adds a new line after the last line, -1 before
+                the last line...)
+
+            Returns
+            -------
+            True if execution is triggered
         """
         current_buffer = self.input_buffer
-        cleaned_buffer = self.prefilter_input(current_buffer)
+        # XXX: This string replace is ugly, but there should be no way it
+        # fails.
+        prompt_less_buffer = re.sub('^' + self.continuation_prompt(),
+                '', current_buffer).replace('\n' + self.continuation_prompt(),
+                                            '\n')
+        cleaned_buffer = self.prefilter_input(prompt_less_buffer)
         if self.is_complete(cleaned_buffer):
             self.execute(cleaned_buffer, raw_string=current_buffer)
+            return True
         else:
-            self.input_buffer += self._get_indent_string(
-                                                current_buffer[:-1])
-            if len(current_buffer.split('\n')) == 2:
-                self.input_buffer += '\t\t'
-            if current_buffer[:-1].split('\n')[-1].rstrip().endswith(':'):
-                self.input_buffer += '\t'
-
+            # Start a new line.
+            new_line_pos = -new_line_pos
+            lines = current_buffer.split('\n')[:-1]
+            prompt_less_lines = prompt_less_buffer.split('\n')
+            # Create the new line, with the continuation prompt, and the 
+            # same amount of indent than the line above it.
+            new_line = self.continuation_prompt() + \
+                  self._get_indent_string('\n'.join(
+                                    prompt_less_lines[:new_line_pos-1]))
+            if len(lines) == 1:
+                # We are starting a first continuation line. Indent it.
+                new_line += '\t'
+            elif current_buffer[:-1].split('\n')[-1].rstrip().endswith(':'):
+                # The last line ends with ":", autoindent the new line.
+                new_line += '\t'
+
+            if new_line_pos == 0:
+                lines.append(new_line)
+            else:
+                lines.insert(new_line_pos, new_line)
+            self.input_buffer = '\n'.join(lines)
+            
 
     def _get_indent_string(self, string):
         """ Return the string of whitespace that prefixes a line. Used to

IPython/frontend/prefilterfrontend.py

@@ -22,9 +22,10 b' __docformat__ = "restructuredtext en"'
 # Imports
 #-------------------------------------------------------------------------------
 import sys
-
-from linefrontendbase import LineFrontEndBase, common_prefix
-from frontendbase import FrontEndBase
+import pydoc
+import os
+import re
+import __builtin__
 
 from IPython.ipmaker import make_IPython
 from IPython.ipapi import IPApi
@@ -33,9 +34,8 b' from IPython.kernel.core.redirector_output_trap import RedirectorOutputTrap'
 from IPython.kernel.core.sync_traceback_trap import SyncTracebackTrap
 
 from IPython.genutils import Term
-import pydoc
-import os
-import sys
+
+from linefrontendbase import LineFrontEndBase, common_prefix
 
 
 def mk_system_call(system_call_function, command):
@@ -45,6 +45,8 b' def mk_system_call(system_call_function, command):'
     """
     def my_system_call(args):
         system_call_function("%s %s" % (command, args))
+
+    my_system_call.__doc__ = "Calls %s" % command
     return my_system_call
 
 #-------------------------------------------------------------------------------
@@ -69,6 +71,13 b' class PrefilterFrontEnd(LineFrontEndBase):'
             ipython0: an optional ipython0 instance to use for command
             prefiltering and completion.
         """
+        # This is a hack to avoid the IPython exception hook to trigger
+        # on exceptions (https://bugs.launchpad.net/bugs/337105)
+        # XXX: This is horrible: module-leve monkey patching -> side
+        # effects.
+        from IPython import iplib
+        iplib.InteractiveShell.isthreaded = True
+
         LineFrontEndBase.__init__(self, *args, **kwargs)
         self.shell.output_trap = RedirectorOutputTrap(
                             out_callback=self.write,
@@ -83,10 +92,16 b' class PrefilterFrontEnd(LineFrontEndBase):'
         if ipython0 is None:
             # Instanciate an IPython0 interpreter to be able to use the
             # prefiltering.
+            # Suppress all key input, to avoid waiting
+            def my_rawinput(x=None):
+                return '\n'
+            old_rawinput = __builtin__.raw_input
+            __builtin__.raw_input = my_rawinput
             # XXX: argv=[] is a bit bold.
             ipython0 = make_IPython(argv=[], 
                                     user_ns=self.shell.user_ns,
                                     user_global_ns=self.shell.user_global_ns)
+            __builtin__.raw_input = old_rawinput
         self.ipython0 = ipython0
         # Set the pager:
         self.ipython0.set_hook('show_in_pager', 
@@ -98,16 +113,17 b' class PrefilterFrontEnd(LineFrontEndBase):'
         self._ip.system = self.system_call
         # XXX: Muck around with magics so that they work better
         # in our environment
-        self.ipython0.magic_ls = mk_system_call(self.system_call, 
-                                                            'ls -CF')
+        if not sys.platform.startswith('win'):
+            self.ipython0.magic_ls = mk_system_call(self.system_call, 
+                                                                'ls -CF')
         # And now clean up the mess created by ipython0
         self.release_output()
 
 
         if not 'banner' in kwargs and self.banner is None:
-            self.banner = self.ipython0.BANNER + """
-This is the wx frontend, by Gael Varoquaux. This is EXPERIMENTAL code."""
+            self.banner = self.ipython0.BANNER
 
+        # FIXME: __init__ and start should be two different steps
         self.start()
 
     #--------------------------------------------------------------------------
@@ -117,7 +133,10 b' This is the wx frontend, by Gael Varoquaux. This is EXPERIMENTAL code."""'
     def show_traceback(self):
         """ Use ipython0 to capture the last traceback and display it.
         """
-        self.capture_output()
+        # Don't do the capture; the except_hook has already done some
+        # modifications to the IO streams, if we store them, we'll be
+        # storing the wrong ones.
+        #self.capture_output()
         self.ipython0.showtraceback(tb_offset=-1)
         self.release_output()
 
@@ -171,7 +190,7 b' This is the wx frontend, by Gael Varoquaux. This is EXPERIMENTAL code."""'
     def complete(self, line):
         # FIXME: This should be factored out in the linefrontendbase
         # method.
-        word = line.split('\n')[-1].split(' ')[-1]
+        word = self._get_completion_text(line)
         completions = self.ipython0.complete(word)
         # FIXME: The proper sort should be done in the complete method.
         key = lambda x: x.replace('_', '')
@@ -244,3 +263,18 b' This is the wx frontend, by Gael Varoquaux. This is EXPERIMENTAL code."""'
         """
         self.ipython0.atexit_operations()
 
+
+    def _get_completion_text(self, line):
+        """ Returns the text to be completed by breaking the line at specified
+        delimiters.
+        """
+        # Break at: spaces, '=', all parentheses (except if balanced).
+        # FIXME2: In the future, we need to make the implementation similar to
+        # that in the 'pyreadline' module (modes/basemode.py) where we break at
+        # each delimiter and try to complete the residual line, until we get a
+        # successful list of completions.
+        expression = '\s|=|,|:|\((?!.*\))|\[(?!.*\])|\{(?!.*\})' 
+        complete_sep = re.compile(expression)
+        text = complete_sep.split(line)[-1]
+        return text
+

IPython/frontend/process/killableprocess.py

@@ -151,7 +151,12 b' else:'
             self._thread = ht
             self.pid = pid
 
-            winprocess.AssignProcessToJobObject(self._job, hp)
+            # XXX: A try/except to fix UAC-related problems under
+            # Windows Vista, when reparenting jobs.
+            try:
+                winprocess.AssignProcessToJobObject(self._job, hp)
+            except WindowsError:
+                pass
             winprocess.ResumeThread(ht)
 
             if p2cread is not None:

IPython/frontend/tests/test_prefilterfrontend.py

@@ -15,9 +15,27 b' __docformat__ = "restructuredtext en"'
 from cStringIO import StringIO
 import string
 
+from nose.tools import assert_equal
+
 from IPython.ipapi import get as get_ipython0
 from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
-from copy import deepcopy
+from copy import copy, deepcopy
+
+def safe_deepcopy(d):
+    """ Deep copy every key of the given dict, when possible. Elsewhere
+        do a copy.
+    """
+    copied_d = dict()
+    for key, value in d.iteritems():
+        try:
+            copied_d[key] = deepcopy(value)
+        except:
+            try:
+                copied_d[key] = copy(value)
+            except:
+                copied_d[key] = value
+    return copied_d
+
 
 class TestPrefilterFrontEnd(PrefilterFrontEnd):
     
@@ -26,16 +44,8 b' class TestPrefilterFrontEnd(PrefilterFrontEnd):'
     banner = ''
 
     def __init__(self):
-        ipython0 = get_ipython0().IP
         self.out = StringIO()
-        PrefilterFrontEnd.__init__(self, ipython0=ipython0)
-        # Clean up the namespace for isolation between tests
-        user_ns = self.ipython0.user_ns
-        # We need to keep references to things so that they don't
-        # get garbage collected (this stinks).
-        self.shadow_ns = dict()
-        for i in self.ipython0.magic_who_ls():
-            self.shadow_ns[i] = user_ns.pop(i)
+        PrefilterFrontEnd.__init__(self)
         # Some more code for isolation (yeah, crazy)
         self._on_enter()
         self.out.flush()
@@ -52,17 +62,31 b' class TestPrefilterFrontEnd(PrefilterFrontEnd):'
 
 def isolate_ipython0(func):
     """ Decorator to isolate execution that involves an iptyhon0.
+
+        Notes
+        ------
+
+        Apply only to functions with no arguments. Nose skips functions
+        with arguments.
     """
-    def my_func(*args, **kwargs):
-        ipython0 = get_ipython0().IP
-        user_ns = deepcopy(ipython0.user_ns)
-        global_ns = deepcopy(ipython0.global_ns)
+    def my_func():
+        iplib = get_ipython0()
+        if iplib is None:
+            return func()
+        ipython0 = iplib.IP
+        global_ns = safe_deepcopy(ipython0.user_global_ns)
+        user_ns = safe_deepcopy(ipython0.user_ns)
         try:
-            func(*args, **kwargs)
+            out = func()
         finally:
             ipython0.user_ns = user_ns
-            ipython0.global_ns = global_ns
+            ipython0.user_global_ns = global_ns
+        # Undo the hack at creation of PrefilterFrontEnd
+        from IPython import iplib
+        iplib.InteractiveShell.isthreaded = False
+        return out
 
+    my_func.__name__ = func.__name__
     return my_func
 
 
@@ -74,7 +98,7 b' def test_execution():'
     f.input_buffer = 'print 1'
     f._on_enter()
     out_value = f.out.getvalue()
-    assert out_value  == '1\n'
+    assert_equal(out_value, '1\n')
 
 
 @isolate_ipython0
@@ -87,20 +111,20 b' def test_multiline():'
     f.input_buffer += 'print 1'
     f._on_enter()
     out_value = f.out.getvalue()
-    assert out_value == ''
+    yield assert_equal, out_value, ''
     f._on_enter()
     out_value = f.out.getvalue()
-    assert out_value == '1\n'
+    yield assert_equal, out_value, '1\n'
     f = TestPrefilterFrontEnd()
     f.input_buffer='(1 +'
     f._on_enter()
     f.input_buffer += '0)'
     f._on_enter()
     out_value = f.out.getvalue()
-    assert out_value == ''
+    yield assert_equal, out_value, ''
     f._on_enter()
     out_value = f.out.getvalue()
-    assert out_value == '1\n'
+    yield assert_equal, out_value, '1\n'
 
 
 @isolate_ipython0
@@ -113,13 +137,13 b' def test_capture():'
             'import os; out=os.fdopen(1, "w"); out.write("1") ; out.flush()'
     f._on_enter()
     out_value = f.out.getvalue()
-    assert out_value == '1'
+    yield assert_equal, out_value, '1'
     f = TestPrefilterFrontEnd()
     f.input_buffer = \
             'import os; out=os.fdopen(2, "w"); out.write("1") ; out.flush()'
     f._on_enter()
     out_value = f.out.getvalue()
-    assert out_value == '1'
+    yield assert_equal, out_value, '1'
 
      
 @isolate_ipython0
@@ -132,7 +156,7 b' def test_magic():'
     f.input_buffer += '%who'
     f._on_enter()
     out_value = f.out.getvalue()
-    assert out_value == 'Interactive namespace is empty.\n'
+    assert_equal(out_value, 'Interactive namespace is empty.\n')
 
 
 @isolate_ipython0
@@ -156,8 +180,8 b' def test_help():'
 
 
 @isolate_ipython0
-def test_completion():
-    """ Test command-line completion.
+def test_completion_simple():
+    """ Test command-line completion on trivial examples.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'zzza = 1'
@@ -167,8 +191,47 b' def test_completion():'
     f.input_buffer = 'zz'
     f.complete_current_input()
     out_value = f.out.getvalue()
-    assert out_value == '\nzzza zzzb '
-    assert f.input_buffer == 'zzz'
+    yield assert_equal, out_value, '\nzzza zzzb '
+    yield assert_equal, f.input_buffer, 'zzz'
+
+
+@isolate_ipython0
+def test_completion_parenthesis():
+    """ Test command-line completion when a parenthesis is open.
+    """
+    f = TestPrefilterFrontEnd()
+    f.input_buffer = 'zzza = 1'
+    f._on_enter()
+    f.input_buffer = 'zzzb = 2'
+    f._on_enter()
+    f.input_buffer = 'map(zz'
+    f.complete_current_input()
+    out_value = f.out.getvalue()
+    yield assert_equal, out_value, '\nzzza zzzb '
+    yield assert_equal, f.input_buffer, 'map(zzz'
+
+
+@isolate_ipython0
+def test_completion_indexing():
+    """ Test command-line completion when indexing on objects.
+    """
+    f = TestPrefilterFrontEnd()
+    f.input_buffer = 'a = [0]'
+    f._on_enter()
+    f.input_buffer = 'a[0].'
+    f.complete_current_input()
+    assert_equal(f.input_buffer, 'a[0].__')
+
+
+@isolate_ipython0
+def test_completion_equal():
+    """ Test command-line completion when the delimiter is "=", not " ".
+    """
+    f = TestPrefilterFrontEnd()
+    f.input_buffer = 'a=1.'
+    f.complete_current_input()
+    assert_equal(f.input_buffer, 'a=1.__')
+
 
 
 if __name__ == '__main__':
@@ -177,4 +240,5 b" if __name__ == '__main__':"
     test_execution()
     test_multiline()
     test_capture()
-    test_completion()
+    test_completion_simple()
+    test_completion_complex()

IPython/frontend/tests/test_process.py

@@ -16,7 +16,7 b' from cStringIO import StringIO'
 from time import sleep
 import sys
 
-from IPython.frontend._process import PipedProcess
+from IPython.frontend.process import PipedProcess
 from IPython.testing import decorators as testdec
 
 

IPython/frontend/wx/console_widget.py

@@ -25,6 +25,8 b' import wx.stc as stc'
 from wx.py import editwindow
 import time
 import sys
+import string
+
 LINESEP = '\n'
 if sys.platform == 'win32':
     LINESEP = '\n\r'
@@ -33,20 +35,26 b' import re'
 
 # FIXME: Need to provide an API for non user-generated display on the
 # screen: this should not be editable by the user.
+#-------------------------------------------------------------------------------
+# Constants 
+#-------------------------------------------------------------------------------
+_COMPLETE_BUFFER_MARKER = 31
+_ERROR_MARKER = 30
+_INPUT_MARKER = 29
 
 _DEFAULT_SIZE = 10
 if sys.platform == 'darwin':
     _DEFAULT_SIZE = 12
 
 _DEFAULT_STYLE = {
-    'stdout'      : 'fore:#0000FF',
-    'stderr'      : 'fore:#007f00',
-    'trace'       : 'fore:#FF0000',
-
+    #background definition
     'default'     : 'size:%d' % _DEFAULT_SIZE,
     'bracegood'   : 'fore:#00AA00,back:#000000,bold',
     'bracebad'    : 'fore:#FF0000,back:#000000,bold',
 
+    # Edge column: a number of None
+    'edge_column' : -1,
+
     # properties for the various Python lexer styles
     'comment'       : 'fore:#007F00',
     'number'        : 'fore:#007F7F',
@@ -57,7 +65,24 b' _DEFAULT_STYLE = {'
     'tripledouble'  : 'fore:#7F0000',
     'class'         : 'fore:#0000FF,bold,underline',
     'def'           : 'fore:#007F7F,bold',
-    'operator'      : 'bold'
+    'operator'      : 'bold',
+
+    # Default colors
+    'trace'         : '#FAFAF1', # Nice green
+    'stdout'        : '#FDFFD3', # Nice yellow
+    'stderr'        : '#FFF1F1', # Nice red
+
+    # Default scintilla settings
+    'antialiasing'  : True,
+    'carret_color'  : 'BLACK',
+    'background_color' :'WHITE', 
+
+    #prompt definition
+    'prompt_in1'    : \
+        '\n\x01\x1b[0;34m\x02In [\x01\x1b[1;34m\x02$number\x01\x1b[0;34m\x02]: \x01\x1b[0m\x02',
+
+    'prompt_out': \
+        '\x01\x1b[0;31m\x02Out[\x01\x1b[1;31m\x02$number\x01\x1b[0;31m\x02]: \x01\x1b[0m\x02',
     }
 
 # new style numbers
@@ -69,6 +94,47 b' _TRACE_STYLE = 17'
 # system colors
 #SYS_COLOUR_BACKGROUND = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BACKGROUND)
 
+# Translation table from ANSI escape sequences to color. 
+ANSI_STYLES = {'0;30': [0, 'BLACK'],            '0;31': [1, 'RED'],
+               '0;32': [2, 'GREEN'],           '0;33': [3, 'BROWN'],
+               '0;34': [4, 'BLUE'],            '0;35': [5, 'PURPLE'],
+               '0;36': [6, 'CYAN'],            '0;37': [7, 'LIGHT GREY'],
+               '1;30': [8, 'DARK GREY'],       '1;31': [9, 'RED'],
+               '1;32': [10, 'SEA GREEN'],      '1;33': [11, 'YELLOW'],
+               '1;34': [12, 'LIGHT BLUE'],     '1;35': 
+                                                 [13, 'MEDIUM VIOLET RED'],
+               '1;36': [14, 'LIGHT STEEL BLUE'], '1;37': [15, 'YELLOW']}
+
+# XXX: Maybe one day we should factor this code with ColorANSI. Right now
+# ColorANSI is hard to reuse and makes our code more complex.
+
+#we define platform specific fonts
+if wx.Platform == '__WXMSW__':
+    FACES = { 'times': 'Times New Roman',
+                'mono' : 'Courier New',
+                'helv' : 'Arial',
+                'other': 'Comic Sans MS',
+                'size' : 10,
+                'size2': 8,
+                }
+elif wx.Platform == '__WXMAC__':
+    FACES = { 'times': 'Times New Roman',
+                'mono' : 'Monaco',
+                'helv' : 'Arial',
+                'other': 'Comic Sans MS',
+                'size' : 10,
+                'size2': 8,
+                }
+else:
+    FACES = { 'times': 'Times',
+                'mono' : 'Courier',
+                'helv' : 'Helvetica',
+                'other': 'new century schoolbook',
+                'size' : 10,
+                'size2': 8,
+                }
+ 
+
 #-------------------------------------------------------------------------------
 # The console widget class
 #-------------------------------------------------------------------------------
@@ -83,6 +149,9 b' class ConsoleWidget(editwindow.EditWindow):'
     # stored.
     title = 'Console'
 
+    # Last prompt printed
+    last_prompt = ''
+
     # The buffer being edited.
     def _set_input_buffer(self, string):
         self.SetSelection(self.current_prompt_pos, self.GetLength())
@@ -103,19 +172,11 b' class ConsoleWidget(editwindow.EditWindow):'
 
     # Translation table from ANSI escape sequences to color. Override
     # this to specify your colors.
-    ANSI_STYLES = {'0;30': [0, 'BLACK'],            '0;31': [1, 'RED'],
-                   '0;32': [2, 'GREEN'],            '0;33': [3, 'BROWN'],
-                   '0;34': [4, 'BLUE'],             '0;35': [5, 'PURPLE'],
-                   '0;36': [6, 'CYAN'],             '0;37': [7, 'LIGHT GREY'],
-                   '1;30': [8, 'DARK GREY'],        '1;31': [9, 'RED'],
-                   '1;32': [10, 'SEA GREEN'],       '1;33': [11, 'YELLOW'],
-                   '1;34': [12, 'LIGHT BLUE'],      '1;35':
-                                                     [13, 'MEDIUM VIOLET RED'],
-                   '1;36': [14, 'LIGHT STEEL BLUE'], '1;37': [15, 'YELLOW']}
-
-    # The color of the carret (call _apply_style() after setting)
-    carret_color = 'BLACK'
+    ANSI_STYLES = ANSI_STYLES.copy()
     
+    # Font faces
+    faces = FACES.copy()
+                 
     # Store the last time a refresh was done
     _last_refresh_time = 0
 
@@ -126,7 +187,11 b' class ConsoleWidget(editwindow.EditWindow):'
     def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, 
                         size=wx.DefaultSize, style=wx.WANTS_CHARS, ):
         editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
-        self._configure_scintilla()
+        self.configure_scintilla()
+        # Track if 'enter' key as ever been processed
+        # This variable will only be reallowed until key goes up
+        self.enter_catched = False 
+        self.current_prompt_pos = 0
 
         self.Bind(wx.EVT_KEY_DOWN, self._on_key_down)
         self.Bind(wx.EVT_KEY_UP, self._on_key_up)
@@ -193,8 +258,19 b' class ConsoleWidget(editwindow.EditWindow):'
         self.current_prompt_pos = self.GetLength()
         self.current_prompt_line = self.GetCurrentLine()
         self.EnsureCaretVisible()
+        self.last_prompt = prompt
 
 
+    def continuation_prompt(self):
+        """ Returns the current continuation prompt.
+            We need to implement this method here to deal with the
+            ascii escape sequences cleaning up.
+        """
+        # ASCII-less prompt
+        ascii_less = ''.join(self.color_pat.split(self.last_prompt)[2::2])
+        return "."*(len(ascii_less)-2) + ': '
+ 
+
     def scroll_to_bottom(self):
         maxrange = self.GetScrollRange(wx.VERTICAL)
         self.ScrollLines(maxrange)
@@ -216,37 +292,24 b' class ConsoleWidget(editwindow.EditWindow):'
         """
         return self.GetSize()[0]/self.GetCharWidth()
 
-    #--------------------------------------------------------------------------
-    # EditWindow API
-    #--------------------------------------------------------------------------
 
-    def OnUpdateUI(self, event):
-        """ Override the OnUpdateUI of the EditWindow class, to prevent 
-            syntax highlighting both for faster redraw, and for more
-            consistent look and feel.
+    def configure_scintilla(self):
+        """ Set up all the styling option of the embedded scintilla
+            widget.
         """
+        p = self.style.copy()
+        
+        # Marker for complete buffer.
+        self.MarkerDefine(_COMPLETE_BUFFER_MARKER, stc.STC_MARK_BACKGROUND,
+                                background=p['trace'])
 
-    #--------------------------------------------------------------------------
-    # Private API
-    #--------------------------------------------------------------------------
-    
-    def _apply_style(self):
-        """ Applies the colors for the different text elements and the
-            carret.
-        """
-        self.SetCaretForeground(self.carret_color)
-
-        #self.StyleClearAll()
-        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,  
-                          "fore:#FF0000,back:#0000FF,bold")
-        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,
-                          "fore:#000000,back:#FF0000,bold")
-
-        for style in self.ANSI_STYLES.values():
-            self.StyleSetSpec(style[0], "bold,fore:%s" % style[1])
+        # Marker for current input buffer.
+        self.MarkerDefine(_INPUT_MARKER, stc.STC_MARK_BACKGROUND,
+                                background=p['stdout'])
+        # Marker for tracebacks.
+        self.MarkerDefine(_ERROR_MARKER, stc.STC_MARK_BACKGROUND,
+                                background=p['stderr'])
 
-   
-    def _configure_scintilla(self):
         self.SetEOLMode(stc.STC_EOL_LF)
 
         # Ctrl"+" or Ctrl "-" can be used to zoomin/zoomout the text inside 
@@ -268,7 +331,9 b' class ConsoleWidget(editwindow.EditWindow):'
         self.SetWrapMode(stc.STC_WRAP_CHAR)
         self.SetWrapMode(stc.STC_WRAP_WORD)
         self.SetBufferedDraw(True)
-        self.SetUseAntiAliasing(True)
+
+        self.SetUseAntiAliasing(p['antialiasing'])
+
         self.SetLayoutCache(stc.STC_CACHE_PAGE)
         self.SetUndoCollection(False)
         self.SetUseTabs(True)
@@ -289,23 +354,48 b' class ConsoleWidget(editwindow.EditWindow):'
         self.SetMarginWidth(1, 0)
         self.SetMarginWidth(2, 0)
 
-        self._apply_style()
-
         # Xterm escape sequences
         self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
         self.title_pat = re.compile('\x1b]0;(.*?)\x07')
 
-        #self.SetEdgeMode(stc.STC_EDGE_LINE)
-        #self.SetEdgeColumn(80)
-
         # styles
-        p = self.style
-        self.StyleSetSpec(stc.STC_STYLE_DEFAULT, p['default'])
+        
+        self.SetCaretForeground(p['carret_color'])
+        
+        background_color = p['background_color']
+            
+        if 'default' in p:
+            if 'back' not in p['default']:
+                p['default'] += ',back:%s' % background_color
+            if 'size' not in p['default']:
+                p['default'] += ',size:%s' % self.faces['size']
+            if 'face' not in p['default']:
+                p['default'] += ',face:%s' % self.faces['mono']
+            
+            self.StyleSetSpec(stc.STC_STYLE_DEFAULT, p['default'])
+        else:
+            self.StyleSetSpec(stc.STC_STYLE_DEFAULT, 
+                            "fore:%s,back:%s,size:%d,face:%s" 
+                            % (self.ANSI_STYLES['0;30'][1], 
+                               background_color,
+                               self.faces['size'], self.faces['mono']))
+        
         self.StyleClearAll()
+        
+        # XXX: two lines below are usefull if not using the lexer        
+        #for style in self.ANSI_STYLES.values():
+        #    self.StyleSetSpec(style[0], "bold,fore:%s" % style[1])        
+
+        # prompt definition
+        self.prompt_in1 = p['prompt_in1']
+        self.prompt_out = p['prompt_out']
+
+        self.output_prompt_template = string.Template(self.prompt_out)
+        self.input_prompt_template = string.Template(self.prompt_in1)
+
         self.StyleSetSpec(_STDOUT_STYLE, p['stdout'])
         self.StyleSetSpec(_STDERR_STYLE, p['stderr'])
         self.StyleSetSpec(_TRACE_STYLE, p['trace'])
-
         self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT, p['bracegood'])
         self.StyleSetSpec(stc.STC_STYLE_BRACEBAD, p['bracebad'])
         self.StyleSetSpec(stc.STC_P_COMMENTLINE, p['comment'])
@@ -321,6 +411,28 b' class ConsoleWidget(editwindow.EditWindow):'
         self.StyleSetSpec(stc.STC_P_OPERATOR, p['operator'])
         self.StyleSetSpec(stc.STC_P_COMMENTBLOCK, p['comment'])
 
+        edge_column = p['edge_column']
+        if edge_column is not None and edge_column > 0:
+            #we add a vertical line to console widget
+            self.SetEdgeMode(stc.STC_EDGE_LINE)
+            self.SetEdgeColumn(edge_column)
+ 
+ 
+    #--------------------------------------------------------------------------
+    # EditWindow API
+    #--------------------------------------------------------------------------
+
+    def OnUpdateUI(self, event):
+        """ Override the OnUpdateUI of the EditWindow class, to prevent 
+            syntax highlighting both for faster redraw, and for more
+            consistent look and feel.
+        """
+
+       
+    #--------------------------------------------------------------------------
+    # Private API
+    #--------------------------------------------------------------------------
+   
     def _on_key_down(self, event, skip=True):
         """ Key press callback used for correcting behavior for 
             console-like interfaces: the cursor is constraint to be after
@@ -329,6 +441,11 b' class ConsoleWidget(editwindow.EditWindow):'
             Return True if event as been catched.
         """
         catched = True
+        # XXX: Would the right way to do this be to have a
+        #  dictionary at the instance level associating keys with
+        #  callbacks? How would we deal with inheritance? And Do the
+        #  different callbacks share local variables?
+
         # Intercept some specific keys.
         if event.KeyCode == ord('L') and event.ControlDown() :
             self.scroll_to_bottom()
@@ -346,6 +463,10 b' class ConsoleWidget(editwindow.EditWindow):'
             self.ScrollPages(-1)
         elif event.KeyCode == wx.WXK_PAGEDOWN:
             self.ScrollPages(1)
+        elif event.KeyCode == wx.WXK_HOME:
+            self.GotoPos(self.GetLength())
+        elif event.KeyCode == wx.WXK_END:
+            self.GotoPos(self.GetLength())
         elif event.KeyCode == wx.WXK_UP and event.ShiftDown():
             self.ScrollLines(-1)
         elif event.KeyCode == wx.WXK_DOWN and event.ShiftDown():
@@ -357,16 +478,20 b' class ConsoleWidget(editwindow.EditWindow):'
             event.Skip()
         else:
             if event.KeyCode in (13, wx.WXK_NUMPAD_ENTER) and \
-                        event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN):
+                                event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN,
+                                                    wx.MOD_SHIFT):
                 catched = True
-                self.CallTipCancel()
-                self.write('\n', refresh=False)
-                # Under windows scintilla seems to be doing funny stuff to the 
-                # line returns here, but the getter for input_buffer filters 
-                # this out.
-                if sys.platform == 'win32':
-                    self.input_buffer = self.input_buffer
-                self._on_enter()
+                if not self.enter_catched:
+                    self.CallTipCancel()
+                    if event.Modifiers == wx.MOD_SHIFT:
+                        # Try to force execution
+                        self.GotoPos(self.GetLength())
+                        self.write('\n' + self.continuation_prompt(), 
+                                        refresh=False)
+                        self._on_enter()
+                    else:
+                        self._on_enter()
+                    self.enter_catched = True
 
             elif event.KeyCode == wx.WXK_HOME:
                 if event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN):
@@ -391,16 +516,28 b' class ConsoleWidget(editwindow.EditWindow):'
                 catched = True
 
             elif event.KeyCode in (wx.WXK_LEFT, wx.WXK_BACK):
-                if self.GetCurrentPos() > self.current_prompt_pos:
+                if not self._keep_cursor_in_buffer(self.GetCurrentPos() - 1):
+                    event.Skip()
+                catched = True
+
+            elif event.KeyCode == wx.WXK_RIGHT:
+                if not self._keep_cursor_in_buffer(self.GetCurrentPos() + 1):
+                    event.Skip()
+                catched = True
+
+
+            elif event.KeyCode == wx.WXK_DELETE:
+                if not self._keep_cursor_in_buffer(self.GetCurrentPos() - 1):
                     event.Skip()
                 catched = True
 
             if skip and not catched:
                 # Put the cursor back in the edit region
-                if self.GetCurrentPos() < self.current_prompt_pos:
-                    self.GotoPos(self.current_prompt_pos)
-                else:
-                    event.Skip()
+                if not self._keep_cursor_in_buffer():
+                    if not (self.GetCurrentPos() == self.GetLength()
+                                and event.KeyCode == wx.WXK_DELETE):
+                        event.Skip()
+                    catched = True
 
         return catched
 
@@ -408,17 +545,69 b' class ConsoleWidget(editwindow.EditWindow):'
     def _on_key_up(self, event, skip=True):
         """ If cursor is outside the editing region, put it back.
         """
-        event.Skip()
-        if self.GetCurrentPos() < self.current_prompt_pos:
-            self.GotoPos(self.current_prompt_pos)
+        if skip:
+            event.Skip()
+        self._keep_cursor_in_buffer()
+
+
+    # XXX:  I need to avoid the problem of having an empty glass;
+    def _keep_cursor_in_buffer(self, pos=None):
+        """ Checks if the cursor is where it is allowed to be. If not,
+            put it back.
 
+            Returns
+            -------
+            cursor_moved: Boolean
+                whether or not the cursor was moved by this routine.
+
+            Notes
+            ------
+                WARNING: This does proper checks only for horizontal
+                movements.
+        """
+        if pos is None:
+            current_pos = self.GetCurrentPos()
+        else:
+            current_pos = pos
+        if  current_pos < self.current_prompt_pos:
+            self.GotoPos(self.current_prompt_pos)
+            return True
+        line_num = self.LineFromPosition(current_pos)
+        if not current_pos > self.GetLength():
+            line_pos = self.GetColumn(current_pos)
+        else:
+            line_pos = self.GetColumn(self.GetLength())
+        line = self.GetLine(line_num)
+        # Jump the continuation prompt
+        continuation_prompt = self.continuation_prompt()
+        if ( line.startswith(continuation_prompt)
+                     and line_pos < len(continuation_prompt)):
+            if line_pos < 2:
+                # We are at the beginning of the line, trying to move
+                # forward: jump forward.
+                self.GotoPos(current_pos + 1 +
+                                    len(continuation_prompt) - line_pos)
+            else:
+                # Jump back up
+                self.GotoPos(self.GetLineEndPosition(line_num-1))
+            return True
+        elif ( current_pos > self.GetLineEndPosition(line_num) 
+                        and not current_pos == self.GetLength()): 
+            # Jump to next line
+            self.GotoPos(current_pos + 1 +
+                                    len(continuation_prompt))
+            return True
+
+        # We re-allow enter event processing
+        self.enter_catched = False 
+        return False
 
 
 if __name__ == '__main__':
     # Some simple code to test the console widget.
     class MainWindow(wx.Frame):
         def __init__(self, parent, id, title):
-            wx.Frame.__init__(self, parent, id, title, size=(300,250))
+            wx.Frame.__init__(self, parent, id, title, size=(300, 250))
             self._sizer = wx.BoxSizer(wx.VERTICAL)
             self.console_widget = ConsoleWidget(self)
             self._sizer.Add(self.console_widget, 1, wx.EXPAND)

IPython/frontend/wx/ipythonx.py

@@ -80,6 +80,15 b' class IPythonX(wx.Frame):'
         self.SetSizer(self._sizer)
         self.SetAutoLayout(1)
         self.Show(True)
+        wx.EVT_CLOSE(self, self.on_close)
+
+        
+    def on_close(self, event):
+        """ Called on closing the windows. 
+            
+            Stops the event loop, to close all the child windows.
+        """
+        wx.CallAfter(wx.Exit)
 
 
 def main():

IPython/frontend/wx/wx_frontend.py

@@ -25,38 +25,19 b' __docformat__ = "restructuredtext en"'
 # Major library imports
 import re
 import __builtin__
-from time import sleep
 import sys
 from threading import Lock
-import string
 
 import wx
 from wx import stc
 
 # Ipython-specific imports.
-from IPython.frontend._process import PipedProcess
-from console_widget import ConsoleWidget
+from IPython.frontend.process import PipedProcess
+from console_widget import ConsoleWidget, _COMPLETE_BUFFER_MARKER, \
+    _ERROR_MARKER, _INPUT_MARKER
 from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
 
 #-------------------------------------------------------------------------------
-# Constants 
-#-------------------------------------------------------------------------------
-
-_COMPLETE_BUFFER_BG = '#FAFAF1' # Nice green
-_INPUT_BUFFER_BG = '#FDFFD3' # Nice yellow
-_ERROR_BG = '#FFF1F1' # Nice red
-
-_COMPLETE_BUFFER_MARKER = 31
-_ERROR_MARKER = 30
-_INPUT_MARKER = 29
-
-prompt_in1 = \
-        '\n\x01\x1b[0;34m\x02In [\x01\x1b[1;34m\x02$number\x01\x1b[0;34m\x02]: \x01\x1b[0m\x02'
-
-prompt_out = \
-    '\x01\x1b[0;31m\x02Out[\x01\x1b[1;31m\x02$number\x01\x1b[0;31m\x02]: \x01\x1b[0m\x02'
-
-#-------------------------------------------------------------------------------
 # Classes to implement the Wx frontend
 #-------------------------------------------------------------------------------
 class WxController(ConsoleWidget, PrefilterFrontEnd):
@@ -66,11 +47,7 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
     This class inherits from ConsoleWidget, that provides a console-like
     widget to provide a text-rendering widget suitable for a terminal.
     """
-
-    output_prompt_template = string.Template(prompt_out)
-
-    input_prompt_template = string.Template(prompt_in1)
-
+    
     # Print debug info on what is happening to the console.
     debug = False
 
@@ -138,25 +115,24 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
     def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition,
                  size=wx.DefaultSize,
                  style=wx.CLIP_CHILDREN|wx.WANTS_CHARS,
+                 styledef=None,
                  *args, **kwds):
         """ Create Shell instance.
+
+            Parameters
+            -----------
+            styledef : dict, optional
+                styledef is the dictionary of options used to define the
+                style.
         """
+        if styledef is not None:
+            self.style = styledef
         ConsoleWidget.__init__(self, parent, id, pos, size, style)
         PrefilterFrontEnd.__init__(self, **kwds)
         
         # Stick in our own raw_input:
         self.ipython0.raw_input = self.raw_input
 
-        # Marker for complete buffer.
-        self.MarkerDefine(_COMPLETE_BUFFER_MARKER, stc.STC_MARK_BACKGROUND,
-                                background=_COMPLETE_BUFFER_BG)
-        # Marker for current input buffer.
-        self.MarkerDefine(_INPUT_MARKER, stc.STC_MARK_BACKGROUND,
-                                background=_INPUT_BUFFER_BG)
-        # Marker for tracebacks.
-        self.MarkerDefine(_ERROR_MARKER, stc.STC_MARK_BACKGROUND,
-                                background=_ERROR_BG)
-
         # A time for flushing the write buffer
         BUFFER_FLUSH_TIMER_ID = 100
         self._buffer_flush_timer = wx.Timer(self, BUFFER_FLUSH_TIMER_ID)
@@ -171,8 +147,7 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
             self.shell.user_ns['self'] = self
         # Inject our own raw_input in namespace
         self.shell.user_ns['raw_input'] = self.raw_input
-
-
+        
     def raw_input(self, prompt=''):
         """ A replacement from python's raw_input.
         """
@@ -251,11 +226,8 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
         if (self.AutoCompActive() and line and not line[-1] == '.') \
                     or create==True:
             suggestion, completions = self.complete(line)
-            offset=0
             if completions:
-                complete_sep =  re.compile('[\s\{\}\[\]\(\)\= ,:]')
-                residual = complete_sep.split(line)[-1]
-                offset = len(residual)
+                offset = len(self._get_completion_text(line))
                 self.pop_completion(completions, offset=offset)
                 if self.debug:
                     print >>sys.__stdout__, completions 
@@ -276,6 +248,14 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
                                         milliseconds=100, oneShot=True)
 
 
+    def clear_screen(self):
+        """ Empty completely the widget.
+        """
+        self.ClearAll()
+        self.new_prompt(self.input_prompt_template.substitute(
+                                number=(self.last_result['number'] + 1)))
+
+
     #--------------------------------------------------------------------------
     # LineFrontEnd interface 
     #--------------------------------------------------------------------------
@@ -299,6 +279,41 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
                                             raw_string=raw_string)
         wx.CallAfter(callback)
 
+
+    def execute_command(self, command, hidden=False):
+        """ Execute a command, not only in the model, but also in the
+            view.
+        """
+        # XXX: This method needs to be integrated in the base fronted
+        # interface
+        if hidden:
+            return self.shell.execute(command)
+        else:
+            # XXX: we are not storing the input buffer previous to the
+            # execution, as this forces us to run the execution
+            # input_buffer a yield, which is not good.
+            ##current_buffer = self.shell.control.input_buffer
+            command = command.rstrip()
+            if len(command.split('\n')) > 1:
+                # The input command is several lines long, we need to
+                # force the execution to happen
+                command += '\n'
+            cleaned_command = self.prefilter_input(command)
+            self.input_buffer = command
+            # Do not use wx.Yield() (aka GUI.process_events()) to avoid
+            # recursive yields.
+            self.ProcessEvent(wx.PaintEvent())
+            self.write('\n')
+            if not self.is_complete(cleaned_command + '\n'):
+                self._colorize_input_buffer()
+                self.render_error('Incomplete or invalid input')
+                self.new_prompt(self.input_prompt_template.substitute(
+                                number=(self.last_result['number'] + 1)))
+                return False
+            self._on_enter()
+            return True
+
+
     def save_output_hooks(self):    
         self.__old_raw_input = __builtin__.raw_input
         PrefilterFrontEnd.save_output_hooks(self)
@@ -356,10 +371,16 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
         self._markers[i] = self.MarkerAdd(i, _INPUT_MARKER)
 
 
+    def continuation_prompt(self, *args, **kwargs):
+        # Avoid multiple inheritence, be explicit about which
+        # parent method class gets called
+        return ConsoleWidget.continuation_prompt(self, *args, **kwargs)
+
+
     def write(self, *args, **kwargs):
         # Avoid multiple inheritence, be explicit about which
         # parent method class gets called
-        ConsoleWidget.write(self, *args, **kwargs)
+        return ConsoleWidget.write(self, *args, **kwargs)
 
 
     def _on_key_down(self, event, skip=True):
@@ -367,7 +388,7 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
             widget handle them, and put our logic afterward.
         """
         # FIXME: This method needs to be broken down in smaller ones.
-        current_line_number = self.GetCurrentLine()
+        current_line_num = self.GetCurrentLine()
         if event.KeyCode in (ord('c'), ord('C')) and event.ControlDown():
             # Capture Control-C
             if self._input_state == 'subprocess':
@@ -413,7 +434,7 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
         else:
             # Up history
             if event.KeyCode == wx.WXK_UP and (
-                    ( current_line_number == self.current_prompt_line and
+                    ( current_line_num == self.current_prompt_line and
                         event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN) ) 
                     or event.ControlDown() ):
                 new_buffer = self.get_history_previous(
@@ -425,7 +446,7 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
                         self.GotoPos(self.current_prompt_pos)
             # Down history
             elif event.KeyCode == wx.WXK_DOWN and (
-                    ( current_line_number == self.LineCount -1 and
+                    ( current_line_num == self.LineCount -1 and
                         event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN) ) 
                     or event.ControlDown() ):
                 new_buffer = self.get_history_next()
@@ -433,15 +454,43 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
                     self.input_buffer = new_buffer
             # Tab-completion
             elif event.KeyCode == ord('\t'):
-                current_line, current_line_number = self.CurLine
+                current_line, current_line_num = self.CurLine
                 if not re.match(r'^\s*$', current_line):
                     self.complete_current_input()
                     if self.AutoCompActive():
                         wx.CallAfter(self._popup_completion, create=True)
                 else:
                     event.Skip()
+            elif event.KeyCode == wx.WXK_BACK:
+                # If characters where erased, check if we have to
+                # remove a line.
+                # XXX: What about DEL?
+                # FIXME: This logics should be in ConsoleWidget, as it is
+                # independant of IPython
+                current_line, _ = self.CurLine
+                current_pos = self.GetCurrentPos()
+                current_line_num = self.LineFromPosition(current_pos)
+                current_col = self.GetColumn(current_pos)
+                len_prompt = len(self.continuation_prompt())
+                if ( current_line.startswith(self.continuation_prompt())
+                                            and current_col == len_prompt):
+                    new_lines = []
+                    for line_num, line in enumerate(
+                                    self.input_buffer.split('\n')):
+                        if (line_num + self.current_prompt_line ==
+                                            current_line_num):
+                            new_lines.append(line[len_prompt:])
+                        else:
+                            new_lines.append('\n'+line)
+                    # The first character is '\n', due to the above
+                    # code:
+                    self.input_buffer = ''.join(new_lines)[1:]
+                    self.GotoPos(current_pos - 1 - len_prompt)
+                else:
+                    ConsoleWidget._on_key_down(self, event, skip=skip)
             else:
                 ConsoleWidget._on_key_down(self, event, skip=skip)
+                        
 
 
     def _on_key_up(self, event, skip=True):
@@ -453,14 +502,40 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
             wx.CallAfter(self._popup_completion, create=True)
         else:
             ConsoleWidget._on_key_up(self, event, skip=skip)
+        # Make sure the continuation_prompts are always followed by a 
+        # whitespace
+        new_lines = []
+        if self._input_state == 'readline':
+            position = self.GetCurrentPos()
+            continuation_prompt = self.continuation_prompt()[:-1]
+            for line in self.input_buffer.split('\n'):
+                if not line == continuation_prompt:
+                    new_lines.append(line)
+            self.input_buffer = '\n'.join(new_lines)
+            self.GotoPos(position)
 
 
     def _on_enter(self):
         """ Called on return key down, in readline input_state.
         """
+        last_line_num = self.LineFromPosition(self.GetLength())
+        current_line_num = self.LineFromPosition(self.GetCurrentPos())
+        new_line_pos = (last_line_num - current_line_num)
         if self.debug:
             print >>sys.__stdout__, repr(self.input_buffer)
-        PrefilterFrontEnd._on_enter(self)
+        self.write('\n', refresh=False)
+        # Under windows scintilla seems to be doing funny
+        # stuff to the line returns here, but the getter for
+        # input_buffer filters this out.
+        if sys.platform == 'win32':
+            self.input_buffer = self.input_buffer
+        old_prompt_num = self.current_prompt_pos
+        has_executed = PrefilterFrontEnd._on_enter(self, 
+                                            new_line_pos=new_line_pos)
+        if old_prompt_num == self.current_prompt_pos:
+            # No execution has happened 
+            self.GotoPos(self.GetLineEndPosition(current_line_num + 1))
+        return has_executed
 
 
     #--------------------------------------------------------------------------

IPython/kernel/core/interpreter.py

@@ -710,8 +710,11 b' class Interpreter(object):'
         # None does the job nicely.
         linenos.append(None)
         
-        # This is causing problems with commands that have a \n embedded in
-        # a string, such as str("""a\nb""")
+        # Same problem at the other end: sometimes the ast tree has its
+        # first complete statement not starting on line 0. In this case
+        # we might miss part of it.  This fixes ticket 266993.  Thanks Gael!
+        linenos[0] = 0
+        
         lines = python.splitlines()
         
         # Create a list of atomic commands.

IPython/kernel/core/tests/test_interpreter.py

@@ -5,12 +5,12 b''
 __docformat__ = "restructuredtext en"
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team                           
+#  Copyright (C) 2008-2009  The IPython Development Team                           
 #                                                                             
 #  Distributed under the terms of the BSD License.  The full license is in    
 #  the file COPYING, distributed as part of this software.                    
 #-----------------------------------------------------------------------------
-                                                                              
+
 #-----------------------------------------------------------------------------
 # Imports                                                                     
 #-----------------------------------------------------------------------------
@@ -18,19 +18,44 b' __docformat__ = "restructuredtext en"'
 import unittest
 from IPython.kernel.core.interpreter import Interpreter
 
+#-----------------------------------------------------------------------------
+# Tests 
+#-----------------------------------------------------------------------------
+
 class TestInterpreter(unittest.TestCase):
-    
+
     def test_unicode(self):
-        """ Test unicode handling with the interpreter.
-        """
+        """ Test unicode handling with the interpreter."""
         i = Interpreter()
         i.execute_python(u'print "ù"')
         i.execute_python('print "ù"')
-    
+
     def test_ticket266993_1(self):
+        """ Test for ticket 266993."""
         i = Interpreter()
         i.execute('str("""a\nb""")')
 
-    def test_ticket266993_2(self):
+    def test_ticket364347(self):
+        """Test for ticket 364347."""
         i = Interpreter()
-        i.execute('str("a\nb")')
  No newline at end of file
+        i.split_commands('str("a\nb")')
+
+    def test_split_commands(self):
+        """ Test that commands are indeed individually split."""
+        i = Interpreter()
+        test_atoms = [('(1\n + 1)', ),
+                      ('1', '1', ),
+                      ]
+        for atoms in test_atoms:
+            atoms = [atom.rstrip() + '\n' for atom in atoms]
+            self.assertEquals(i.split_commands(''.join(atoms)),atoms)
+
+    def test_long_lines(self):
+        """ Test for spurious syntax error created by the interpreter."""
+        test_strings = [u'( 1 +\n 1\n )\n\n',
+                        u'(1 \n + 1\n )\n\n',
+                       ]
+        i = Interpreter()
+        for s in test_strings:
+            i.execute(s)
+

setupbase.py

@@ -109,7 +109,7 b' def find_packages():'
     add_package(packages, 'gui')
     add_package(packages, 'gui.wx')
     add_package(packages, 'frontend', tests=True)
-    add_package(packages, 'frontend._process')
+    add_package(packages, 'frontend.process')
     add_package(packages, 'frontend.wx')
     add_package(packages, 'frontend.cocoa', tests=True)
     add_package(packages, 'kernel', config=True, tests=True, scripts=True)