BUG: Make the frontend compatible with wxPython 2.6

IPython/frontend/wx/console_widget.py

@@ -1,625 +1,624 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 time
 import sys
 import string
 
 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.
 #-------------------------------------------------------------------------------
 # Constants 
 #-------------------------------------------------------------------------------
 _COMPLETE_BUFFER_MARKER = 31
 _ERROR_MARKER = 30
 _INPUT_MARKER = 29
 
 _DEFAULT_SIZE = 10
 if sys.platform == 'darwin':
     _DEFAULT_SIZE = 12
 
 _DEFAULT_STYLE = {
     #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',
     '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',
 
     # 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
 _STDOUT_STYLE = 15
 _STDERR_STYLE = 16
 _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
 #-------------------------------------------------------------------------------
 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'
 
     # Last prompt printed
     last_prompt = ''
 
     # 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 = ANSI_STYLES.copy()
     
     # Font faces
     faces = FACES.copy()
                  
     # Store the last time a refresh was done
     _last_refresh_time = 0
 
     #--------------------------------------------------------------------------
     # Public API
     #--------------------------------------------------------------------------
     
     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()
         # 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)
     
 
     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:
             current_time = time.time()
             if current_time - self._last_refresh_time > 0.03:
                 if sys.platform == 'win32':
                     wx.SafeYield()
                 else:
                     wx.Yield()
                 #    self.ProcessEvent(wx.PaintEvent())
                 self._last_refresh_time = current_time 
 
    
     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, refresh=False)
         # now we update our cursor giving end of prompt
         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)
 
 
     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()
 
 
     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'])
 
         # 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'])
 
         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.CmdKeyClear(ord('A'), 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(p['antialiasing'])
 
         self.SetLayoutCache(stc.STC_CACHE_PAGE)
         self.SetUndoCollection(False)
         self.SetUseTabs(True)
         self.SetIndent(4)
         self.SetTabWidth(4)
 
         # 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)
 
         # Xterm escape sequences
         self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
         self.title_pat = re.compile('\x1b]0;(.*?)\x07')
 
         # styles
         
         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'])
         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'])
 
         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
             the last prompt.
 
             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() :
+        key_code = event.GetKeyCode()
+        if key_code == ord('L') and event.ControlDown() :
             self.scroll_to_bottom()
-        elif event.KeyCode == ord('K') and event.ControlDown() :
+        elif key_code == ord('K') and event.ControlDown() :
             self.input_buffer = ''
-        elif event.KeyCode == ord('A') and event.ControlDown() :
+        elif key_code == ord('A') and event.ControlDown() :
             self.GotoPos(self.GetLength())
             self.SetSelectionStart(self.current_prompt_pos)
             self.SetSelectionEnd(self.GetCurrentPos())
             catched = True
-        elif event.KeyCode == ord('E') and event.ControlDown() :
+        elif key_code == ord('E') and event.ControlDown() :
             self.GotoPos(self.GetLength())
             catched = True
-        elif event.KeyCode == wx.WXK_PAGEUP:
+        elif key_code == wx.WXK_PAGEUP:
             self.ScrollPages(-1)
-        elif event.KeyCode == wx.WXK_PAGEDOWN:
+        elif key_code == wx.WXK_PAGEDOWN:
             self.ScrollPages(1)
-        elif event.KeyCode == wx.WXK_HOME:
+        elif key_code == wx.WXK_HOME:
             self.GotoPos(self.GetLength())
-        elif event.KeyCode == wx.WXK_END:
+        elif key_code == wx.WXK_END:
             self.GotoPos(self.GetLength())
-        elif event.KeyCode == wx.WXK_UP and event.ShiftDown():
+        elif key_code == wx.WXK_UP and event.ShiftDown():
             self.ScrollLines(-1)
-        elif event.KeyCode == wx.WXK_DOWN and event.ShiftDown():
+        elif key_code == 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,
-                                                    wx.MOD_SHIFT):
+            if key_code in (13, wx.WXK_NUMPAD_ENTER):
+                # XXX: not catching modifiers, to be wx2.6-compatible
                 catched = True
                 if not self.enter_catched:
                     self.CallTipCancel()
