* Moved KernelManager attribute management code in FrontendWidget into a mixin class usable in any Qt frontend. Registering handlers for message types is now trivial.

* Made the Qt kernel manager signal interface more consistent with the revised message specification.

IPython/frontend/qt/base_frontend_mixin.py

@@ -0,0 +1,85 b''
+""" Defines a convenient mix-in class for implementing Qt frontends.
+"""
+
+class BaseFrontendMixin(object):
+    """ A mix-in class for implementing Qt frontends.
+
+    To handle messages of a particular type, frontends need only define an
+    appropriate handler method. For example, to handle 'stream' messaged, define
+    a '_handle_stream(msg)' method.
+    """
+
+    #---------------------------------------------------------------------------
+    # 'BaseFrontendMixin' concrete interface
+    #---------------------------------------------------------------------------
+    
+    def _get_kernel_manager(self):
+        """ Returns the current kernel manager.
+        """
+        return self._kernel_manager
+
+    def _set_kernel_manager(self, kernel_manager):
+        """ Disconnect from the current kernel manager (if any) and set a new
+            kernel manager.
+        """
+        # Disconnect the old kernel manager, if necessary.
+        old_manager = self._kernel_manager
+        if old_manager is not None:
+            old_manager.started_channels.disconnect(self._started_channels)
+            old_manager.stopped_channels.disconnect(self._stopped_channels)
+
+            # Disconnect the old kernel manager's channels.
+            old_manager.sub_channel.message_received.disconnect(self._dispatch)
+            old_manager.xreq_channel.message_received.disconnect(self._dispatch)
+            old_manager.rep_channel.message_received.connect(self._dispatch)
+
+            # Handle the case where the old kernel manager is still listening.
+            if old_manager.channels_running:
+                self._stopped_channels()
+
+        # Set the new kernel manager.
+        self._kernel_manager = kernel_manager
+        if kernel_manager is None:
+            return
+
+        # Connect the new kernel manager.
+        kernel_manager.started_channels.connect(self._started_channels)
+        kernel_manager.stopped_channels.connect(self._stopped_channels)
+
+        # Connect the new kernel manager's channels.
+        kernel_manager.sub_channel.message_received.connect(self._dispatch)
+        kernel_manager.xreq_channel.message_received.connect(self._dispatch)
+        kernel_manager.rep_channel.message_received.connect(self._dispatch)
+        
+        # Handle the case where the kernel manager started channels before
+        # we connected.
+        if kernel_manager.channels_running:
+            self._started_channels()
+
+    kernel_manager = property(_get_kernel_manager, _set_kernel_manager)
+
+    #---------------------------------------------------------------------------
+    # 'BaseFrontendMixin' abstract interface
+    #---------------------------------------------------------------------------
+    
+    def _started_channels(self):
+        """ Called when the KernelManager channels have started listening or 
+            when the frontend is assigned an already listening KernelManager.
+        """
+
+    def _stopped_channels(self):
+        """ Called when the KernelManager channels have stopped listening or
+            when a listening KernelManager is removed from the frontend.
+        """
+
+    #---------------------------------------------------------------------------
+    # Private interface
+    #---------------------------------------------------------------------------
+
+    def _dispatch(self, msg):
+        """ Call the frontend handler associated with
+        """
+        msg_type = msg['msg_type']
+        handler = getattr(self, '_handle_' + msg_type, None)
+        if handler:
+            handler(msg)

IPython/frontend/qt/console/frontend_widget.py

@@ -1,376 +1,340 b''
 # Standard library imports
 import signal
 import sys
 
 # System library imports
 from pygments.lexers import PythonLexer
 from PyQt4 import QtCore, QtGui
 import zmq
 
 # Local imports
 from IPython.core.inputsplitter import InputSplitter
+from IPython.frontend.qt.base_frontend_mixin import BaseFrontendMixin
 from call_tip_widget import CallTipWidget
 from completion_lexer import CompletionLexer
 from console_widget import HistoryConsoleWidget
 from pygments_highlighter import PygmentsHighlighter
 
 
 class FrontendHighlighter(PygmentsHighlighter):
     """ A PygmentsHighlighter that can be turned on and off and that ignores
         prompts.
     """
 
     def __init__(self, frontend):
         super(FrontendHighlighter, self).__init__(frontend._control.document())
         self._current_offset = 0
         self._frontend = frontend
         self.highlighting_on = False
 
     def highlightBlock(self, qstring):
         """ Highlight a block of text. Reimplemented to highlight selectively.
         """
         if not self.highlighting_on:
             return
 
         # The input to this function is unicode string that may contain
         # paragraph break characters, non-breaking spaces, etc. Here we acquire
         # the string as plain text so we can compare it.
         current_block = self.currentBlock()
         string = self._frontend._get_block_plain_text(current_block)
 
         # Decide whether to check for the regular or continuation prompt.
         if current_block.contains(self._frontend._prompt_pos):
             prompt = self._frontend._prompt
         else:
             prompt = self._frontend._continuation_prompt
 
         # Don't highlight the part of the string that contains the prompt.
         if string.startswith(prompt):
             self._current_offset = len(prompt)
             qstring.remove(0, len(prompt))
         else:
             self._current_offset = 0
 
         PygmentsHighlighter.highlightBlock(self, qstring)
 
     def setFormat(self, start, count, format):
         """ Reimplemented to highlight selectively.
         """
         start += self._current_offset
         PygmentsHighlighter.setFormat(self, start, count, format)
 
 
