Merging upstream changes from inputhook and config-refactor.

Some minor changes needed to be made to make sure component queries 
in ipapi worked properly.

docs/examples/lib/gui-gtk.py

@@ -0,0 +1,35 b''
+#!/usr/bin/env python
+"""Simple GTK example to manually test event loop integration.
+
+This is meant to run tests manually in ipython as:
+
+In [5]: %gui gtk
+
+In [6]: %run gui-gtk.py
+"""
+
+
+import pygtk
+pygtk.require('2.0')
+import gtk
+
+
+def hello_world(wigdet, data=None):
+    print "Hello World"
+
+window = gtk.Window(gtk.WINDOW_TOPLEVEL)
+button = gtk.Button("Hello World")
+button.connect("clicked", hello_world, None)
+
+window.add(self.button)
+button.show()
+window.show()
+
+try:
+    from IPython.lib.inputhook import appstart_gtk
+    appstart_gtk()
+except ImportError:
+    gtk.main()
+
+
+

docs/examples/lib/gui-mpl.py

@@ -0,0 +1,54 b''
+"""Test the new %gui command.  Run this in ipython as
+
+In [1]: %gui [backend]
+
+In [2]: %run switchgui [backend]
+
+where the optional backend can be one of:  qt4, gtk, tk, wx.
+
+Because of subtle difference in how Matplotlib handles the different GUI 
+toolkits (in things like draw and show), minor modifications to this script
+have to be made for Tk to get it to work with the 0.99 and below releases
+of Matplotlib.  However, in the future, Matplotlib should be able to have 
+similar logic for all the toolkits, as they are all now using PyOS_InputHook.
+"""
+
+import sys
+import time
+
+from  IPython.lib import inputhook
+
+gui = inputhook.current_gui()
+if gui is None:
+    gui = 'qt4'
+    inputhook.enable_qt4(app=True)
+
+backends = dict(wx='wxagg', qt4='qt4agg', gtk='gtkagg', tk='tkagg')
+
+import matplotlib
+matplotlib.use(backends[gui])
+matplotlib.interactive(True)
+
+import matplotlib
+from matplotlib import pyplot as plt, mlab, pylab
+import numpy as np
+
+from numpy import *
+from matplotlib.pyplot import *
+
+x = np.linspace(0,pi,500)
+
+print "A plot has been created"
+line, = plot(x,sin(2*x))
+inputhook.spin() # This has to be removed for Tk
+
+
+print "Now, we will update the plot..."
+print
+for i in range(1,51):
+    print i, 
+    sys.stdout.flush()
+    line.set_data(x,sin(x*i))
+    plt.title('i=%d' % i)
+    plt.draw()
+    inputhook.spin() # This has to be removed for Tk

docs/examples/lib/gui-qt.py

@@ -0,0 +1,40 b''
+#!/usr/bin/env python
+"""Simple Qt4 example to manually test event loop integration.
+
+This is meant to run tests manually in ipython as:
+
+In [5]: %gui qt
+
+In [6]: %run gui-qt.py
+
+Ref: Modified from http://zetcode.com/tutorials/pyqt4/firstprograms/
+"""
+
+import sys
+from PyQt4 import QtGui, QtCore
+
+class SimpleWindow(QtGui.QWidget):
+    def __init__(self, parent=None):
+        QtGui.QWidget.__init__(self, parent)
+
+        self.setGeometry(300, 300, 200, 80)
+        self.setWindowTitle('Hello World')
+
+        quit = QtGui.QPushButton('Close', self)
+        quit.setGeometry(10, 10, 60, 35)
+
+        self.connect(quit, QtCore.SIGNAL('clicked()'),
+                     self, QtCore.SLOT('close()'))
+
+if __name__ == '__main__':
+    app = QtCore.QCoreApplication.instance()
+    if app is None:
+        app = QtGui.QApplication([])
+
+    sw = SimpleWindow()
+    sw.show()
+
+    try:
+        from IPython import appstart_qt4; appstart_qt4(app)
+    except ImportError:
+        app.exec_()

