Fixed the segfaults on application exit. The BracketMatcher, CallTipWidget, and CompletionWidget were using the text control as their parents. This should not be a problem, but for some reason it resulted in problems during shutdown. I suspect that PyQt is bugged and was deleting the C++ objects a second time in the garbage collection phase after they had already been deleted automatically by the C++ layer of Qt.

IPython/frontend/qt/console/bracket_matcher.py

@@ -1,101 +1,101 b''
 """ Provides bracket matching for Q[Plain]TextEdit widgets.
 """
 
 # System library imports
 from PyQt4 import QtCore, QtGui
 
 
 class BracketMatcher(QtCore.QObject):
     """ Matches square brackets, braces, and parentheses based on cursor
         position.
     """
     
     # Protected class variables.
     _opening_map = { '(':')', '{':'}', '[':']' }
     _closing_map = { ')':'(', '}':'{', ']':'[' }
 
     #--------------------------------------------------------------------------
     # 'QObject' interface
     #--------------------------------------------------------------------------
 
-    def __init__(self, parent):
+    def __init__(self, text_edit):
         """ Create a call tip manager that is attached to the specified Qt
             text edit widget.
         """
-        assert isinstance(parent, (QtGui.QTextEdit, QtGui.QPlainTextEdit))
-        QtCore.QObject.__init__(self, parent)
+        assert isinstance(text_edit, (QtGui.QTextEdit, QtGui.QPlainTextEdit))
+        super(BracketMatcher, self).__init__()
 
         # The format to apply to matching brackets.
         self.format = QtGui.QTextCharFormat()
         self.format.setBackground(QtGui.QColor('silver'))
 
-        parent.cursorPositionChanged.connect(self._cursor_position_changed)
+        self._text_edit = text_edit
+        text_edit.cursorPositionChanged.connect(self._cursor_position_changed)
 
     #--------------------------------------------------------------------------
     # Protected interface
     #--------------------------------------------------------------------------
 
     def _find_match(self, position):
         """ Given a valid position in the text document, try to find the
             position of the matching bracket. Returns -1 if unsuccessful.
         """
         # Decide what character to search for and what direction to search in.
-        document = self.parent().document()
+        document = self._text_edit.document()
         qchar = document.characterAt(position)
         start_char = qchar.toAscii()
         search_char = self._opening_map.get(start_char)
         if search_char:
             increment = 1
         else:
             search_char = self._closing_map.get(start_char)
             if search_char:
                 increment = -1
             else:
                 return -1
 
         # Search for the character.
         depth = 0
         while position >= 0 and position < document.characterCount():
             char = qchar.toAscii()
             if char == start_char:
                 depth += 1
             elif char == search_char:
                 depth -= 1
             if depth == 0:
                 break
             position += increment
             qchar = document.characterAt(position)
         else:
             position = -1
         return position
 
     def _selection_for_character(self, position):
         """ Convenience method for selecting a character.
         """
         selection = QtGui.QTextEdit.ExtraSelection()
-        cursor = self.parent().textCursor()
+        cursor = self._text_edit.textCursor()
         cursor.setPosition(position)
         cursor.movePosition(QtGui.QTextCursor.NextCharacter, 
                             QtGui.QTextCursor.KeepAnchor)
         selection.cursor = cursor
         selection.format = self.format
         return selection
 
     #------ Signal handlers ----------------------------------------------------
 
     def _cursor_position_changed(self):
         """ Updates the document formatting based on the new cursor position.
         """
         # Clear out the old formatting.
-        text_edit = self.parent()
-        text_edit.setExtraSelections([])
+        self._text_edit.setExtraSelections([])
 
         # Attempt to match a bracket for the new cursor position.
-        cursor = text_edit.textCursor()
+        cursor = self._text_edit.textCursor()
         if not cursor.hasSelection():
             position = cursor.position() - 1
             match_position = self._find_match(position)
             if match_position != -1:
                 extra_selections = [ self._selection_for_character(pos)
                                      for pos in (position, match_position) ]
