Refactored ConsoleWidget to encapsulate, rather than inherit from, QPlainTextEdit. This permits a QTextEdit to be substituted for a QPlainTextEdit if desired. It also makes it more clear what is the public interface of ConsoleWidget.

IPython/frontend/qt/console/console_widget.py

@@ -1,978 +1,1052 b''
 # Standard library imports
 import sys
 
 # System library imports
 from PyQt4 import QtCore, QtGui
 
 # Local imports
 from ansi_code_processor import QtAnsiCodeProcessor
 from completion_widget import CompletionWidget
 
 
-class ConsoleWidget(QtGui.QPlainTextEdit):
+class ConsoleWidget(QtGui.QWidget):
     """ Base class for console-type widgets. This class is mainly concerned with
         dealing with the prompt, keeping the cursor inside the editing line, and
         handling ANSI escape sequences.
     """
 
     # Whether to process ANSI escape codes.
     ansi_codes = True
 
     # The maximum number of lines of text before truncation.
     buffer_size = 500
 
     # Whether to use a CompletionWidget or plain text output for tab completion.
     gui_completion = True
 
     # Whether to override ShortcutEvents for the keybindings defined by this
     # widget (Ctrl+n, Ctrl+a, etc). Enable this if you want this widget to take
     # priority (when it has focus) over, e.g., window-level menu shortcuts.
     override_shortcuts = False
 
+    # Signals that indicate ConsoleWidget state.
+    copy_available = QtCore.pyqtSignal(bool)
+    redo_available = QtCore.pyqtSignal(bool)
+    undo_available = QtCore.pyqtSignal(bool)
+
     # Protected class variables.
     _ctrl_down_remap = { QtCore.Qt.Key_B : QtCore.Qt.Key_Left,
                          QtCore.Qt.Key_F : QtCore.Qt.Key_Right,
                          QtCore.Qt.Key_A : QtCore.Qt.Key_Home,
                          QtCore.Qt.Key_E : QtCore.Qt.Key_End,
                          QtCore.Qt.Key_P : QtCore.Qt.Key_Up,
                          QtCore.Qt.Key_N : QtCore.Qt.Key_Down,
                          QtCore.Qt.Key_D : QtCore.Qt.Key_Delete, }
     _shortcuts = set(_ctrl_down_remap.keys() +
                      [ QtCore.Qt.Key_C, QtCore.Qt.Key_V ])
 
     #---------------------------------------------------------------------------
     # 'QObject' interface
     #---------------------------------------------------------------------------
 
-    def __init__(self, parent=None):
-        QtGui.QPlainTextEdit.__init__(self, parent)
+    def __init__(self, kind='plain', parent=None):
+        """ Create a ConsoleWidget.
+        
+        Parameters
+        ----------
+        kind : str, optional [default 'plain']            
+            The type of text widget to use. Valid values are 'plain', which
+            specifies a QPlainTextEdit, and 'rich', which specifies an
+            QTextEdit.
+
+        parent : QWidget, optional [default None]
+            The parent for this widget.
+        """
+        super(ConsoleWidget, self).__init__(parent)
+
+        # Create the underlying text widget.
+        self._control = self._create_control(kind)
 
         # Initialize protected variables. Some variables contain useful state
         # information for subclasses; they should be considered read-only.
         self._ansi_processor = QtAnsiCodeProcessor()
-        self._completion_widget = CompletionWidget(self)
+        self._completion_widget = CompletionWidget(self._control)
         self._continuation_prompt = '> '
         self._continuation_prompt_html = None
         self._executing = False
         self._prompt = ''
         self._prompt_html = None
         self._prompt_pos = 0
         self._reading = False
         self._reading_callback = None
         self._tab_width = 8
 
-        # Set a monospaced font.
-        self.reset_font()
-
         # Define a custom context menu.
-        self._context_menu = QtGui.QMenu(self)
-
-        copy_action = QtGui.QAction('Copy', self)
-        copy_action.triggered.connect(self.copy)
-        self.copyAvailable.connect(copy_action.setEnabled)
-        self._context_menu.addAction(copy_action)
+        self._context_menu = self._create_context_menu()
 
-        self._paste_action = QtGui.QAction('Paste', self)
-        self._paste_action.triggered.connect(self.paste)
-        self._context_menu.addAction(self._paste_action)
-        self._context_menu.addSeparator()
+        # Set a monospaced font.
+        self.reset_font()
 
-        select_all_action = QtGui.QAction('Select All', self)
-        select_all_action.triggered.connect(self.selectAll)
-        self._context_menu.addAction(select_all_action)
-
-    def event(self, event):
-        """ Reimplemented to override shortcuts, if necessary.
-        """
-        # On Mac OS, it is always unnecessary to override shortcuts, hence the
-        # check below. Users should just use the Control key instead of the
-        # Command key.
-        if self.override_shortcuts and \
-                sys.platform != 'darwin' and \
-                event.type() == QtCore.QEvent.ShortcutOverride and \
-                self._control_down(event.modifiers()) and \
-                event.key() in self._shortcuts:
-            event.accept()
-            return True
-        else:
-            return QtGui.QPlainTextEdit.event(self, event)
+    def eventFilter(self, obj, event):
+        """ Reimplemented to ensure a console-like behavior in the underlying
+            text widget.
+        """
+        if obj == self._control:
+            etype = event.type()
+
+            # Override the default context menu with one that does not have
+            # destructive actions.
+            if etype == QtCore.QEvent.ContextMenu:
+                self._context_menu.exec_(event.globalPos())
+                return True
+
+            # Disable moving text by drag and drop.
+            elif etype == QtCore.QEvent.DragMove:
+                return True
+
+            elif etype == QtCore.QEvent.KeyPress:
+                return self._event_filter_keypress(event)
+
+            # On Mac OS, it is always unnecessary to override shortcuts, hence
+            # the check below. Users should just use the Control key instead of
+            # the Command key.
+            elif etype == QtCore.QEvent.ShortcutOverride:
+                if sys.platform != 'darwin' and \
+                        self._control_key_down(event.modifiers()) and \
+                        event.key() in self._shortcuts:
+                    event.accept()
+                return False
+
+        return super(ConsoleWidget, self).eventFilter(obj, event)
 
     #---------------------------------------------------------------------------
-    # 'QWidget' interface
+    # 'ConsoleWidget' public interface
     #---------------------------------------------------------------------------
 