docs/examples/lib/gui-tk.py

@@ -0,0 +1,32 b''
+#!/usr/bin/env python
+"""Simple Tk example to manually test event loop integration.
+
+This is meant to run tests manually in ipython as:
+
+In [5]: %gui tk
+
+In [6]: %run gui-tk.py
+"""
+
+from Tkinter import *
+
+class MyApp:
+
+    def __init__(self, root):
+        frame = Frame(root)
+        frame.pack()
+
+        self.button = Button(frame, text="Hello", command=self.hello_world)
+        self.button.pack(side=LEFT)
+
+    def hello_world(self):
+        print "Hello World!"
+
+root = Tk()
+
+app = MyApp(root)
+
+try:
+    from IPython import appstart_tk; appstart_tk(root)
+except ImportError:
+    root.mainloop()

docs/examples/lib/gui-wx.py

@@ -0,0 +1,99 b''
+"""A Simple wx example to test IPython's event loop integration.
+
+To run this do:
+
+In [5]: %gui wx
+
+In [6]: %run gui-wx.py
+
+Ref: Modified from wxPython source code wxPython/samples/simple/simple.py
+
+This example can only be run once in a given IPython session.
+"""
+
+import wx
+
+
+class MyFrame(wx.Frame):
+    """
+    This is MyFrame.  It just shows a few controls on a wxPanel,
+    and has a simple menu.
+    """
+    def __init__(self, parent, title):
+        wx.Frame.__init__(self, parent, -1, title,
+                          pos=(150, 150), size=(350, 200))
+
+        # Create the menubar
+        menuBar = wx.MenuBar()
+
+        # and a menu 
+        menu = wx.Menu()
+
+        # add an item to the menu, using \tKeyName automatically
+        # creates an accelerator, the third param is some help text
+        # that will show up in the statusbar
+        menu.Append(wx.ID_EXIT, "E&xit\tAlt-X", "Exit this simple sample")
+
+        # bind the menu event to an event handler
+        self.Bind(wx.EVT_MENU, self.OnTimeToClose, id=wx.ID_EXIT)
+
+        # and put the menu on the menubar
+        menuBar.Append(menu, "&File")
+        self.SetMenuBar(menuBar)
+
+        self.CreateStatusBar()
+
+        # Now create the Panel to put the other controls on.
+        panel = wx.Panel(self)
+
+        # and a few controls
+        text = wx.StaticText(panel, -1, "Hello World!")
+        text.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.BOLD))
+        text.SetSize(text.GetBestSize())
+        btn = wx.Button(panel, -1, "Close")
+        funbtn = wx.Button(panel, -1, "Just for fun...")
+
+        # bind the button events to handlers
+        self.Bind(wx.EVT_BUTTON, self.OnTimeToClose, btn)
+        self.Bind(wx.EVT_BUTTON, self.OnFunButton, funbtn)
+
+        # Use a sizer to layout the controls, stacked vertically and with
+        # a 10 pixel border around each
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(text, 0, wx.ALL, 10)
+        sizer.Add(btn, 0, wx.ALL, 10)
+        sizer.Add(funbtn, 0, wx.ALL, 10)
+        panel.SetSizer(sizer)
+        panel.Layout()
+
+
+    def OnTimeToClose(self, evt):
+        """Event handler for the button click."""
+        print "See ya later!"
+        self.Close()
+
+    def OnFunButton(self, evt):
+        """Event handler for the button click."""
+        print "Having fun yet?"
+
+
+class MyApp(wx.App):
+    def OnInit(self):
+        frame = MyFrame(None, "Simple wxPython App")
+        self.SetTopWindow(frame)
+
+        print "Print statements go to this stdout window by default."
+
+        frame.Show(True)
+        return True
+
+app = wx.GetApp()
+if app is None:
+    app = MyApp(redirect=False, clearSigInt=False)
+
+try:
+    from IPython.lib.inputhook import appstart_wx
+    appstart_wx(app)
+except ImportError:
+    app.MainLoop()
+

IPython/__init__.py