-class FrontendWidget(HistoryConsoleWidget):
+class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):
     """ A Qt frontend for a generic Python kernel.
     """
    
     # Emitted when an 'execute_reply' is received from the kernel.
     executed = QtCore.pyqtSignal(object)
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
     
     def __init__(self, *args, **kw):
         super(FrontendWidget, self).__init__(*args, **kw)
 
         # FrontendWidget protected variables.
         self._call_tip_widget = CallTipWidget(self._control)
         self._completion_lexer = CompletionLexer(PythonLexer())
         self._hidden = True
         self._highlighter = FrontendHighlighter(self)
         self._input_splitter = InputSplitter(input_mode='replace')
         self._kernel_manager = None
 
         # Configure the ConsoleWidget.
         self.tab_width = 4
         self._set_continuation_prompt('... ')
 
         # Connect signal handlers.
         document = self._control.document()
         document.contentsChange.connect(self._document_contents_change)
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' abstract interface
     #---------------------------------------------------------------------------
 
     def _is_complete(self, source, interactive):
         """ Returns whether 'source' can be completely processed and a new
             prompt created. When triggered by an Enter/Return key press,
             'interactive' is True; otherwise, it is False.
         """
         complete = self._input_splitter.push(source.expandtabs(4))
         if interactive:
             complete = not self._input_splitter.push_accepts_more()
         return complete
 
     def _execute(self, source, hidden):
         """ Execute 'source'. If 'hidden', do not show any output.
         """
         self.kernel_manager.xreq_channel.execute(source)
         self._hidden = hidden
 
     def _execute_interrupt(self):
         """ Attempts to stop execution. Returns whether this method has an
             implementation.
         """
         self._interrupt_kernel()
         return True
         
     def _prompt_started_hook(self):
         """ Called immediately after a new prompt is displayed.
         """
         if not self._reading:
             self._highlighter.highlighting_on = True
 
             # Auto-indent if this is a continuation prompt.
             if self._get_prompt_cursor().blockNumber() != \
                     self._get_end_cursor().blockNumber():
                 spaces = self._input_splitter.indent_spaces
                 self._append_plain_text('\t' * (spaces / self.tab_width))
                 self._append_plain_text(' ' * (spaces % self.tab_width))
 
     def _prompt_finished_hook(self):
         """ Called immediately after a prompt is finished, i.e. when some input
             will be processed and a new prompt displayed.
         """
         if not self._reading:
             self._highlighter.highlighting_on = False
 
     def _tab_pressed(self):
         """ Called when the tab key is pressed. Returns whether to continue
             processing the event.
         """
         self._keep_cursor_in_buffer()
         cursor = self._get_cursor()
         return not self._complete()
 
     #---------------------------------------------------------------------------
-    # 'FrontendWidget' interface
+    # 'BaseFrontendMixin' abstract interface
     #---------------------------------------------------------------------------
 
-    def execute_file(self, path, hidden=False):
-        """ Attempts to execute file with 'path'. If 'hidden', no output is
-            shown.
+    def _handle_complete_reply(self, rep):
+        """ Handle replies for tab completion.
         """
-        self.execute('execfile("%s")' % path, hidden=hidden)
+        cursor = self._get_cursor()
+        if rep['parent_header']['msg_id'] == self._complete_id and \
+                cursor.position() == self._complete_pos:
+            text = '.'.join(self._get_context())
+            cursor.movePosition(QtGui.QTextCursor.Left, n=len(text))
+            self._complete_with_items(cursor, rep['content']['matches'])
 
-    def _get_kernel_manager(self):
-        """ Returns the current kernel manager.
+    def _handle_execute_reply(self, msg):
+        """ Handles replies for code execution.
         """
-        return self._kernel_manager
+        if not self._hidden:
+            # Make sure that all output from the SUB channel has been processed
+            # before writing a new prompt.
+            self.kernel_manager.sub_channel.flush()
+
+            content = msg['content']
+            status = content['status']
+            if status == 'ok':
+                self._process_execute_ok(msg)
+            elif status == 'error':
+                self._process_execute_error(msg)
+            elif status == 'abort':
+                self._process_execute_abort(msg)
+
+            self._hidden = True
+            self._show_interpreter_prompt()
+            self.executed.emit(msg)
 