-    def contextMenuEvent(self, event):
-        """ Reimplemented to create a menu without destructive actions like
-            'Cut' and 'Delete'.
-        """
-        clipboard_empty = QtGui.QApplication.clipboard().text().isEmpty()
-        self._paste_action.setEnabled(not clipboard_empty)
-        
-        self._context_menu.exec_(event.globalPos())
-
-    def dragMoveEvent(self, event):
-        """ Reimplemented to disable moving text by drag and drop.
-        """
-        event.ignore()
-
-    def keyPressEvent(self, event):
-        """ Reimplemented to create a console-like interface.
-        """
-        intercepted = False
-        cursor = self.textCursor()
-        position = cursor.position()
-        key = event.key()
-        ctrl_down = self._control_down(event.modifiers())
-        alt_down = event.modifiers() & QtCore.Qt.AltModifier
-        shift_down = event.modifiers() & QtCore.Qt.ShiftModifier
-
-        # Even though we have reimplemented 'paste', the C++ level slot is still
-        # called by Qt. So we intercept the key press here.
-        if event.matches(QtGui.QKeySequence.Paste):
-            self.paste()
-            intercepted = True
-
-        elif ctrl_down:
-            if key in self._ctrl_down_remap:
-                ctrl_down = False
-                key = self._ctrl_down_remap[key]
-                event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress, key, 
-                                        QtCore.Qt.NoModifier)
-
-            elif key == QtCore.Qt.Key_K:
-                if self._in_buffer(position):
-                    cursor.movePosition(QtGui.QTextCursor.EndOfLine,
-                                        QtGui.QTextCursor.KeepAnchor)
-                    cursor.removeSelectedText()
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_X:
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_Y:
-                self.paste()
-                intercepted = True
-
-        elif alt_down:
-            if key == QtCore.Qt.Key_B:
-                self.setTextCursor(self._get_word_start_cursor(position))
-                intercepted = True
-                
-            elif key == QtCore.Qt.Key_F:
-                self.setTextCursor(self._get_word_end_cursor(position))
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_Backspace:
-                cursor = self._get_word_start_cursor(position)
-                cursor.setPosition(position, QtGui.QTextCursor.KeepAnchor)
-                cursor.removeSelectedText()
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_D:
-                cursor = self._get_word_end_cursor(position)
-                cursor.setPosition(position, QtGui.QTextCursor.KeepAnchor)
-                cursor.removeSelectedText()
-                intercepted = True
-
-        if self._completion_widget.isVisible():
-            self._completion_widget.keyPressEvent(event)
-            intercepted = event.isAccepted()
-        
-        else:
-            if key in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter):
-                if self._reading:
-                    self.appendPlainText('\n')
-                    self._reading = False
-                    if self._reading_callback:
-                        self._reading_callback()
-                elif not self._executing:
-                    self.execute(interactive=True)
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_Up:
-                if self._reading or not self._up_pressed():
-                    intercepted = True
-                else:
-                    prompt_line = self._get_prompt_cursor().blockNumber()
-                    intercepted = cursor.blockNumber() <= prompt_line
-
-            elif key == QtCore.Qt.Key_Down:
-                if self._reading or not self._down_pressed():
-                    intercepted = True
-                else:
-                    end_line = self._get_end_cursor().blockNumber()
-                    intercepted = cursor.blockNumber() == end_line
-
-            elif key == QtCore.Qt.Key_Tab:
-                if self._reading:
-                    intercepted = False
-                else:
-                    intercepted = not self._tab_pressed()
-
-            elif key == QtCore.Qt.Key_Left:
-                intercepted = not self._in_buffer(position - 1)
-
-            elif key == QtCore.Qt.Key_Home:
-                cursor.movePosition(QtGui.QTextCursor.StartOfLine)
-                start_line = cursor.blockNumber()
-                if start_line == self._get_prompt_cursor().blockNumber():
-                    start_pos = self._prompt_pos
-                else:
-                    start_pos = cursor.position()
-                    start_pos += len(self._continuation_prompt)
-                if shift_down and self._in_buffer(position):
-                    self._set_selection(position, start_pos)
-                else:
-                    self._set_position(start_pos)
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_Backspace and not alt_down:
-
-                # Line deletion (remove continuation prompt)
-                len_prompt = len(self._continuation_prompt)
-                if not self._reading and \
-                        cursor.columnNumber() == len_prompt and \
-                        position != self._prompt_pos:
-                    cursor.setPosition(position - len_prompt, 
-                                       QtGui.QTextCursor.KeepAnchor)
-                    cursor.removeSelectedText()
-
-                # Regular backwards deletion
-                else:
-                    anchor = cursor.anchor()
-                    if anchor == position:
-                        intercepted = not self._in_buffer(position - 1)
-                    else:
-                        intercepted = not self._in_buffer(min(anchor, position))
-
-            elif key == QtCore.Qt.Key_Delete:
-                anchor = cursor.anchor()
-                intercepted = not self._in_buffer(min(anchor, position))
-
-        # Don't move cursor if control is down to allow copy-paste using
-        # the keyboard in any part of the buffer.
-        if not ctrl_down:
-            self._keep_cursor_in_buffer()
-
-        if not intercepted:
-            QtGui.QPlainTextEdit.keyPressEvent(self, event)
-
-    #--------------------------------------------------------------------------
-    # 'QPlainTextEdit' interface
-    #--------------------------------------------------------------------------
-
-    def appendHtml(self, html):
-        """ Reimplemented to not append HTML as a new paragraph, which doesn't
-            make sense for a console widget.
-        """
-        cursor = self._get_end_cursor()
-        self._insert_html(cursor, html)
-
-    def appendPlainText(self, text):
-        """ Reimplemented to not append text as a new paragraph, which doesn't
-            make sense for a console widget. Also, if enabled, handle ANSI
-            codes.
-        """
-        cursor = self._get_end_cursor()
-        if self.ansi_codes:
-            for substring in self._ansi_processor.split_string(text):
-                format = self._ansi_processor.get_format()
-                cursor.insertText(substring, format)
-        else:
-            cursor.insertText(text)
-
     def clear(self, keep_input=False):
-        """ Reimplemented to write a new prompt. If 'keep_input' is set,
+        """ Clear the console, then write a new prompt. If 'keep_input' is set,
             restores the old input buffer when the new prompt is written.
         """
-        QtGui.QPlainTextEdit.clear(self)
+        self._control.clear()
         if keep_input:
             input_buffer = self.input_buffer
         self._show_prompt()
         if keep_input:
             self.input_buffer = input_buffer
 
-    def paste(self):
-        """ Reimplemented to ensure that text is pasted in the editing region.
+    def copy(self):
+        """ Copy the current selected text to the clipboard.
         """