@@ -34,8 +34,23 b" if sys.version[0:3] < '2.4':"
 # Therefore, non-IPython modules can be added to extensions directory
 sys.path.append(os.path.join(os.path.dirname(__file__), "extensions"))
 
-from IPython.core import iplib
+#-----------------------------------------------------------------------------
+# Setup the top level names
+#-----------------------------------------------------------------------------
 
+from IPython.core.iplib import InteractiveShell
+from IPython.core.error import TryNext
+
+from IPython.lib import (
+    enable_wx, disable_wx,
+    enable_gtk, disable_gtk,
+    enable_qt4, disable_qt4,
+    enable_tk, disable_tk,
+    set_inputhook, clear_inputhook,
+    current_gui, spin,
+    appstart_qt4, appstart_wx,
+    appstart_gtk, appstart_tk
+)
 
 # Release data
 __author__ = ''

IPython/core/component.py

@@ -60,34 +60,30 b' class MetaComponentTracker(type):'
                 c.__instance_refs[c.__numcreated] = instance
         return instance
 
-    def get_instances(cls, name=None, klass=None, root=None):
+    def get_instances(cls, name=None, root=None):
         """Get all instances of cls and its subclasses.
 
         Parameters
         ----------
         name : str
             Limit to components with this name.
-        klass : class
-            Limit to components having isinstance(component, klass)
         root : Component or subclass
             Limit to components having this root.
         """
         instances = cls.__instance_refs.values()
         if name is not None:
             instances = [i for i in instances if i.name == name]
-        if klass is not None:
-            instances = [i for i in instances if isinstance(i, klass)]
         if root is not None:
             instances = [i for i in instances if i.root == root]
         return instances
 
-    def get_instances_by_condition(cls, call, name=None, klass=None, root=None):
+    def get_instances_by_condition(cls, call, name=None, root=None):
         """Get all instances of cls, i such that call(i)==True.
 
-        This also takes the ``name``, ``klass`` and ``root`` arguments of
+        This also takes the ``name`` and ``root`` arguments of
         :meth:`get_instance`
         """
-        return [i for i in cls.get_instances(name,klass,root) if call(i)]
+        return [i for i in cls.get_instances(name, root) if call(i)]
 
 
 class ComponentNameGenerator(object):
@@ -199,6 +195,14 b' class Component(HasTraitlets):'
                                      "root != parent.root")
 
     def _config_changed(self, name, old, new):
+        """Update all the class traits having a config_key with the config.
+
+        For any class traitlet with a ``config_key`` metadata attribute, we
+        update the traitlet with the value of the corresponding config entry.
+
+        In the future, we might want to do a pop here so stale config info
+        is not passed onto children.
+        """
         # Get all traitlets with a config_key metadata entry
         traitlets = self.traitlets('config_key')
         for k, v in traitlets.items():
@@ -215,13 +219,13 b' class Component(HasTraitlets):'
         return self._children
 
     def _remove_child(self, child):
-        """A private method for removing children componenets."""
+        """A private method for removing children components."""
         if child in self._children:
             index = self._children.index(child)
             del self._children[index]
 
     def _add_child(self, child):
-        """A private method for adding children componenets."""
+        """A private method for adding children components."""
         if child not in self._children:
             self._children.append(child)
 

IPython/core/ipapi.py

@@ -29,6 +29,7 b' Authors:'
 
 from IPython.core.error import TryNext, UsageError
 from IPython.core.component import Component
+from IPython.core.iplib import InteractiveShell
 
 #-----------------------------------------------------------------------------
 # Classes and functions
@@ -36,7 +37,7 b' from IPython.core.component import Component'
 
 def get():
     """Get the most recently created InteractiveShell instance."""
-    insts = Component.get_instances(name='__IP')
+    insts = InteractiveShell.get_instances()
     most_recent = insts[0]
     for inst in insts[1:]:
         if inst.created > most_recent.created:

IPython/core/magic.py

