Add a banner.

IPython/frontend/linefrontendbase.py

@@ -1,286 +1,294 b''
 """
 Base front end class for all line-oriented frontends, rather than
 block-oriented.
 
 Currently this focuses on synchronous frontends.
 """
 __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.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 import re
 
 import IPython
 import sys
 
 from frontendbase import FrontEndBase
 from IPython.kernel.core.interpreter import Interpreter
 
 def common_prefix(strings):
     """ Given a list of strings, return the common prefix between all
         these strings.
     """
     ref = strings[0]
     prefix = ''
     for size in range(len(ref)):
         test_prefix = ref[:size+1]
         for string in strings[1:]:
             if not string.startswith(test_prefix):
                 return prefix
         prefix = test_prefix
 
     return prefix
 
 #-------------------------------------------------------------------------------
 # Base class for the line-oriented front ends
 #-------------------------------------------------------------------------------
 class LineFrontEndBase(FrontEndBase):
     """ Concrete implementation of the FrontEndBase class. This is meant
     to be the base class behind all the frontend that are line-oriented,
     rather than block-oriented.
     """
     
     # We need to keep the prompt number, to be able to increment
     # it when there is an exception.
     prompt_number = 1
 
     # We keep a reference to the last result: it helps testing and
     # programatic control of the frontend. 
     last_result = dict(number=0)
 
     # The input buffer being edited
     input_buffer = ''
 
     # Set to true for debug output
     debug = False
 
+    # A banner to print at startup
+    banner = None
+
     #--------------------------------------------------------------------------
     # FrontEndBase interface
     #--------------------------------------------------------------------------
 
-    def __init__(self, shell=None, history=None, *args, **kwargs):
+    def __init__(self, shell=None, history=None, banner=None, *args, **kwargs):
         if shell is None:
             shell = Interpreter()
         FrontEndBase.__init__(self, shell=shell, history=history)