-        self._keep_cursor_in_buffer()
-        QtGui.QPlainTextEdit.paste(self)
-
-    def print_(self, printer):
-        """ Reimplemented to work around a bug in PyQt: the C++ level 'print_'
-            slot has the wrong signature.
-        """
-        QtGui.QPlainTextEdit.print_(self, printer)
-
-    #---------------------------------------------------------------------------
-    # 'ConsoleWidget' public interface
-    #---------------------------------------------------------------------------
+        self._control.copy()
 
     def execute(self, source=None, hidden=False, interactive=False):
         """ Executes source or the input buffer, possibly prompting for more
         input.
 
         Parameters:
         -----------     
         source : str, optional
 
             The source to execute. If not specified, the input buffer will be
             used. If specified and 'hidden' is False, the input buffer will be
             replaced with the source before execution.
 
         hidden : bool, optional (default False)
 
             If set, no output will be shown and the prompt will not be modified.
             In other words, it will be completely invisible to the user that
             an execution has occurred.
 
         interactive : bool, optional (default False)
 
             Whether the console is to treat the source as having been manually
             entered by the user. The effect of this parameter depends on the
             subclass implementation.
 
         Raises:
         -------
         RuntimeError
             If incomplete input is given and 'hidden' is True. In this case,
             it not possible to prompt for more input.
 
         Returns:
         --------
         A boolean indicating whether the source was executed.
         """
         if not hidden:
             if source is not None:
                 self.input_buffer = source
 
-            self.appendPlainText('\n')
+            self._append_plain_text('\n')
             self._executing_input_buffer = self.input_buffer
             self._executing = True
             self._prompt_finished()
 
         real_source = self.input_buffer if source is None else source
         complete = self._is_complete(real_source, interactive)
         if complete:
             if not hidden:
                 # The maximum block count is only in effect during execution.
                 # This ensures that _prompt_pos does not become invalid due to
                 # text truncation.
-                self.setMaximumBlockCount(self.buffer_size)
+                self._control.document().setMaximumBlockCount(self.buffer_size)
             self._execute(real_source, hidden)
         elif hidden:
             raise RuntimeError('Incomplete noninteractive input: "%s"' % source)
         else:
             self._show_continuation_prompt()
 
         return complete
 
     def _get_input_buffer(self):
         """ The text that the user has entered entered at the current prompt.
         """
         # If we're executing, the input buffer may not even exist anymore due to
         # the limit imposed by 'buffer_size'. Therefore, we store it.
         if self._executing:
             return self._executing_input_buffer
 
         cursor = self._get_end_cursor()
         cursor.setPosition(self._prompt_pos, QtGui.QTextCursor.KeepAnchor)
         input_buffer = str(cursor.selection().toPlainText())
 
         # Strip out continuation prompts.
         return input_buffer.replace('\n' + self._continuation_prompt, '\n')
 
     def _set_input_buffer(self, string):
         """ Replaces the text in the input buffer with 'string'.
         """
         # Remove old text.
         cursor = self._get_end_cursor()
         cursor.setPosition(self._prompt_pos, QtGui.QTextCursor.KeepAnchor)
         cursor.removeSelectedText()
 
         # Insert new text with continuation prompts.
         lines = string.splitlines(True)
         if lines:
-            self.appendPlainText(lines[0])
+            self._append_plain_text(lines[0])
             for i in xrange(1, len(lines)):
                 if self._continuation_prompt_html is None:
-                    self.appendPlainText(self._continuation_prompt)
+                    self._append_plain_text(self._continuation_prompt)
                 else:
-                    self.appendHtml(self._continuation_prompt_html)
-                self.appendPlainText(lines[i])
-        self.moveCursor(QtGui.QTextCursor.End)
+                    self._append_html(self._continuation_prompt_html)
+                self._append_plain_text(lines[i])
+        self._control.moveCursor(QtGui.QTextCursor.End)
 
     input_buffer = property(_get_input_buffer, _set_input_buffer)
 
     def _get_input_buffer_cursor_line(self):
         """ The text in the line of the input buffer in which the user's cursor
             rests. Returns a string if there is such a line; otherwise, None.
         """
         if self._executing:
             return None
-        cursor = self.textCursor()
+        cursor = self._control.textCursor()
         if cursor.position() >= self._prompt_pos:
             text = self._get_block_plain_text(cursor.block())
             if cursor.blockNumber() == self._get_prompt_cursor().blockNumber():
                 return text[len(self._prompt):]
             else:
                 return text[len(self._continuation_prompt):]
         else:
             return None
 
     input_buffer_cursor_line = property(_get_input_buffer_cursor_line)
 
     def _get_font(self):
         """ The base font being used by the ConsoleWidget.
         """
-        return self.document().defaultFont()
+        return self._control.document().defaultFont()
 
     def _set_font(self, font):
         """ Sets the base font for the ConsoleWidget to the specified QFont.
         """
         font_metrics = QtGui.QFontMetrics(font)
-        self.setTabStopWidth(self.tab_width * font_metrics.width(' '))
+        self._control.setTabStopWidth(self.tab_width * font_metrics.width(' '))
 
         self._completion_widget.setFont(font)
-        self.document().setDefaultFont(font)
+        self._control.document().setDefaultFont(font)
 
     font = property(_get_font, _set_font)
 
+    def paste(self):
+        """ Paste the contents of the clipboard into the input region.
+        """
+        self._keep_cursor_in_buffer()
+        self._control.paste()
+
+    def print_(self, printer):
+        """ Print the contents of the ConsoleWidget to the specified QPrinter.
+        """
+        self._control.print_(printer)
+
+    def redo(self):
+        """ Redo the last operation. If there is no operation to redo, nothing
+            happens.
+        """
+        self._control.redo()
+
     def reset_font(self):
         """ Sets the font to the default fixed-width font for this platform.
         """
         if sys.platform == 'win32':
             name = 'Courier'
         elif sys.platform == 'darwin':
             name = 'Monaco'
         else:
             name = 'Monospace'
         font = QtGui.QFont(name, QtGui.qApp.font().pointSize())
         font.setStyleHint(QtGui.QFont.TypeWriter)
         self._set_font(font)
 
+    def select_all(self):
+        """ Selects all the text in the buffer.
+        """
+        self._control.selectAll()
+
     def _get_tab_width(self):
         """ The width (in terms of space characters) for tab characters.
         """
         return self._tab_width
 
     def _set_tab_width(self, tab_width):
         """ Sets the width (in terms of space characters) for tab characters.
         """
         font_metrics = QtGui.QFontMetrics(self.font)