@@ -3549,7 +3549,7 b' Defaulting color scheme to \'NoColor\'"""'
         are supports:  wxPython, PyQt4, PyGTK, and Tk::
 
             %gui wx    # enable wxPython event loop integration
-            %gui qt4   # enable PyQt4 event loop integration
+            %gui qt4|qt  # enable PyQt4 event loop integration
             %gui gtk   # enable PyGTK event loop integration
             %gui tk    # enable Tk event loop integration
             %gui       # disable all event loop integration
@@ -3574,7 +3574,7 b' Defaulting color scheme to \'NoColor\'"""'
             inputhook.clear_inputhook()
         elif 'wx' in parameter_s:
             return inputhook.enable_wx(app)
-        elif 'qt4' in parameter_s:
+        elif ('qt4' in parameter_s) or ('qt' in parameter_s):
             return inputhook.enable_qt4(app)
         elif 'gtk' in parameter_s:
             return inputhook.enable_gtk(app)

IPython/core/tests/test_component.py

@@ -52,7 +52,7 b' class TestComponentMeta(TestCase):'
         c2 = MyOtherComponent(c1)
         c3 = MyOtherComponent(c2)
         self.assertEquals(MyComponent.get_instances(), [c1, c2, c3])
-        self.assertEquals(MyComponent.get_instances(klass=MyOtherComponent), [c2, c3])
+        self.assertEquals(MyOtherComponent.get_instances(), [c2, c3])
 
     def test_get_instances_root(self):
         class MyComponent(Component):

IPython/lib/__init__.py

@@ -20,7 +20,10 b' from IPython.lib.inputhook import ('
     enable_gtk, disable_gtk,
     enable_qt4, disable_qt4,
     enable_tk, disable_tk,
-    set_inputhook, clear_inputhook
+    set_inputhook, clear_inputhook,
+    current_gui, spin,
+    appstart_qt4, appstart_wx,
+    appstart_gtk, appstart_tk
 )
 
 #-----------------------------------------------------------------------------

IPython/lib/inputhook.py

@@ -19,7 +19,153 b' import ctypes'
 import sys
 
 #-----------------------------------------------------------------------------