-                text_edit.setExtraSelections(extra_selections)
+                self._text_edit.setExtraSelections(extra_selections)

IPython/frontend/qt/console/call_tip_widget.py

@@ -1,214 +1,215 b''
 # Standard library imports
 import re
 from textwrap import dedent
 
 # System library imports
 from PyQt4 import QtCore, QtGui
 
 
 class CallTipWidget(QtGui.QLabel):
     """ Shows call tips by parsing the current text of Q[Plain]TextEdit.
     """
 
     #--------------------------------------------------------------------------
     # 'QObject' interface
     #--------------------------------------------------------------------------
 
-    def __init__(self, parent):
+    def __init__(self, text_edit):
         """ Create a call tip manager that is attached to the specified Qt
             text edit widget.
         """
-        assert isinstance(parent, (QtGui.QTextEdit, QtGui.QPlainTextEdit))
-        QtGui.QLabel.__init__(self, parent, QtCore.Qt.ToolTip)
+        assert isinstance(text_edit, (QtGui.QTextEdit, QtGui.QPlainTextEdit))
+        super(CallTipWidget, self).__init__(None, QtCore.Qt.ToolTip)
 
         self._hide_timer = QtCore.QBasicTimer()
+        self._text_edit = text_edit
 
-        self.setFont(parent.document().defaultFont())
+        self.setFont(text_edit.document().defaultFont())
         self.setForegroundRole(QtGui.QPalette.ToolTipText)
         self.setBackgroundRole(QtGui.QPalette.ToolTipBase)
         self.setPalette(QtGui.QToolTip.palette())
 
         self.setAlignment(QtCore.Qt.AlignLeft)
         self.setIndent(1)
         self.setFrameStyle(QtGui.QFrame.NoFrame)
         self.setMargin(1 + self.style().pixelMetric(
                 QtGui.QStyle.PM_ToolTipLabelFrameWidth, None, self))
         self.setWindowOpacity(self.style().styleHint(
                 QtGui.QStyle.SH_ToolTipLabel_Opacity, None, self) / 255.0)
 
     def eventFilter(self, obj, event):
