Changed tabs to whitespace in the wx frontend

(took me a while to figure this out, I couldn't even understand what the
blocks where supposed to be)

IPython/gui/wx/ipython_history.py

@@ -1,411 +1,411 b''
 #!/usr/bin/python
 # -*- coding: iso-8859-15 -*-
 import wx
 import wx.stc  as  stc
 import keyword
 
 #-----------------------------------------
 # History widget for IPython
 __version__ = 0.5
 __author__  = "Laurent Dufrechou"
 __email__   = "laurent.dufrechou _at_ gmail.com"
 __license__ = "BSD"
 #-----------------------------------------
 class IPythonHistoryPanel(wx.Panel):
 
     def __init__(self, parent,flt_empty=True,
                  flt_doc=True,flt_cmd=True,flt_magic=True):
         
         wx.Panel.__init__(self,parent,-1)
         #text_ctrl = wx.TextCtrl(self, -1, style=wx.TE_MULTILINE)
         text_ctrl = PythonSTC(self, -1)
         
         
         st_filt = wx.StaticText(self, -1, " Filter:")
 
         self.filter_empty = wx.CheckBox(self, -1, "Empty commands")
         self.filter_doc   = wx.CheckBox(self, -1, "?: Doc commands")
         self.filter_cmd   = wx.CheckBox(self, -1, "!: Sys commands")
         self.filter_magic = wx.CheckBox(self, -1, "%: Magic keys")
 
         self.filter_empty.SetValue(flt_empty)
         self.filter_doc.SetValue(flt_doc)
         self.filter_cmd.SetValue(flt_cmd)
         self.filter_magic.SetValue(flt_magic)
         
         sizer = wx.BoxSizer(wx.VERTICAL)
 
         sizer.Add(text_ctrl, 1, wx.EXPAND)
         sizer.AddMany( [(5,5),
                         st_filt,
                         (10,10),
                         self.filter_empty,
                         self.filter_doc,
                         self.filter_cmd,
                         self.filter_magic,
                         (10,10),
                         ])
         self.SetAutoLayout(True)
         sizer.Fit(self)
         sizer.SetSizeHints(self)
         self.SetSizer(sizer)
         self.text_ctrl=text_ctrl
         #text_ctrl.SetText(demoText + open('Main.py').read())
         text_ctrl.EmptyUndoBuffer()
         text_ctrl.Colourise(0, -1)
 
         # line numbers in the margin
         text_ctrl.SetMarginType(1, stc.STC_MARGIN_NUMBER)
         text_ctrl.SetMarginWidth(1, 15)
 
         
     def write(self,history_line):
         add = True
         if self.filter_empty.GetValue() == True and history_line == '':
             add = False
         if len(history_line)>0:
             if self.filter_doc.GetValue() == True and history_line[-1:] == '?':
                 add = False
             if self.filter_cmd.GetValue() == True and history_line[0] == '!':
                 add = False
             if self.filter_magic.GetValue() == True and history_line[0] == '%':
                 add = False