-# Code
+# Constants
+#-----------------------------------------------------------------------------
+
+# Constants for identifying the GUI toolkits.
+GUI_WX = 'wx'
+GUI_QT4 = 'qt4'
+GUI_GTK = 'gtk'
+GUI_TK = 'tk'
+
+#-----------------------------------------------------------------------------
+# Utility classes
+#-----------------------------------------------------------------------------
+
+
+class _DummyMainloop(object):
+    """A special manager to hijack GUI mainloops that is mostly a no-op.
+
+    We are not using this class currently as it breaks GUI code that calls 
+    a mainloop function after the app has started to process pending events.
+    """
+    def __init__(self, ml, ihm, gui_type):
+        self.ml = ml
+        self.ihm = ihm
+        self.gui_type = gui_type
+
+    def __call__(self, *args, **kw):
+        if self.ihm.current_gui() == self.gui_type:
+            pass
+        else:
+            self.ml(*args, **kw)
+
+
+#-----------------------------------------------------------------------------
+# Appstart and spin functions
+#-----------------------------------------------------------------------------
+
+
+def appstart_qt4(app):
+    """Start the qt4 event loop in a way that plays with IPython.
+
+    When a qt4 app is run interactively in IPython, the event loop should
+    not be started.  This function checks to see if IPython's qt4 integration
+    is activated and if so, it passes.  If not, it will call the :meth:`exec_`
+    method of the main qt4 app.
+
+    This function should be used by users who want their qt4 scripts to work
+    both at the command line and in IPython.  These users should put the 
+    following logic at the bottom on their script, after they create a
+    :class:`QApplication` instance (called ``app`` here)::
+
+    try:
+        from IPython.lib.inputhook import appstart_qt4
+        appstart_qt4(app)
+    except ImportError:
+        app.exec_()
+    """
+    from PyQt4 import QtCore, QtGui
+
+    assert isinstance(app, QtCore.QCoreApplication)
+    if app is not None:
+        if current_gui() == GUI_QT4:
+            pass
+        else:
+            app.exec_()
+
+
+def appstart_wx(app):
+    """Start the wx event loop in a way that plays with IPython.
+
+    When a wx app is run interactively in IPython, the event loop should
+    not be started.  This function checks to see if IPython's wx integration
+    is activated and if so, it passes.  If not, it will call the 
+    :meth:`MainLoop` method of the main qt4 app.
+
+    This function should be used by users who want their wx scripts to work
+    both at the command line and in IPython.  These users should put the 
+    following logic at the bottom on their script, after they create a
+    :class:`App` instance (called ``app`` here)::
+
+    try:
+        from IPython.lib.inputhook import appstart_wx
+        appstart_wx(app)
+    except ImportError:
+        app.MainLoop()
+    """
+    import wx
+
+    assert isinstance(app, wx.App)
+    if app is not None:
+        if current_gui() == GUI_WX:
+            pass
+        else:
+            app.MainLoop()
+
+
+def appstart_tk(app):
+    """Start the tk event loop in a way that plays with IPython.
+
+    When a tk app is run interactively in IPython, the event loop should
+    not be started.  This function checks to see if IPython's tk integration
+    is activated and if so, it passes.  If not, it will call the 
+    :meth:`mainloop` method of the tk object passed to this method.
+
+    This function should be used by users who want their tk scripts to work
+    both at the command line and in IPython.  These users should put the 
+    following logic at the bottom on their script, after they create a
+    :class:`Tk` instance (called ``app`` here)::
+
+    try:
+        from IPython.lib.inputhook import appstart_tk
+        appstart_tk(app)
+    except ImportError:
+        app.mainloop()
+    """
+    if app is not None:
+        if current_gui() == GUI_TK:
+            pass
+        else:
+            app.mainloop()
+
+def appstart_gtk():
+    """Start the gtk event loop in a way that plays with IPython.
+
+    When a gtk app is run interactively in IPython, the event loop should
+    not be started.  This function checks to see if IPython's gtk integration
+    is activated and if so, it passes.  If not, it will call 
+    :func:`gtk.main`.  Unlike the other appstart implementations, this does
+    not take an ``app`` argument.
+
+    This function should be used by users who want their gtk scripts to work
+    both at the command line and in IPython.  These users should put the 
+    following logic at the bottom on their script::
+
+    try:
+        from IPython.lib.inputhook import appstart_gtk
+        appstart_gtk()
+    except ImportError:
+        gtk.main()
+    """
+    import gtk
+    if current_gui() == GUI_GTK:
+        pass
+    else:
+        gtk.main()
+
+#-----------------------------------------------------------------------------
+# Main InputHookManager class
 #-----------------------------------------------------------------------------
 
 
@@ -32,6 +178,12 b' class InputHookManager(object):'
     
     def __init__(self):
         self.PYFUNC = ctypes.PYFUNCTYPE(ctypes.c_int)
+        self._apps = {}
+        self._spinner_dict = {
+            GUI_QT4 : self._spin_qt4,
+            GUI_WX  : self._spin_wx,
+            GUI_GTK : self._spin_gtk,
+            GUI_TK  : self._spin_tk}
         self._reset()
 
     def _reset(self):
@@ -40,19 +192,131 b' class InputHookManager(object):'
         self._installed = False
         self._current_gui = None
 