-    def _set_kernel_manager(self, kernel_manager):
-        """ Disconnect from the current kernel manager (if any) and set a new
-            kernel manager.
+    def _handle_input_request(self, msg):
+        """ Handle requests for raw_input.
         """
-        # Disconnect the old kernel manager, if necessary.
-        if self._kernel_manager is not None:
-            self._kernel_manager.started_channels.disconnect(
-                self._started_channels)
-            self._kernel_manager.stopped_channels.disconnect(
-                self._stopped_channels)
-
-            # Disconnect the old kernel manager's channels.
-            sub = self._kernel_manager.sub_channel
-            xreq = self._kernel_manager.xreq_channel
-            rep = self._kernel_manager.rep_channel
-            sub.message_received.disconnect(self._handle_sub)
-            xreq.execute_reply.disconnect(self._handle_execute_reply)
-            xreq.complete_reply.disconnect(self._handle_complete_reply)
-            xreq.object_info_reply.disconnect(self._handle_object_info_reply)
-            rep.input_requested.disconnect(self._handle_req)
-
-            # Handle the case where the old kernel manager is still listening.
-            if self._kernel_manager.channels_running:
-                self._stopped_channels()
-
-        # Set the new kernel manager.
-        self._kernel_manager = kernel_manager
-        if kernel_manager is None:
-            return
+        # Make sure that all output from the SUB channel has been processed
+        # before entering readline mode.
+        self.kernel_manager.sub_channel.flush()
 
-        # Connect the new kernel manager.
-        kernel_manager.started_channels.connect(self._started_channels)
-        kernel_manager.stopped_channels.connect(self._stopped_channels)
+        def callback(line):
+            self.kernel_manager.rep_channel.input(line)
+        self._readline(msg['content']['prompt'], callback=callback)
 
-        # Connect the new kernel manager's channels.
-        sub = kernel_manager.sub_channel
-        xreq = kernel_manager.xreq_channel
-        rep = kernel_manager.rep_channel
-        sub.message_received.connect(self._handle_sub)
-        xreq.execute_reply.connect(self._handle_execute_reply)
-        xreq.complete_reply.connect(self._handle_complete_reply)
-        xreq.object_info_reply.connect(self._handle_object_info_reply)
-        rep.input_requested.connect(self._handle_req)
+    def _handle_object_info_reply(self, rep):
+        """ Handle replies for call tips.
+        """
+        cursor = self._get_cursor()
+        if rep['parent_header']['msg_id'] == self._call_tip_id and \
+                cursor.position() == self._call_tip_pos:
+            doc = rep['content']['docstring']
+            if doc:
+                self._call_tip_widget.show_docstring(doc)
         
-        # Handle the case where the kernel manager started channels before
-        # we connected.
-        if kernel_manager.channels_running:
-            self._started_channels()
+    def _handle_pyout(self, msg):
+        """ Handle display hook output.
+        """
+        self._append_plain_text(msg['content']['data'] + '\n')
+
+    def _handle_stream(self, msg):
+        """ Handle stdout, stderr, and stdin.
+        """
+        self._append_plain_text(msg['content']['data'])
+        self._control.moveCursor(QtGui.QTextCursor.End)
 
-    kernel_manager = property(_get_kernel_manager, _set_kernel_manager)
+    def _started_channels(self):
+        """ Called when the KernelManager channels have started listening or 
+            when the frontend is assigned an already listening KernelManager.
+        """
+        self._reset()
+        self._append_plain_text(self._get_banner())
+        self._show_interpreter_prompt()
+
+    def _stopped_channels(self):
+        """ Called when the KernelManager channels have stopped listening or
+            when a listening KernelManager is removed from the frontend.
+        """
+        # FIXME: Print a message here?
+        pass
+
+    #---------------------------------------------------------------------------
+    # 'FrontendWidget' interface
+    #---------------------------------------------------------------------------
+
+    def execute_file(self, path, hidden=False):
+        """ Attempts to execute file with 'path'. If 'hidden', no output is
+            shown.
+        """
+        self.execute('execfile("%s")' % path, hidden=hidden)
 
     #---------------------------------------------------------------------------
     # 'FrontendWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _call_tip(self):
         """ Shows a call tip, if appropriate, at the current cursor location.
         """
         # Decide if it makes sense to show a call tip
         cursor = self._get_cursor()
         cursor.movePosition(QtGui.QTextCursor.Left)
         document = self._control.document()
         if document.characterAt(cursor.position()).toAscii() != '(':
             return False
         context = self._get_context(cursor)
         if not context:
             return False
 
         # Send the metadata request to the kernel
         name = '.'.join(context)
         self._call_tip_id = self.kernel_manager.xreq_channel.object_info(name)
         self._call_tip_pos = self._get_cursor().position()
         return True
 
     def _complete(self):
         """ Performs completion at the current cursor location.
         """
         # Decide if it makes sense to do completion
         context = self._get_context()
         if not context:
             return False
 
         # Send the completion request to the kernel
         text = '.'.join(context)
         self._complete_id = self.kernel_manager.xreq_channel.complete(
             text, self._get_input_buffer_cursor_line(), self.input_buffer)
         self._complete_pos = self._get_cursor().position()
         return True
 
     def _get_banner(self):
         """ Gets a banner to display at the beginning of a session.
         """
         banner = 'Python %s on %s\nType "help", "copyright", "credits" or ' \
             '"license" for more information.'
         return banner % (sys.version, sys.platform)
 
     def _get_context(self, cursor=None):
         """ Gets the context at the current cursor location.
         """
         if cursor is None:
             cursor = self._get_cursor()
         cursor.movePosition(QtGui.QTextCursor.StartOfBlock, 
                             QtGui.QTextCursor.KeepAnchor)
         text = str(cursor.selection().toPlainText())
         return self._completion_lexer.get_context(text)
 
     def _interrupt_kernel(self):
         """ Attempts to the interrupt the kernel.
         """
         if self.kernel_manager.has_kernel:
             self.kernel_manager.signal_kernel(signal.SIGINT)
         else:
             self._append_plain_text('Kernel process is either remote or '
                                     'unspecified. Cannot interrupt.\n')
 
-    def _show_interpreter_prompt(self):
-        """ Shows a prompt for the interpreter.
+    def _process_execute_abort(self, msg):
+        """ Process a reply for an aborted execution request.
         """