-	if add:
-        	self.text_ctrl.AppendText(history_line+'\n')
+        if add:
+                self.text_ctrl.AppendText(history_line+'\n')
 
 
 #----------------------------------------------------------------------
 # Font definition for Styled Text Control
 
 if wx.Platform == '__WXMSW__':
     faces = { 'times': 'Times New Roman',
               'mono' : 'Courier New',
               'helv' : 'Arial',
               'other': 'Comic Sans MS',
               'size' : 8,
               'size2': 6,
              }
 elif wx.Platform == '__WXMAC__':
     faces = { 'times': 'Times New Roman',
               'mono' : 'Monaco',
               'helv' : 'Arial',
               'other': 'Comic Sans MS',
               'size' : 8,
               'size2': 6,
              }
 else:
     faces = { 'times': 'Times',
               'mono' : 'Courier',
               'helv' : 'Helvetica',
               'other': 'new century schoolbook',
               'size' : 8,
               'size2': 6,
              }
 
 
 #----------------------------------------------------------------------
 
 class PythonSTC(stc.StyledTextCtrl):
 
     fold_symbols = 3
     
     def __init__(self, parent, ID,
                  pos=wx.DefaultPosition, size=wx.DefaultSize,
                  style=0):
         stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
         #self.CmdKeyAssign(ord('B'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
         #self.CmdKeyAssign(ord('N'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
 
         self.SetLexer(stc.STC_LEX_PYTHON)
         self.SetKeyWords(0, " ".join(keyword.kwlist))
 
         #self.SetProperty("fold", "1")
         #self.SetProperty("tab.timmy.whinge.level", "1")
         #self.SetMargins(0,0)
 
         #self.SetViewWhiteSpace(False)
         #self.SetBufferedDraw(False)
         #self.SetViewEOL(True)
         self.SetEOLMode(stc.STC_EOL_CRLF)
         #self.SetUseAntiAliasing(True)
         
         self.SetEdgeMode(stc.STC_EDGE_LINE)
         self.SetEdgeColumn(80)
         self.SetEdgeColour(wx.LIGHT_GREY)
         self.SetLayoutCache(stc.STC_CACHE_PAGE)
 
         # Setup a margin to hold fold markers
         #self.SetFoldFlags(16)  ###  WHAT IS THIS VALUE?  WHAT ARE THE OTHER FLAGS?  DOES IT MATTER?
         self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)
         self.SetMarginMask(2, stc.STC_MASK_FOLDERS)
         self.SetMarginSensitive(2, True)
         self.SetMarginWidth(2, 12)
 
         if self.fold_symbols == 0:
             # Arrow pointing right for contracted folders, arrow pointing down for expanded
             self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_ARROWDOWN, "black", "black")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_ARROW, "black", "black")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_EMPTY, "black", "black")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_EMPTY, "black", "black")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_EMPTY,     "white", "black")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_EMPTY,     "white", "black")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_EMPTY,     "white", "black")
             
         elif self.fold_symbols == 1:
             # Plus for contracted folders, minus for expanded
             self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_MINUS, "white", "black")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_PLUS,  "white", "black")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_EMPTY, "white", "black")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_EMPTY, "white", "black")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_EMPTY, "white", "black")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_EMPTY, "white", "black")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_EMPTY, "white", "black")
 
         elif self.fold_symbols == 2:
             # Like a flattened tree control using circular headers and curved joins
             self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_CIRCLEMINUS,          "white", "#404040")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_CIRCLEPLUS,           "white", "#404040")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_VLINE,                "white", "#404040")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_LCORNERCURVE,         "white", "#404040")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_CIRCLEPLUSCONNECTED,  "white", "#404040")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_CIRCLEMINUSCONNECTED, "white", "#404040")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNERCURVE,         "white", "#404040")
 
         elif self.fold_symbols == 3:
             # Like a flattened tree control using square headers
             self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_BOXMINUS,          "white", "#808080")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_BOXPLUS,           "white", "#808080")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_VLINE,             "white", "#808080")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_LCORNER,           "white", "#808080")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_BOXPLUSCONNECTED,  "white", "#808080")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_BOXMINUSCONNECTED, "white", "#808080")
             self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNER,           "white", "#808080")
 
 
         self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI)
         self.Bind(stc.EVT_STC_MARGINCLICK, self.OnMarginClick)
         self.Bind(wx.EVT_KEY_DOWN, self.OnKeyPressed)
 
         # Make some styles,  The lexer defines what each style is used for, we
         # just have to define what each style looks like.  This set is adapted from
         # Scintilla sample property files.
 
         # Global default styles for all languages
         self.StyleSetSpec(stc.STC_STYLE_DEFAULT,     "face:%(helv)s,size:%(size)d" % faces)
         self.StyleClearAll()  # Reset all to be like the default
 
         # Global default styles for all languages
         self.StyleSetSpec(stc.STC_STYLE_DEFAULT,     "face:%(helv)s,size:%(size)d" % faces)
         self.StyleSetSpec(stc.STC_STYLE_LINENUMBER,  "back:#C0C0C0,face:%(helv)s,size:%(size2)d" % faces)
         self.StyleSetSpec(stc.STC_STYLE_CONTROLCHAR, "face:%(other)s" % faces)
         self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,  "fore:#FFFFFF,back:#0000FF,bold")
         self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,    "fore:#000000,back:#FF0000,bold")
 
         # Python styles
         # Default 
         self.StyleSetSpec(stc.STC_P_DEFAULT, "fore:#000000,face:%(helv)s,size:%(size)d" % faces)
         # Comments
         self.StyleSetSpec(stc.STC_P_COMMENTLINE, "fore:#007F00,face:%(other)s,size:%(size)d" % faces)
         # Number
         self.StyleSetSpec(stc.STC_P_NUMBER, "fore:#007F7F,size:%(size)d" % faces)
         # String
         self.StyleSetSpec(stc.STC_P_STRING, "fore:#7F007F,face:%(helv)s,size:%(size)d" % faces)
         # Single quoted string
         self.StyleSetSpec(stc.STC_P_CHARACTER, "fore:#7F007F,face:%(helv)s,size:%(size)d" % faces)
         # Keyword
         self.StyleSetSpec(stc.STC_P_WORD, "fore:#00007F,bold,size:%(size)d" % faces)
         # Triple quotes
         self.StyleSetSpec(stc.STC_P_TRIPLE, "fore:#7F0000,size:%(size)d" % faces)
         # Triple double quotes
         self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE, "fore:#7F0000,size:%(size)d" % faces)
         # Class name definition
         self.StyleSetSpec(stc.STC_P_CLASSNAME, "fore:#0000FF,bold,underline,size:%(size)d" % faces)
         # Function or method name definition
         self.StyleSetSpec(stc.STC_P_DEFNAME, "fore:#007F7F,bold,size:%(size)d" % faces)
         # Operators
         self.StyleSetSpec(stc.STC_P_OPERATOR, "bold,size:%(size)d" % faces)
         # Identifiers
         self.StyleSetSpec(stc.STC_P_IDENTIFIER, "fore:#000000,face:%(helv)s,size:%(size)d" % faces)
         # Comment-blocks
         self.StyleSetSpec(stc.STC_P_COMMENTBLOCK, "fore:#7F7F7F,size:%(size)d" % faces)
         # End of line where string is not closed
         self.StyleSetSpec(stc.STC_P_STRINGEOL, "fore:#000000,face:%(mono)s,back:#E0C0E0,eol,size:%(size)d" % faces)
 
         self.SetCaretForeground("BLUE")
 
 
         # register some images for use in the AutoComplete box.
         #self.RegisterImage(1, images.getSmilesBitmap())
         #self.RegisterImage(2, 
         #    wx.ArtProvider.GetBitmap(wx.ART_NEW, size=(16,16)))
         #self.RegisterImage(3, 
         #    wx.ArtProvider.GetBitmap(wx.ART_COPY, size=(16,16)))
 
 
     def OnKeyPressed(self, event):
         if self.CallTipActive():
             self.CallTipCancel()
         key = event.GetKeyCode()
 
         if key == 32 and event.ControlDown():
             pos = self.GetCurrentPos()
 
             # Tips
             if event.ShiftDown():
                 self.CallTipSetBackground("yellow")
                 self.CallTipShow(pos, 'lots of of text: blah, blah, blah\n\n'
                                  'show some suff, maybe parameters..\n\n'
                                  'fubar(param1, param2)')
             # Code completion
             else:
                 #lst = []
                 #for x in range(50000):
                 #    lst.append('%05d' % x)
                 #st = " ".join(lst)
                 #print len(st)
                 #self.AutoCompShow(0, st)
 
                 kw = keyword.kwlist[:]
                 
                 kw.sort()  # Python sorts are case sensitive
                 self.AutoCompSetIgnoreCase(False)  # so this needs to match
 
                 # Images are specified with a appended "?type"
                 for i in range(len(kw)):
                     if kw[i] in keyword.kwlist:
                         kw[i] = kw[i]# + "?1"
 
                 self.AutoCompShow(0, " ".join(kw))
         else:
             event.Skip()
 
 
     def OnUpdateUI(self, evt):
         # check for matching braces
         braceAtCaret = -1
         braceOpposite = -1
         charBefore = None
         caretPos = self.GetCurrentPos()
 
         if caretPos > 0:
             charBefore = self.GetCharAt(caretPos - 1)
             styleBefore = self.GetStyleAt(caretPos - 1)
 
         # check before
         if charBefore and chr(charBefore) in "[]{}()" and styleBefore == stc.STC_P_OPERATOR:
             braceAtCaret = caretPos - 1
 
         # check after
         if braceAtCaret < 0:
             charAfter = self.GetCharAt(caretPos)
             styleAfter = self.GetStyleAt(caretPos)
 
             if charAfter and chr(charAfter) in "[]{}()" and styleAfter == stc.STC_P_OPERATOR:
                 braceAtCaret = caretPos
 
         if braceAtCaret >= 0:
             braceOpposite = self.BraceMatch(braceAtCaret)
 
         if braceAtCaret != -1  and braceOpposite == -1:
             self.BraceBadLight(braceAtCaret)
         else:
             self.BraceHighlight(braceAtCaret, braceOpposite)
             #pt = self.PointFromPosition(braceOpposite)
             #self.Refresh(True, wxRect(pt.x, pt.y, 5,5))
             #print pt
             #self.Refresh(False)
 
 
     def OnMarginClick(self, evt):
         # fold and unfold as needed
         if evt.GetMargin() == 2:
             if evt.GetShift() and evt.GetControl():
                 self.FoldAll()
             else:
                 lineClicked = self.LineFromPosition(evt.GetPosition())
 
                 if self.GetFoldLevel(lineClicked) & stc.STC_FOLDLEVELHEADERFLAG:
                     if evt.GetShift():
                         self.SetFoldExpanded(lineClicked, True)
                         self.Expand(lineClicked, True, True, 1)
                     elif evt.GetControl():
                         if self.GetFoldExpanded(lineClicked):
                             self.SetFoldExpanded(lineClicked, False)
                             self.Expand(lineClicked, False, True, 0)
                         else:
                             self.SetFoldExpanded(lineClicked, True)
                             self.Expand(lineClicked, True, True, 100)
                     else:
                         self.ToggleFold(lineClicked)
 
 
     def FoldAll(self):
         lineCount = self.GetLineCount()
         expanding = True
 
         # find out if we are folding or unfolding
         for lineNum in range(lineCount):
             if self.GetFoldLevel(lineNum) & stc.STC_FOLDLEVELHEADERFLAG:
                 expanding = not self.GetFoldExpanded(lineNum)
                 break
 
         lineNum = 0
 
         while lineNum < lineCount:
             level = self.GetFoldLevel(lineNum)
             if level & stc.STC_FOLDLEVELHEADERFLAG and \
                (level & stc.STC_FOLDLEVELNUMBERMASK) == stc.STC_FOLDLEVELBASE:
 
                 if expanding:
                     self.SetFoldExpanded(lineNum, True)
                     lineNum = self.Expand(lineNum, True)
                     lineNum = lineNum - 1
                 else:
                     lastChild = self.GetLastChild(lineNum, -1)
                     self.SetFoldExpanded(lineNum, False)
 
                     if lastChild > lineNum:
                         self.HideLines(lineNum+1, lastChild)
 
             lineNum = lineNum + 1
 
 
 
     def Expand(self, line, doExpand, force=False, visLevels=0, level=-1):
         lastChild = self.GetLastChild(line, level)
         line = line + 1
 
         while line <= lastChild:
             if force:
                 if visLevels > 0:
                     self.ShowLines(line, line)
                 else:
                     self.HideLines(line, line)
             else:
                 if doExpand:
                     self.ShowLines(line, line)
 
             if level == -1:
                 level = self.GetFoldLevel(line)
 
             if level & stc.STC_FOLDLEVELHEADERFLAG:
                 if force:
                     if visLevels > 1:
                         self.SetFoldExpanded(line, True)
                     else:
                         self.SetFoldExpanded(line, False)
 
                     line = self.Expand(line, doExpand, force, visLevels-1)
 
                 else:
                     if doExpand and self.GetFoldExpanded(line):
                         line = self.Expand(line, True, force, visLevels-1)
                     else:
                         line = self.Expand(line, False, force, visLevels-1)
             else:
                 line = line + 1
 
         return line
 
 
 #----------------------------------------------------------------------

IPython/gui/wx/ipython_view.py