-                    if event.Modifiers == wx.MOD_SHIFT:
+                    if event.ShiftDown():
                         # 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):
+            elif key_code == wx.WXK_HOME:
+                if not event.ShiftDown():
                     self.GotoPos(self.current_prompt_pos)
                     catched = True
-
-                elif event.Modifiers == wx.MOD_SHIFT:
+                else:
                     # 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:
+            elif key_code == 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):
+            elif key_code in (wx.WXK_LEFT, wx.WXK_BACK):
                 if not self._keep_cursor_in_buffer(self.GetCurrentPos() - 1):
                     event.Skip()
                 catched = True
 
-            elif event.KeyCode == wx.WXK_RIGHT:
+            elif key_code == wx.WXK_RIGHT:
                 if not self._keep_cursor_in_buffer(self.GetCurrentPos() + 1):
                     event.Skip()
                 catched = True
 
 
-            elif event.KeyCode == wx.WXK_DELETE:
+            elif key_code == 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 not self._keep_cursor_in_buffer():
                     if not (self.GetCurrentPos() == self.GetLength()
-                                and event.KeyCode == wx.WXK_DELETE):
+                                and key_code == wx.WXK_DELETE):
                         event.Skip()
                     catched = True
 
         return catched
 
 
     def _on_key_up(self, event, skip=True):
         """ If cursor is outside the editing region, put it back.
         """
         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))
             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/wx_frontend.py

