First hook of the widget to the interpreter.

IPython/frontend/wx/console_widget.py

@@ -27,6 +27,40 b' import re'
 # FIXME: Need to provide an API for non user-generated display on the
 # screen: this should not be editable by the user.
 
+if wx.Platform == '__WXMSW__':
+    _DEFAULT_SIZE = 80
+else:
+    _DEFAULT_SIZE = 10
+
+_DEFAULT_STYLE = {
+    'stdout'      : 'fore:#0000FF',
+    'stderr'      : 'fore:#007f00',
+    'trace'       : 'fore:#FF0000',
+
+    'default'     : 'size:%d' % _DEFAULT_SIZE,
+    'bracegood'   : 'fore:#FFFFFF,back:#0000FF,bold',
+    'bracebad'    : 'fore:#000000,back:#FF0000,bold',
+
+    # properties for the various Python lexer styles
+    'comment'     : 'fore:#007F00',
+    'number'      : 'fore:#007F7F',
+    'string'      : 'fore:#7F007F,italic',
+    'char'        : 'fore:#7F007F,italic',
+    'keyword'     : 'fore:#00007F,bold',
+    'triple'      : 'fore:#7F0000',
+    'tripledouble': 'fore:#7F0000',
+    'class'       : 'fore:#0000FF,bold,underline',
+    'def'         : 'fore:#007F7F,bold',
+    'operator'    : 'bold',
+
+    }
+
+# new style numbers
+_STDOUT_STYLE = 15
+_STDERR_STYLE = 16
+_TRACE_STYLE  = 17
+
+
 #-------------------------------------------------------------------------------
 # The console widget class
 #-------------------------------------------------------------------------------
@@ -37,6 +71,8 b' class ConsoleWidget(stc.StyledTextCtrl):'
         keeping the cursor inside the editing line.
     """
 
+    style = _DEFAULT_STYLE.copy()
+
     # Translation table from ANSI escape sequences to color. Override
     # this to specify your colors.
     ANSI_STYLES = {'0;30': [0, 'BLACK'],            '0;31': [1, 'RED'],
@@ -57,6 +93,88 b' class ConsoleWidget(stc.StyledTextCtrl):'
     # Public API
     #--------------------------------------------------------------------------
     
+    def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, 
+                        size=wx.DefaultSize, style=0, 
+                        autocomplete_mode='IPYTHON'):
+        """ Autocomplete_mode: Can be 'IPYTHON' or 'STC'
+            'IPYTHON' show autocompletion the ipython way
+            'STC" show it scintilla text control way
+        """
+        stc.StyledTextCtrl.__init__(self, parent, id, pos, size, style)
+        self.configure_scintilla()
+
+        # FIXME: we need to retrieve this from the interpreter.
+        self.prompt = \
+            '\n\x01\x1b[0;34m\x02In [\x01\x1b[1;34m\x02%i\x01\x1b[0;34m\x02]: \x01\x1b[0m\x02'
+        self.new_prompt(self.prompt % 1)
+
+        self.autocomplete_mode = autocomplete_mode
+        
+        self.Bind(wx.EVT_KEY_DOWN, self._onKeypress)
+    
+
+    def configure_scintilla(self):
+        # 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)
+
+        self.SetEOLMode(stc.STC_EOL_CRLF)
+        self.SetWrapMode(stc.STC_WRAP_CHAR)
+        self.SetWrapMode(stc.STC_WRAP_WORD)
+        self.SetBufferedDraw(True)
+        self.SetUseAntiAliasing(True)
+        self.SetLayoutCache(stc.STC_CACHE_PAGE)
+        self.SetUndoCollection(False)
+        self.SetUseTabs(True)
+        self.SetIndent(4)
+        self.SetTabWidth(4)
+
+        self.EnsureCaretVisible()
+        
+        self.SetMargins(3, 3) #text is moved away from border with 3px
+        # Suppressing Scintilla margins
+        self.SetMarginWidth(0, 0)
+        self.SetMarginWidth(1, 0)
+        self.SetMarginWidth(2, 0)
+
+        self._apply_style()
+        
+        self.indent = 0
+        self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
+
+        #self.SetEdgeMode(stc.STC_EDGE_LINE)
+        #self.SetEdgeColumn(80)
+
+        # styles
+        p = self.style
+        self.StyleSetSpec(stc.STC_STYLE_DEFAULT, p['default'])
+        self.StyleClearAll()
+        self.StyleSetSpec(_STDOUT_STYLE, p['stdout'])
+        self.StyleSetSpec(_STDERR_STYLE, p['stderr'])
+        self.StyleSetSpec(_TRACE_STYLE, p['trace'])
+
+        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT, p['bracegood'])
+        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD, p['bracebad'])
+        self.StyleSetSpec(stc.STC_P_COMMENTLINE, p['comment'])
+        self.StyleSetSpec(stc.STC_P_NUMBER, p['number'])
+        self.StyleSetSpec(stc.STC_P_STRING, p['string'])
+        self.StyleSetSpec(stc.STC_P_CHARACTER, p['char'])
+        self.StyleSetSpec(stc.STC_P_WORD, p['keyword'])
+        self.StyleSetSpec(stc.STC_P_TRIPLE, p['triple'])
+        self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE, p['tripledouble'])
+        self.StyleSetSpec(stc.STC_P_CLASSNAME, p['class'])
+        self.StyleSetSpec(stc.STC_P_DEFNAME, p['def'])
+        self.StyleSetSpec(stc.STC_P_OPERATOR, p['operator'])
+        self.StyleSetSpec(stc.STC_P_COMMENTBLOCK, p['comment'])
+
+
+
+
+
     def write(self, text):
         """ Write given text to buffer, while translating the ansi escape
             sequences.