@@ -1,767 +1,767 b''
 #!/usr/bin/python
 # -*- coding: iso-8859-15 -*-
 '''
 Provides IPython WX console widgets.
 
 @author: Laurent Dufrechou
 laurent.dufrechou _at_ gmail.com
 This WX widget is based on the original work of Eitan Isaacson
 that provided the console for the GTK toolkit.
 
 Original work from:
 @author: Eitan Isaacson
 @organization: IBM Corporation
 @copyright: Copyright (c) 2007 IBM Corporation
 @license: BSD
 
 All rights reserved. This program and the accompanying materials are made
 available under the terms of the BSD which accompanies this distribution, and
 is available at U{http://www.opensource.org/licenses/bsd-license.php}
 '''
 
 __version__ = 0.8
 __author__  = "Laurent Dufrechou"
 __email__   = "laurent.dufrechou _at_ gmail.com"
 __license__ = "BSD"
 
 import wx
 import wx.stc  as  stc
 import wx.lib.newevent
 
 import re
 import sys
 import os
 import locale
 import time
 from StringIO import StringIO
 try:
         import IPython
 except Exception,e:
         raise "Error importing IPython (%s)" % str(e)
 
 
 from non_blocking_ip_shell import NonBlockingIPShell
 
 class WxNonBlockingIPShell(NonBlockingIPShell):
     '''
     An NonBlockingIPShell Thread that is WX dependent.
     '''
     def __init__(self, parent, 
                  argv=[],user_ns={},user_global_ns=None,
                  cin=None, cout=None, cerr=None,
                  ask_exit_handler=None):
         
         NonBlockingIPShell.__init__(self,argv,user_ns,user_global_ns,
                                  cin, cout, cerr,
                                  ask_exit_handler)
 
         self.parent = parent
 
         self.ask_exit_callback = ask_exit_handler
         self._IP.ask_exit = self._askExit
 
         
     def addGUIShortcut(self,text,func):
         wx.CallAfter(self.parent.add_button_handler, 
                 button_info={   'text':text, 
                                 'func':self.parent.doExecuteLine(func)})
                     
     def _askExit(self):
         wx.CallAfter(self.ask_exit_callback, ())
 
     def _afterExecute(self):
         wx.CallAfter(self.parent.evtStateExecuteDone, ())
 
                 
 class WxConsoleView(stc.StyledTextCtrl):
     '''
     Specialized styled text control view for console-like workflow.
     We use here a scintilla frontend thus it can be reused in any GUI taht supports
     scintilla with less work.
 
     @cvar ANSI_COLORS_BLACK: Mapping of terminal colors to X11 names.(with Black background)
     @type ANSI_COLORS_BLACK: dictionary
 
     @cvar ANSI_COLORS_WHITE: Mapping of terminal colors to X11 names.(with White background)
     @type ANSI_COLORS_WHITE: dictionary
 
     @ivar color_pat: Regex of terminal color pattern
     @type color_pat: _sre.SRE_Pattern
     '''
     ANSI_STYLES_BLACK ={'0;30': [0,'WHITE'],             '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']}
 
     ANSI_STYLES_WHITE ={'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']}
 
     def __init__(self,parent,prompt,intro="",background_color="BLACK",pos=wx.DefaultPosition, ID = -1, size=wx.DefaultSize,
                  style=0):
         '''
         Initialize console view.
 
         @param parent: Parent widget
         @param prompt: User specified prompt
         @type intro: string
         @param intro: User specified startup introduction string
         @type intro: string
         @param background_color: Can be BLACK or WHITE
         @type background_color: string
         @param other: init param of styledTextControl (can be used as-is)
         '''
         stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
 
         ####### Scintilla configuration ##################################################
         
         # Ctrl + B or Ctrl + N can be used to zoomin/zoomout the text inside the widget
         self.CmdKeyAssign(ord('B'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
         self.CmdKeyAssign(ord('N'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
 
         #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,
                      }
 
         #We draw a line at position 80
         self.SetEdgeMode(stc.STC_EDGE_LINE)
         self.SetEdgeColumn(80)
         self.SetEdgeColour(wx.LIGHT_GREY)
 
         #self.SetViewWhiteSpace(True)
         #self.SetViewEOL(True)
         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.EnsureCaretVisible()
         
         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)
 
         # make some styles
         if background_color != "BLACK":
             self.background_color = "WHITE"
             self.SetCaretForeground("BLACK")
             self.ANSI_STYLES = self.ANSI_STYLES_WHITE
         else:
             self.background_color = background_color
             self.SetCaretForeground("WHITE")
             self.ANSI_STYLES = self.ANSI_STYLES_BLACK
 
         self.StyleSetSpec(stc.STC_STYLE_DEFAULT, "fore:%s,back:%s,size:%d,face:%s" % (self.ANSI_STYLES['0;30'][1],
                                                                                       self.background_color,
                                                                                       faces['size'], faces['mono']))
         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])
         
         #######################################################################
         
         self.indent = 0
         self.prompt_count = 0
         self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
         
         self.write(intro)
         self.setPrompt(prompt)
         self.showPrompt()
         
         self.Bind(wx.EVT_KEY_DOWN, self._onKeypress, self)
         #self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI)
 
     def write(self, text):
         '''
         Write given text to buffer.
 
         @param text: Text to append.
         @type text: string
         '''
         segments = self.color_pat.split(text)
         segment = segments.pop(0)
         self.StartStyling(self.getCurrentLineEnd(),0xFF)
         self.AppendText(segment)
         
         if segments:
             ansi_tags = self.color_pat.findall(text)
 
             for tag in ansi_tags:
                 i = segments.index(tag)
                 self.StartStyling(self.getCurrentLineEnd(),0xFF)
                 self.AppendText(segments[i+1])
 
                 if tag != '0':
                     self.SetStyling(len(segments[i+1]),self.ANSI_STYLES[tag][0])
 
                 segments.pop(i)
                 
         self.moveCursor(self.getCurrentLineEnd())
          
     def getPromptLen(self):
         '''
         Return the length of current prompt
         '''
         return len(str(self.prompt_count)) + 7
 
     def setPrompt(self,prompt):
         self.prompt = prompt
 
     def setIndentation(self,indentation):
         self.indent = indentation
         
     def setPromptCount(self,count):
         self.prompt_count = count
         
     def showPrompt(self):
         '''
         Prints prompt at start of line.
 
         @param prompt: Prompt to print.
         @type prompt: string
         '''
         self.write(self.prompt)
         #now we update the position of end of prompt
         self.current_start = self.getCurrentLineEnd()
         
         autoindent = self.indent*' '
         autoindent = autoindent.replace('    ','\t')
         self.write(autoindent)
         
     def changeLine(self, text):
         '''
         Replace currently entered command line with given text.
 
         @param text: Text to use as replacement.
         @type text: string
         '''
         self.SetSelection(self.getCurrentPromptStart(),self.getCurrentLineEnd())
         self.ReplaceSelection(text)
         self.moveCursor(self.getCurrentLineEnd())
 
     def getCurrentPromptStart(self):
         return self.current_start
 
     def getCurrentLineStart(self):
         return self.GotoLine(self.LineFromPosition(self.GetCurrentPos()))
 
     def getCurrentLineEnd(self):
         return self.GetLength()
 
     def getCurrentLine(self):
         '''
         Get text in current command line.
 
         @return: Text of current command line.
         @rtype: string
         '''
         return self.GetTextRange(self.getCurrentPromptStart(),
                                  self.getCurrentLineEnd())
 
     def showReturned(self, text):
         '''
         Show returned text from last command and print new prompt.
 
         @param text: Text to show.
         @type text: string
         '''
         self.write('\n'+text)
         if text:
             self.write('\n')
         self.showPrompt()
 
     def moveCursorOnNewValidKey(self):
         #If cursor is at wrong position put it at last line...
         if self.GetCurrentPos() < self.getCurrentPromptStart():
             self.GotoPos(self.getCurrentPromptStart())
         
     def removeFromTo(self,from_pos,to_pos):
         if from_pos < to_pos:
             self.SetSelection(from_pos,to_pos)
             self.DeleteBack()
                                                           
     def removeCurrentLine(self):
         self.LineDelete()
         
     def moveCursor(self,position):
         self.GotoPos(position)
 
     def getCursorPos(self):
         return self.GetCurrentPos()
 
     def selectFromTo(self,from_pos,to_pos):
         self.SetSelectionStart(from_pos)
         self.SetSelectionEnd(to_pos)
         
     def writeHistory(self,history):
         self.removeFromTo(self.getCurrentPromptStart(),self.getCurrentLineEnd())
         self.changeLine(history)
         
     def writeCompletion(self, possibilities):
         max_len = len(max(possibilities,key=len))
         max_symbol =' '*max_len
         
         #now we check how much symbol we can put on a line...
         cursor_pos = self.getCursorPos()
         test_buffer = max_symbol + ' '*4
         current_lines = self.GetLineCount()
         
         allowed_symbols = 80/len(test_buffer)
         if allowed_symbols == 0:
                 allowed_symbols = 1
         
         pos = 1
         buf = ''
         for symbol in possibilities:
             #buf += symbol+'\n'#*spaces)
             if pos<allowed_symbols:
                 spaces = max_len - len(symbol) + 4
                 buf += symbol+' '*spaces
                 pos += 1
             else:
                 buf+=symbol+'\n'
                 pos = 1
         self.write(buf)
                              
     def _onKeypress(self, event, skip=True):
         '''
         Key press callback used for correcting behavior for console-like
         interfaces. For example 'home' should go to prompt, not to begining of
         line.
 
         @param widget: Widget that key press accored in.
         @type widget: gtk.Widget
         @param event: Event object
         @type event: gtk.gdk.Event
 
         @return: Return True if event as been catched.
         @rtype: boolean
         '''