-        self.setTabStopWidth(tab_width * font_metrics.width(' '))
+        self._control.setTabStopWidth(tab_width * font_metrics.width(' '))
 
         self._tab_width = tab_width
 
     tab_width = property(_get_tab_width, _set_tab_width)
-        
+
+    def undo(self):
+        """ Undo the last operation. If there is no operation to undo, nothing
+            happens.
+        """
+        self._control.undo()
+
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' abstract interface
     #---------------------------------------------------------------------------
 
     def _is_complete(self, source, interactive):
         """ Returns whether 'source' can be executed. When triggered by an
             Enter/Return key press, 'interactive' is True; otherwise, it is
             False.
         """
         raise NotImplementedError
 
     def _execute(self, source, hidden):
         """ Execute 'source'. If 'hidden', do not show any output.
         """
         raise NotImplementedError
 
     def _prompt_started_hook(self):
         """ Called immediately after a new prompt is displayed.
         """
         pass
 
     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.
         """
         pass
 
     def _up_pressed(self):
         """ Called when the up key is pressed. Returns whether to continue
             processing the event.
         """
         return True
 
     def _down_pressed(self):
         """ Called when the down key is pressed. Returns whether to continue
             processing the event.
         """
         return True
 
     def _tab_pressed(self):
         """ Called when the tab key is pressed. Returns whether to continue
             processing the event.
         """
         return False
 
     #--------------------------------------------------------------------------
     # 'ConsoleWidget' protected interface
     #--------------------------------------------------------------------------
 
+    def _append_html(self, html):
+        """ Appends html at the end of the console buffer.
+        """
+        cursor = self._get_end_cursor()
+        self._insert_html(cursor, html)
+
     def _append_html_fetching_plain_text(self, html):
         """ Appends 'html', then returns the plain text version of it.
         """
         anchor = self._get_end_cursor().position()
-        self.appendHtml(html)
+        self._append_html(html)
         cursor = self._get_end_cursor()
         cursor.setPosition(anchor, QtGui.QTextCursor.KeepAnchor)
         return str(cursor.selection().toPlainText())
 
+    def _append_plain_text(self, text):
+        """ Appends plain text at the end of the console buffer, processing
+            ANSI codes if enabled.
+        """
+        cursor = self._get_end_cursor()
+        if self.ansi_codes:
+            for substring in self._ansi_processor.split_string(text):
+                format = self._ansi_processor.get_format()
+                cursor.insertText(substring, format)
+        else:
+            cursor.insertText(text)
+
     def _append_plain_text_keeping_prompt(self, text):
         """ Writes 'text' after the current prompt, then restores the old prompt
             with its old input buffer.
         """
         input_buffer = self.input_buffer
-        self.appendPlainText('\n')
+        self._append_plain_text('\n')
         self._prompt_finished()
 
-        self.appendPlainText(text)
+        self._append_plain_text(text)
         self._show_prompt()
         self.input_buffer = input_buffer
 
-    def _control_down(self, modifiers):
+    def _complete_with_items(self, cursor, items):
+        """ Performs completion with 'items' at the specified cursor location.
+        """
+        if len(items) == 1:
+            cursor.setPosition(self._control.textCursor().position(), 
+                               QtGui.QTextCursor.KeepAnchor)
+            cursor.insertText(items[0])
+        elif len(items) > 1:
+            if self.gui_completion:
+                self._completion_widget.show_items(cursor, items) 
+            else:
+                text = self._format_as_columns(items)
+                self._append_plain_text_keeping_prompt(text)
+
+    def _control_key_down(self, modifiers):
         """ Given a KeyboardModifiers flags object, return whether the Control
             key is down (on Mac OS, treat the Command key as a synonym for
             Control).
         """
         down = bool(modifiers & QtCore.Qt.ControlModifier)
 
         # Note: on Mac OS, ControlModifier corresponds to the Command key while
         # MetaModifier corresponds to the Control key.
         if sys.platform == 'darwin':
             down = down ^ bool(modifiers & QtCore.Qt.MetaModifier)
             
         return down
-    
-    def _complete_with_items(self, cursor, items):
-        """ Performs completion with 'items' at the specified cursor location.
+
+    def _create_context_menu(self):
+        """ Creates a context menu for the underlying text widget.
         """