-    def get_pyos_inputhook(self):
-        """Return the current PyOS_InputHook as a ctypes.c_void_p.
+    def _hijack_wx(self):
+        """Hijack the wx mainloop so a user calling it won't cause badness.
+
+        We are not currently using this as it breaks GUI code that calls a 
+        mainloop at anytime but startup.
+        """
+        import wx
+        if hasattr(wx, '_core_'): core = getattr(wx, '_core_')
+        elif hasattr(wx, '_core'): core = getattr(wx, '_core')
+        else: raise AttributeError('Could not find wx core module')
+        orig_mainloop = core.PyApp_MainLoop
+        core.PyApp_MainLoop = _DummyMainloop
+        return orig_mainloop
+
+    def _hijack_qt4(self):
+        """Hijack the qt4 mainloop so a user calling it won't cause badness.
+
+        We are not currently using this as it breaks GUI code that calls a 
+        mainloop at anytime but startup.
+        """
+        from PyQt4 import QtGui, QtCore
+        orig_mainloop = QtGui.qApp.exec_
+        dumb_ml = _DummyMainloop(orig_mainloop, self, GUI_QT4)
+        QtGui.qApp.exec_ = dumb_ml
+        QtGui.QApplication.exec_ = dumb_ml
+        QtCore.QCoreApplication.exec_ = dumb_ml
+        return orig_mainloop
+
+    def _hijack_gtk(self):
+        """Hijack the gtk mainloop so a user calling it won't cause badness.
+
+        We are not currently using this as it breaks GUI code that calls a 
+        mainloop at anytime but startup.
+        """
+        import gtk
+        orig_mainloop = gtk.main
+        dumb_ml = _DummyMainloop(orig_mainloop, self, GUI_GTK)
+        gtk.mainloop = dumb_ml
+        gtk.main = dumb_ml
+        return orig_mainloop
+
+    def _hijack_tk(self):
+        """Hijack the tk mainloop so a user calling it won't cause badness.
+
+        We are not currently using this as it breaks GUI code that calls a 
+        mainloop at anytime but startup.
+        """
+        import Tkinter
+        orig_mainloop = gtk.main
+        dumb_ml = _DummyMainloop(orig_mainloop, self, GUI_TK)
+        Tkinter.Misc.mainloop = dumb_ml
+        Tkinter.mainloop = dumb_ml
+
+    def _spin_qt4(self):
+        """Process all pending events in the qt4 event loop.
+
+        This is for internal IPython use only and user code should not call this.
+        Instead, they should issue the raw GUI calls themselves.
+        """
+        from PyQt4 import QtCore, QtGui
+
+        app = QtCore.QCoreApplication.instance()
+        if app is not None:
+            QtCore.QCoreApplication.processEvents(QtCore.QEventLoop.AllEvents)
+
+    def _spin_wx(self):
+        """Process all pending events in the wx event loop.
+
+        This is for internal IPython use only and user code should not call this.
+        Instead, they should issue the raw GUI calls themselves.
+        """
+        import wx
+        app = wx.GetApp()
+        if app is not None and wx.Thread_IsMain():
+            evtloop = wx.EventLoop()
+            ea = wx.EventLoopActivator(evtloop)
+            while evtloop.Pending():
+                evtloop.Dispatch()
+            app.ProcessIdle()
+            del ea
+
+    def _spin_gtk(self):
+        """Process all pending events in the gtk event loop.
+
+        This is for internal IPython use only and user code should not call this.
+        Instead, they should issue the raw GUI calls themselves.
+        """
+        import gtk
+        gtk.gdk.threads_enter()
+        while gtk.events_pending():
+            gtk.main_iteration(False)
+        gtk.gdk.flush()
+        gtk.gdk.threads_leave()
+
+    def _spin_tk(self):
+        """Process all pending events in the tk event loop.
+
+        This is for internal IPython use only and user code should not call this.
+        Instead, they should issue the raw GUI calls themselves.
         """
+        app = self._apps.get(GUI_TK)
+        if app is not None:
+            app.update()
+
+    def spin(self):
+        """Process pending events in the current gui.
+
+        This method is just provided for IPython to use internally if needed
+        for things like testing.  Third party projects should not call this
+        method, but instead should call the underlying GUI toolkit methods
+        that we are calling.
+        """
+        spinner = self._spinner_dict.get(self._current_gui, lambda: None)
+        spinner()
+
+    def get_pyos_inputhook(self):
+        """Return the current PyOS_InputHook as a ctypes.c_void_p."""
         return ctypes.c_void_p.in_dll(ctypes.pythonapi,"PyOS_InputHook")
 
     def get_pyos_inputhook_as_func(self):
-        """Return the current PyOS_InputHook as a ctypes.PYFUNCYPE.
-        """
+        """Return the current PyOS_InputHook as a ctypes.PYFUNCYPE."""
         return self.PYFUNC.in_dll(ctypes.pythonapi,"PyOS_InputHook")
 
     def set_inputhook(self, callback):
-        """Set PyOS_InputHook to callback and return the previous one.
-        """
+        """Set PyOS_InputHook to callback and return the previous one."""
         self._callback = callback
         self._callback_pyfunctype = self.PYFUNC(callback)
         pyos_inputhook_ptr = self.get_pyos_inputhook()
@@ -63,14 +327,33 b' class InputHookManager(object):'
         return original
 
     def clear_inputhook(self):
-        """Set PyOS_InputHook to NULL and return the previous one.
-        """
+        """Set PyOS_InputHook to NULL and return the previous one."""
         pyos_inputhook_ptr = self.get_pyos_inputhook()
         original = self.get_pyos_inputhook_as_func()
         pyos_inputhook_ptr.value = ctypes.c_void_p(None).value
         self._reset()
         return original
 
+    def clear_app_refs(self, gui=None):
+        """Clear IPython's internal reference to an application instance.
+
+        Whenever we create an app for a user on qt4 or wx, we hold a
+        reference to the app.  This is needed because in some cases bad things
+        can happen if a user doesn't hold a reference themselves.  This
+        method is provided to clear the references we are holding.
+
+        Parameters
+        ----------
+        gui : None or str
+            If None, clear all app references.  If ('wx', 'qt4') clear
+            the app for that toolkit.  References are not held for gtk or tk
+            as those toolkits don't have the notion of an app.
+        """
+        if gui is None:
+            self._apps = {}
+        elif self._apps.has_key(gui):
+            del self._apps[gui]
+
     def enable_wx(self, app=False):
         """Enable event loop integration with wxPython.
 