-	
+        
         if event.GetKeyCode() == wx.WXK_HOME:
             if event.Modifiers == wx.MOD_NONE:
                 self.moveCursorOnNewValidKey()
                 self.moveCursor(self.getCurrentPromptStart())
                 return True
             elif event.Modifiers == wx.MOD_SHIFT:
                 self.moveCursorOnNewValidKey()
                 self.selectFromTo(self.getCurrentPromptStart(),self.getCursorPos())
                 return True
             else:
                 return False
 
         elif event.GetKeyCode() == wx.WXK_LEFT:
             if event.Modifiers == wx.MOD_NONE:
                 self.moveCursorOnNewValidKey()
                 
                 self.moveCursor(self.getCursorPos()-1)
                 if self.getCursorPos() < self.getCurrentPromptStart():
                     self.moveCursor(self.getCurrentPromptStart())
                 return True
 
         elif event.GetKeyCode() == wx.WXK_BACK:
             self.moveCursorOnNewValidKey()
-	    if self.getCursorPos() > self.getCurrentPromptStart():
+            if self.getCursorPos() > self.getCurrentPromptStart():
                 self.removeFromTo(self.getCursorPos()-1,self.getCursorPos())
-	    return True
+            return True
         
         if skip:
             if event.GetKeyCode() not in [wx.WXK_PAGEUP,wx.WXK_PAGEDOWN] and event.Modifiers == wx.MOD_NONE:
                 self.moveCursorOnNewValidKey()
                 
             event.Skip()
             return True
         return False
 
     def OnUpdateUI(self, evt):
         # check for matching braces
         braceAtCaret = -1
         braceOpposite = -1
         charBefore = None
         caretPos = self.GetCurrentPos()
 
         if caretPos > 0:
             charBefore = self.GetCharAt(caretPos - 1)
             styleBefore = self.GetStyleAt(caretPos - 1)
 
         # check before
         if charBefore and chr(charBefore) in "[]{}()" and styleBefore == stc.STC_P_OPERATOR:
             braceAtCaret = caretPos - 1
 
         # check after
         if braceAtCaret < 0:
             charAfter = self.GetCharAt(caretPos)
             styleAfter = self.GetStyleAt(caretPos)
 
             if charAfter and chr(charAfter) in "[]{}()" and styleAfter == stc.STC_P_OPERATOR:
                 braceAtCaret = caretPos
 
         if braceAtCaret >= 0:
             braceOpposite = self.BraceMatch(braceAtCaret)
 
         if braceAtCaret != -1  and braceOpposite == -1:
             self.BraceBadLight(braceAtCaret)
         else:
             self.BraceHighlight(braceAtCaret, braceOpposite)
             #pt = self.PointFromPosition(braceOpposite)
             #self.Refresh(True, wxRect(pt.x, pt.y, 5,5))
             #print pt
             #self.Refresh(False)
         
 class WxIPythonViewPanel(wx.Panel):
     '''
     This is wx.Panel that embbed the IPython Thread and the wx.StyledTextControl
     If you want to port this to any other GUI toolkit, just replace the WxConsoleView
     by YOURGUIConsoleView and make YOURGUIIPythonView derivate from whatever container you want.
     I've choosed to derivate from a wx.Panel because it seems to be ore usefull
     Any idea to make it more 'genric' welcomed.
     '''
 
     def __init__(self, parent, ask_exit_handler=None, intro=None,
                  background_color="BLACK", add_button_handler=None, 
                  wx_ip_shell=None,
                  ):
         '''
         Initialize.
         Instanciate an IPython thread.
         Instanciate a WxConsoleView.
         Redirect I/O to console.
         '''
         wx.Panel.__init__(self,parent,-1)
 
         ### IPython thread instanciation ###
         self.cout = StringIO()
 
         self.add_button_handler = add_button_handler
         self.ask_exit_handler = ask_exit_handler
 
         if wx_ip_shell is not None:
             self.IP = wx_ip_shell
         else:
             self.IP = WxNonBlockingIPShell(self,
                                     cout=self.cout,cerr=self.cout,
                                     ask_exit_handler = ask_exit_handler)
         ### IPython wx console view instanciation ###
         #If user didn't defined an intro text, we create one for him
         #If you really wnat an empty intrp just call wxIPythonViewPanel with intro=''
         if intro == None:
             welcome_text = "Welcome to WxIPython Shell.\n\n"
             welcome_text+= self.IP.getBanner()
             welcome_text+= "!command  -> Execute command in shell\n"
             welcome_text+= "TAB       -> Autocompletion\n"
 
         self.text_ctrl = WxConsoleView(self,
                                        self.IP.getPrompt(),
                                        intro=welcome_text,
                                        background_color=background_color)
         
         self.text_ctrl.Bind(wx.EVT_KEY_DOWN, self.keyPress, self.text_ctrl)
 
         ### making the layout of the panel ###
         sizer = wx.BoxSizer(wx.VERTICAL)
         sizer.Add(self.text_ctrl, 1, wx.EXPAND)
         self.SetAutoLayout(True)
         sizer.Fit(self)
         sizer.SetSizeHints(self)
         self.SetSizer(sizer)
         #and we focus on the widget :)
         self.SetFocus()
 
         ### below are the thread communication variable ###
         # the IPython thread is managed via unidirectional communication.
         # It's a thread slave that can't interact by itself with the GUI.
         # When the GUI event loop is done runStateMachine() is called and the thread sate is then
         # managed.
         
         #Initialize the state machine #kept for information
         #self.states = ['IDLE',
         #               'DO_EXECUTE_LINE',
         #               'WAIT_END_OF_EXECUTION',
         #               'SHOW_DOC',
         #               'SHOW_PROMPT']
         
         self.cur_state = 'IDLE'
         self.pager_state = 'DONE'
         #wx.CallAfter(self.runStateMachine)
 
         # This creates a new Event class and a EVT binder function
         #(self.AskExitEvent, EVT_ASK_EXIT) = wx.lib.newevent.NewEvent()
         #(self.AddButtonEvent, EVT_ADDBUTTON_EXIT) = wx.lib.newevent.NewEvent()
         
         
         #self.Bind(wx.EVT_IDLE, self.runStateMachine)
                 
     def __del__(self):
         WxConsoleView.__del__()
         
     #---------------------------- IPython Thread Management ---------------------------------------
     def stateDoExecuteLine(self):
         #print >>sys.__stdout__,"command:",self.getCurrentLine()
         self.doExecuteLine(self.text_ctrl.getCurrentLine())
         
     def doExecuteLine(self,line):
         #print >>sys.__stdout__,"command:",line
         self.IP.doExecute(line.replace('\t',' '*4))
         self.updateHistoryTracker(self.text_ctrl.getCurrentLine())
         self.cur_state = 'WAIT_END_OF_EXECUTION'
 
         
     def evtStateExecuteDone(self,evt):
         self.doc = self.IP.getDocText()
         self.help = self.IP.getHelpText()
         if self.doc:
             self.pager_state = 'INIT'
             self.cur_state = 'SHOW_DOC'
             self.pager(self.doc)
             #if self.pager_state == 'DONE':
         if self.help:
             self.pager_state = 'INIT_HELP'
             self.cur_state = 'SHOW_DOC'
             self.pager(self.help)
                 
         else:
             self.stateShowPrompt()
 
     def stateShowPrompt(self):
         self.cur_state = 'SHOW_PROMPT'
         self.text_ctrl.setPrompt(self.IP.getPrompt())
         self.text_ctrl.setIndentation(self.IP.getIndentation())
         self.text_ctrl.setPromptCount(self.IP.getPromptCount())
         rv = self.cout.getvalue()
         if rv: rv = rv.strip('\n')
         self.text_ctrl.showReturned(rv)
         self.cout.truncate(0)
         self.IP.initHistoryIndex()
         self.cur_state = 'IDLE'
         
 ##    def runStateMachine(self,event):
 ##        #print >>sys.__stdout__,"state:",self.cur_state
 ##        self.updateStatusTracker(self.cur_state)
 ##        
 ##        #if self.cur_state == 'DO_EXECUTE_LINE':
 ##        #    self.doExecuteLine()
 ##            
 ##        if self.cur_state == 'WAIT_END_OF_EXECUTION':
 ##            if self.IP.isExecuteDone():
 ##                #self.button = self.IP.getAddButton()
 ##                #if self.IP.getAskExit():
 ##                #    evt = self.AskExitEvent()
 ##                #    wx.PostEvent(self, evt)
 ##                #    self.IP.clearAskExit()
 ##                self.doc = self.IP.getDocText()
 ##                if self.doc:
 ##                    self.pager_state = 'INIT'
 ##          self.cur_state = 'SHOW_DOC'
 ##      #if self.button:
 ##                    #self.IP.doExecute('print "cool"')#self.button['func'])
 ##                    #self.updateHistoryTracker(self.text_ctrl.getCurrentLine())
 ##            
 ##                #    self.button['func']='print "cool!"'
 ##                #    self.add_button_handler(self.button)
 ##                #    self.IP.shortcutProcessed()
 ##                    
 ##                else:
 ##                    self.cur_state = 'SHOW_PROMPT'
 ##                
 ##        if self.cur_state == 'SHOW_PROMPT':
 ##            self.text_ctrl.setPrompt(self.IP.getPrompt())
 ##            self.text_ctrl.setIndentation(self.IP.getIndentation())
 ##            self.text_ctrl.setPromptCount(self.IP.getPromptCount())
 ##            rv = self.cout.getvalue()
 ##            if rv: rv = rv.strip('\n')
 ##            self.text_ctrl.showReturned(rv)
 ##            self.cout.truncate(0)