-        if len(items) == 1:
-            cursor.setPosition(self.textCursor().position(), 
-                               QtGui.QTextCursor.KeepAnchor)
-            cursor.insertText(items[0])
-        elif len(items) > 1:
-            if self.gui_completion:
-                self._completion_widget.show_items(cursor, items) 
-            else:
-                text = self._format_as_columns(items)
-                self._append_plain_text_keeping_prompt(text)
+        menu = QtGui.QMenu(self)
+        clipboard = QtGui.QApplication.clipboard()
+
+        copy_action = QtGui.QAction('Copy', self)
+        copy_action.triggered.connect(self.copy)
+        self.copy_available.connect(copy_action.setEnabled)
+        menu.addAction(copy_action)
+
+        paste_action = QtGui.QAction('Paste', self)
+        paste_action.triggered.connect(self.paste)
+        clipboard.dataChanged.connect(
+            lambda: paste_action.setEnabled(not clipboard.text().isEmpty()))
+        menu.addAction(paste_action)
+        menu.addSeparator()
+
+        select_all_action = QtGui.QAction('Select All', self)
+        select_all_action.triggered.connect(self.select_all)
+        menu.addAction(select_all_action)
+
+        return menu
+
+    def _create_control(self, kind):
+        """ Creates and sets the underlying text widget.
+        """
+        layout = QtGui.QVBoxLayout(self)
+        layout.setMargin(0)
+        if kind == 'plain':
+            control = QtGui.QPlainTextEdit()
+        elif kind == 'rich':
+            control = QtGui.QTextEdit()
+        else:
+            raise ValueError("Kind %s unknown." % repr(kind))
+        layout.addWidget(control)
+
+        control.installEventFilter(self)
+        control.copyAvailable.connect(self.copy_available)
+        control.redoAvailable.connect(self.redo_available)
+        control.undoAvailable.connect(self.undo_available)
+
+        return control
+
+    def _event_filter_keypress(self, event):
+        """ Filter key events for the underlying text widget to create a
+            console-like interface.
+        """
+        intercepted = False
+        replaced_event = None
+        cursor = self._control.textCursor()
+        position = cursor.position()
+        key = event.key()
+        ctrl_down = self._control_key_down(event.modifiers())
+        alt_down = event.modifiers() & QtCore.Qt.AltModifier
+        shift_down = event.modifiers() & QtCore.Qt.ShiftModifier
+
+        # Even though we have reimplemented 'paste', the C++ level slot is still
+        # called by Qt. So we intercept the key press here.
+        if event.matches(QtGui.QKeySequence.Paste):
+            self.paste()
+            intercepted = True
+
+        elif ctrl_down:
+            if key in self._ctrl_down_remap:
+                ctrl_down = False
+                key = self._ctrl_down_remap[key]
+                replaced_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress, key, 
+                                                 QtCore.Qt.NoModifier)
+
+            elif key == QtCore.Qt.Key_K:
+                if self._in_buffer(position):
+                    cursor.movePosition(QtGui.QTextCursor.EndOfLine,
+                                        QtGui.QTextCursor.KeepAnchor)
+                    cursor.removeSelectedText()
+                intercepted = True
+
+            elif key == QtCore.Qt.Key_X:
+                intercepted = True
+
+            elif key == QtCore.Qt.Key_Y:
+                self.paste()
+                intercepted = True
+
+        elif alt_down:
+            if key == QtCore.Qt.Key_B:
+                self._set_cursor(self._get_word_start_cursor(position))
+                intercepted = True
+                
+            elif key == QtCore.Qt.Key_F:
+                self._set_cursor(self._get_word_end_cursor(position))
+                intercepted = True
+
+            elif key == QtCore.Qt.Key_Backspace:
+                cursor = self._get_word_start_cursor(position)
+                cursor.setPosition(position, QtGui.QTextCursor.KeepAnchor)
+                cursor.removeSelectedText()
+                intercepted = True
+
+            elif key == QtCore.Qt.Key_D:
+                cursor = self._get_word_end_cursor(position)
+                cursor.setPosition(position, QtGui.QTextCursor.KeepAnchor)
+                cursor.removeSelectedText()
+                intercepted = True
+
+        if self._completion_widget.isVisible():
+            self._completion_widget.keyPressEvent(event)
+            intercepted = event.isAccepted()
+        
+        else:
+            if key in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter):
+                if self._reading:
+                    self._append_plain_text('\n')
+                    self._reading = False
+                    if self._reading_callback:
+                        self._reading_callback()
+                elif not self._executing:
+                    self.execute(interactive=True)
+                intercepted = True
+
+            elif key == QtCore.Qt.Key_Up:
+                if self._reading or not self._up_pressed():
+                    intercepted = True
+                else:
+                    prompt_line = self._get_prompt_cursor().blockNumber()
+                    intercepted = cursor.blockNumber() <= prompt_line
+
+            elif key == QtCore.Qt.Key_Down:
+                if self._reading or not self._down_pressed():
+                    intercepted = True
+                else:
+                    end_line = self._get_end_cursor().blockNumber()
+                    intercepted = cursor.blockNumber() == end_line
+
+            elif key == QtCore.Qt.Key_Tab:
+                if self._reading:
+                    intercepted = False
+                else:
+                    intercepted = not self._tab_pressed()
+
+            elif key == QtCore.Qt.Key_Left:
+                intercepted = not self._in_buffer(position - 1)
+
+            elif key == QtCore.Qt.Key_Home:
+                cursor.movePosition(QtGui.QTextCursor.StartOfLine)
+                start_line = cursor.blockNumber()
+                if start_line == self._get_prompt_cursor().blockNumber():
+                    start_pos = self._prompt_pos
+                else:
+                    start_pos = cursor.position()
+                    start_pos += len(self._continuation_prompt)
+                if shift_down and self._in_buffer(position):
+                    self._set_selection(position, start_pos)
+                else:
+                    self._set_position(start_pos)
+                intercepted = True
+
+            elif key == QtCore.Qt.Key_Backspace and not alt_down:
+
+                # Line deletion (remove continuation prompt)
+                len_prompt = len(self._continuation_prompt)
+                if not self._reading and \
+                        cursor.columnNumber() == len_prompt and \
+                        position != self._prompt_pos:
+                    cursor.setPosition(position - len_prompt, 
+                                       QtGui.QTextCursor.KeepAnchor)
+                    cursor.removeSelectedText()
+
+                # Regular backwards deletion
+                else:
+                    anchor = cursor.anchor()
+                    if anchor == position:
+                        intercepted = not self._in_buffer(position - 1)
+                    else:
+                        intercepted = not self._in_buffer(min(anchor, position))
+
+            elif key == QtCore.Qt.Key_Delete:
+                anchor = cursor.anchor()
+                intercepted = not self._in_buffer(min(anchor, position))
+
+        # Don't move cursor if control is down to allow copy-paste using
+        # the keyboard in any part of the buffer.
+        if not ctrl_down:
+            self._keep_cursor_in_buffer()
+
+        if not intercepted and replaced_event:
+            QtGui.qApp.sendEvent(self._control, replaced_event)
+        return intercepted
 
     def _format_as_columns(self, items, separator='  '):
         """ Transform a list of strings into a single string with columns.
 
         Parameters
         ----------
         items : sequence of strings
             The strings to process.
 
         separator : str, optional [default is two spaces]
             The string that separates columns.
 
         Returns
         -------
         The formatted string.
         """
         # Note: this code is adapted from columnize 0.3.2.
         # See http://code.google.com/p/pycolumnize/
 
         font_metrics = QtGui.QFontMetrics(self.font)
         displaywidth = max(5, (self.width() / font_metrics.width(' ')) - 1)
 
         # Some degenerate cases.
         size = len(items)
         if size == 0: 
             return '\n'
         elif size == 1:
             return '%s\n' % str(items[0])
 
         # Try every row count from 1 upwards
         array_index = lambda nrows, row, col: nrows*col + row
         for nrows in range(1, size):
             ncols = (size + nrows - 1) // nrows
             colwidths = []
             totwidth = -len(separator)
             for col in range(ncols):
                 # Get max column width for this column
                 colwidth = 0
                 for row in range(nrows):
                     i = array_index(nrows, row, col)
                     if i >= size: break
                     x = items[i]
                     colwidth = max(colwidth, len(x))
                 colwidths.append(colwidth)
                 totwidth += colwidth + len(separator)
                 if totwidth > displaywidth: 
                     break
             if totwidth <= displaywidth: 
                 break
 
         # The smallest number of rows computed and the max widths for each
         # column has been obtained. Now we just have to format each of the rows.
         string = ''
         for row in range(nrows):
             texts = []
             for col in range(ncols):
                 i = row + nrows*col
                 if i >= size:
                     texts.append('')
                 else:
                     texts.append(items[i])
             while texts and not texts[-1]:
                 del texts[-1]
             for col in range(len(texts)):
                 texts[col] = texts[col].ljust(colwidths[col])
             string += '%s\n' % str(separator.join(texts))
         return string
 
     def _get_block_plain_text(self, block):
         """ Given a QTextBlock, return its unformatted text.
         """
         cursor = QtGui.QTextCursor(block)
         cursor.movePosition(QtGui.QTextCursor.StartOfBlock)
         cursor.movePosition(QtGui.QTextCursor.EndOfBlock, 
                             QtGui.QTextCursor.KeepAnchor)
         return str(cursor.selection().toPlainText())