-        self._show_prompt('>>> ')
+        self._append_plain_text("ERROR: execution aborted\n")
 
-    #------ Signal handlers ----------------------------------------------------
-
-    def _started_channels(self):
-        """ Called when the kernel manager has started listening.
+    def _process_execute_error(self, msg):
+        """ Process a reply for an execution request that resulted in an error.
         """
-        self._reset()
-        self._append_plain_text(self._get_banner())
-        self._show_interpreter_prompt()
+        content = msg['content']
+        traceback = ''.join(content['traceback'])
+        self._append_plain_text(traceback)
 
-    def _stopped_channels(self):
-        """ Called when the kernel manager has stopped listening.
+    def _process_execute_ok(self, msg):
+        """ Process a reply for a successful execution equest.
         """
-        # FIXME: Print a message here?
+        # The basic FrontendWidget doesn't handle payloads, as they are a
+        # mechanism for going beyond the standard Python interpreter model.
         pass
 
+    def _show_interpreter_prompt(self):
+        """ Shows a prompt for the interpreter.
+        """
+        self._show_prompt('>>> ')
+
+    #------ Signal handlers ----------------------------------------------------
+
     def _document_contents_change(self, position, removed, added):
         """ Called whenever the document's content changes. Display a call tip
             if appropriate.
         """
         # Calculate where the cursor should be *after* the change:
         position += added
 
         document = self._control.document()
         if position == self._get_cursor().position():
             self._call_tip()
-
-    def _handle_req(self, req):
-        # Make sure that all output from the SUB channel has been processed
-        # before entering readline mode.
-        self.kernel_manager.sub_channel.flush()
-
-        def callback(line):
-            self.kernel_manager.rep_channel.input(line)
-        self._readline(req['content']['prompt'], callback=callback)
-
-    def _handle_sub(self, omsg):
-        if self._hidden:
-            return
-        handler = getattr(self, '_handle_%s' % omsg['msg_type'], None)
-        if handler is not None:
-            handler(omsg)
-
-    def _handle_pyout(self, omsg):
-        self._append_plain_text(omsg['content']['data'] + '\n')
-
-    def _handle_stream(self, omsg):
-        self._append_plain_text(omsg['content']['data'])
-        self._control.moveCursor(QtGui.QTextCursor.End)
-        
-    def _handle_execute_reply(self, reply):
-        if self._hidden:
-            return
-
-        # Make sure that all output from the SUB channel has been processed
-        # before writing a new prompt.
-        self.kernel_manager.sub_channel.flush()
-
-        content = reply['content']
-        status = content['status']
-        if status == 'ok':
-            self._handle_execute_payload(content['payload'])
-        elif status == 'error':
-            self._handle_execute_error(reply)
-        elif status == 'aborted':
-            text = "ERROR: ABORTED\n"
-            self._append_plain_text(text)
-
-        self._hidden = True
-        self._show_interpreter_prompt()
-        self.executed.emit(reply)
-
-    def _handle_execute_error(self, reply):
-        content = reply['content']
-        traceback = ''.join(content['traceback'])
-        self._append_plain_text(traceback)
-
-    def _handle_execute_payload(self, payload):
-        pass
-
-    def _handle_complete_reply(self, rep):
-        cursor = self._get_cursor()
-        if rep['parent_header']['msg_id'] == self._complete_id and \
-                cursor.position() == self._complete_pos:
-            text = '.'.join(self._get_context())
-            cursor.movePosition(QtGui.QTextCursor.Left, n=len(text))
-            self._complete_with_items(cursor, rep['content']['matches'])
-
-    def _handle_object_info_reply(self, rep):
-        cursor = self._get_cursor()
-        if rep['parent_header']['msg_id'] == self._call_tip_id and \
-                cursor.position() == self._call_tip_pos:
-            doc = rep['content']['docstring']
-            if doc:
-                self._call_tip_widget.show_docstring(doc)