-##	    self.IP.initHistoryIndex()
+##          self.IP.initHistoryIndex()
 ##            self.cur_state = 'IDLE'
 ##            
 ##        if self.cur_state == 'SHOW_DOC':
 ##            self.pager(self.doc)
 ##            if self.pager_state == 'DONE':
 ##                self.cur_state = 'SHOW_PROMPT'
 ##                
 ##        event.Skip()
 
     #---------------------------- IPython pager ---------------------------------------
     def pager(self,text):#,start=0,screen_lines=0,pager_cmd = None):
         if self.pager_state == 'WAITING':
-		#print >>sys.__stdout__,"PAGER waiting"
-        	return
-	
-	if self.pager_state == 'INIT':
-		#print >>sys.__stdout__,"PAGER state:",self.pager_state
-        	self.pager_lines = text[7:].split('\n')
-		self.pager_nb_lines = len(self.pager_lines)
-		self.pager_index = 0
-		self.pager_do_remove = False
-		self.text_ctrl.write('\n')
-		self.pager_state = 'PROCESS_LINES'
-
-	if self.pager_state == 'INIT_HELP':
-		#print >>sys.__stdout__,"HELP PAGER state:",self.pager_state
-        	self.pager_lines = text[:].split('\n')
-		self.pager_nb_lines = len(self.pager_lines)
-		self.pager_index = 0
-		self.pager_do_remove = False
-		self.text_ctrl.write('\n')
-		self.pager_state = 'PROCESS_LINES'
-		
-	if self.pager_state == 'PROCESS_LINES':
-        	#print >>sys.__stdout__,"PAGER state:",self.pager_state
-        	if self.pager_do_remove == True:
-			self.text_ctrl.removeCurrentLine()
-			self.pager_do_remove = False
-	
-		if self.pager_nb_lines > 10:
-	                #print >>sys.__stdout__,"PAGER processing 10 lines"
-			if self.pager_index > 0:
-				self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
-			else:
-				self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
-			
-			for line in self.pager_lines[self.pager_index+1:self.pager_index+9]:
-				self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
-			self.pager_index += 10
-			self.pager_nb_lines -= 10
-			self.text_ctrl.write("--- Push Enter to continue or 'Q' to quit---")
-			self.pager_do_remove = True
-			self.pager_state = 'WAITING'
-			return
-        	else:
-	                #print >>sys.__stdout__,"PAGER processing last lines"
-			if self.pager_nb_lines > 0:
-				if self.pager_index > 0:
-					self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
-				else:
-					self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
-				
-				self.pager_index += 1
+                #print >>sys.__stdout__,"PAGER waiting"
+                return
+        
+        if self.pager_state == 'INIT':
+                #print >>sys.__stdout__,"PAGER state:",self.pager_state
+                self.pager_lines = text[7:].split('\n')
+                self.pager_nb_lines = len(self.pager_lines)
+                self.pager_index = 0
+                self.pager_do_remove = False
+                self.text_ctrl.write('\n')
+                self.pager_state = 'PROCESS_LINES'
+
+        if self.pager_state == 'INIT_HELP':
+                #print >>sys.__stdout__,"HELP PAGER state:",self.pager_state
+                self.pager_lines = text[:].split('\n')
+                self.pager_nb_lines = len(self.pager_lines)
+                self.pager_index = 0
+                self.pager_do_remove = False
+                self.text_ctrl.write('\n')
+                self.pager_state = 'PROCESS_LINES'
+                
+        if self.pager_state == 'PROCESS_LINES':
+                #print >>sys.__stdout__,"PAGER state:",self.pager_state
+                if self.pager_do_remove == True:
+                        self.text_ctrl.removeCurrentLine()
+                        self.pager_do_remove = False
+        
+                if self.pager_nb_lines > 10:
+                        #print >>sys.__stdout__,"PAGER processing 10 lines"
+                        if self.pager_index > 0:
+                                self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
+                        else:
+                                self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
+                        
+                        for line in self.pager_lines[self.pager_index+1:self.pager_index+9]:
+                                self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
+                        self.pager_index += 10
+                        self.pager_nb_lines -= 10
+                        self.text_ctrl.write("--- Push Enter to continue or 'Q' to quit---")
+                        self.pager_do_remove = True
+                        self.pager_state = 'WAITING'
+                        return
+                else:
+                        #print >>sys.__stdout__,"PAGER processing last lines"
+                        if self.pager_nb_lines > 0:
+                                if self.pager_index > 0:
+                                        self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
+                                else:
+                                        self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
+                                
+                                self.pager_index += 1
                                 self.pager_nb_lines -= 1
-	              	if self.pager_nb_lines > 0:
-        	        	for line in self.pager_lines[self.pager_index:]:
-					self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
-                			self.pager_nb_lines = 0
-			self.pager_state = 'DONE'
-			self.stateShowPrompt()
+                        if self.pager_nb_lines > 0:
+                                for line in self.pager_lines[self.pager_index:]:
+                                        self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
+                                        self.pager_nb_lines = 0
+                        self.pager_state = 'DONE'
+                        self.stateShowPrompt()
                 
     #---------------------------- Key Handler --------------------------------------------
     def keyPress(self, event):
         '''
         Key press callback with plenty of shell goodness, like history,
         autocompletions, etc.
         '''