-        
+
+        if banner is not None:
+            self.banner = banner
+        if self.banner is not None:
+            self.write(self.banner, refresh=False)
+
         self.new_prompt(self.input_prompt_template.substitute(number=1))
 
 
     def complete(self, line):
         """Complete line in engine's user_ns
         
         Parameters
         ----------
         line : string
         
         Result
         ------
         The replacement for the line and the list of possible completions.
         """
         completions = self.shell.complete(line)
         complete_sep =  re.compile('[\s\{\}\[\]\(\)\=]')
         if completions:
             prefix = common_prefix(completions) 
             residual = complete_sep.split(line)[:-1]
             line = line[:-len(residual)] + prefix
         return line, completions 
  
 
     def render_result(self, result):
         """ Frontend-specific rendering of the result of a calculation
         that has been sent to an engine.
         """
         if 'stdout' in result and result['stdout']:
             self.write('\n' + result['stdout'])
         if 'display' in result and result['display']:
             self.write("%s%s\n" % ( 
                             self.output_prompt_template.substitute(
                                     number=result['number']),
                             result['display']['pprint']
                             ) )
        
 
     def render_error(self, failure):
         """ Frontend-specific rendering of error. 
         """
         self.write('\n\n'+str(failure)+'\n\n')
         return failure
 
 
     def is_complete(self, string):
         """ Check if a string forms a complete, executable set of
         commands.
 
         For the line-oriented frontend, multi-line code is not executed
         as soon as it is complete: the users has to enter two line
         returns.
         """
         if string in ('', '\n'):
             # Prefiltering, eg through ipython0, may return an empty
             # string although some operations have been accomplished. We
             # thus want to consider an empty string as a complete
             # statement.
             return True
         elif ( len(self.input_buffer.split('\n'))>2 
                         and not re.findall(r"\n[\t ]*\n[\t ]*$", string)):
             return False
         else:
             # Add line returns here, to make sure that the statement is
             # complete.
             return FrontEndBase.is_complete(self, string.rstrip() + '\n\n')
 
 
     def write(self, string, refresh=True):
         """ Write some characters to the display.
 
             Subclass should overide this method.
 
             The refresh keyword argument is used in frontends with an
             event loop, to choose whether the write should trigget an UI
             refresh, and thus be syncrhonous, or not.
         """
         print >>sys.__stderr__, string
 
 
     def execute(self, python_string, raw_string=None):
         """ Stores the raw_string in the history, and sends the
         python string to the interpreter.
         """
         if raw_string is None:
             raw_string = python_string
         # 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()
 
     #--------------------------------------------------------------------------
     # LineFrontEndBase interface
     #--------------------------------------------------------------------------
 
     def prefilter_input(self, string):
         """ Priflter the input to turn it in valid python.
         """
         string = string.replace('\r\n', '\n')
         string = string.replace('\t', 4*' ')
         # Clean the trailing whitespace
         string = '\n'.join(l.rstrip()  for l in string.split('\n'))
         return string
 
 
     def after_execute(self):
         """ All the operations required after an execution to put the
             terminal back in a shape where it is usable.
         """
         self.prompt_number += 1
         self.new_prompt(self.input_prompt_template.substitute(
                             number=(self.last_result['number'] + 1)))
         # Start a new empty history entry
         self._add_history(None, '')
         self.history_cursor = len(self.history.input_cache) - 1
 
 
     def complete_current_input(self):
         """ Do code completion on current line. 
         """
         if self.debug:
             print >>sys.__stdout__, "complete_current_input", 
         line = self.input_buffer
         new_line, completions = self.complete(line)
         if len(completions)>1:
             self.write_completion(completions)
         self.input_buffer = new_line
         if self.debug:
             print >>sys.__stdout__, completions 
 
 
     def get_line_width(self):
         """ Return the width of the line in characters.
         """
         return 80
 
 
     def write_completion(self, possibilities):
         """ Write the list of possible completions.
         """
         current_buffer = self.input_buffer
         
         self.write('\n')
         max_len = len(max(possibilities, key=len)) + 1
         
         # Now we check how much symbol we can put on a line...
         chars_per_line = self.get_line_width()
         symbols_per_line = max(1, chars_per_line/max_len)
 
         pos = 1
         buf = []
         for symbol in possibilities:
             if pos < symbols_per_line:
                 buf.append(symbol.ljust(max_len))
                 pos += 1
             else:
                 buf.append(symbol.rstrip() + '\n')
                 pos = 1
         self.write(''.join(buf))
         self.new_prompt(self.input_prompt_template.substitute(
                             number=self.last_result['number'] + 1))
         self.input_buffer = current_buffer
 
 
     def new_prompt(self, prompt):
         """ Prints a prompt and starts a new editing buffer. 
 
             Subclasses should use this method to make sure that the
             terminal is put in a state favorable for a new line
             input.
         """
         self.input_buffer = ''
         self.write(prompt)
 
 
     #--------------------------------------------------------------------------
     # Private API
     #--------------------------------------------------------------------------
  
     def _on_enter(self):
         """ Called when the return key is pressed in a line editing
             buffer.
         """
         current_buffer = self.input_buffer
         cleaned_buffer = self.prefilter_input(current_buffer)
         if self.is_complete(cleaned_buffer):
             self.execute(cleaned_buffer, raw_string=current_buffer)
         else:
             self.input_buffer += self._get_indent_string(
                                                 current_buffer[:-1])
             if current_buffer[:-1].split('\n')[-1].rstrip().endswith(':'):
                 self.input_buffer += '\t'
 
 
     def _get_indent_string(self, string):
         """ Return the string of whitespace that prefixes a line. Used to
         add the right amount of indendation when creating a new line.
         """
         string = string.replace('\t', ' '*4)
         string = string.split('\n')[-1]
         indent_chars = len(string) - len(string.lstrip())
         indent_string = '\t'*(indent_chars // 4) + \
                             ' '*(indent_chars % 4)
 
         return indent_string
  
     

IPython/frontend/prefilterfrontend.py

@@ -1,203 +1,208 b''
 """
 Frontend class that uses IPython0 to prefilter the inputs.
 
 Using the IPython0 mechanism gives us access to the magics.
 
 This is a transitory class, used here to do the transition between
 ipython0 and ipython1. This class is meant to be short-lived as more
 functionnality is abstracted out of ipython0 in reusable functions and
 is added on the interpreter. This class can be a used to guide this
 refactoring.
 """
 __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.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 import sys
 
 from linefrontendbase import LineFrontEndBase, common_prefix
 
 from IPython.ipmaker import make_IPython
 from IPython.ipapi import IPApi
 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
 
 
 def mk_system_call(system_call_function, command):
     """ given a os.system replacement, and a leading string command,
         returns a function that will execute the command with the given
         argument string.
     """
     def my_system_call(args):
         system_call_function("%s %s" % (command, args))
     return my_system_call
 
 #-------------------------------------------------------------------------------
 # Frontend class using ipython0 to do the prefiltering. 
 #-------------------------------------------------------------------------------
 class PrefilterFrontEnd(LineFrontEndBase):
     """ Class that uses ipython0 to do prefilter the input, do the
     completion and the magics.
 
     The core trick is to use an ipython0 instance to prefilter the
     input, and share the namespace between the interpreter instance used
     to execute the statements and the ipython0 used for code
     completion...
     """
     
     def __init__(self, *args, **kwargs):
-        LineFrontEndBase.__init__(self, *args, **kwargs)
         self.save_output_hooks()
         # Instanciate an IPython0 interpreter to be able to use the
         # prefiltering.
         self.ipython0 = make_IPython()
         # Set the pager:
         self.ipython0.set_hook('show_in_pager', 
                     lambda s, string: self.write("\n"+string))
         self.ipython0.write = self.write
         self._ip = _ip = IPApi(self.ipython0)
-        # XXX: Hack: mix the two namespaces
-        self.shell.user_ns = self.ipython0.user_ns
-        self.shell.user_global_ns = self.ipython0.user_global_ns
         # Make sure the raw system call doesn't get called, as we don't
         # have a stdin accessible.
         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')
         # And now clean up the mess created by ipython0
         self.release_output()
+        if not 'banner' in kwargs:
+            kwargs['banner'] = self.ipython0.BANNER + """
+This is the wx frontend, by Gael Varoquaux. This is EXPERIMENTAL code."""
+
+        LineFrontEndBase.__init__(self, *args, **kwargs)
+        # XXX: Hack: mix the two namespaces
+        self.shell.user_ns = self.ipython0.user_ns
+        self.shell.user_global_ns = self.ipython0.user_global_ns
+
         self.shell.output_trap = RedirectorOutputTrap(
                             out_callback=self.write,
                             err_callback=self.write,
                                             )
         self.shell.traceback_trap = SyncTracebackTrap(
                         formatters=self.shell.traceback_trap.formatters,
                             )
 
     #--------------------------------------------------------------------------
     # FrontEndBase interface 
     #--------------------------------------------------------------------------
 
     def show_traceback(self):
         """ Use ipython0 to capture the last traceback and display it.
         """
         self.capture_output()
         self.ipython0.showtraceback()
         self.release_output()
 
 
     def execute(self, python_string, raw_string=None):
         self.capture_output()
         LineFrontEndBase.execute(self, python_string,
                                     raw_string=raw_string)
         self.release_output()
 
 
     def save_output_hooks(self):
         """ Store all the output hooks we can think of, to be able to
         restore them. 
         
         We need to do this early, as starting the ipython0 instance will
         screw ouput hooks.
         """
         self.__old_cout_write = Term.cout.write
         self.__old_cerr_write = Term.cerr.write
         self.__old_stdout = sys.stdout
         self.__old_stderr= sys.stderr
         self.__old_help_output = pydoc.help.output
         self.__old_display_hook = sys.displayhook
 
 
     def capture_output(self):
         """ Capture all the output mechanisms we can think of.
         """
         self.save_output_hooks()
         Term.cout.write = self.write
         Term.cerr.write = self.write
         sys.stdout = Term.cout
         sys.stderr = Term.cerr
         pydoc.help.output = self.shell.output_trap.out
 
 
     def release_output(self):
         """ Release all the different captures we have made.
         """
         Term.cout.write = self.__old_cout_write
         Term.cerr.write = self.__old_cerr_write
         sys.stdout = self.__old_stdout
         sys.stderr = self.__old_stderr
         pydoc.help.output = self.__old_help_output 
         sys.displayhook = self.__old_display_hook 
 
 
     def complete(self, line):
         word = line.split('\n')[-1].split(' ')[-1]
         completions = self.ipython0.complete(word)
         # FIXME: The proper sort should be done in the complete method.
         key = lambda x: x.replace('_', '')
         completions.sort(key=key)
         if completions:
             prefix = common_prefix(completions) 
             line = line[:-len(word)] + prefix
         return line, completions 
  
     
     #--------------------------------------------------------------------------
     # LineFrontEndBase interface 
     #--------------------------------------------------------------------------
 
     def prefilter_input(self, input_string):
         """ Using IPython0 to prefilter the commands to turn them
         in executable statements that are valid Python strings.
         """
         input_string = LineFrontEndBase.prefilter_input(self, input_string)
         filtered_lines = []
         # The IPython0 prefilters sometime produce output. We need to
         # capture it.
         self.capture_output()
         self.last_result = dict(number=self.prompt_number)
         try:
             for line in input_string.split('\n'):
                 filtered_lines.append(self.ipython0.prefilter(line, False))
         except:
             # XXX: probably not the right thing to do.
             self.ipython0.showsyntaxerror()
             self.after_execute()
         finally:
             self.release_output()
 
         filtered_string = '\n'.join(filtered_lines)
         return filtered_string
 
 
     #--------------------------------------------------------------------------
     # PrefilterFrontEnd interface 
     #--------------------------------------------------------------------------
  
     def system_call(self, command_string):
         """ Allows for frontend to define their own system call, to be
             able capture output and redirect input.
         """
         return os.system(command_string)
 
 
     def do_exit(self):
         """ Exit the shell, cleanup and save the history.
         """
         self.ipython0.atexit_operations()
 

IPython/frontend/wx/console_widget.py

@@ -1,408 +1,406 b''
 # encoding: utf-8
 """
 A Wx widget to act as a console and input commands.
 
 This widget deals with prompts and provides an edit buffer
 restricted to after the last prompt.
 """
 
 __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.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import wx
 import wx.stc  as  stc
 
 from wx.py import editwindow
 import sys
 LINESEP = '\n'
 if sys.platform == 'win32':
     LINESEP = '\n\r'
 
 import re
 
 # FIXME: Need to provide an API for non user-generated display on the
 # screen: this should not be editable by the user.
 
 _DEFAULT_SIZE = 10
 
 _DEFAULT_STYLE = {
     'stdout'      : 'fore:#0000FF',
     'stderr'      : 'fore:#007f00',
     'trace'       : 'fore:#FF0000',
 
     'default'     : 'size:%d' % _DEFAULT_SIZE,
     'bracegood'   : 'fore:#00AA00,back:#000000,bold',
     'bracebad'    : 'fore:#FF0000,back:#000000,bold',
 
     # properties for the various Python lexer styles
     'comment'       : 'fore:#007F00',
     'number'        : 'fore:#007F7F',
     'string'        : 'fore:#7F007F,italic',
     'char'          : 'fore:#7F007F,italic',
     'keyword'       : 'fore:#00007F,bold',
     'triple'        : 'fore:#7F0000',
     'tripledouble'  : 'fore:#7F0000',
     'class'         : 'fore:#0000FF,bold,underline',
     'def'           : 'fore:#007F7F,bold',
     'operator'      : 'bold'
     }
 
 # new style numbers
 _STDOUT_STYLE = 15
 _STDERR_STYLE = 16
 _TRACE_STYLE  = 17
 
 
 # system colors
 #SYS_COLOUR_BACKGROUND = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BACKGROUND)
 
 #-------------------------------------------------------------------------------
 # The console widget class
 #-------------------------------------------------------------------------------
 class ConsoleWidget(editwindow.EditWindow):
     """ Specialized styled text control view for console-like workflow.
 
         This widget is mainly interested in dealing with the prompt and
         keeping the cursor inside the editing line.
     """
 
     # This is where the title captured from the ANSI escape sequences are
     # stored.
     title = 'Console'
 
     # The buffer being edited.
     def _set_input_buffer(self, string):
         self.SetSelection(self.current_prompt_pos, self.GetLength())
         self.ReplaceSelection(string)
         self.GotoPos(self.GetLength())
 
     def _get_input_buffer(self):
         """ Returns the text in current edit buffer.
         """
         input_buffer = self.GetTextRange(self.current_prompt_pos,
                                                 self.GetLength())
         input_buffer = input_buffer.replace(LINESEP, '\n')
         return input_buffer
 
     input_buffer = property(_get_input_buffer, _set_input_buffer)
 
     style = _DEFAULT_STYLE.copy()
 
     # 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'
     
     #--------------------------------------------------------------------------
     # Public API
     #--------------------------------------------------------------------------
     
     def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, 
                         size=wx.DefaultSize, style=0, ):
         editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
         self._configure_scintilla()
 
         self.Bind(wx.EVT_KEY_DOWN, self._on_key_down)
         self.Bind(wx.EVT_KEY_UP, self._on_key_up)
     
 
     def write(self, text, refresh=True):
         """ Write given text to buffer, while translating the ansi escape
             sequences.
         """
         # XXX: do not put print statements to sys.stdout/sys.stderr in 
         # this method, the print statements will call this method, as 
         # you will end up with an infinit loop
         title = self.title_pat.split(text)
         if len(title)>1:
             self.title = title[-2]
 
         text = self.title_pat.sub('', text)
         segments = self.color_pat.split(text)
         segment = segments.pop(0)
         self.GotoPos(self.GetLength())
         self.StartStyling(self.GetLength(), 0xFF)
         try:
             self.AppendText(segment)
         except UnicodeDecodeError:
             # XXX: Do I really want to skip the exception?
             pass
         
         if segments:
             for ansi_tag, text in zip(segments[::2], segments[1::2]):
                 self.StartStyling(self.GetLength(), 0xFF)
                 try:
                     self.AppendText(text)
                 except UnicodeDecodeError:
                     # XXX: Do I really want to skip the exception?
                     pass
 
                 if ansi_tag not in self.ANSI_STYLES:
                     style = 0
                 else:
                     style = self.ANSI_STYLES[ansi_tag][0]
 
                 self.SetStyling(len(text), style) 
                 
         self.GotoPos(self.GetLength())
         if refresh:
             wx.Yield()
 
    
     def new_prompt(self, prompt):
         """ Prints a prompt at start of line, and move the start of the
             current block there.
 
             The prompt can be given with ascii escape sequences.
         """