IPython/frontend/qt/console/ipython_widget.py

@@ -1,184 +1,186 b''
 # System library imports
 from PyQt4 import QtCore, QtGui
 
 # Local imports
 from IPython.core.usage import default_banner
 from frontend_widget import FrontendWidget
 
 
 class IPythonWidget(FrontendWidget):
     """ A FrontendWidget for an IPython kernel.
     """
 
     # The default stylesheet: black text on a white background.
     default_stylesheet = """
         .error { color: red; }
         .in-prompt { color: navy; }
         .in-prompt-number { font-weight: bold; }
         .out-prompt { color: darkred; }
         .out-prompt-number { font-weight: bold; }
     """
 
     # A dark stylesheet: white text on a black background.
     dark_stylesheet = """
         QPlainTextEdit { background-color: black; color: white }
         QFrame { border: 1px solid grey; }
         .error { color: red; }
         .in-prompt { color: lime; }
         .in-prompt-number { color: lime; font-weight: bold; }
         .out-prompt { color: red; }
         .out-prompt-number { color: red; font-weight: bold; }
     """
 
     # Default prompts.
     in_prompt = '<br/>In [<span class="in-prompt-number">%i</span>]: '
     out_prompt = 'Out[<span class="out-prompt-number">%i</span>]: '
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
     
     def __init__(self, *args, **kw):
         super(IPythonWidget, self).__init__(*args, **kw)
 
         # Initialize protected variables.
         self._previous_prompt_blocks = []
         self._prompt_count = 0
 
         # Set a default stylesheet.
         self.reset_styling()
 
     #---------------------------------------------------------------------------
+    # 'BaseFrontendMixin' abstract interface
+    #---------------------------------------------------------------------------
+
+    def _handle_pyout(self, msg):
+        """ Reimplemented for IPython-style "display hook".
+        """
+        self._append_html(self._make_out_prompt(self._prompt_count))
+        self._save_prompt_block()
+        
+        self._append_plain_text(msg['content']['data'] + '\n')
+
+    #---------------------------------------------------------------------------
     # 'FrontendWidget' interface
     #---------------------------------------------------------------------------
 
     def execute_file(self, path, hidden=False):
         """ Reimplemented to use the 'run' magic.
         """
         self.execute('run %s' % path, hidden=hidden)
 
     #---------------------------------------------------------------------------
     # 'FrontendWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _get_banner(self):
         """ Reimplemented to return IPython's default banner.
         """
         return default_banner
 
+    def _process_execute_error(self, msg):
+        """ Reimplemented for IPython-style traceback formatting.
+        """
+        content = msg['content']
+        traceback_lines = content['traceback'][:]
+        traceback = ''.join(traceback_lines)
+        traceback = traceback.replace(' ', '&nbsp;')
+        traceback = traceback.replace('\n', '<br/>')
+
+        ename = content['ename']
+        ename_styled = '<span class="error">%s</span>' % ename
+        traceback = traceback.replace(ename, ename_styled)
+
+        self._append_html(traceback)
+
     def _show_interpreter_prompt(self):
         """ Reimplemented for IPython-style prompts.
         """
         # Update old prompt numbers if necessary.
         previous_prompt_number = self._prompt_count
         if previous_prompt_number != self._prompt_count:
             for i, (block, length) in enumerate(self._previous_prompt_blocks):
                 if block.isValid():
                     cursor = QtGui.QTextCursor(block)
                     cursor.movePosition(QtGui.QTextCursor.Right,
                                         QtGui.QTextCursor.KeepAnchor, length-1)
                     if i == 0:
                         prompt = self._make_in_prompt(previous_prompt_number)
                     else:
                         prompt = self._make_out_prompt(previous_prompt_number)
                     self._insert_html(cursor, prompt)
         self._previous_prompt_blocks = []
 
         # Show a new prompt.
         self._prompt_count += 1
         self._show_prompt(self._make_in_prompt(self._prompt_count), html=True)
         self._save_prompt_block()
 
         # Update continuation prompt to reflect (possibly) new prompt length.
         self._set_continuation_prompt(
             self._make_continuation_prompt(self._prompt), html=True)
 