-	
+        
         if event.GetKeyCode() == ord('C'):
             if event.Modifiers == wx.MOD_CONTROL:
                 if self.cur_state == 'WAIT_END_OF_EXECUTION':
                     #we raise an exception inside the IPython thread container
                     self.IP.ce.raise_exc(KeyboardInterrupt)
                     return
                 
         if event.KeyCode == wx.WXK_RETURN:
             if self.cur_state == 'IDLE':
                 #we change the state ot the state machine
                 self.cur_state = 'DO_EXECUTE_LINE'
                 self.stateDoExecuteLine()
                 return
             if self.pager_state == 'WAITING':
                 self.pager_state = 'PROCESS_LINES'
                 self.pager(self.doc)
                 return
             
         if event.GetKeyCode() in [ord('q'),ord('Q')]:
             if self.pager_state == 'WAITING':
                 self.pager_state = 'DONE'
                 self.stateShowPrompt()
                 return
             
         #scroll_position = self.text_ctrl.GetScrollPos(wx.VERTICAL)
-	if self.cur_state == 'IDLE':
+        if self.cur_state == 'IDLE':
             if event.KeyCode == wx.WXK_UP:
                 history = self.IP.historyBack()
                 self.text_ctrl.writeHistory(history)
                 return
             if event.KeyCode == wx.WXK_DOWN:
                 history = self.IP.historyForward()
                 self.text_ctrl.writeHistory(history)
                 return
             if event.KeyCode == wx.WXK_TAB:
                 #if line empty we disable tab completion
                 if not self.text_ctrl.getCurrentLine().strip():
                     self.text_ctrl.write('\t')
                     return
                 completed, possibilities = self.IP.complete(self.text_ctrl.getCurrentLine())
                 if len(possibilities) > 1:
                     cur_slice = self.text_ctrl.getCurrentLine()
                     self.text_ctrl.write('\n')
                     self.text_ctrl.writeCompletion(possibilities)
                     self.text_ctrl.write('\n')
 
                     self.text_ctrl.showPrompt()
                     self.text_ctrl.write(cur_slice)
                 self.text_ctrl.changeLine(completed or cur_slice)
                 
                 return
             event.Skip()
-	
+        
     #---------------------------- Hook Section --------------------------------------------
     def updateHistoryTracker(self,command_line):
         '''
         Default history tracker (does nothing)
         '''
         pass
     
     def setHistoryTrackerHook(self,func):
         '''
         Define a new history tracker
         '''
         self.updateHistoryTracker = func
     def updateStatusTracker(self,status):
         '''
         Default status tracker (does nothing)
         '''
         pass
     
     def setStatusTrackerHook(self,func):
         '''
         Define a new status tracker
         '''
         self.updateStatusTracker = func
     

IPython/gui/wx/non_blocking_ip_shell.py

@@ -1,473 +1,473 b''
 #!/usr/bin/python
 # -*- coding: iso-8859-15 -*-
 '''
 Provides IPython remote instance.
 
 @author: Laurent Dufrechou
 laurent.dufrechou _at_ gmail.com
 @license: BSD
 
 All rights reserved. This program and the accompanying materials are made
 available under the terms of the BSD which accompanies this distribution, and
 is available at U{http://www.opensource.org/licenses/bsd-license.php}
 '''
 
 __version__ = 0.9
 __author__  = "Laurent Dufrechou"
 __email__   = "laurent.dufrechou _at_ gmail.com"
 __license__ = "BSD"
 
 import re
 import sys
 import os
 import locale
 import time
 import pydoc,__builtin__,site
 from thread_ex import ThreadEx
 from StringIO import StringIO
 
 try:
         import IPython
 except Exception,e:
         raise "Error importing IPython (%s)" % str(e)
 
 ##############################################################################
 class _Helper(object):
     """Redefine the built-in 'help'.
     This is a wrapper around pydoc.help (with a twist).
     """
 
     def __init__(self,pager):
         self._pager = pager
 
     def __repr__(self):
         return "Type help() for interactive help, " \
                "or help(object) for help about object."
     
     def __call__(self, *args, **kwds):
         class DummyWriter(object):
             def __init__(self,pager):
                 self._pager = pager
                 
             def write(self,data):
                 self._pager(data)
 
         import pydoc
         pydoc.help.output = DummyWriter(self._pager)
         pydoc.help.interact = lambda :1
         
         #helper.output.write = self.doc.append
         return pydoc.help(*args, **kwds)
 
   
 ##############################################################################
 class _CodeExecutor(ThreadEx):
     
     def __init__(self, instance, after):
         ThreadEx.__init__(self)
         self.instance = instance
         self._afterExecute=after
 
     def run(self):
         try:
             self.instance._doc_text = None
             self.instance._help_text = None
             self.instance._execute()
             # used for uper class to generate event after execution
             self._afterExecute() 
             
         except KeyboardInterrupt:
             pass
  
 
 ##############################################################################
 class NonBlockingIPShell(object):
     '''
     Create an IPython instance, running the commands in a separate,
     non-blocking thread. 
     This allows embedding in any GUI without blockage.
 
     Note: The ThreadEx class supports asynchroneous function call
           via raise_exc()
     '''
 
     def __init__(self,argv
                  =[],user_ns={},user_global_ns=None,
                  cin=None, cout=None, cerr=None,
                  ask_exit_handler=None):
         '''
         @param argv: Command line options for IPython
         @type argv: list
         @param user_ns: User namespace.
         @type user_ns: dictionary
         @param user_global_ns: User global namespace.
         @type user_global_ns: dictionary.
         @param cin: Console standard input.
         @type cin: IO stream
         @param cout: Console standard output.
         @type cout: IO stream
         @param cerr: Console standard error.
         @type cerr: IO stream
         @param exit_handler: Replacement for builtin exit() function
         @type exit_handler: function
         @param time_loop: Define the sleep time between two thread's loop
         @type int
         '''
         #first we redefine in/out/error functions of IPython 
         if cin:
             IPython.Shell.Term.cin = cin
         if cout:
             IPython.Shell.Term.cout = cout
         if cerr:
             IPython.Shell.Term.cerr = cerr
         
         # This is to get rid of the blockage that accurs during
         # IPython.Shell.InteractiveShell.user_setup()
         IPython.iplib.raw_input = lambda x: None
 
         self._term = IPython.genutils.IOTerm(cin=cin, cout=cout, cerr=cerr)
 
         excepthook = sys.excepthook
 
         self._IP = IPython.Shell.make_IPython(
                                             argv,user_ns=user_ns,
                                             user_global_ns=user_global_ns,
                                             embedded=True,
                                             shell_class=IPython.Shell.InteractiveShell)
 
         #we replace IPython default encoding by wx locale encoding
-	loc = locale.getpreferredencoding()
-	if loc:
-        	self._IP.stdin_encoding = loc
+        loc = locale.getpreferredencoding()
+        if loc:
+                self._IP.stdin_encoding = loc
         #we replace the ipython default pager by our pager
         self._IP.set_hook('show_in_pager',self._pager)
         
         #we replace the ipython default shell command caller by our shell handler