+
+    def _get_cursor(self):
+        """ Convenience method that returns a cursor for the current position.
+        """
+        return self._control.textCursor()
                 
     def _get_end_cursor(self):
         """ Convenience method that returns a cursor for the last character.
         """
-        cursor = self.textCursor()
+        cursor = self._control.textCursor()
         cursor.movePosition(QtGui.QTextCursor.End)
         return cursor
 
     def _get_prompt_cursor(self):
         """ Convenience method that returns a cursor for the prompt position.
         """
-        cursor = self.textCursor()
+        cursor = self._control.textCursor()
         cursor.setPosition(self._prompt_pos)
         return cursor
 
     def _get_selection_cursor(self, start, end):
         """ Convenience method that returns a cursor with text selected between
             the positions 'start' and 'end'.
         """
-        cursor = self.textCursor()
+        cursor = self._control.textCursor()
         cursor.setPosition(start)
         cursor.setPosition(end, QtGui.QTextCursor.KeepAnchor)
         return cursor
 
     def _get_word_start_cursor(self, position):
         """ Find the start of the word to the left the given position. If a
             sequence of non-word characters precedes the first word, skip over
             them. (This emulates the behavior of bash, emacs, etc.)
         """
-        document = self.document()
+        document = self._control.document()
         position -= 1
         while self._in_buffer(position) and \
                 not document.characterAt(position).isLetterOrNumber():
             position -= 1
         while self._in_buffer(position) and \
                 document.characterAt(position).isLetterOrNumber():
             position -= 1
-        cursor = self.textCursor()
+        cursor = self._control.textCursor()
         cursor.setPosition(position + 1)
         return cursor
 
     def _get_word_end_cursor(self, position):
         """ Find the end of the word to the right the given position. If a
             sequence of non-word characters precedes the first word, skip over
             them. (This emulates the behavior of bash, emacs, etc.)
         """
-        document = self.document()
+        document = self._control.document()
         end = self._get_end_cursor().position()
         while position < end and \
                 not document.characterAt(position).isLetterOrNumber():
             position += 1
         while position < end and \
                 document.characterAt(position).isLetterOrNumber():
             position += 1
-        cursor = self.textCursor()
+        cursor = self._control.textCursor()
         cursor.setPosition(position)
         return cursor
 
     def _insert_html(self, cursor, html):
         """ Insert HTML using the specified cursor in such a way that future
             formatting is unaffected.
         """
         cursor.insertHtml(html)
 
         # After inserting HTML, the text document "remembers" the current
         # formatting, which means that subsequent calls adding plain text
         # will result in similar formatting, a behavior that we do not want. To
         # prevent this, we make sure that the last character has no formatting.
         cursor.movePosition(QtGui.QTextCursor.Left, 
                             QtGui.QTextCursor.KeepAnchor)
         if cursor.selection().toPlainText().trimmed().isEmpty():
             # If the last character is whitespace, it doesn't matter how it's
             # formatted, so just clear the formatting.
             cursor.setCharFormat(QtGui.QTextCharFormat())
         else:
             # Otherwise, add an unformatted space.
             cursor.movePosition(QtGui.QTextCursor.Right)
             cursor.insertText(' ', QtGui.QTextCharFormat())
 
+    def _in_buffer(self, position):
+        """ Returns whether the given position is inside the editing region.
+        """
+        return position >= self._prompt_pos
+
+    def _keep_cursor_in_buffer(self):
+        """ Ensures that the cursor is inside the editing region. Returns
+            whether the cursor was moved.
+        """
+        cursor = self._control.textCursor()
+        if cursor.position() < self._prompt_pos:
+            cursor.movePosition(QtGui.QTextCursor.End)
+            self._control.setTextCursor(cursor)
+            return True
+        else:
+            return False
+
     def _prompt_started(self):
         """ Called immediately after a new prompt is displayed.
         """
         # Temporarily disable the maximum block count to permit undo/redo and 
         # to ensure that the prompt position does not change due to truncation.
-        self.setMaximumBlockCount(0)
-        self.setUndoRedoEnabled(True)
+        self._control.document().setMaximumBlockCount(0)
+        self._control.setUndoRedoEnabled(True)
 
-        self.setReadOnly(False)
-        self.moveCursor(QtGui.QTextCursor.End)
-        self.centerCursor()
+        self._control.setReadOnly(False)
+        self._control.moveCursor(QtGui.QTextCursor.End)
 
         self._executing = False
         self._prompt_started_hook()
 
     def _prompt_finished(self):
         """ Called immediately after a prompt is finished, i.e. when some input
             will be processed and a new prompt displayed.
         """
-        self.setUndoRedoEnabled(False)
-        self.setReadOnly(True)
+        self._control.setUndoRedoEnabled(False)
+        self._control.setReadOnly(True)
         self._prompt_finished_hook()
 
     def _readline(self, prompt='', callback=None):
         """ Reads one line of input from the user. 
 
         Parameters
         ----------
         prompt : str, optional
             The prompt to print before reading the line.
 
         callback : callable, optional
             A callback to execute with the read line. If not specified, input is
             read *synchronously* and this method does not return until it has
             been read.
 
         Returns
         -------
         If a callback is specified, returns nothing. Otherwise, returns the
         input string with the trailing newline stripped.
         """
         if self._reading:
             raise RuntimeError('Cannot read a line. Widget is already reading.')
 
         if not callback and not self.isVisible():
             # If the user cannot see the widget, this function cannot return.
             raise RuntimeError('Cannot synchronously read a line if the widget'
                                'is not visible!')
 
         self._reading = True
         self._show_prompt(prompt, newline=False)
 
         if callback is None:
             self._reading_callback = None
             while self._reading:
                 QtCore.QCoreApplication.processEvents()
             return self.input_buffer.rstrip('\n')
 
         else:
             self._reading_callback = lambda: \
                 callback(self.input_buffer.rstrip('\n'))
 
     def _reset(self):
         """ Clears the console and resets internal state variables.
         """