-    #------ Signal handlers ----------------------------------------------------
-
-    def _handle_execute_error(self, reply):
-        """ Reimplemented for IPython-style traceback formatting.
-        """
-        content = reply['content']
-        traceback_lines = content['traceback'][:]
-        traceback = ''.join(traceback_lines)
-        traceback = traceback.replace(' ', '&nbsp;')
-        traceback = traceback.replace('\n', '<br/>')
-
-        ename = content['ename']
-        ename_styled = '<span class="error">%s</span>' % ename
-        traceback = traceback.replace(ename, ename_styled)
-
-        self._append_html(traceback)
-
-    def _handle_pyout(self, omsg):
-        """ Reimplemented for IPython-style "display hook".
-        """
-        self._append_html(self._make_out_prompt(self._prompt_count))
-        self._save_prompt_block()
-        
-        self._append_plain_text(omsg['content']['data'] + '\n')
-
     #---------------------------------------------------------------------------
     # 'IPythonWidget' interface
     #---------------------------------------------------------------------------
 
     def reset_styling(self):
         """ Restores the default IPythonWidget styling.
         """
         self.set_styling(self.default_stylesheet, syntax_style='default')
         #self.set_styling(self.dark_stylesheet, syntax_style='monokai')
 
     def set_styling(self, stylesheet, syntax_style=None):
         """ Sets the IPythonWidget styling.
 
         Parameters:
         -----------
         stylesheet : str
             A CSS stylesheet. The stylesheet can contain classes for:
                 1. Qt: QPlainTextEdit, QFrame, QWidget, etc
                 2. Pygments: .c, .k, .o, etc (see PygmentsHighlighter)
                 3. IPython: .error, .in-prompt, .out-prompt, etc.
 
         syntax_style : str or None [default None]
             If specified, use the Pygments style with given name. Otherwise, 
             the stylesheet is queried for Pygments style information.
         """
         self.setStyleSheet(stylesheet)
         self._control.document().setDefaultStyleSheet(stylesheet)
 
         if syntax_style is None:
             self._highlighter.set_style_sheet(stylesheet)
         else:
             self._highlighter.set_style(syntax_style)
 
     #---------------------------------------------------------------------------
     # 'IPythonWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _make_in_prompt(self, number):
         """ Given a prompt number, returns an HTML In prompt.
         """
         body = self.in_prompt % number
         return '<span class="in-prompt">%s</span>' % body
 
     def _make_continuation_prompt(self, prompt):
         """ Given a plain text version of an In prompt, returns an HTML
             continuation prompt.
         """
         end_chars = '...: '
         space_count = len(prompt.lstrip('\n')) - len(end_chars)
         body = '&nbsp;' * space_count + end_chars
         return '<span class="in-prompt">%s</span>' % body
         
     def _make_out_prompt(self, number):
         """ Given a prompt number, returns an HTML Out prompt.
         """
         body = self.out_prompt % number
         return '<span class="out-prompt">%s</span>' % body
 
     def _save_prompt_block(self):
         """ Assuming a prompt has just been written at the end of the buffer,
             store the QTextBlock that contains it and its length.
         """
         block = self._control.document().lastBlock()
         self._previous_prompt_blocks.append((block, block.length()))

IPython/frontend/qt/console/rich_ipython_widget.py

@@ -1,118 +1,119 b''
 # System library imports
 from PyQt4 import QtCore, QtGui
 
 # Local imports
 from IPython.frontend.qt.svg import save_svg, svg_to_clipboard, svg_to_image
 from ipython_widget import IPythonWidget
 
 
 class RichIPythonWidget(IPythonWidget):
     """ An IPythonWidget that supports rich text, including lists, images, and
         tables. Note that raw performance will be reduced compared to the plain
         text version.
     """
 
     # Protected class variables.
     _svg_text_format_property = 1
 
     #---------------------------------------------------------------------------
     # 'QObject' interface
     #---------------------------------------------------------------------------
 
     def __init__(self, parent=None):
         """ Create a RichIPythonWidget.
         """
         super(RichIPythonWidget, self).__init__(kind='rich', parent=parent)
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _show_context_menu(self, pos):
         """ Reimplemented to show a custom context menu for images.
         """
         format = self._control.cursorForPosition(pos).charFormat()
         name = format.stringProperty(QtGui.QTextFormat.ImageName)
         if name.isEmpty():
             super(RichIPythonWidget, self)._show_context_menu(pos)
         else:
             menu = QtGui.QMenu()
 
             menu.addAction('Copy Image', lambda: self._copy_image(name))
             menu.addAction('Save Image As...', lambda: self._save_image(name))
             menu.addSeparator()
 
             svg = format.stringProperty(self._svg_text_format_property)
             if not svg.isEmpty():
                 menu.addSeparator()
                 menu.addAction('Copy SVG', lambda: svg_to_clipboard(svg))
                 menu.addAction('Save SVG As...', 
                                lambda: save_svg(svg, self._control))
                 
             menu.exec_(self._control.mapToGlobal(pos))
     
     #---------------------------------------------------------------------------
     # 'FrontendWidget' protected interface
     #---------------------------------------------------------------------------
 