@@ -1,602 +1,602 b''
 # encoding: utf-8 -*- test-case-name:
 # FIXME: Need to add tests.
 # ipython1.frontend.wx.tests.test_wx_frontend -*-
 
 """Classes to provide a Wx frontend to the
 IPython.kernel.core.interpreter.
 
 This class inherits from ConsoleWidget, that provides a console-like
 widget to provide a text-rendering widget suitable for a terminal.
 """
 
 __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
 #-------------------------------------------------------------------------------
 
 # Major library imports
 import re
 import __builtin__
 import sys
 from threading import Lock
 
 import wx
 from wx import stc
 
 # Ipython-specific imports.
 from IPython.frontend.process import PipedProcess
 from console_widget import ConsoleWidget, _COMPLETE_BUFFER_MARKER, \
     _ERROR_MARKER, _INPUT_MARKER
 from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
 
 #-------------------------------------------------------------------------------
 # Classes to implement the Wx frontend
 #-------------------------------------------------------------------------------
 class WxController(ConsoleWidget, PrefilterFrontEnd):
     """Classes to provide a Wx frontend to the
     IPython.kernel.core.interpreter.
 
     This class inherits from ConsoleWidget, that provides a console-like
     widget to provide a text-rendering widget suitable for a terminal.
     """
     
     # Print debug info on what is happening to the console.
     debug = False
 
     # The title of the terminal, as captured through the ANSI escape
     # sequences.
     def _set_title(self, title):
             return self.Parent.SetTitle(title)
 
     def _get_title(self):
             return self.Parent.GetTitle()
 
     title = property(_get_title, _set_title)
 
 
     # The buffer being edited.
     # We are duplicating the definition here because of multiple
     # inheritence
     def _set_input_buffer(self, string):
         ConsoleWidget._set_input_buffer(self, string)
         self._colorize_input_buffer()
 
     def _get_input_buffer(self):
         """ Returns the text in current edit buffer.
         """
         return ConsoleWidget._get_input_buffer(self)
 
     input_buffer = property(_get_input_buffer, _set_input_buffer)
 
 
     #--------------------------------------------------------------------------
     # Private Attributes
     #--------------------------------------------------------------------------
 
     # A flag governing the behavior of the input. Can be:
     #
     #       'readline' for readline-like behavior with a prompt 
     #            and an edit buffer.
     #       'raw_input' similar to readline, but triggered by a raw-input
     #           call. Can be used by subclasses to act differently.
     #       'subprocess' for sending the raw input directly to a
     #           subprocess.
     #       'buffering' for buffering of the input, that will be used
     #           when the input state switches back to another state.
     _input_state = 'readline'
 
     # Attribute to store reference to the pipes of a subprocess, if we
     # are running any.
     _running_process = False
 
     # A queue for writing fast streams to the screen without flooding the
     # event loop
     _out_buffer = []
 
     # A lock to lock the _out_buffer to make sure we don't empty it
     # while it is being swapped
     _out_buffer_lock = Lock()
 
     # The different line markers used to higlight the prompts.
     _markers = dict()
 
     #--------------------------------------------------------------------------
     # Public API
     #--------------------------------------------------------------------------
  
     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
 
         # A time for flushing the write buffer
         BUFFER_FLUSH_TIMER_ID = 100
         self._buffer_flush_timer = wx.Timer(self, BUFFER_FLUSH_TIMER_ID)
         wx.EVT_TIMER(self, BUFFER_FLUSH_TIMER_ID, self._buffer_flush)
 
         if 'debug' in kwds:
             self.debug = kwds['debug']
             kwds.pop('debug')
 
         # Inject self in namespace, for debug
         if self.debug:
             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.
         """
         self.new_prompt(prompt)
         self._input_state = 'raw_input'
         if hasattr(self, '_cursor'):
             del self._cursor 
         self.SetCursor(wx.StockCursor(wx.CURSOR_CROSS))
         self.__old_on_enter = self._on_enter
         event_loop = wx.EventLoop()
         def my_on_enter():
             event_loop.Exit()
         self._on_enter = my_on_enter
         # XXX: Running a separate event_loop. Ugly.
         event_loop.Run() 
         self._on_enter = self.__old_on_enter
         self._input_state = 'buffering'
         self._cursor = wx.BusyCursor()
         return self.input_buffer.rstrip('\n')
 
 
     def system_call(self, command_string):
         self._input_state = 'subprocess'
         event_loop = wx.EventLoop()
         def _end_system_call():
             self._input_state = 'buffering'
             self._running_process = False
             event_loop.Exit()
 
         self._running_process = PipedProcess(command_string, 
                     out_callback=self.buffered_write,
                     end_callback = _end_system_call)
         self._running_process.start()
         # XXX: Running a separate event_loop. Ugly.
         event_loop.Run() 
         # Be sure to flush the buffer.
         self._buffer_flush(event=None)
 
 
     def do_calltip(self):
         """ Analyse current and displays useful calltip for it.
         """
         if self.debug:
             print >>sys.__stdout__, "do_calltip" 
         separators =  re.compile('[\s\{\}\[\]\(\)\= ,:]')
         symbol = self.input_buffer
         symbol_string = separators.split(symbol)[-1]
         base_symbol_string = symbol_string.split('.')[0]
         if base_symbol_string in self.shell.user_ns:
             symbol = self.shell.user_ns[base_symbol_string]
         elif base_symbol_string in self.shell.user_global_ns:
             symbol = self.shell.user_global_ns[base_symbol_string]
         elif base_symbol_string in __builtin__.__dict__:
             symbol = __builtin__.__dict__[base_symbol_string]
         else:
             return False
         try:
             for name in symbol_string.split('.')[1:] + ['__doc__']:
                 symbol = getattr(symbol, name)
             self.AutoCompCancel()
             # Check that the symbol can indeed be converted to a string:
             symbol += ''
             wx.CallAfter(self.CallTipShow, self.GetCurrentPos(), symbol)
         except:
             # The retrieve symbol couldn't be converted to a string
             pass
 
 
     def _popup_completion(self, create=False):
         """ Updates the popup completion menu if it exists. If create is 
             true, open the menu.
         """
         if self.debug:
             print >>sys.__stdout__, "_popup_completion" 
         line = self.input_buffer
         if (self.AutoCompActive() and line and not line[-1] == '.') \
                     or create==True:
             suggestion, completions = self.complete(line)
             if completions:
                 offset = len(self._get_completion_text(line))
                 self.pop_completion(completions, offset=offset)
                 if self.debug:
                     print >>sys.__stdout__, completions 
 
 
     def buffered_write(self, text):
         """ A write method for streams, that caches the stream in order
             to avoid flooding the event loop.
 
             This can be called outside of the main loop, in separate
             threads.
         """
         self._out_buffer_lock.acquire()
         self._out_buffer.append(text)
         self._out_buffer_lock.release()
         if not self._buffer_flush_timer.IsRunning():
             wx.CallAfter(self._buffer_flush_timer.Start, 
                                         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 
     #--------------------------------------------------------------------------
  
     def execute(self, python_string, raw_string=None):
         self._input_state = 'buffering'
         self.CallTipCancel()
         self._cursor = wx.BusyCursor()
         if raw_string is None:
             raw_string = python_string
         end_line = self.current_prompt_line \
                         + max(1,  len(raw_string.split('\n'))-1)
         for i in range(self.current_prompt_line, end_line):
             if i in self._markers:
                 self.MarkerDeleteHandle(self._markers[i])
             self._markers[i] = self.MarkerAdd(i, _COMPLETE_BUFFER_MARKER)
         # Use a callafter to update the display robustly under windows
         def callback():
             self.GotoPos(self.GetLength())
             PrefilterFrontEnd.execute(self, python_string, 
                                             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)
 
     def capture_output(self):
         self.SetLexer(stc.STC_LEX_NULL)
         PrefilterFrontEnd.capture_output(self)
         __builtin__.raw_input = self.raw_input
         
     
     def release_output(self):
         __builtin__.raw_input = self.__old_raw_input
         PrefilterFrontEnd.release_output(self)
         self.SetLexer(stc.STC_LEX_PYTHON)
 
 
     def after_execute(self):
         PrefilterFrontEnd.after_execute(self)
         # Clear the wait cursor
         if hasattr(self, '_cursor'):
             del self._cursor
         self.SetCursor(wx.StockCursor(wx.CURSOR_CHAR))
 
 
     def show_traceback(self):
         start_line = self.GetCurrentLine()
         PrefilterFrontEnd.show_traceback(self)
         self.ProcessEvent(wx.PaintEvent())
         #wx.Yield()
         for i in range(start_line, self.GetCurrentLine()):
             self._markers[i] = self.MarkerAdd(i, _ERROR_MARKER)
 
     
     #--------------------------------------------------------------------------
     # FrontEndBase interface 
     #--------------------------------------------------------------------------
     
     def render_error(self, e):
         start_line = self.GetCurrentLine()
         self.write('\n' + e + '\n')
         for i in range(start_line, self.GetCurrentLine()):
             self._markers[i] = self.MarkerAdd(i, _ERROR_MARKER)
 
 
     #--------------------------------------------------------------------------
     # ConsoleWidget interface 
     #--------------------------------------------------------------------------
 
     def new_prompt(self, prompt):
         """ Display a new prompt, and start a new input buffer.
         """
         self._input_state = 'readline'
         ConsoleWidget.new_prompt(self, prompt)
         i = self.current_prompt_line
         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
         return ConsoleWidget.write(self, *args, **kwargs)
 
 
     def _on_key_down(self, event, skip=True):
         """ Capture the character events, let the parent
             widget handle them, and put our logic afterward.
         """
         # FIXME: This method needs to be broken down in smaller ones.
         current_line_num = self.GetCurrentLine()
-        if event.KeyCode in (ord('c'), ord('C')) and event.ControlDown():
+        key_code = event.GetKeyCode()
+        if key_code in (ord('c'), ord('C')) and event.ControlDown():
             # Capture Control-C
             if self._input_state == 'subprocess':
                 if self.debug:
                     print >>sys.__stderr__, 'Killing running process'
                 if hasattr(self._running_process, 'process'):
                     self._running_process.process.kill()
             elif self._input_state == 'buffering':
                 if self.debug:
                     print >>sys.__stderr__, 'Raising KeyboardInterrupt'
                 raise KeyboardInterrupt
                 # XXX: We need to make really sure we
                 # get back to a prompt.
         elif self._input_state == 'subprocess' and (
-                ( event.KeyCode<256 and
-                        not event.ControlDown() )
+                ( key_code <256 and not event.ControlDown() )
                     or 
-                ( event.KeyCode in (ord('d'), ord('D')) and
+                ( key_code in (ord('d'), ord('D')) and
                   event.ControlDown())):
             #  We are running a process, we redirect keys.
             ConsoleWidget._on_key_down(self, event, skip=skip)
-            char = chr(event.KeyCode)
+            char = chr(key_code)
             # Deal with some inconsistency in wx keycodes:
             if char == '\r':
                 char = '\n'
             elif not event.ShiftDown():
                 char = char.lower()
-            if event.ControlDown() and event.KeyCode in (ord('d'), ord('D')):
+            if event.ControlDown() and key_code in (ord('d'), ord('D')):
                 char = '\04'
             self._running_process.process.stdin.write(char)
             self._running_process.process.stdin.flush()
-        elif event.KeyCode in (ord('('), 57, 53):
+        elif key_code in (ord('('), 57, 53):
             # Calltips
             event.Skip()
             self.do_calltip()
-        elif self.AutoCompActive() and not event.KeyCode == ord('\t'):
+        elif self.AutoCompActive() and not key_code == ord('\t'):
             event.Skip()
-            if event.KeyCode in (wx.WXK_BACK, wx.WXK_DELETE): 
+            if key_code in (wx.WXK_BACK, wx.WXK_DELETE): 
                 wx.CallAfter(self._popup_completion, create=True)
-            elif not event.KeyCode in (wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT,
+            elif not key_code in (wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT,
                             wx.WXK_RIGHT, wx.WXK_ESCAPE):
                 wx.CallAfter(self._popup_completion)
         else:
             # Up history
-            if event.KeyCode == wx.WXK_UP and (
-                    ( current_line_num == self.current_prompt_line and
-                        event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN) ) 
-                    or event.ControlDown() ):
+            if key_code == wx.WXK_UP and (
+                            event.ControlDown() or
+                            current_line_num == self.current_prompt_line
+                    ):
                 new_buffer = self.get_history_previous(
                                             self.input_buffer)
                 if new_buffer is not None:
                     self.input_buffer = new_buffer
                     if self.GetCurrentLine() > self.current_prompt_line:
                         # Go to first line, for seemless history up.
                         self.GotoPos(self.current_prompt_pos)
             # Down history
             elif event.KeyCode == wx.WXK_DOWN and (
-                    ( current_line_num == self.LineCount -1 and
-                        event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN) ) 
-                    or event.ControlDown() ):
+                            event.ControlDown() or
+                            current_line_num == self.LineCount -1
+                    ):
                 new_buffer = self.get_history_next()
                 if new_buffer is not None:
                     self.input_buffer = new_buffer
             # Tab-completion
             elif event.KeyCode == ord('\t'):
                 current_line, current_line_num = self.CurLine
                 if not re.match(r'^%s\s*$' % self.continuation_prompt(), 
                                                             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):
         """ Called when any key is released.
         """
         if event.KeyCode in (59, ord('.')):
             # Intercepting '.'
             event.Skip()
             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)
         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
 
 
     #--------------------------------------------------------------------------
     # 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.
         """
         if not self._input_state == 'readline':
             ConsoleWidget.OnUpdateUI(self, event)
 
     #--------------------------------------------------------------------------
     # Private API
     #--------------------------------------------------------------------------
  
     def _buffer_flush(self, event):
         """ Called by the timer to flush the write buffer.
             
             This is always called in the mainloop, by the wx timer.
         """
         self._out_buffer_lock.acquire()
         _out_buffer = self._out_buffer
         self._out_buffer = []
         self._out_buffer_lock.release()
         self.write(''.join(_out_buffer), refresh=False)
 
 
     def _colorize_input_buffer(self):
         """ Keep the input buffer lines at a bright color.
         """
         if not self._input_state in ('readline', 'raw_input'):
             return
         end_line = self.GetCurrentLine()
         if not sys.platform == 'win32':
             end_line += 1
         for i in range(self.current_prompt_line, end_line):
             if i in self._markers:
                 self.MarkerDeleteHandle(self._markers[i])
             self._markers[i] = self.MarkerAdd(i, _INPUT_MARKER)
 
 
 if __name__ == '__main__':
     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.shell = WxController(self)
             self._sizer.Add(self.shell, 1, wx.EXPAND)
             self.SetSizer(self._sizer)
             self.SetAutoLayout(1)
             self.Show(True)
 
     app = wx.PySimpleApp()
     frame = MainWindow(None, wx.ID_ANY, 'Ipython')
     frame.shell.SetFocus()
     frame.SetSize((680, 460))
     self = frame.shell
 
     app.MainLoop()