-        """ Reimplemented to hide on certain key presses and on parent focus
+        """ Reimplemented to hide on certain key presses and on text edit focus
             changes.
         """
-        if obj == self.parent():
+        if obj == self._text_edit:
             etype = event.type()
 
             if etype == QtCore.QEvent.KeyPress:
                 key = event.key()
                 if key in (QtCore.Qt.Key_Enter, QtCore.Qt.Key_Return):
                     self.hide()
                 elif key == QtCore.Qt.Key_Escape:
                     self.hide()
                     return True
 
             elif etype == QtCore.QEvent.FocusOut:
                 self.hide()
 
             elif etype == QtCore.QEvent.Enter:
                 self._hide_timer.stop()
 
             elif etype == QtCore.QEvent.Leave:
                 self._hide_later()
 
-        return QtGui.QLabel.eventFilter(self, obj, event)
+        return super(CallTipWidget, self).eventFilter(obj, event)
 
     def timerEvent(self, event):
         """ Reimplemented to hide the widget when the hide timer fires.
         """
         if event.timerId() == self._hide_timer.timerId():
             self._hide_timer.stop()
             self.hide()
 
     #--------------------------------------------------------------------------
     # 'QWidget' interface
     #--------------------------------------------------------------------------
 
     def enterEvent(self, event):
         """ Reimplemented to cancel the hide timer.
         """
-        QtGui.QLabel.enterEvent(self, event)
+        super(CallTipWidget, self).enterEvent(event)
         self._hide_timer.stop()
 
     def hideEvent(self, event):
         """ Reimplemented to disconnect signal handlers and event filter.
         """
-        QtGui.QLabel.hideEvent(self, event)
-        parent = self.parent()
-        parent.cursorPositionChanged.disconnect(self._cursor_position_changed)
-        parent.removeEventFilter(self)
+        super(CallTipWidget, self).hideEvent(event)
+        self._text_edit.cursorPositionChanged.disconnect(
+            self._cursor_position_changed)
+        self._text_edit.removeEventFilter(self)
 
     def leaveEvent(self, event):
         """ Reimplemented to start the hide timer.
         """
-        QtGui.QLabel.leaveEvent(self, event)
+        super(CallTipWidget, self).leaveEvent(event)
         self._hide_later()
 
     def paintEvent(self, event):
         """ Reimplemented to paint the background panel.
         """
         painter = QtGui.QStylePainter(self)
         option = QtGui.QStyleOptionFrame()
         option.init(self)
         painter.drawPrimitive(QtGui.QStyle.PE_PanelTipLabel, option)
         painter.end()
 
-        QtGui.QLabel.paintEvent(self, event)
+        super(CallTipWidget, self).paintEvent(event)
 
     def showEvent(self, event):
         """ Reimplemented to connect signal handlers and event filter.
         """
-        QtGui.QLabel.showEvent(self, event)
-        parent = self.parent()
-        parent.cursorPositionChanged.connect(self._cursor_position_changed)
-        parent.installEventFilter(self)
+        super(CallTipWidget, self).showEvent(event)
+        self._text_edit.cursorPositionChanged.connect(
+            self._cursor_position_changed)
+        self._text_edit.installEventFilter(self)
 
     #--------------------------------------------------------------------------
     # 'CallTipWidget' interface
     #--------------------------------------------------------------------------
 
     def show_docstring(self, doc, maxlines=20):
         """ Attempts to show the specified docstring at the current cursor
             location. The docstring is dedented and possibly truncated for
             length.
         """
         doc = dedent(doc.rstrip()).lstrip()
         match = re.match("(?:[^\n]*\n){%i}" % maxlines, doc)
         if match:
             doc = doc[:match.end()] + '\n[Documentation continues...]'
         return self.show_tip(doc)
 
     def show_tip(self, tip):
         """ Attempts to show the specified tip at the current cursor location.
         """
         # Attempt to find the cursor position at which to show the call tip.
-        text_edit = self.parent()
+        text_edit = self._text_edit
         document = text_edit.document()
         cursor = text_edit.textCursor()
         search_pos = cursor.position() - 1
         self._start_position, _ = self._find_parenthesis(search_pos, 
                                                          forward=False)
         if self._start_position == -1:
             return False
 
         # Set the text and resize the widget accordingly.
         self.setText(tip)
         self.resize(self.sizeHint())
     
         # Locate and show the widget. Place the tip below the current line
         # unless it would be off the screen. In that case, place it above
         # the current line.
         padding = 3 # Distance in pixels between cursor bounds and tip box.
         cursor_rect = text_edit.cursorRect(cursor)
         screen_rect = QtGui.qApp.desktop().screenGeometry(text_edit)
         point = text_edit.mapToGlobal(cursor_rect.bottomRight())
         point.setY(point.y() + padding)
         tip_height = self.size().height()
         if point.y() + tip_height > screen_rect.height():
             point = text_edit.mapToGlobal(cursor_rect.topRight())
             point.setY(point.y() - tip_height - padding)
         self.move(point)
         self.show()
         return True
             
     #--------------------------------------------------------------------------
     # Protected interface
     #--------------------------------------------------------------------------
 
     def _find_parenthesis(self, position, forward=True):
         """ If 'forward' is True (resp. False), proceed forwards
             (resp. backwards) through the line that contains 'position' until an
             unmatched closing (resp. opening) parenthesis is found. Returns a
             tuple containing the position of this parenthesis (or -1 if it is
             not found) and the number commas (at depth 0) found along the way.
         """
         commas = depth = 0
-        document = self.parent().document()
+        document = self._text_edit.document()
         qchar = document.characterAt(position)
         while (position > 0 and qchar.isPrint() and 
                # Need to check explicitly for line/paragraph separators:
                qchar.unicode() not in (0x2028, 0x2029)):
             char = qchar.toAscii()
             if char == ',' and depth == 0:
                 commas += 1
             elif char == ')':
                 if forward and depth == 0:
                     break
                 depth += 1
             elif char == '(':
                 if not forward and depth == 0:
                     break
                 depth -= 1
             position += 1 if forward else -1
             qchar = document.characterAt(position)
         else:
             position = -1
         return position, commas
 
     def _hide_later(self):
         """ Hides the tooltip after some time has passed.
         """
         if not self._hide_timer.isActive():
             self._hide_timer.start(300, self)
 
     #------ Signal handlers ----------------------------------------------------
 
     def _cursor_position_changed(self):
         """ Updates the tip based on user cursor movement.
         """
-        cursor = self.parent().textCursor()
+        cursor = self._text_edit.textCursor()
         if cursor.position() <= self._start_position:
             self.hide()
         else:
             position, commas = self._find_parenthesis(self._start_position + 1)
             if position != -1:
                 self.hide()

IPython/frontend/qt/console/completion_widget.py

@@ -1,136 +1,133 b''
 # System library imports
 from PyQt4 import QtCore, QtGui
 
 
 class CompletionWidget(QtGui.QListWidget):
     """ A widget for GUI tab completion.
     """
 
     #--------------------------------------------------------------------------
     # 'QObject' interface
     #--------------------------------------------------------------------------
 
-    def __init__(self, parent):
+    def __init__(self, text_edit):
         """ Create a completion widget that is attached to the specified Qt
             text edit widget.
         """
-        assert isinstance(parent, (QtGui.QTextEdit, QtGui.QPlainTextEdit))
-        QtGui.QListWidget.__init__(self, parent)
+        assert isinstance(text_edit, (QtGui.QTextEdit, QtGui.QPlainTextEdit))
+        super(CompletionWidget, self).__init__()
+
+        self._text_edit = text_edit
 
-        self.setWindowFlags(QtCore.Qt.ToolTip | QtCore.Qt.WindowStaysOnTopHint)
         self.setAttribute(QtCore.Qt.WA_StaticContents)
+        self.setWindowFlags(QtCore.Qt.ToolTip | QtCore.Qt.WindowStaysOnTopHint)
 
-        # Ensure that parent keeps focus when widget is displayed.
-        self.setFocusProxy(parent)
+        # Ensure that the text edit keeps focus when widget is displayed.
+        self.setFocusProxy(self._text_edit)
 
         self.setFrameShadow(QtGui.QFrame.Plain)
         self.setFrameShape(QtGui.QFrame.StyledPanel)
 
         self.itemActivated.connect(self._complete_current)
 
     def eventFilter(self, obj, event):
-        """ Reimplemented to handle keyboard input and to auto-hide when our
-            parent loses focus.
+        """ Reimplemented to handle keyboard input and to auto-hide when the
+            text edit loses focus.
         """