-    def _handle_execute_payload(self, payload):
-        """ Reimplemented to handle pylab plot payloads.
+    def _process_execute_ok(self, msg):
+        """ Reimplemented to handle matplotlib plot payloads.
         """
+        payload = msg['content']['payload']
         plot_payload = payload.get('plot', None)
         if plot_payload and plot_payload['format'] == 'svg':
             svg = plot_payload['data']
             try:
                 image = svg_to_image(svg)
             except ValueError:
                 self._append_plain_text('Received invalid plot data.')
             else:
                 format = self._add_image(image)
                 format.setProperty(self._svg_text_format_property, svg)
                 cursor = self._get_end_cursor()
                 cursor.insertBlock()
                 cursor.insertImage(format)
                 cursor.insertBlock()
         else:
-            super(RichIPythonWidget, self)._handle_execute_payload(payload)
+            super(RichIPythonWidget, self)._process_execute_ok(msg)
 
     #---------------------------------------------------------------------------
     # 'RichIPythonWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _add_image(self, image):
         """ Adds the specified QImage to the document and returns a
             QTextImageFormat that references it.
         """
         document = self._control.document()
         name = QtCore.QString.number(image.cacheKey())
         document.addResource(QtGui.QTextDocument.ImageResource,
                              QtCore.QUrl(name), image)
         format = QtGui.QTextImageFormat()
         format.setName(name)
         return format
 
     def _copy_image(self, name):
         """ Copies the ImageResource with 'name' to the clipboard.
         """
         image = self._get_image(name)
         QtGui.QApplication.clipboard().setImage(image)
 
     def _get_image(self, name):
         """ Returns the QImage stored as the ImageResource with 'name'.
         """
         document = self._control.document()
         variant = document.resource(QtGui.QTextDocument.ImageResource,
                                     QtCore.QUrl(name))
         return variant.toPyObject()
 
     def _save_image(self, name, format='PNG'):
         """ Shows a save dialog for the ImageResource with 'name'.
         """
         dialog = QtGui.QFileDialog(self._control, 'Save Image')
         dialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
         dialog.setDefaultSuffix(format.lower())
         dialog.setNameFilter('%s file (*.%s)' % (format, format.lower()))
         if dialog.exec_():
             filename = dialog.selectedFiles()[0]
             image = self._get_image(name)
             image.save(filename, format)

IPython/frontend/qt/kernelmanager.py

@@ -1,180 +1,192 b''
 """ Defines a KernelManager that provides signals and slots.
 """
 
 # System library imports.
 from PyQt4 import QtCore
 import zmq
 
 # IPython imports.
 from IPython.zmq.kernelmanager import KernelManager, SubSocketChannel, \
     XReqSocketChannel, RepSocketChannel
 from util import MetaQObjectHasTraits
 
 # When doing multiple inheritance from QtCore.QObject and other classes
 # the calling of the parent __init__'s is a subtle issue:
 # * QtCore.QObject does not call super so you can't use super and put
 #   QObject first in the inheritance list.
 # * QtCore.QObject.__init__ takes 1 argument, the parent. So if you are going
 #   to use super, any class that comes before QObject must pass it something
 #   reasonable.
 # In summary, I don't think using super in these situations will work.
 # Instead we will need to call the __init__ methods of both parents
 # by hand.  Not pretty, but it works.
 
 class QtSubSocketChannel(SubSocketChannel, QtCore.QObject):
 
     # Emitted when any message is received.
     message_received = QtCore.pyqtSignal(object)
 
-    # Emitted when a message of type 'pyout' or 'stdout' is received.
-    output_received = QtCore.pyqtSignal(object)
+    # Emitted when a message of type 'stream' is received.
+    stream_received = QtCore.pyqtSignal(object)
 
-    # Emitted when a message of type 'pyerr' or 'stderr' is received.
-    error_received = QtCore.pyqtSignal(object)
+    # Emitted when a message of type 'pyin' is received.
+    pyin_received = QtCore.pyqtSignal(object)
+
+    # Emitted when a message of type 'pyout' is received.
+    pyout_received = QtCore.pyqtSignal(object)
+
+    # Emitted when a message of type 'pyerr' is received.
+    pyerr_received = QtCore.pyqtSignal(object)
+
+    # Emitted when a crash report message is received from the kernel's
+    # last-resort sys.excepthook.
+    crash_received = QtCore.pyqtSignal(object)
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
     
     def __init__(self, *args, **kw):
         """ Reimplemented to ensure that QtCore.QObject is initialized first.
         """
         QtCore.QObject.__init__(self)
         SubSocketChannel.__init__(self, *args, **kw)
 
     #---------------------------------------------------------------------------
     # 'SubSocketChannel' interface
     #---------------------------------------------------------------------------
     
     def call_handlers(self, msg):
         """ Reimplemented to emit signals instead of making callbacks.
         """
         # Emit the generic signal.
         self.message_received.emit(msg)
         
         # Emit signals for specialized message types.
         msg_type = msg['msg_type']
-        if msg_type in ('pyout', 'stdout'):
-            self.output_received.emit(msg)
-        elif msg_type in ('pyerr', 'stderr'):
-            self.error_received.emit(msg)
+        signal = getattr(self, msg_type + '_received', None)
+        if signal:
+            signal.emit(msg)
+        elif msg_type in ('stdout', 'stderr'):
+            self.stream_received.emit(msg)
 
     def flush(self):
         """ Reimplemented to ensure that signals are dispatched immediately.
         """
         super(QtSubSocketChannel, self).flush()
         QtCore.QCoreApplication.instance().processEvents()
 
 
 class QtXReqSocketChannel(XReqSocketChannel, QtCore.QObject):
 
     # Emitted when any message is received.
     message_received = QtCore.pyqtSignal(object)
 
     # Emitted when a reply has been received for the corresponding request type.
     execute_reply = QtCore.pyqtSignal(object)
     complete_reply = QtCore.pyqtSignal(object)
     object_info_reply = QtCore.pyqtSignal(object)
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
     
     def __init__(self, *args, **kw):
         """ Reimplemented to ensure that QtCore.QObject is initialized first.
         """
         QtCore.QObject.__init__(self)
         XReqSocketChannel.__init__(self, *args, **kw)
 
     #---------------------------------------------------------------------------
     # 'XReqSocketChannel' interface
     #---------------------------------------------------------------------------
     
     def call_handlers(self, msg):
         """ Reimplemented to emit signals instead of making callbacks.
         """
         # Emit the generic signal.
         self.message_received.emit(msg)
         
         # Emit signals for specialized message types.
         msg_type = msg['msg_type']
         signal = getattr(self, msg_type, None)
         if signal:
             signal.emit(msg)
 
 
 class QtRepSocketChannel(RepSocketChannel, QtCore.QObject):
 
     # Emitted when any message is received.
     message_received = QtCore.pyqtSignal(object)
 
     # Emitted when an input request is received.
     input_requested = QtCore.pyqtSignal(object)
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
     
     def __init__(self, *args, **kw):
         """ Reimplemented to ensure that QtCore.QObject is initialized first.
         """
         QtCore.QObject.__init__(self)
         RepSocketChannel.__init__(self, *args, **kw)
 
     #---------------------------------------------------------------------------
     # 'RepSocketChannel' interface
     #---------------------------------------------------------------------------
 
     def call_handlers(self, msg):
         """ Reimplemented to emit signals instead of making callbacks.
         """
         # Emit the generic signal.
         self.message_received.emit(msg)
         
         # Emit signals for specialized message types.
         msg_type = msg['msg_type']
         if msg_type == 'input_request':
             self.input_requested.emit(msg)
 
+
 class QtKernelManager(KernelManager, QtCore.QObject):
     """ A KernelManager that provides signals and slots.
     """
 
     __metaclass__ = MetaQObjectHasTraits
 
     # Emitted when the kernel manager has started listening.
     started_channels = QtCore.pyqtSignal()
 
     # Emitted when the kernel manager has stopped listening.
     stopped_channels = QtCore.pyqtSignal()
 
     # Use Qt-specific channel classes that emit signals.
     sub_channel_class = QtSubSocketChannel
     xreq_channel_class = QtXReqSocketChannel
     rep_channel_class = QtRepSocketChannel
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
     
     def __init__(self, *args, **kw):
         """ Reimplemented to ensure that QtCore.QObject is initialized first.
         """
         QtCore.QObject.__init__(self)
         KernelManager.__init__(self, *args, **kw)
 
     #---------------------------------------------------------------------------
     # 'KernelManager' interface
     #---------------------------------------------------------------------------
     
     def start_channels(self):
         """ Reimplemented to emit signal.
         """
         super(QtKernelManager, self).start_channels()
         self.started_channels.emit()
 
     def stop_channels(self):
         """ Reimplemented to emit signal.
         """ 
         super(QtKernelManager, self).stop_channels()
         self.stopped_channels.emit()