@@ -81,27 +364,30 b' class InputHookManager(object):'
 
         Notes
         -----
-        This methods sets the PyOS_InputHook for wxPython, which allows
+        This methods sets the ``PyOS_InputHook`` for wxPython, which allows
         the wxPython to integrate with terminal based applications like
         IPython.
         
-        Once this has been called, you can use wx interactively by doing::
+        If ``app`` is True, we create an :class:`wx.App` as follows::
         
-            >>> import wx
-            >>> app = wx.App(redirect=False, clearSigInt=False)
+            import wx
+            app = wx.App(redirect=False, clearSigInt=False)
         
         Both options this constructor are important for things to work
         properly in an interactive context.
         
-        But, *don't start the event loop*.  That is handled automatically by
-        PyOS_InputHook.
+        But, we first check to see if an application has already been 
+        created.  If so, we simply return that instance.
         """
         from IPython.lib.inputhookwx import inputhook_wx
         self.set_inputhook(inputhook_wx)
-        self._current_gui = 'wx'
+        self._current_gui = GUI_WX
         if app:
             import wx
+            app = wx.GetApp()
+            if app is None:
             app = wx.App(redirect=False, clearSigInt=False)
+                self._apps[GUI_WX] = app
             return app
 
     def disable_wx(self):
@@ -121,13 +407,17 b' class InputHookManager(object):'
 
         Notes
         -----
-        This methods sets the PyOS_InputHook for wxPython, which allows
+        This methods sets the PyOS_InputHook for PyQt4, which allows
         the PyQt4 to integrate with terminal based applications like
         IPython.
         
-        Once this has been called, you can simply create a QApplication and
-        use it.  But, *don't start the event loop*.  That is handled
-        automatically by PyOS_InputHook.
+        If ``app`` is True, we create an :class:`QApplication` as follows::
+
+            from PyQt4 import QtCore
+            app = QtGui.QApplication(sys.argv)
+
+        But, we first check to see if an application has already been 
+        created.  If so, we simply return that instance.
         """
         from PyQt4 import QtCore
         # PyQt4 has had this since 4.3.1.  In version 4.2, PyOS_InputHook