-        if obj == self.parent():
+        if obj == self._text_edit:
             etype = event.type()
 
             if etype == QtCore.QEvent.KeyPress:
                 key, text = event.key(), event.text()
                 if key in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter, 
                            QtCore.Qt.Key_Tab):
                     self._complete_current()
                     return True
                 elif key == QtCore.Qt.Key_Escape:
                     self.hide()
                     return True
                 elif key in (QtCore.Qt.Key_Up, QtCore.Qt.Key_Down, 
                              QtCore.Qt.Key_PageUp, QtCore.Qt.Key_PageDown, 
                              QtCore.Qt.Key_Home, QtCore.Qt.Key_End):
-                    QtGui.QListWidget.keyPressEvent(self, event)
+                    self.keyPressEvent(event)
                     return True
 
             elif etype == QtCore.QEvent.FocusOut:
                 self.hide()
 
-        return QtGui.QListWidget.eventFilter(self, obj, event)
+        return super(CompletionWidget, self).eventFilter(obj, event)
 
     #--------------------------------------------------------------------------
     # 'QWidget' interface
     #--------------------------------------------------------------------------
 
     def hideEvent(self, event):
         """ Reimplemented to disconnect signal handlers and event filter.
         """
-        QtGui.QListWidget.hideEvent(self, event)
-        parent = self.parent()
-        try:
-            parent.cursorPositionChanged.disconnect(self._update_current)
-        except TypeError:
-            pass
-        parent.removeEventFilter(self)
+        super(CompletionWidget, self).hideEvent(event)
+        self._text_edit.cursorPositionChanged.disconnect(self._update_current)
+        self._text_edit.removeEventFilter(self)
 
     def showEvent(self, event):
         """ Reimplemented to connect signal handlers and event filter.
         """