-        QtGui.QPlainTextEdit.clear(self)
+        self._control.clear()
         self._executing = self._reading = False
 
     def _set_continuation_prompt(self, prompt, html=False):
         """ Sets the continuation prompt.
 
         Parameters
         ----------
         prompt : str
             The prompt to show when more input is needed.
 
         html : bool, optional (default False)
             If set, the prompt will be inserted as formatted HTML. Otherwise,
             the prompt will be treated as plain text, though ANSI color codes
             will be handled.
         """
         if html:
             self._continuation_prompt_html = prompt
         else:
             self._continuation_prompt = prompt
             self._continuation_prompt_html = None
+            
+    def _set_cursor(self, cursor):
+        """ Convenience method to set the current cursor.
+        """
+        self._control.setTextCursor(cursor)
 
     def _set_position(self, position):
         """ Convenience method to set the position of the cursor.
         """
-        cursor = self.textCursor()
+        cursor = self._control.textCursor()
         cursor.setPosition(position)
-        self.setTextCursor(cursor)
+        self._control.setTextCursor(cursor)
 
     def _set_selection(self, start, end):
         """ Convenience method to set the current selected text.
         """
-        self.setTextCursor(self._get_selection_cursor(start, end))
+        self._control.setTextCursor(self._get_selection_cursor(start, end))
 
     def _show_prompt(self, prompt=None, html=False, newline=True):
         """ Writes a new prompt at the end of the buffer.
 
         Parameters
         ----------
         prompt : str, optional
             The prompt to show. If not specified, the previous prompt is used.
 
         html : bool, optional (default False)
             Only relevant when a prompt is specified. If set, the prompt will
             be inserted as formatted HTML. Otherwise, the prompt will be treated
             as plain text, though ANSI color codes will be handled.
 
         newline : bool, optional (default True)
             If set, a new line will be written before showing the prompt if 
             there is not already a newline at the end of the buffer.
         """
         # Insert a preliminary newline, if necessary.
         if newline:
             cursor = self._get_end_cursor()
             if cursor.position() > 0:
                 cursor.movePosition(QtGui.QTextCursor.Left, 
                                     QtGui.QTextCursor.KeepAnchor)
                 if str(cursor.selection().toPlainText()) != '\n':
-                    self.appendPlainText('\n')
+                    self._append_plain_text('\n')
 
         # Write the prompt.
         if prompt is None:
             if self._prompt_html is None:
-                self.appendPlainText(self._prompt)
+                self._append_plain_text(self._prompt)
             else:
-                self.appendHtml(self._prompt_html)
+                self._append_html(self._prompt_html)
         else:
             if html:
                 self._prompt = self._append_html_fetching_plain_text(prompt)
                 self._prompt_html = prompt
             else:
-                self.appendPlainText(prompt)
+                self._append_plain_text(prompt)
                 self._prompt = prompt
                 self._prompt_html = None
 
         self._prompt_pos = self._get_end_cursor().position()
         self._prompt_started()
 
     def _show_continuation_prompt(self):
         """ Writes a new continuation prompt at the end of the buffer.
         """
         if self._continuation_prompt_html is None:
-            self.appendPlainText(self._continuation_prompt)
+            self._append_plain_text(self._continuation_prompt)
         else:
             self._continuation_prompt = self._append_html_fetching_plain_text(
                 self._continuation_prompt_html)
 
         self._prompt_started()
 
-    def _in_buffer(self, position):
-        """ Returns whether the given position is inside the editing region.
-        """
-        return position >= self._prompt_pos
-
-    def _keep_cursor_in_buffer(self):
-        """ Ensures that the cursor is inside the editing region. Returns
-            whether the cursor was moved.
-        """
-        cursor = self.textCursor()
-        if cursor.position() < self._prompt_pos:
-            cursor.movePosition(QtGui.QTextCursor.End)
-            self.setTextCursor(cursor)
-            return True
-        else:
-            return False
-
 
 class HistoryConsoleWidget(ConsoleWidget):
     """ A ConsoleWidget that keeps a history of the commands that have been
         executed.
     """
     
     #---------------------------------------------------------------------------
-    # 'QObject' interface
+    # 'object' interface
     #---------------------------------------------------------------------------
 
-    def __init__(self, parent=None):
-        super(HistoryConsoleWidget, self).__init__(parent)
-
+    def __init__(self, *args, **kw):
+        super(HistoryConsoleWidget, self).__init__(*args, **kw)
         self._history = []
         self._history_index = 0
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' public interface
     #---------------------------------------------------------------------------
 
     def execute(self, source=None, hidden=False, interactive=False):
         """ Reimplemented to the store history.
         """
         if not hidden:
             history = self.input_buffer if source is None else source
 
         executed = super(HistoryConsoleWidget, self).execute(
             source, hidden, interactive)
 
         if executed and not hidden:
             self._history.append(history.rstrip())
             self._history_index = len(self._history)
 
         return executed
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' abstract interface
     #---------------------------------------------------------------------------
 
     def _up_pressed(self):
         """ Called when the up key is pressed. Returns whether to continue
             processing the event.
         """
         prompt_cursor = self._get_prompt_cursor()
-        if self.textCursor().blockNumber() == prompt_cursor.blockNumber():
+        if self._get_cursor().blockNumber() == prompt_cursor.blockNumber():
             self.history_previous()
 
             # Go to the first line of prompt for seemless history scrolling.
             cursor = self._get_prompt_cursor()
             cursor.movePosition(QtGui.QTextCursor.EndOfLine)
-            self.setTextCursor(cursor)
+            self._set_cursor(cursor)
 
             return False
         return True
 
     def _down_pressed(self):
         """ Called when the down key is pressed. Returns whether to continue
             processing the event.
         """
         end_cursor = self._get_end_cursor()
-        if self.textCursor().blockNumber() == end_cursor.blockNumber():
+        if self._get_cursor().blockNumber() == end_cursor.blockNumber():
             self.history_next()
             return False
         return True
 
     #---------------------------------------------------------------------------
     # 'HistoryConsoleWidget' interface
     #---------------------------------------------------------------------------
 
     def history_previous(self):
         """ If possible, set the input buffer to the previous item in the
             history.
         """
         if self._history_index > 0:
             self._history_index -= 1
             self.input_buffer = self._history[self._history_index]
 
     def history_next(self):
         """ Set the input buffer to the next item in the history, or a blank
             line if there is no subsequent item.
         """
         if self._history_index < len(self._history):
             self._history_index += 1
             if self._history_index < len(self._history):
                 self.input_buffer = self._history[self._history_index]
             else:
                 self.input_buffer = ''