-        self.write(prompt)
+        self.write(prompt, refresh=False)
         # now we update our cursor giving end of prompt
         self.current_prompt_pos = self.GetLength()
         self.current_prompt_line = self.GetCurrentLine()
         wx.Yield()
         self.EnsureCaretVisible()
 
 
     def scroll_to_bottom(self):
         maxrange = self.GetScrollRange(wx.VERTICAL)
         self.ScrollLines(maxrange)
 
 
     def pop_completion(self, possibilities, offset=0):
         """ Pops up an autocompletion menu. Offset is the offset
             in characters of the position at which the menu should
             appear, relativ to the cursor.
         """
         self.AutoCompSetIgnoreCase(False)
         self.AutoCompSetAutoHide(False)
         self.AutoCompSetMaxHeight(len(possibilities))
         self.AutoCompShow(offset, " ".join(possibilities))
 
 
     def get_line_width(self):
         """ Return the width of the line in characters.
         """
         return self.GetSize()[0]/self.GetCharWidth()
 
 
     #--------------------------------------------------------------------------
     # 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])
 
    
     def _configure_scintilla(self):
         self.SetEOLMode(stc.STC_EOL_LF)
 
         # Ctrl"+" or Ctrl "-" can be used to zoomin/zoomout the text inside 
         # the widget
         self.CmdKeyAssign(ord('+'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
         self.CmdKeyAssign(ord('-'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
         # Also allow Ctrl Shift "=" for poor non US keyboard users. 
         self.CmdKeyAssign(ord('='), stc.STC_SCMOD_CTRL|stc.STC_SCMOD_SHIFT, 
                                             stc.STC_CMD_ZOOMIN)
         
         # Keys: we need to clear some of the keys the that don't play
         # well with a console.
         self.CmdKeyClear(ord('D'), stc.STC_SCMOD_CTRL)
         self.CmdKeyClear(ord('L'), stc.STC_SCMOD_CTRL)
         self.CmdKeyClear(ord('T'), stc.STC_SCMOD_CTRL)
 
         self.SetEOLMode(stc.STC_EOL_CRLF)
         self.SetWrapMode(stc.STC_WRAP_CHAR)
         self.SetWrapMode(stc.STC_WRAP_WORD)
         self.SetBufferedDraw(True)
         self.SetUseAntiAliasing(True)
         self.SetLayoutCache(stc.STC_CACHE_PAGE)
         self.SetUndoCollection(False)
         self.SetUseTabs(True)
         self.SetIndent(4)
         self.SetTabWidth(4)
 
-        self.EnsureCaretVisible()
         # we don't want scintilla's autocompletion to choose 
         # automaticaly out of a single choice list, as we pop it up
         # automaticaly
         self.AutoCompSetChooseSingle(False)
         self.AutoCompSetMaxHeight(10)
         # XXX: this doesn't seem to have an effect.
         self.AutoCompSetFillUps('\n')
 
         self.SetMargins(3, 3) #text is moved away from border with 3px
         # Suppressing Scintilla margins
         self.SetMarginWidth(0, 0)
         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.StyleClearAll()
         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'])
         self.StyleSetSpec(stc.STC_P_NUMBER, p['number'])
         self.StyleSetSpec(stc.STC_P_STRING, p['string'])
         self.StyleSetSpec(stc.STC_P_CHARACTER, p['char'])
         self.StyleSetSpec(stc.STC_P_WORD, p['keyword'])
         self.StyleSetSpec(stc.STC_P_WORD2, p['keyword'])
         self.StyleSetSpec(stc.STC_P_TRIPLE, p['triple'])
         self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE, p['tripledouble'])
         self.StyleSetSpec(stc.STC_P_CLASSNAME, p['class'])
         self.StyleSetSpec(stc.STC_P_DEFNAME, p['def'])
         self.StyleSetSpec(stc.STC_P_OPERATOR, p['operator'])
         self.StyleSetSpec(stc.STC_P_COMMENTBLOCK, p['comment'])
 
-
     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
             the last prompt.
 
             Return True if event as been catched.
         """
         catched = True
         # Intercept some specific keys.
         if event.KeyCode == ord('L') and event.ControlDown() :
             self.scroll_to_bottom()
         elif event.KeyCode == ord('K') and event.ControlDown() :
             self.input_buffer = ''
         elif event.KeyCode == wx.WXK_PAGEUP:
             self.ScrollPages(-1)
         elif event.KeyCode == wx.WXK_PAGEDOWN:
             self.ScrollPages(1)
         elif event.KeyCode == wx.WXK_UP and event.ShiftDown():
             self.ScrollLines(-1)
         elif event.KeyCode == wx.WXK_DOWN and event.ShiftDown():
             self.ScrollLines(1)
         else:
             catched = False
 
         if self.AutoCompActive():
             event.Skip()
         else:
             if event.KeyCode in (13, wx.WXK_NUMPAD_ENTER) and \
                         event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN):
                 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()
 
             elif event.KeyCode == wx.WXK_HOME:
                 if event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN):
                     self.GotoPos(self.current_prompt_pos)
                     catched = True
 
                 elif event.Modifiers in  (wx.MOD_SHIFT, wx.MOD_WIN) :
                     # FIXME: This behavior is not ideal: if the selection
                     # is already started, it will jump.
                     self.SetSelectionStart(self.current_prompt_pos) 
                     self.SetSelectionEnd(self.GetCurrentPos())
                     catched = True
 
             elif event.KeyCode == wx.WXK_UP:
                 if self.GetCurrentLine() > self.current_prompt_line:
                     if self.GetCurrentLine() == self.current_prompt_line + 1 \
                             and self.GetColumn(self.GetCurrentPos()) < \
                                 self.GetColumn(self.current_prompt_pos):
                         self.GotoPos(self.current_prompt_pos)
                     else:
                         event.Skip()
                 catched = True
 
             elif event.KeyCode in (wx.WXK_LEFT, wx.WXK_BACK):
                 if self.GetCurrentPos() > self.current_prompt_pos:
                     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()
 
         return catched
 
 
     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 __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))
             self._sizer = wx.BoxSizer(wx.VERTICAL)
             self.console_widget = ConsoleWidget(self)
             self._sizer.Add(self.console_widget, 1, wx.EXPAND)
             self.SetSizer(self._sizer)
             self.SetAutoLayout(1)
             self.Show(True)
 
     app = wx.PySimpleApp()
     w = MainWindow(None, wx.ID_ANY, 'ConsoleWidget')
     w.SetSize((780, 460))
     w.Show()
 
     app.MainLoop()
 
 

IPython/frontend/wx/ipythonx.py

@@ -1,103 +1,107 b''
 """
 Entry point for a simple application giving a graphical frontend to
 ipython.
 """
 
 try:
     import wx
 except ImportError, e:
     e.message = """%s
 ________________________________________________________________________________
 You need wxPython to run this application.
 """ % e.message
     e.args = (e.message, ) + e.args[1:]
     raise e
 
 from wx_frontend import WxController
 import __builtin__
 
+
 class IPythonXController(WxController):
     """ Sub class of WxController that adds some application-specific
         bindings.
     """
 
     debug = False
 
     def __init__(self, *args, **kwargs):
         WxController.__init__(self, *args, **kwargs)
         self.ipython0.ask_exit = self.do_exit
+        # Scroll to top
+        maxrange = self.GetScrollRange(wx.VERTICAL)
+        self.ScrollLines(-maxrange)
 
 
     def _on_key_down(self, event, skip=True):
         # Intercept Ctrl-D to quit
         if event.KeyCode == ord('D') and event.ControlDown() and \
                 self.input_buffer == '' and \
                 self._input_state == 'readline':
             wx.CallAfter(self.ask_exit)
         else:
             WxController._on_key_down(self, event, skip=skip) 
 
 
     def ask_exit(self):
         """ Ask the user whether to exit.
         """
         self._input_state = 'subprocess'
         self.write('\n', refresh=False)
         self.capture_output()
         self.ipython0.shell.exit()
         self.release_output()
         if not self.ipython0.exit_now:
             wx.CallAfter(self.new_prompt,
                          self.input_prompt_template.substitute(
                                 number=self.last_result['number'] + 1))
  
 
     def do_exit(self):
         """ Exits the interpreter, kills the windows.
         """
         WxController.do_exit(self)
         self.release_output()
         wx.CallAfter(wx.Exit)
 
 
 
 class IPythonX(wx.Frame):
     """ Main frame of the IPythonX app.
     """
 
     def __init__(self, parent, id, title, debug=False):
         wx.Frame.__init__(self, parent, id, title, size=(300,250))
         self._sizer = wx.BoxSizer(wx.VERTICAL)
         self.shell = IPythonXController(self, debug=debug)
         self._sizer.Add(self.shell, 1, wx.EXPAND)
         self.SetSizer(self._sizer)
         self.SetAutoLayout(1)
         self.Show(True)
 
 
 def main():
     from optparse import OptionParser
     usage = """usage: %prog [options]
 
 Simple graphical frontend to IPython, using WxWidgets."""
     parser = OptionParser(usage=usage)
     parser.add_option("-d", "--debug",
                     action="store_true", dest="debug", default=False,
                     help="Enable debug message for the wx frontend.")
 
     options, args = parser.parse_args()
 
     # Clear the options, to avoid having the ipython0 instance complain
     import sys
     sys.argv = sys.argv[:1]
 
     app = wx.PySimpleApp()
     frame = IPythonX(None, wx.ID_ANY, 'IPythonX', debug=options.debug)
     frame.shell.SetFocus()
     frame.shell.app = app
     frame.SetSize((680, 460))
 
     app.MainLoop()
 
 if __name__ == '__main__':
     main()