-        QtGui.QListWidget.showEvent(self, event)
-        parent = self.parent()
-        parent.cursorPositionChanged.connect(self._update_current)
-        parent.installEventFilter(self)
+        super(CompletionWidget, self).showEvent(event)
+        self._text_edit.cursorPositionChanged.connect(self._update_current)
+        self._text_edit.installEventFilter(self)
 
     #--------------------------------------------------------------------------
     # 'CompletionWidget' interface
     #--------------------------------------------------------------------------
 
     def show_items(self, cursor, items):
         """ Shows the completion widget with 'items' at the position specified
             by 'cursor'.
         """
-        text_edit = self.parent()
+        text_edit = self._text_edit
         point = text_edit.cursorRect(cursor).bottomRight()
         point = text_edit.mapToGlobal(point)
         screen_rect = QtGui.QApplication.desktop().availableGeometry(self)
         if screen_rect.size().height() - point.y() - self.height() < 0:
             point = text_edit.mapToGlobal(text_edit.cursorRect().topRight())
             point.setY(point.y() - self.height())
         self.move(point)
 
         self._start_position = cursor.position()
         self.clear()
         self.addItems(items)
         self.setCurrentRow(0)
         self.show()
 
     #--------------------------------------------------------------------------
     # Protected interface
     #--------------------------------------------------------------------------
 
     def _complete_current(self):
         """ Perform the completion with the currently selected item.
         """
         self._current_text_cursor().insertText(self.currentItem().text())
         self.hide()
 
     def _current_text_cursor(self):
         """ Returns a cursor with text between the start position and the
             current position selected.
         """
-        cursor = self.parent().textCursor()
+        cursor = self._text_edit.textCursor()
         if cursor.position() >= self._start_position:
             cursor.setPosition(self._start_position, 
                                QtGui.QTextCursor.KeepAnchor)
         return cursor
         
     def _update_current(self):
         """ Updates the current item based on the current text.
         """
         prefix = self._current_text_cursor().selection().toPlainText()
         if prefix:
             items = self.findItems(prefix, (QtCore.Qt.MatchStartsWith | 
                                             QtCore.Qt.MatchCaseSensitive))
             if items:
                 self.setCurrentItem(items[0])
             else:
                 self.hide()
         else:
             self.hide()

IPython/frontend/qt/console/ipythonqt.py