@@ -138,10 +428,13 b' class InputHookManager(object):'
             QtCore.pyqtRestoreInputHook()
         except AttributeError:
             pass
-        self._current_gui = 'qt4'
+        self._current_gui = GUI_QT4
         if app:
             from PyQt4 import QtGui
+            app = QtCore.QCoreApplication.instance()
+            if app is None:
             app = QtGui.QApplication(sys.argv)
+                self._apps[GUI_QT4] = app
             return app
 
     def disable_qt4(self):
@@ -157,26 +450,24 b' class InputHookManager(object):'
         Parameters
         ----------
         app : bool
-            Create a running application object or not.
+            Create a running application object or not.  Because gtk does't
+            have an app class, this does nothing.
 
         Notes
         -----
         This methods sets the PyOS_InputHook for PyGTK, which allows
         the PyGTK to integrate with terminal based applications like
         IPython.
-        
-        Once this has been called, you can simple create PyGTK objects and
-        use them.  But, *don't start the event loop*.  That is handled
-        automatically by PyOS_InputHook.
         """
         import gtk
         try:
             gtk.set_interactive(True)
-            self._current_gui = 'gtk'
+            self._current_gui = GUI_GTK
         except AttributeError:
             # For older versions of gtk, use our own ctypes version
             from IPython.lib.inputhookgtk import inputhook_gtk
-            add_inputhook(inputhook_gtk)
+            self.set_inputhook(inputhook_gtk)
+            self._current_gui = GUI_GTK
 
     def disable_gtk(self):
         """Disable event loop integration with PyGTK.
@@ -198,7 +489,13 b' class InputHookManager(object):'
         Currently this is a no-op as creating a :class:`Tkinter.Tk` object 
         sets ``PyOS_InputHook``.
         """
-        self._current_gui = 'tk'
+        self._current_gui = GUI_TK
+        if app:
+            import Tkinter
+            app = Tkinter.Tk()
+            app.withdraw()
+            self._apps[GUI_TK] = app
+            return app
 
     def disable_tk(self):
         """Disable event loop integration with Tkinter.
@@ -224,3 +521,5 b' disable_tk = inputhook_manager.disable_tk'
 clear_inputhook = inputhook_manager.clear_inputhook
 set_inputhook = inputhook_manager.set_inputhook
 current_gui = inputhook_manager.current_gui
+clear_app_refs = inputhook_manager.clear_app_refs
+spin = inputhook_manager.spin

IPython/lib/inputhookwx.py

@@ -19,6 +19,7 b' Authors: Robin Dunn, Brian Granger, Ondrej Certik'
 #-----------------------------------------------------------------------------
 
 import os
+import signal
 import sys
 import time
 from timeit import default_timer as clock
@@ -122,6 +123,12 b' def inputhook_wx3():'
     if app is not None:
         assert wx.Thread_IsMain()
 
+        # The import of wx on Linux sets the handler for signal.SIGINT
+        # to 0.  This is a bug in wx or gtk.  We fix by just setting it
+        # back to the Python default.
+        if not callable(signal.getsignal(signal.SIGINT)):
+            signal.signal(signal.SIGINT, signal.default_int_handler)
+
         evtloop = wx.EventLoop()
         ea = wx.EventLoopActivator(evtloop)
         t = clock()
@@ -140,6 +147,8 b' def inputhook_wx3():'
             # 0.005   3%
             # 0.01    1.5%
             # 0.05    0.5%            
+            if clock()-t > 1.0:
+                time.sleep(1.0)
             if clock()-t > 0.1:
                 # Few GUI events coming in, so we can sleep longer
                 time.sleep(0.05)

docs/source/interactive/reference.txt

@@ -1412,6 +1412,9 b' the form of a library, the capabilities are exposed in library form'
 in the :mod:`IPython.lib.inputhook`.  Interested developers should see the
 module docstrings for more information.
 
+In addition, we also have a number of examples in our source directory
+:file:`docs/examples/lib` that demonstrate these capabilities.
+
 .. _matplotlib_support:
 
 Plotting with matplotlib