@@ -118,59 +236,6 b' class ConsoleWidget(stc.StyledTextCtrl):'
     # Private API
     #--------------------------------------------------------------------------
     
-    def __init__(self, parent, pos=wx.DefaultPosition, ID=-1, 
-                        size=wx.DefaultSize, style=0, 
-                        autocomplete_mode='IPYTHON'):
-        """ Autocomplete_mode: Can be 'IPYTHON' or 'STC'
-            'IPYTHON' show autocompletion the ipython way
-            'STC" show it scintilla text control way
-        """
-        stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
-
-        #------ Scintilla configuration -----------------------------------
-        
-        # 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)
-
-        self.SetEOLMode(stc.STC_EOL_CRLF)
-        self.SetWrapMode(stc.STC_WRAP_CHAR)
-        self.SetWrapMode(stc.STC_WRAP_WORD)
-        self.SetBufferedDraw(True)
-        self.SetUseAntiAliasing(True)
-        self.SetLayoutCache(stc.STC_CACHE_PAGE)
-        self.SetUndoCollection(False)
-        self.SetUseTabs(True)
-        self.SetIndent(4)
-        self.SetTabWidth(4)
-
-        self.EnsureCaretVisible()
-        
-        self.SetMargins(3, 3) #text is moved away from border with 3px
-        # Suppressing Scintilla margins
-        self.SetMarginWidth(0, 0)
-        self.SetMarginWidth(1, 0)
-        self.SetMarginWidth(2, 0)
-
-        self._apply_style()
-        
-        self.indent = 0
-        self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
-        
-        # FIXME: we need to retrieve this from the interpreter.
-        self.prompt = \
-            '\n\x01\x1b[0;34m\x02In [\x01\x1b[1;34m\x026\x01\x1b[0;34m\x02]: \x01\x1b[0m\x02'
-        self.new_prompt(self.prompt)
-
-        self.autocomplete_mode = autocomplete_mode
-        
-        self.Bind(wx.EVT_KEY_DOWN, self._onKeypress)
-    
-    
     def _apply_style(self):
         """ Applies the colors for the different text elements and the
             carret.
@@ -220,7 +285,7 b' class ConsoleWidget(stc.StyledTextCtrl):'
             self.StyleSetSpec(style[0], "bold,fore:%s" % style[1])
 
 
-     def removeFromTo(self, from_pos, to_pos):
+    def removeFromTo(self, from_pos, to_pos):
         if from_pos < to_pos:
             self.SetSelection(from_pos, to_pos)
             self.DeleteBack()
@@ -278,7 +343,7 b' class ConsoleWidget(stc.StyledTextCtrl):'
         if self.AutoCompActive():
             event.Skip()
         else:
-            if event.GetKeyCode() == wx.WXK_HOME:
+            if event.KeyCode == wx.WXK_HOME:
                 if event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN):
                     self.GotoPos(self.current_prompt_pos)
                     catched = True
@@ -288,7 +353,7 b' class ConsoleWidget(stc.StyledTextCtrl):'
                                                         self.GetCurrentPos())
                     catched = True
 
-            elif event.GetKeyCode() == wx.WXK_UP:
+            elif event.KeyCode == wx.WXK_UP:
                 if self.GetCurrentLine() > self.current_prompt_line:
                     if self.GetCurrentLine() == self.current_prompt_line + 1 \
                             and self.GetColumn(self.GetCurrentPos()) < \
@@ -298,7 +363,7 b' class ConsoleWidget(stc.StyledTextCtrl):'
                         event.Skip()
                 catched = True
 
-            elif event.GetKeyCode() in (wx.WXK_LEFT, wx.WXK_BACK):
+            elif event.KeyCode in (wx.WXK_LEFT, wx.WXK_BACK):
                 if self.GetCurrentPos() > self.current_prompt_pos:
                     event.Skip()
                 catched = True
@@ -306,7 +371,7 b' class ConsoleWidget(stc.StyledTextCtrl):'
             if skip and not catched:
                 event.Skip()
 
-            if event.GetKeyCode() not in (wx.WXK_PAGEUP, wx.WXK_PAGEDOWN)\
+            if event.KeyCode not in (wx.WXK_PAGEUP, wx.WXK_PAGEDOWN)\
                     and event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN,
                                                             wx.MOD_SHIFT):
                 # If cursor is outside the editing region, put it back.

IPython/frontend/wx/wx_frontend.py

@@ -25,42 +25,45 b' from console_widget import ConsoleWidget'
 
 
 import IPython
-from IPython.kernel.engineservice import EngineService, ThreadedEngineService
+from IPython.kernel.engineservice import EngineService
 from IPython.frontend.frontendbase import FrontEndBase
 
 
-from twisted.internet.threads import blockingCallFromThread
-
 #-------------------------------------------------------------------------------
 # Classes to implement the Wx frontend
 #-------------------------------------------------------------------------------
 
-# TODO: 
-#   1. Remove any multithreading. 
-    
+   
 
 
 class IPythonWxController(FrontEndBase, ConsoleWidget):
-    userNS = dict() #mirror of engine.user_ns (key=>str(value))
-    waiting_for_engine = False
-    textView = False 
+
+    output_prompt = \
+    '\n\x01\x1b[0;31m\x02Out[\x01\x1b[1;31m\x02%i\x01\x1b[0;31m\x02]: \x01\x1b[0m\x02'
    
+    #--------------------------------------------------------------------------
+    # Public API
+    #--------------------------------------------------------------------------
+ 
     def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition,
                  size=wx.DefaultSize, style=wx.CLIP_CHILDREN,
                  *args, **kwds):
         """ Create Shell instance.
         """
         ConsoleWidget.__init__(self, parent, id, pos, size, style)
-        FrontEndBase.__init__(self, engine=ThreadedEngineService())
+        FrontEndBase.__init__(self, engine=EngineService())
 
         self.lines = {}
         
         # Start the IPython engine
         self.engine.startService()
         
+        # Capture Character keys
+        self.Bind(wx.EVT_KEY_UP, self._on_key_up)
        
         #FIXME: print banner.
-        banner = """IPython1 %s -- An enhanced Interactive Python.""" % IPython.__version__
+        banner = """IPython1 %s -- An enhanced Interactive Python.""" \
+                            % IPython.__version__
     
     
     def appWillTerminate_(self, notification):
@@ -85,168 +88,12 b' class IPythonWxController(FrontEndBase, ConsoleWidget):'
         return self.engine.complete(token)
     
     
-    def execute(self, block, blockID=None):
-        self.waiting_for_engine = True
-        self.willChangeValueForKey_('commandHistory')
-        d = FrontEndBase.execute(block, blockID)
-        d.addBoth(self._engine_done)
-        
-        return d
-    
-        
-    def _engine_done(self, x):
-        self.waiting_for_engine = False
-        self.didChangeValueForKey_('commandHistory')
-        return x
-    
-    
-    def _store_engine_namespace_values(self, values, keys=[]):
-        assert(len(values) == len(keys))
-        self.willChangeValueForKey_('userNS')
-        for (k,v) in zip(keys,values):
-            self.userNS[k] = saferepr(v)
-        self.didChangeValueForKey_('userNS')
-    
-    
-    def textView_doCommandBySelector_(self, textView, selector):
-        assert(textView == self.textView)
-        NSLog("textView_doCommandBySelector_: "+selector)
-        
-        
-        if(selector == 'insertNewline:'):
-            indent = self.current_indent_string()
-            if(indent):
-                line = indent + self.current_line()
-            else:
-                line = self.current_line()
-            
-            if(self.is_complete(self.current_block())):
-                self.execute(self.current_block(),
-                                blockID=self.currentBlockID)
-                self.start_new_block()
-                
-                return True
-            
-            return False
-        
-        elif(selector == 'moveUp:'):
-            prevBlock = self.get_history_previous(self.current_block())
-            if(prevBlock != None):
-                self.replace_current_block_with_string(textView, prevBlock)
-            else:
-                NSBeep()
-            return True
-        
-        elif(selector == 'moveDown:'):
-            nextBlock = self.get_history_next()
-            if(nextBlock != None):
-                self.replace_current_block_with_string(textView, nextBlock)
-            else:
-                NSBeep()
-            return True
-        
-        elif(selector == 'moveToBeginningOfParagraph:'):
-            textView.setSelectedRange_(NSMakeRange(
-                                        self.current_block_range().location, 
-                                        0))
-            return True
-        elif(selector == 'moveToEndOfParagraph:'):
-            textView.setSelectedRange_(NSMakeRange(
-                                    self.current_block_range().location + \
-                                    self.current_block_range().length, 0))
-            return True
-        elif(selector == 'deleteToEndOfParagraph:'):
-            if(textView.selectedRange().location <= \
-                self.current_block_range().location):
-                # Intersect the selected range with the current line range
-                if(self.current_block_range().length < 0):
-                    self.blockRanges[self.currentBlockID].length = 0
-            
-                r = NSIntersectionRange(textView.rangesForUserTextChange()[0],
-                                        self.current_block_range())
-                
-                if(r.length > 0): #no intersection
-                    textView.setSelectedRange_(r)
-            
-            return False # don't actually handle the delete
-        
-        elif(selector == 'insertTab:'):
-            if(len(self.current_line().strip()) == 0): #only white space
-                return False
-            else:
-                self.textView.complete_(self)
-                return True
-        
-        elif(selector == 'deleteBackward:'):
-            #if we're at the beginning of the current block, ignore
-            if(textView.selectedRange().location == \
-                self.current_block_range().location):
-                return True
-            else:
-                self.current_block_range().length-=1
-                return False
-        return False
-    
-    
-    def textView_shouldChangeTextInRanges_replacementStrings_(self, 
-        textView, ranges, replacementStrings):
-        """
-        Delegate method for NSTextView.
-        
-        Refuse change text in ranges not at end, but make those changes at 
-        end.
-        """
-        
-        assert(len(ranges) == len(replacementStrings))
-        allow = True
-        for r,s in zip(ranges, replacementStrings):
-            r = r.rangeValue()
-            if(textView.textStorage().length() > 0 and
-                    r.location < self.current_block_range().location):
-                self.insert_text(s)
-                allow = False
-            
-            
-            self.blockRanges.setdefault(self.currentBlockID, 
-                                        self.current_block_range()).length +=\
-                                         len(s)
-        
-        return allow
-
-
-    def textView_completions_forPartialWordRange_indexOfSelectedItem_(self, 
-        textView, words, charRange, index):
-        try:
-            ts = textView.textStorage()
-            token = ts.string().substringWithRange_(charRange)
-            completions = blockingCallFromThread(self.complete, token)
-        except:
-            completions = objc.nil
-            NSBeep()
-        
-        return (completions,0)
-    
-    
-    def currentLine(self):
-        block = self.textForRange(self.currentBlockRange())
-        block = block.split('\n')
-        return block[-1]
-    
-    def update_cell_prompt(self, result):
-        blockID = result['blockID']
-        self.insert_text(self.inputPrompt(result=result),
-                        scrollToVisible=False
-                        )
-        
-        return result
-    
-    
     def render_result(self, result):
-        self.insert_text('\n' +
-                        self.outputPrompt(result) +
-                        result.get('display',{}).get('pprint','') +
-                        '\n\n')
-        return result
+        if 'stdout' in result:
+            self.write(result['stdout'])
+        if 'display' in result:
+            self.write(self.output_prompt % result['number']
+                + result['display']['pprint'])
     
         
     def render_error(self, failure):
@@ -254,26 +101,30 b' class IPythonWxController(FrontEndBase, ConsoleWidget):'
         return failure
     
     
-    def insert_text(self, string, scrollToVisible=True):
-        """Insert text into console_widget"""
-        self.write(string)
-    
-    
-    def currentIndentString(self):
-        """returns string for indent or None if no indent"""
-        
-        if(len(self.currentBlock()) > 0):
-            lines = self.currentBlock().split('\n')
-            currentIndent = len(lines[-1]) - len(lines[-1].lstrip())
-            if(currentIndent == 0):
-                currentIndent = 4 
-        
-            result = ' ' * currentIndent
-        else:
-            result = None
-        
-        return result
+    #--------------------------------------------------------------------------
+    # Private API
+    #--------------------------------------------------------------------------
+ 
+
+    def _on_key_up(self, event, skip=True):
+        """ Capture the character events, let the parent
+            widget handle them, and put our logic afterward.
+        """
+        event.Skip()
+        # Capture enter
+        if event.KeyCode == 13 and \
+                event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN):
+            self._on_enter()
+
     
+    def _on_enter(self):
+        """ Called when the return key is pressed in a line editing
+            buffer.
+        """
+        result = self.engine.shell.execute(self.get_current_edit_buffer())
+        self.render_result(result)
+        self.new_prompt(self.prompt % result['number'])
+
 
 if __name__ == '__main__':
     class MainWindow(wx.Frame):
@@ -288,8 +139,9 b" if __name__ == '__main__':"
 
     app = wx.PySimpleApp()
     frame = MainWindow(None, wx.ID_ANY, 'Ipython')
+    frame.shell.SetFocus()
     frame.SetSize((780, 460))
     shell = frame.shell
 
-    app.MainLoop()
+    #app.MainLoop()