-	self._IP.set_hook('shell_hook',self._shell)
+        self._IP.set_hook('shell_hook',self._shell)
         
         #we replace the ipython default input command caller by our method
         IPython.iplib.raw_input_original = self._raw_input
         #we replace the ipython default exit command by our method
         self._IP.exit = self._setAskExit
         #we modify Exit and Quit Magic
         ip = IPython.ipapi.get()
         ip.expose_magic('Exit', self._setDoExit)
         ip.expose_magic('Quit', self._setDoExit)
 
         sys.excepthook = excepthook
 
         self._iter_more = 0
         self._history_level = 0
         self._complete_sep =  re.compile('[\s\{\}\[\]\(\)]')
         self._prompt = str(self._IP.outputcache.prompt1).strip()
 
         #thread working vars
         self._line_to_execute = ''
 
         #vars that will be checked by GUI loop to handle thread states...
         #will be replaced later by PostEvent GUI funtions...
         self._doc_text = None
         self._help_text = None
         self._ask_exit = False
         self._add_button = None
 
         #we replace the help command
         self._IP.user_ns['help'] = _Helper(self._pager_help)
         
     #----------------------- Thread management section ----------------------    
     def doExecute(self,line):
         """
         Tell the thread to process the 'line' command
         """
 
         self._line_to_execute = line
        
         self.ce = _CodeExecutor(self,self._afterExecute)
         self.ce.start()
         
     #----------------------- IPython management section ----------------------    
     def getAskExit(self):
         '''
         returns the _ask_exit variable that can be checked by GUI to see if
         IPython request an exit handling
         '''
         return self._ask_exit
 
     def clearAskExit(self):
         '''
         clear the _ask_exit var when GUI as handled the request.
         '''
         self._ask_exit = False
         
     def getDocText(self):
         """
         Returns the output of the processing that need to be paged (if any)
 
         @return: The std output string.
         @rtype: string
         """
         return self._doc_text
         
     def getHelpText(self):
         """
         Returns the output of the processing that need to be paged via help pager(if any)
 
         @return: The std output string.
         @rtype: string
         """
         return self._help_text
 
     def getBanner(self):
         """
         Returns the IPython banner for useful info on IPython instance
 
         @return: The banner string.
         @rtype: string
         """
         return self._IP.BANNER
     
     def getPromptCount(self):
         """
         Returns the prompt number.
         Each time a user execute a line in the IPython shell the prompt count is increased
 
         @return: The prompt number
         @rtype: int
         """
         return self._IP.outputcache.prompt_count
 
     def getPrompt(self):
         """
         Returns current prompt inside IPython instance
         (Can be In [...]: ot ...:)
 
         @return: The current prompt.
         @rtype: string
         """
         return self._prompt
 
     def getIndentation(self):
         """
         Returns the current indentation level
         Usefull to put the caret at the good start position if we want to do autoindentation.
 
         @return: The indentation level.
         @rtype: int
         """
         return self._IP.indent_current_nsp
         
     def updateNamespace(self, ns_dict):
         '''
         Add the current dictionary to the shell namespace.
 
         @param ns_dict: A dictionary of symbol-values.
         @type ns_dict: dictionary
         '''
         self._IP.user_ns.update(ns_dict)
 
     def complete(self, line):
         '''
         Returns an auto completed line and/or posibilities for completion.
 
         @param line: Given line so far.
         @type line: string
 
         @return: Line completed as for as possible,
         and possible further completions.
         @rtype: tuple
         '''
         split_line = self._complete_sep.split(line)
         possibilities = self._IP.complete(split_line[-1])
         if possibilities:
 
             def _commonPrefix(str1, str2):
                 '''
                 Reduction function. returns common prefix of two given strings.
 
                 @param str1: First string.
                 @type str1: string
                 @param str2: Second string
                 @type str2: string
 
                 @return: Common prefix to both strings.
                 @rtype: string
                 '''
                 for i in range(len(str1)):
                     if not str2.startswith(str1[:i+1]):
                         return str1[:i]
                 return str1
             common_prefix = reduce(_commonPrefix, possibilities)
             completed = line[:-len(split_line[-1])]+common_prefix
         else:
             completed = line
         return completed, possibilities
 
     def historyBack(self):
         '''
         Provides one history command back.
 
         @return: The command string.
         @rtype: string
         '''
         history = ''
         #the below while loop is used to suppress empty history lines
-	while((history == '' or history == '\n') and self._history_level >0):
-		if self._history_level>=1:
-			self._history_level -= 1
-		history = self._getHistory()		
+        while((history == '' or history == '\n') and self._history_level >0):
+                if self._history_level>=1:
+                        self._history_level -= 1
+                history = self._getHistory()            
         return history
 
     def historyForward(self):
         '''
         Provides one history command forward.
 
         @return: The command string.
         @rtype: string
         '''
-	history = ''
-	#the below while loop is used to suppress empty history lines
-	while((history == '' or history == '\n') and self._history_level <= self._getHistoryMaxIndex()):
-		if self._history_level < self._getHistoryMaxIndex():
-			self._history_level += 1
-			history = self._getHistory()
-		else:
-			if self._history_level == self._getHistoryMaxIndex():
-				history = self._getHistory()
-				self._history_level += 1
-			else:
-				history = ''
+        history = ''
+        #the below while loop is used to suppress empty history lines
+        while((history == '' or history == '\n') and self._history_level <= self._getHistoryMaxIndex()):
+                if self._history_level < self._getHistoryMaxIndex():
+                        self._history_level += 1
+                        history = self._getHistory()
+                else:
+                        if self._history_level == self._getHistoryMaxIndex():
+                                history = self._getHistory()
+                                self._history_level += 1
+                        else:
+                                history = ''
         return history
 
     def initHistoryIndex(self):
         '''
         set history to last command entered
         '''
         self._history_level = self._getHistoryMaxIndex()+1
 
     #----------------------- IPython PRIVATE management section --------------
     def _afterExecute(self):
         '''
         Can be redefined to generate post event after excution is done
         '''
         pass
 
     def _setAskExit(self):
         '''
         set the _ask_exit variable that can be checked by GUI to see if
         IPython request an exit handling
         '''
         self._ask_exit = True
 
     def _setDoExit(self, toto, arg):
         '''
         set the _do_exit variable that can be checked by GUI to see if
         IPython do a direct exit of the app
         '''
         self._do_exit = True
         
     def _getHistoryMaxIndex(self):
         '''
         returns the max length of the history buffer
 
         @return: history length
         @rtype: int
         '''
         return len(self._IP.input_hist_raw)-1
         
     def _getHistory(self):
         '''
         Get's the command string of the current history level.
 
         @return: Historic command stri
         @rtype: string
         '''
         rv = self._IP.input_hist_raw[self._history_level].strip('\n')
         return rv
 
     def _pager_help(self,text):
         '''
         This function is used as a callback replacment to IPython help pager function
 
         It puts the 'text' value inside the self._help_text string that can be retrived via getHelpText
         function.
         '''
         if self._help_text == None:
             self._help_text = text
         else:
             self._help_text += text
     
     def _pager(self,IP,text):
         '''
         This function is used as a callback replacment to IPython pager function
 
         It puts the 'text' value inside the self._doc_text string that can be retrived via getDocText
         function.
         '''
         self._doc_text = text
     
     def _raw_input(self, prompt=''):
         '''
         Custom raw_input() replacement. Get's current line from console buffer.
 
         @param prompt: Prompt to print. Here for compatability as replacement.
         @type prompt: string
 
         @return: The current command line text.
         @rtype: string
         '''
         return self._line_to_execute
 
     def _execute(self):
         '''
         Executes the current line provided by the shell object.
         '''
         orig_stdout = sys.stdout
         sys.stdout = IPython.Shell.Term.cout
                 
         try:
             line = self._IP.raw_input(None, self._iter_more)
             if self._IP.autoindent:
                 self._IP.readline_startup_hook(None)
 
         except KeyboardInterrupt:
             self._IP.write('\nKeyboardInterrupt\n')
             self._IP.resetbuffer()
             # keep cache in sync with the prompt counter:
             self._IP.outputcache.prompt_count -= 1
 
             if self._IP.autoindent:
                 self._IP.indent_current_nsp = 0
             self._iter_more = 0
         except:
             self._IP.showtraceback()
         else:
             self._iter_more = self._IP.push(line)
             if (self._IP.SyntaxTB.last_syntax_error and
                     self._IP.rc.autoedit_syntax):
                 self._IP.edit_syntax_error()
         if self._iter_more:
             self._prompt = str(self._IP.outputcache.prompt2).strip()
             if self._IP.autoindent:
                 self._IP.readline_startup_hook(self._IP.pre_readline)
         else:
             self._prompt = str(self._IP.outputcache.prompt1).strip()
             self._IP.indent_current_nsp = 0 #we set indentation to 0
         sys.stdout = orig_stdout
     
     def _shell(self, ip, cmd):
         '''
         Replacement method to allow shell commands without them blocking.
 
         @param ip: Ipython instance, same as self._IP
         @type cmd: Ipython instance
         @param cmd: Shell command to execute.
         @type cmd: string
         '''
         stdin, stdout = os.popen4(cmd)
         result = stdout.read().decode('cp437').encode(locale.getpreferredencoding())
         #we use print command because the shell command is called inside IPython instance and thus is
         #redirected to thread cout
         #"\x01\x1b[1;36m\x02" <-- add colour to the text...
         print "\x01\x1b[1;36m\x02"+result
         stdout.close()
         stdin.close()