IPython/frontend/qt/console/frontend_widget.py

@@ -1,382 +1,384 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 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.document())
+        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):
     """ A Qt frontend for a generic Python kernel.
     """
    
     # Emitted when an 'execute_reply' is received from the kernel.
     executed = QtCore.pyqtSignal(object)
 
     #---------------------------------------------------------------------------
-    # 'QObject' interface
+    # 'object' interface
     #---------------------------------------------------------------------------
     
-    def __init__(self, parent=None):
-        super(FrontendWidget, self).__init__(parent)
+    def __init__(self, *args, **kw):
+        super(FrontendWidget, self).__init__(*args, **kw)
 
         # FrontendWidget protected variables.
-        self._call_tip_widget = CallTipWidget(self)
+        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('... ')
 
-        self.document().contentsChange.connect(self._document_contents_change)
+        # Connect signal handlers.
+        document = self._control.document()
+        document.contentsChange.connect(self._document_contents_change)
 
     #---------------------------------------------------------------------------
     # 'QWidget' interface
     #---------------------------------------------------------------------------
 
     def focusOutEvent(self, event):
         """ Reimplemented to hide calltips.
         """
         self._call_tip_widget.hide()
         super(FrontendWidget, self).focusOutEvent(event)
 
     def keyPressEvent(self, event):
         """ Reimplemented to allow calltips to process events and to send
             signals to the kernel.
         """
         if self._executing and event.key() == QtCore.Qt.Key_C and \
                 self._control_down(event.modifiers()):
             self._interrupt_kernel()
         else:
             if self._call_tip_widget.isVisible():
                 self._call_tip_widget.keyPressEvent(event)
             super(FrontendWidget, self).keyPressEvent(event)
 
     #---------------------------------------------------------------------------
     # '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 _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.appendPlainText('\t' * (spaces / self.tab_width))
-                self.appendPlainText(' ' * (spaces % self.tab_width))
+                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.textCursor()
+        cursor = self._get_cursor()
         return not self._complete()
 
     #---------------------------------------------------------------------------
     # '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)
 
     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.
         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
 
         # 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.
         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)
         
         # 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)
 
     #---------------------------------------------------------------------------
     # '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.textCursor()
+        cursor = self._get_cursor()
         cursor.movePosition(QtGui.QTextCursor.Left)
-        document = self.document()
+        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._calltip_id = self.kernel_manager.xreq_channel.object_info(name)
-        self._calltip_pos = self.textCursor().position()
+        self._calltip_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.input_buffer_cursor_line, self.input_buffer)
-        self._complete_pos = self.textCursor().position()
+        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.textCursor()
+            cursor = self._get_cursor()
         cursor.movePosition(QtGui.QTextCursor.StartOfLine, 
                             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.appendPlainText('Kernel process is either remote or '
-                                 'unspecified. Cannot interrupt.\n')
+            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.
         """
         self._show_prompt('>>> ')
 
     #------ Signal handlers ----------------------------------------------------
 
     def _started_channels(self):
         """ Called when the kernel manager has started listening.
         """
         self._reset()
-        self.appendPlainText(self._get_banner())
+        self._append_plain_text(self._get_banner())
         self._show_interpreter_prompt()
 
     def _stopped_channels(self):
         """ Called when the kernel manager has stopped listening.
         """
         # FIXME: Print a message here?
         pass
 
     def _document_contents_change(self, position, removed, added):
         """ Called whenever the document's content changes. Display a calltip
             if appropriate.
         """
         # Calculate where the cursor should be *after* the change:
         position += added
 
-        document = self.document()
-        if position == self.textCursor().position():
+        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.appendPlainText(omsg['content']['data'] + '\n')
+        self._append_plain_text(omsg['content']['data'] + '\n')
 
     def _handle_stream(self, omsg):
-        self.appendPlainText(omsg['content']['data'])
-        self.moveCursor(QtGui.QTextCursor.End)
+        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()
 
         status = reply['content']['status']
         if status == 'error':
             self._handle_execute_error(reply)
         elif status == 'aborted':
             text = "ERROR: ABORTED\n"
-            self.appendPlainText(text)
+            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.appendPlainText(traceback)
+        self._append_plain_text(traceback)
 
     def _handle_complete_reply(self, rep):
-        cursor = self.textCursor()
+        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.textCursor()
+        cursor = self._get_cursor()
         if rep['parent_header']['msg_id'] == self._calltip_id and \
                 cursor.position() == self._calltip_pos:
             doc = rep['content']['docstring']
             if doc:
                 self._call_tip_widget.show_docstring(doc)

IPython/frontend/qt/console/ipython_widget.py

@@ -1,206 +1,206 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>]: '
 
     #---------------------------------------------------------------------------
-    # 'QObject' interface
+    # 'object' interface
     #---------------------------------------------------------------------------
     
-    def __init__(self, parent=None):
-        super(IPythonWidget, self).__init__(parent)
+    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()
 
     #---------------------------------------------------------------------------
     # '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 _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.appendHtml(traceback)
+        self._append_html(traceback)
 
     def _handle_pyout(self, omsg):
         """ Reimplemented for IPython-style "display hook".
         """
-        self.appendHtml(self._make_out_prompt(self._prompt_count))
+        self._append_html(self._make_out_prompt(self._prompt_count))
         self._save_prompt_block()
         
-        self.appendPlainText(omsg['content']['data'] + '\n')
+        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.document().setDefaultStyleSheet(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.document().lastBlock()
+        block = self._control.document().lastBlock()
         self._previous_prompt_blocks.append((block, block.length()))
 
 
 if __name__ == '__main__':
     from IPython.frontend.qt.kernelmanager import QtKernelManager
 
     # Don't let Qt or ZMQ swallow KeyboardInterupts.
     import signal
     signal.signal(signal.SIGINT, signal.SIG_DFL)
 
     # Create a KernelManager.
     kernel_manager = QtKernelManager()
     kernel_manager.start_kernel()
     kernel_manager.start_channels()
 
     # Launch the application.
     app = QtGui.QApplication([])
     widget = IPythonWidget()
     widget.kernel_manager = kernel_manager
     widget.setWindowTitle('Python')
     widget.resize(640, 480)
     widget.show()
     app.exec_()