@@ -1,143 +1,147 b''
 """ A minimal application using the Qt console-style IPython frontend.
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Systemm library imports
 from PyQt4 import QtGui
 
 # Local imports
 from IPython.external.argparse import ArgumentParser
 from IPython.frontend.qt.console.frontend_widget import FrontendWidget
 from IPython.frontend.qt.console.ipython_widget import IPythonWidget
 from IPython.frontend.qt.console.rich_ipython_widget import RichIPythonWidget
 from IPython.frontend.qt.kernelmanager import QtKernelManager
 
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 LOCALHOST = '127.0.0.1'
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class MainWindow(QtGui.QMainWindow):
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
     
     def __init__(self, frontend):
         """ Create a MainWindow for the specified FrontendWidget.
         """
         super(MainWindow, self).__init__()
         self._frontend = frontend
         self._frontend.exit_requested.connect(self.close)
         self.setCentralWidget(frontend)
     
     #---------------------------------------------------------------------------
     # QWidget interface
     #---------------------------------------------------------------------------
     
     def closeEvent(self, event):
         """ Reimplemented to prompt the user and close the kernel cleanly.
         """
-        reply = QtGui.QMessageBox.question(self, self.window().windowTitle(),
-            'Close console?', QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
-        if reply == QtGui.QMessageBox.Yes:
-            self._frontend.kernel_manager.shutdown_kernel()
-            event.accept()
-        else:
-            event.ignore()
+        kernel_manager = self._frontend.kernel_manager
+        if kernel_manager and kernel_manager.channels_running:
+            title = self.window().windowTitle()
+            reply = QtGui.QMessageBox.question(self, title,
+                'Close console?', QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
+            if reply == QtGui.QMessageBox.Yes:
+                kernel_manager.shutdown_kernel()
+                #kernel_manager.stop_channels()
+                event.accept()
+            else:
+                event.ignore()
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 def main():
     """ Entry point for application.
     """
     # Parse command line arguments.
     parser = ArgumentParser()
     kgroup = parser.add_argument_group('kernel options')
     kgroup.add_argument('-e', '--existing', action='store_true',
                         help='connect to an existing kernel')
     kgroup.add_argument('--ip', type=str, default=LOCALHOST,
                         help='set the kernel\'s IP address [default localhost]')
     kgroup.add_argument('--xreq', type=int, metavar='PORT', default=0,
                         help='set the XREQ channel port [default random]')
     kgroup.add_argument('--sub', type=int, metavar='PORT', default=0,
                         help='set the SUB channel port [default random]')
     kgroup.add_argument('--rep', type=int, metavar='PORT', default=0,
                         help='set the REP channel port [default random]')
     kgroup.add_argument('--hb', type=int, metavar='PORT', default=0,
                         help='set the heartbeat port [default: random]')
 
     egroup = kgroup.add_mutually_exclusive_group()
     egroup.add_argument('--pure', action='store_true', help = \
                         'use a pure Python kernel instead of an IPython kernel')
     egroup.add_argument('--pylab', type=str, metavar='GUI', nargs='?', 
                        const='auto', help = \
         "Pre-load matplotlib and numpy for interactive use. If GUI is not \
          given, the GUI backend is matplotlib's, otherwise use one of: \
          ['tk', 'gtk', 'qt', 'wx', 'payload-svg'].")
 
     wgroup = parser.add_argument_group('widget options')
     wgroup.add_argument('--paging', type=str, default='inside',
                         choices = ['inside', 'hsplit', 'vsplit', 'none'],
                         help='set the paging style [default inside]')
     wgroup.add_argument('--rich', action='store_true',
                         help='enable rich text support')
     wgroup.add_argument('--gui-completion', action='store_true',
                         help='use a GUI widget for tab completion')
 
     args = parser.parse_args()
 
     # Don't let Qt or ZMQ swallow KeyboardInterupts.
     import signal
     signal.signal(signal.SIGINT, signal.SIG_DFL)
 
     # Create a KernelManager and start a kernel.
     kernel_manager = QtKernelManager(xreq_address=(args.ip, args.xreq),
                                      sub_address=(args.ip, args.sub),
                                      rep_address=(args.ip, args.rep),
                                      hb_address=(args.ip, args.hb))
     if args.ip == LOCALHOST and not args.existing:
         if args.pure:
             kernel_manager.start_kernel(ipython=False)
         elif args.pylab:
             if args.rich:
                 kernel_manager.start_kernel(pylab='payload-svg')
             else:
                 kernel_manager.start_kernel(pylab=args.pylab)
         else:
             kernel_manager.start_kernel()
     kernel_manager.start_channels()
 
     # Create the widget.
     app = QtGui.QApplication([])
     if args.pure:
         kind = 'rich' if args.rich else 'plain'
         widget = FrontendWidget(kind=kind, paging=args.paging)
     elif args.rich:
         widget = RichIPythonWidget(paging=args.paging)
     else:
         widget = IPythonWidget(paging=args.paging)
     widget.gui_completion = args.gui_completion
     widget.kernel_manager = kernel_manager
 
     # Create the main window.
     window = MainWindow(widget)
     window.setWindowTitle('Python' if args.pure else 'IPython')
     window.show()
 
     # Start the application main loop.
     app.exec_()
 
 
 if __name__ == '__main__':
     main()