IPython/gui/wx/wxIPython.py

@@ -1,199 +1,199 b''
 #!/usr/bin/python
 # -*- coding: iso-8859-15 -*-
 
 import wx.aui
 import wx.py
 from wx.lib.wordwrap import wordwrap
 
 from ipython_view import *
 from ipython_history import *
 
 __version__ = 0.8
 __author__  = "Laurent Dufrechou"
 __email__   = "laurent.dufrechou _at_ gmail.com"
 __license__ = "BSD"
 
 #-----------------------------------------
 # Creating one main frame for our 
 # application with movables windows
 #-----------------------------------------
 class MyFrame(wx.Frame):
     """Creating one main frame for our 
     application with movables windows"""
     def __init__(self, parent=None, id=-1, title="WxIPython", pos=wx.DefaultPosition,
                 size=(800, 600), style=wx.DEFAULT_FRAME_STYLE):
         wx.Frame.__init__(self, parent, id, title, pos, size, style)
         self._mgr = wx.aui.AuiManager()
         
         # notify PyAUI which frame to use
         self._mgr.SetManagedWindow(self)
         
         #create differents panels and make them persistant 
         self.history_panel    = IPythonHistoryPanel(self)
         
         self.ipython_panel    = WxIPythonViewPanel(self,self.OnExitDlg,
                                                    background_color = "BLACK")
         
         #self.ipython_panel    = WxIPythonViewPanel(self,self.OnExitDlg,
         #                                           background_color = "WHITE")
 
         self.ipython_panel.setHistoryTrackerHook(self.history_panel.write)
         self.ipython_panel.setStatusTrackerHook(self.updateStatus)
 
         self.statusbar = self.createStatus()
         self.createMenu()
         
         ########################################################################
         ### add the panes to the manager
         # main panels
         self._mgr.AddPane(self.ipython_panel , wx.CENTER, "IPython Shell")
         self._mgr.AddPane(self.history_panel , wx.RIGHT,  "IPython history")
-        	
+                
         # now we specify some panel characteristics
         self._mgr.GetPane(self.ipython_panel).CaptionVisible(True);
         self._mgr.GetPane(self.history_panel).CaptionVisible(True);
         self._mgr.GetPane(self.history_panel).MinSize((200,400));
         
         # tell the manager to "commit" all the changes just made
         self._mgr.Update()
 
         #global event handling
         self.Bind(wx.EVT_CLOSE, self.OnClose)
         self.Bind(wx.EVT_MENU,  self.OnClose,id=wx.ID_EXIT)
         self.Bind(wx.EVT_MENU,  self.OnShowIPythonPanel,id=wx.ID_HIGHEST+1)
         self.Bind(wx.EVT_MENU,  self.OnShowHistoryPanel,id=wx.ID_HIGHEST+2)
         self.Bind(wx.EVT_MENU,  self.OnShowAbout, id=wx.ID_HIGHEST+3)
         self.Bind(wx.EVT_MENU,  self.OnShowAllPanel,id=wx.ID_HIGHEST+6)
 
         warn_text = 'Hello from IPython and wxPython.\n'
         warn_text +='Please Note that this work is still EXPERIMENTAL\n'
         warn_text +='It does NOT emulate currently all the IPython functions.\n'
         
         dlg = wx.MessageDialog(self,
                                warn_text,
                                'Warning Box',
                                wx.OK | wx.ICON_INFORMATION
                                )
         dlg.ShowModal()
         dlg.Destroy()
      
     def createMenu(self):
         """local method used to create one menu bar"""
         
         mb = wx.MenuBar()
 
         file_menu = wx.Menu()
         file_menu.Append(wx.ID_EXIT, "Exit")
         
         view_menu = wx.Menu()
         view_menu.Append(wx.ID_HIGHEST+1, "Show IPython Panel")
         view_menu.Append(wx.ID_HIGHEST+2, "Show History Panel")
         view_menu.AppendSeparator()
         view_menu.Append(wx.ID_HIGHEST+6, "Show All")
         
         about_menu = wx.Menu()
         about_menu.Append(wx.ID_HIGHEST+3, "About")
 
         #view_menu.AppendSeparator()
         #options_menu = wx.Menu()
         #options_menu.AppendCheckItem(wx.ID_HIGHEST+7, "Allow Floating")
         #options_menu.AppendCheckItem(wx.ID_HIGHEST+8, "Transparent Hint")
         #options_menu.AppendCheckItem(wx.ID_HIGHEST+9, "Transparent Hint Fade-in")
         
         
         mb.Append(file_menu, "File")
         mb.Append(view_menu, "View")
         mb.Append(about_menu, "About")
         #mb.Append(options_menu, "Options")
         
         self.SetMenuBar(mb)
 
     def createStatus(self):
         statusbar = self.CreateStatusBar(2, wx.ST_SIZEGRIP)
         statusbar.SetStatusWidths([-2, -3])
         statusbar.SetStatusText("Ready", 0)
         statusbar.SetStatusText("WxIPython "+str(__version__), 1)
         return statusbar
 
     def updateStatus(self,text):
         states = {'IDLE':'Idle',
                   'DO_EXECUTE_LINE':'Send command',
                   'WAIT_END_OF_EXECUTION':'Running command',
                   'SHOW_DOC':'Showing doc',
                   'SHOW_PROMPT':'Showing prompt'}
         self.statusbar.SetStatusText(states[text], 0)
         
     def OnClose(self, event):
         """#event used to close program  """
         # deinitialize the frame manager
         self._mgr.UnInit()
         self.Destroy()        
         event.Skip()
     
     def OnExitDlg(self, event):
         dlg = wx.MessageDialog(self, 'Are you sure you want to quit WxIPython',
                                 'WxIPython exit',
                                 wx.ICON_QUESTION |
                                 wx.YES_NO | wx.NO_DEFAULT
                                 )
         if dlg.ShowModal() == wx.ID_YES:
             dlg.Destroy()
             self._mgr.UnInit()
             self.Destroy()
         dlg.Destroy()
       
     #event to display IPython pannel      
     def OnShowIPythonPanel(self,event):
         """ #event to display Boxpannel """
         self._mgr.GetPane(self.ipython_panel).Show(True)
         self._mgr.Update()  
     #event to display History pannel      
     def OnShowHistoryPanel(self,event):
         self._mgr.GetPane(self.history_panel).Show(True)
         self._mgr.Update()  
          
     def OnShowAllPanel(self,event):
         """#event to display all Pannels"""
         self._mgr.GetPane(self.ipython_panel).Show(True)
         self._mgr.GetPane(self.history_panel).Show(True)
         self._mgr.Update()
 
     def OnShowAbout(self, event):
         # First we create and fill the info object
         info = wx.AboutDialogInfo()
         info.Name = "WxIPython"
         info.Version = str(__version__)
         info.Copyright = "(C) 2007 Laurent Dufrechou"
         info.Description = wordwrap(
             "A Gui that embbed a multithreaded IPython Shell",
             350, wx.ClientDC(self))
         info.WebSite = ("http://ipython.scipy.org/", "IPython home page")
         info.Developers = [ "Laurent Dufrechou" ]
         licenseText="BSD License.\nAll rights reserved. This program and the accompanying materials are made available under the terms of the BSD which accompanies this distribution, and is available at http://www.opensource.org/licenses/bsd-license.php"
         info.License = wordwrap(licenseText, 500, wx.ClientDC(self))
 
         # Then we call wx.AboutBox giving it that info object
         wx.AboutBox(info) 
         
 #-----------------------------------------
 #Creating our application
 #----------------------------------------- 
 class MyApp(wx.PySimpleApp):
     """Creating our application"""
     def __init__(self):
         wx.PySimpleApp.__init__(self)
         
         self.frame = MyFrame()
         self.frame.Show()
         
 #-----------------------------------------
 #Main loop
 #----------------------------------------- 
 def main():
     app = MyApp()
     app.SetTopWindow(app.frame)
     app.MainLoop()
 
 #if launched as main program run this
 if __name__ == '__main__':
     main()