Merge pull request #5666 from takluyver/inputhook-extensible

Refactor inputhook to allow easy extension

docs/source/config/eventloops.rst

@@ -0,0 +1,103 b''
+================================
+Integrating with GUI event loops
+================================
+
+When the user types ``%gui qt``, IPython integrates itself with the Qt event
+loop, so you can use both a GUI and an interactive prompt together. IPython
+supports a number of common GUI toolkits, but from IPython 3.0, it is possible
+to integrate other event loops without modifying IPython itself.
+
+Terminal IPython handles event loops very differently from the IPython kernel,
+so different steps are needed to integrate with each.
+
+Event loops in the terminal
+---------------------------
+
+In the terminal, IPython uses a blocking Python function to wait for user input.
+However, the Python C API provides a hook, :c:func:`PyOS_InputHook`, which is
+called frequently while waiting for input. This can be set to a function which
+briefly runs the event loop and then returns.
+
+IPython provides Python level wrappers for setting and resetting this hook. To
+use them, subclass :class:`IPython.lib.inputhook.InputHookBase`, and define
+an ``enable(app=None)`` method, which initialises the event loop and calls
+``self.manager.set_inputhook(f)`` with a function which will briefly run the
+event loop before exiting. Decorate the class with a call to
+:func:`IPython.lib.inputhook.register`::
+
+    from IPython.lib.inputhook import register, InputHookBase
+
+    @register('clutter')
+    class ClutterInputHook(InputHookBase):
+        def enable(self, app=None):
+            self.manager.set_inputhook(inputhook_clutter)
+
+You can also optionally define a ``disable()`` method, taking no arguments, if
+there are extra steps needed to clean up. IPython will take care of resetting
+the hook, whether or not you provide a disable method.
+
+The simplest way to define the hook function is just to run one iteration of the
+event loop, or to run until no events are pending. Most event loops provide some
+mechanism to do one of these things. However, the GUI may lag slightly,
+because the hook is only called every 0.1 seconds. Alternatively, the hook can
+keep running the event loop until there is input ready on stdin. IPython
+provides a function to facilitate this:
+
+.. currentmodule:: IPython.lib.inputhook
+
+.. function:: stdin_ready()
+
+   Returns True if there is something ready to read on stdin.
+   
+   If this is the case, the hook function should return immediately.
+   
+   This is implemented for Windows and POSIX systems - on other platforms, it
+   always returns True, so that the hook always gives Python a chance to check
+   for input.
+
+
+Event loops in the kernel
+-------------------------
+
+The kernel runs its own event loop, so it's simpler to integrate with others.
+IPython allows the other event loop to take control, but it must call
+:meth:`IPython.kernel.zmq.kernelbase.Kernel.do_one_iteration` periodically.
+
+To integrate with this, write a function that takes a single argument,
+the IPython kernel instance, arranges for your event loop to call
+``kernel.do_one_iteration()`` at least every ``kernel._poll_interval`` seconds,
+and starts the event loop.
+
+Decorate this function with :func:`IPython.kernel.zmq.eventloops.register_integration`,
+passing in the names you wish to register it for. Here is a slightly simplified
+version of the Tkinter integration already included in IPython::
+
+    @register_integration('tk')
+    def loop_tk(kernel):
+        """Start a kernel with the Tk event loop."""
+        from tkinter import Tk
+
+        # Tk uses milliseconds
+        poll_interval = int(1000*kernel._poll_interval)
+        # For Tkinter, we create a Tk object and call its withdraw method.
+        class Timer(object):
+            def __init__(self, func):
+                self.app = Tk()
+                self.app.withdraw()
+                self.func = func
+
+            def on_timer(self):
+                self.func()
+                self.app.after(poll_interval, self.on_timer)
+
+            def start(self):
+                self.on_timer()  # Call it once to get things going.
+                self.app.mainloop()
+
+        kernel.timer = Timer(kernel.do_one_iteration)
+        kernel.timer.start()
+
+Some event loops can go one better, and integrate checking for messages on the
+kernel's ZMQ sockets, making the kernel more responsive than plain polling. How
+to do this is outside the scope of this document; if you are interested, look at
+the integration with Qt in :mod:`IPython.kernel.zmq.eventloops`.

docs/source/whatsnew/pr/inputhook_extensible.rst

@@ -0,0 +1,7 b''
+* It's now possible to provide mechanisms to integrate IPython with other event
+  loops, in addition to the ones we already support. This lets you run GUI code
+  in IPython with an interactive prompt, and to embed the IPython
+  kernel in GUI applications. See :doc:`/config/eventloops` for details. As part
+  of this, the direct ``enable_*`` and ``disable_*`` functions for various GUIs
+  in :mod:`IPython.lib.inputhook` have been deprecated in favour of
+  :meth:`~.InputHookManager.enable_gui` and :meth:`~.InputHookManager.disable_gui`.

IPython/kernel/zmq/eventloops.py

@@ -1,264 +1,285 b''
 # encoding: utf-8
 """Event loop integration for the ZeroMQ-based kernels.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import sys
 
 # System library imports
 import zmq
 
 # Local imports
 from IPython.config.application import Application
 from IPython.utils import io
 
 
 #------------------------------------------------------------------------------
 # Eventloops for integrating the Kernel into different GUIs
 #------------------------------------------------------------------------------
 
 def _on_os_x_10_9():
     import platform
     from distutils.version import LooseVersion as V
     return sys.platform == 'darwin' and V(platform.mac_ver()[0]) >= V('10.9')
 
 def _notify_stream_qt(kernel, stream):
     
     from IPython.external.qt_for_kernel import QtCore
     
     if _on_os_x_10_9() and kernel._darwin_app_nap:
         from IPython.external.appnope import nope_scope as context
     else:
         from IPython.core.interactiveshell import NoOpContext as context
 
     def process_stream_events():
         while stream.getsockopt(zmq.EVENTS) & zmq.POLLIN:
             with context():
                 kernel.do_one_iteration()
     
     fd = stream.getsockopt(zmq.FD)
     notifier = QtCore.QSocketNotifier(fd, QtCore.QSocketNotifier.Read, kernel.app)
     notifier.activated.connect(process_stream_events)
 
+# mapping of keys to loop functions
+loop_map = {
+    'inline': None,
+    None : None,
+}
+
+def register_integration(*toolkitnames):
+    """Decorator to register an event loop to integrate with the IPython kernel
+    
+    The decorator takes names to register the event loop as for the %gui magic.
+    You can provide alternative names for the same toolkit.
+    
+    The decorated function should take a single argument, the IPython kernel
+    instance, arrange for the event loop to call ``kernel.do_one_iteration()``
+    at least every ``kernel._poll_interval`` seconds, and start the event loop.
+    
+    :mod:`IPython.kernel.zmq.eventloops` provides and registers such functions
+    for a few common event loops.
+    """
+    def decorator(func):
+        for name in toolkitnames:
+            loop_map[name] = func
+        return func
+    
+    return decorator
+
+
+@register_integration('qt', 'qt4')
 def loop_qt4(kernel):
     """Start a kernel with PyQt4 event loop integration."""
 
     from IPython.lib.guisupport import get_app_qt4, start_event_loop_qt4
 
     kernel.app = get_app_qt4([" "])
     kernel.app.setQuitOnLastWindowClosed(False)
     
     for s in kernel.shell_streams:
         _notify_stream_qt(kernel, s)
     
     start_event_loop_qt4(kernel.app)
 
 
+@register_integration('wx')
 def loop_wx(kernel):
     """Start a kernel with wx event loop support."""
 
     import wx
     from IPython.lib.guisupport import start_event_loop_wx
     
     if _on_os_x_10_9() and kernel._darwin_app_nap:
         # we don't hook up App Nap contexts for Wx,
         # just disable it outright.
         from IPython.external.appnope import nope
         nope()
 
     doi = kernel.do_one_iteration
      # Wx uses milliseconds
     poll_interval = int(1000*kernel._poll_interval)
 
     # We have to put the wx.Timer in a wx.Frame for it to fire properly.
     # We make the Frame hidden when we create it in the main app below.
     class TimerFrame(wx.Frame):
         def __init__(self, func):
             wx.Frame.__init__(self, None, -1)
             self.timer = wx.Timer(self)
             # Units for the timer are in milliseconds
             self.timer.Start(poll_interval)
             self.Bind(wx.EVT_TIMER, self.on_timer)
             self.func = func
 
         def on_timer(self, event):
             self.func()
 
     # We need a custom wx.App to create our Frame subclass that has the
     # wx.Timer to drive the ZMQ event loop.
     class IPWxApp(wx.App):
         def OnInit(self):
             self.frame = TimerFrame(doi)
             self.frame.Show(False)
             return True
 
     # The redirect=False here makes sure that wx doesn't replace
     # sys.stdout/stderr with its own classes.
     kernel.app = IPWxApp(redirect=False)
 
     # 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.
     import signal
     if not callable(signal.getsignal(signal.SIGINT)):
         signal.signal(signal.SIGINT, signal.default_int_handler)
 
     start_event_loop_wx(kernel.app)
 
 
+@register_integration('tk')
 def loop_tk(kernel):
     """Start a kernel with the Tk event loop."""
 
     try:
         from tkinter import Tk  # Py 3
     except ImportError:
         from Tkinter import Tk  # Py 2
     doi = kernel.do_one_iteration
     # Tk uses milliseconds
     poll_interval = int(1000*kernel._poll_interval)
     # For Tkinter, we create a Tk object and call its withdraw method.
     class Timer(object):
         def __init__(self, func):
             self.app = Tk()
             self.app.withdraw()
             self.func = func
 
         def on_timer(self):
             self.func()
             self.app.after(poll_interval, self.on_timer)
 
         def start(self):
             self.on_timer()  # Call it once to get things going.
             self.app.mainloop()
 
     kernel.timer = Timer(doi)
     kernel.timer.start()
 
 
+@register_integration('gtk')
 def loop_gtk(kernel):
     """Start the kernel, coordinating with the GTK event loop"""
     from .gui.gtkembed import GTKEmbed
 
     gtk_kernel = GTKEmbed(kernel)
     gtk_kernel.start()
 
 
+@register_integration('gtk3')
 def loop_gtk3(kernel):
     """Start the kernel, coordinating with the GTK event loop"""
     from .gui.gtk3embed import GTKEmbed
 
     gtk_kernel = GTKEmbed(kernel)
     gtk_kernel.start()
 
 
+@register_integration('osx')
 def loop_cocoa(kernel):
     """Start the kernel, coordinating with the Cocoa CFRunLoop event loop
     via the matplotlib MacOSX backend.
     """
     import matplotlib
     if matplotlib.__version__ < '1.1.0':
         kernel.log.warn(
         "MacOSX backend in matplotlib %s doesn't have a Timer, "
         "falling back on Tk for CFRunLoop integration.  Note that "
         "even this won't work if Tk is linked against X11 instead of "
         "Cocoa (e.g. EPD).  To use the MacOSX backend in the kernel, "
         "you must use matplotlib >= 1.1.0, or a native libtk."
         )
         return loop_tk(kernel)
     
     from matplotlib.backends.backend_macosx import TimerMac, show
 
     # scale interval for sec->ms
     poll_interval = int(1000*kernel._poll_interval)
 
     real_excepthook = sys.excepthook
     def handle_int(etype, value, tb):
         """don't let KeyboardInterrupts look like crashes"""
         if etype is KeyboardInterrupt:
             io.raw_print("KeyboardInterrupt caught in CFRunLoop")
         else:
             real_excepthook(etype, value, tb)
 
     # add doi() as a Timer to the CFRunLoop
     def doi():
         # restore excepthook during IPython code
         sys.excepthook = real_excepthook
         kernel.do_one_iteration()
         # and back:
         sys.excepthook = handle_int
 
     t = TimerMac(poll_interval)
     t.add_callback(doi)
     t.start()
 
     # but still need a Poller for when there are no active windows,
     # during which time mainloop() returns immediately
     poller = zmq.Poller()
     if kernel.control_stream:
         poller.register(kernel.control_stream.socket, zmq.POLLIN)
     for stream in kernel.shell_streams:
         poller.register(stream.socket, zmq.POLLIN)
 
     while True:
         try:
             # double nested try/except, to properly catch KeyboardInterrupt
             # due to pyzmq Issue #130
             try:
                 # don't let interrupts during mainloop invoke crash_handler:
                 sys.excepthook = handle_int
                 show.mainloop()
                 sys.excepthook = real_excepthook
                 # use poller if mainloop returned (no windows)
                 # scale by extra factor of 10, since it's a real poll
                 poller.poll(10*poll_interval)
                 kernel.do_one_iteration()
             except:
                 raise
         except KeyboardInterrupt:
             # Ctrl-C shouldn't crash the kernel
             io.raw_print("KeyboardInterrupt caught in kernel")
         finally:
             # ensure excepthook is restored
             sys.excepthook = real_excepthook
 
-# mapping of keys to loop functions
-loop_map = {
-    'qt' : loop_qt4,
-    'qt4': loop_qt4,
-    'inline': None,
-    'osx': loop_cocoa,
-    'wx' : loop_wx,
-    'tk' : loop_tk,
-    'gtk': loop_gtk,
-    'gtk3': loop_gtk3,
-    None : None,
-}
 
 
 def enable_gui(gui, kernel=None):
     """Enable integration with a given GUI"""
     if gui not in loop_map:
         e = "Invalid GUI request %r, valid ones are:%s" % (gui, loop_map.keys())
         raise ValueError(e)
     if kernel is None:
         if Application.initialized():
             kernel = getattr(Application.instance(), 'kernel', None)
         if kernel is None:
             raise RuntimeError("You didn't specify a kernel,"
                 " and no IPython Application with a kernel appears to be running."
             )
     loop = loop_map[gui]
     if loop and kernel.eventloop is not None and kernel.eventloop is not loop:
         raise RuntimeError("Cannot activate multiple GUI eventloops")
     kernel.eventloop = loop

IPython/lib/inputhook.py

@@ -1,542 +1,569 b''
 # coding: utf-8
 """
 Inputhook management for GUI event loop integration.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 try:
     import ctypes
 except ImportError:
     ctypes = None
 except SystemError: # IronPython issue, 2/8/2014
     ctypes = None
 import os
 import sys
 from distutils.version import LooseVersion as V
 
 from IPython.utils.warn import warn
 
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 # Constants for identifying the GUI toolkits.
 GUI_WX = 'wx'
 GUI_QT = 'qt'
 GUI_QT4 = 'qt4'
 GUI_GTK = 'gtk'
 GUI_TK = 'tk'
 GUI_OSX = 'osx'
 GUI_GLUT = 'glut'
 GUI_PYGLET = 'pyglet'
 GUI_GTK3 = 'gtk3'
 GUI_NONE = 'none' # i.e. disable
 
 #-----------------------------------------------------------------------------
 # Utilities
 #-----------------------------------------------------------------------------
 
 def _stdin_ready_posix():
     """Return True if there's something to read on stdin (posix version)."""
     infds, outfds, erfds = select.select([sys.stdin],[],[],0)
     return bool(infds)
 
 def _stdin_ready_nt():
     """Return True if there's something to read on stdin (nt version)."""
     return msvcrt.kbhit()
 
 def _stdin_ready_other():
     """Return True, assuming there's something to read on stdin."""
     return True #
 
 
 def _ignore_CTRL_C_posix():
     """Ignore CTRL+C (SIGINT)."""
     signal.signal(signal.SIGINT, signal.SIG_IGN)
 
 def _allow_CTRL_C_posix():
     """Take CTRL+C into account (SIGINT)."""
     signal.signal(signal.SIGINT, signal.default_int_handler)
 
 def _ignore_CTRL_C_other():
     """Ignore CTRL+C (not implemented)."""
     pass
 
 def _allow_CTRL_C_other():
     """Take CTRL+C into account (not implemented)."""
     pass
 
 if os.name == 'posix':
     import select
     import signal
     stdin_ready = _stdin_ready_posix
     ignore_CTRL_C = _ignore_CTRL_C_posix
     allow_CTRL_C = _allow_CTRL_C_posix
 elif os.name == 'nt':
     import msvcrt
     stdin_ready = _stdin_ready_nt
     ignore_CTRL_C = _ignore_CTRL_C_other
     allow_CTRL_C = _allow_CTRL_C_other
 else:
     stdin_ready = _stdin_ready_other
     ignore_CTRL_C = _ignore_CTRL_C_other
     allow_CTRL_C = _allow_CTRL_C_other
 
 
 #-----------------------------------------------------------------------------
 # Main InputHookManager class
 #-----------------------------------------------------------------------------
 
 
 class InputHookManager(object):
     """Manage PyOS_InputHook for different GUI toolkits.
 
     This class installs various hooks under ``PyOSInputHook`` to handle
     GUI event loop integration.
     """
     
     def __init__(self):
         if ctypes is None:
             warn("IPython GUI event loop requires ctypes, %gui will not be available")
             return
         self.PYFUNC = ctypes.PYFUNCTYPE(ctypes.c_int)
-        self._apps = {}
+        self.guihooks = {}
+        self.aliases = {}
+        self.apps = {}
         self._reset()
 
     def _reset(self):
         self._callback_pyfunctype = None
         self._callback = None
         self._installed = False
         self._current_gui = None
 
     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 self.PYFUNC.in_dll(ctypes.pythonapi,"PyOS_InputHook")
 
     def set_inputhook(self, callback):
         """Set PyOS_InputHook to callback and return the previous one."""
         # On platforms with 'readline' support, it's all too likely to
         # have a KeyboardInterrupt signal delivered *even before* an
         # initial ``try:`` clause in the callback can be executed, so
         # we need to disable CTRL+C in this situation.
         ignore_CTRL_C()
         self._callback = callback
         self._callback_pyfunctype = self.PYFUNC(callback)
         pyos_inputhook_ptr = self.get_pyos_inputhook()
         original = self.get_pyos_inputhook_as_func()
         pyos_inputhook_ptr.value = \
             ctypes.cast(self._callback_pyfunctype, ctypes.c_void_p).value
         self._installed = True
         return original
 
     def clear_inputhook(self, app=None):
         """Set PyOS_InputHook to NULL and return the previous one.
 
         Parameters
         ----------
         app : optional, ignored
           This parameter is allowed only so that clear_inputhook() can be
           called with a similar interface as all the ``enable_*`` methods.  But
           the actual value of the parameter is ignored.  This uniform interface
           makes it easier to have user-level entry points in the main IPython
           app like :meth:`enable_gui`."""
         pyos_inputhook_ptr = self.get_pyos_inputhook()
         original = self.get_pyos_inputhook_as_func()
         pyos_inputhook_ptr.value = ctypes.c_void_p(None).value
         allow_CTRL_C()
         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 gui in self._apps:
-            del self._apps[gui]
+            self.apps = {}
+        elif gui in self.apps:
+            del self.apps[gui]
 
-    def enable_wx(self, app=None):
+    def register(self, toolkitname, *aliases):
+        """Register a class to provide the event loop for a given GUI.
+        
+        This is intended to be used as a class decorator. It should be passed
+        the names with which to register this GUI integration. The classes
+        themselves should subclass :class:`InputHookBase`.
+        
+        ::
+        
+            @inputhook_manager.register('qt')
+            class QtInputHook(InputHookBase):
+                def enable(self, app=None):
+                    ...
+        """
+        def decorator(cls):
+            inst = cls(self)
+            self.guihooks[toolkitname] = inst
+            for a in aliases:
+                self.aliases[a] = toolkitname
+            return cls
+        return decorator
+
+    def current_gui(self):
+        """Return a string indicating the currently active GUI or None."""
+        return self._current_gui
+
+    def enable_gui(self, gui=None, app=None):
+        """Switch amongst GUI input hooks by name.
+
+        This is a higher level method than :meth:`set_inputhook` - it uses the
+        GUI name to look up a registered object which enables the input hook
+        for that GUI.
+
+        Parameters
+        ----------
+        gui : optional, string or None
+          If None (or 'none'), clears input hook, otherwise it must be one
+          of the recognized GUI names (see ``GUI_*`` constants in module).
+
+        app : optional, existing application object.
+          For toolkits that have the concept of a global app, you can supply an
+          existing one.  If not given, the toolkit will be probed for one, and if
+          none is found, a new one will be created.  Note that GTK does not have
+          this concept, and passing an app if ``gui=="GTK"`` will raise an error.
+
+        Returns
+        -------
+        The output of the underlying gui switch routine, typically the actual
+        PyOS_InputHook wrapper object or the GUI toolkit app created, if there was
+        one.
+        """
+        if gui in (None, GUI_NONE):
+            return self.disable_gui()
+        
+        if gui in self.aliases:
+            return self.enable_gui(self.aliases[gui], app)
+        
+        try:
+            gui_hook = self.guihooks[gui]
+        except KeyError:
+            e = "Invalid GUI request {!r}, valid ones are: {}"
+            raise ValueError(e.format(gui, ', '.join(self.guihooks)))
+        self._current_gui = gui
+        return gui_hook.enable(app)
+
+    def disable_gui(self):
+        """Disable GUI event loop integration.
+        
+        If an application was registered, this sets its ``_in_event_loop``
+        attribute to False. It then calls :meth:`clear_inputhook`.
+        """
+        gui = self._current_gui
+        if gui in self.apps:
+            self.apps[gui]._in_event_loop = False
+        return self.clear_inputhook()
+
+class InputHookBase(object):
+    """Base class for input hooks for specific toolkits.
+    
+    Subclasses should define an :meth:`enable` method with one argument, ``app``,
+    which will either be an instance of the toolkit's application class, or None.
+    They may also define a :meth:`disable` method with no arguments.
+    """
+    def __init__(self, manager):
+        self.manager = manager
+
+    def disable(self):
+        pass
+
+inputhook_manager = InputHookManager()
+
+@inputhook_manager.register('wx')
+class WxInputHook(InputHookBase):
+    def enable(self, app=None):
         """Enable event loop integration with wxPython.
 
         Parameters
         ----------
         app : WX Application, optional.
             Running application to use.  If not given, we probe WX for an
             existing application object, and create a new one if none is found.
 
         Notes
         -----
         This methods sets the ``PyOS_InputHook`` for wxPython, which allows
         the wxPython to integrate with terminal based applications like
         IPython.
 
         If ``app`` is not given we probe for an existing one, and return it if
         found.  If no existing app is found, we create an :class:`wx.App` as
         follows::
 
             import wx
             app = wx.App(redirect=False, clearSigInt=False)
         """
         import wx
         
         wx_version = V(wx.__version__).version
         
         if wx_version < [2, 8]:
             raise ValueError("requires wxPython >= 2.8, but you have %s" % wx.__version__)
         
         from IPython.lib.inputhookwx import inputhook_wx
         from IPython.external.appnope import nope
-        self.set_inputhook(inputhook_wx)
+        self.manager.set_inputhook(inputhook_wx)
         nope()
-        self._current_gui = GUI_WX
+
         import wx
         if app is None:
             app = wx.GetApp()
         if app is None:
             app = wx.App(redirect=False, clearSigInt=False)
         app._in_event_loop = True
-        self._apps[GUI_WX] = app
+        self.manager.apps[GUI_WX] = app
         return app
 
-    def disable_wx(self):
+    def disable(self):
         """Disable event loop integration with wxPython.
 
-        This merely sets PyOS_InputHook to NULL.
+        This restores appnapp on OS X
         """
         from IPython.external.appnope import nap
-        if GUI_WX in self._apps:
-            self._apps[GUI_WX]._in_event_loop = False
-        self.clear_inputhook()
         nap()
 
-    def enable_qt4(self, app=None):
+@inputhook_manager.register('qt', 'qt4')
+class Qt4InputHook(InputHookBase):
+    def enable(self, app=None):
         """Enable event loop integration with PyQt4.
         
         Parameters
         ----------
         app : Qt Application, optional.
             Running application to use.  If not given, we probe Qt for an
             existing application object, and create a new one if none is found.
 
         Notes
         -----
         This methods sets the PyOS_InputHook for PyQt4, which allows
         the PyQt4 to integrate with terminal based applications like
         IPython.
 
         If ``app`` is not given we probe for an existing one, and return it if
         found.  If no existing app is found, we create an :class:`QApplication`
         as follows::
 
             from PyQt4 import QtCore
             app = QtGui.QApplication(sys.argv)
         """
         from IPython.lib.inputhookqt4 import create_inputhook_qt4
         from IPython.external.appnope import nope
         app, inputhook_qt4 = create_inputhook_qt4(self, app)
-        self.set_inputhook(inputhook_qt4)
+        self.manager.set_inputhook(inputhook_qt4)
         nope()
 
-        self._current_gui = GUI_QT4
         app._in_event_loop = True
-        self._apps[GUI_QT4] = app
+        self.manager.apps[GUI_QT4] = app
         return app
 
     def disable_qt4(self):
         """Disable event loop integration with PyQt4.
 
-        This merely sets PyOS_InputHook to NULL.
+        This restores appnapp on OS X
         """
         from IPython.external.appnope import nap
-        if GUI_QT4 in self._apps:
-            self._apps[GUI_QT4]._in_event_loop = False
-        self.clear_inputhook()
         nap()
 
-    def enable_gtk(self, app=None):
+@inputhook_manager.register('gtk')
+class GtkInputHook(InputHookBase):
+    def enable(self, app=None):
         """Enable event loop integration with PyGTK.
 
         Parameters
         ----------
         app : ignored
            Ignored, it's only a placeholder to keep the call signature of all
            gui activation methods consistent, which simplifies the logic of
            supporting magics.
 
         Notes
         -----
         This methods sets the PyOS_InputHook for PyGTK, which allows
         the PyGTK to integrate with terminal based applications like
         IPython.
         """
         import gtk
         try:
             gtk.set_interactive(True)
-            self._current_gui = GUI_GTK
         except AttributeError:
             # For older versions of gtk, use our own ctypes version
             from IPython.lib.inputhookgtk import inputhook_gtk
-            self.set_inputhook(inputhook_gtk)
-            self._current_gui = GUI_GTK
+            self.manager.set_inputhook(inputhook_gtk)
 
-    def disable_gtk(self):
-        """Disable event loop integration with PyGTK.
-        
-        This merely sets PyOS_InputHook to NULL.
-        """
-        self.clear_inputhook()
 
-    def enable_tk(self, app=None):
+@inputhook_manager.register('tk')
+class TkInputHook(InputHookBase):
+    def enable(self, app=None):
         """Enable event loop integration with Tk.
 
         Parameters
         ----------
         app : toplevel :class:`Tkinter.Tk` widget, optional.
             Running toplevel widget to use.  If not given, we probe Tk for an
             existing one, and create a new one if none is found.
 
         Notes
         -----
         If you have already created a :class:`Tkinter.Tk` object, the only
         thing done by this method is to register with the
         :class:`InputHookManager`, since creating that object automatically
         sets ``PyOS_InputHook``.
         """
-        self._current_gui = GUI_TK
         if app is None:
             try:
                 from tkinter import Tk  # Py 3
             except ImportError:
                 from Tkinter import Tk  # Py 2
             app = Tk()
             app.withdraw()
-            self._apps[GUI_TK] = app
+            self.manager.apps[GUI_TK] = app
             return app
 
-    def disable_tk(self):
-        """Disable event loop integration with Tkinter.
-        
-        This merely sets PyOS_InputHook to NULL.
-        """
-        self.clear_inputhook()
-
 
-    def enable_glut(self, app=None):
-        """ Enable event loop integration with GLUT.
+@inputhook_manager.register('glut')
+class GlutInputHook(InputHookBase):
+    def enable(self, app=None):
+        """Enable event loop integration with GLUT.
 
         Parameters
         ----------
 
         app : ignored
             Ignored, it's only a placeholder to keep the call signature of all
             gui activation methods consistent, which simplifies the logic of
             supporting magics.
 
         Notes
         -----
 
         This methods sets the PyOS_InputHook for GLUT, which allows the GLUT to
         integrate with terminal based applications like IPython. Due to GLUT
         limitations, it is currently not possible to start the event loop
         without first creating a window. You should thus not create another
         window but use instead the created one. See 'gui-glut.py' in the
         docs/examples/lib directory.
         
         The default screen mode is set to:
         glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH
         """
 
         import OpenGL.GLUT as glut
         from IPython.lib.inputhookglut import glut_display_mode, \
                                               glut_close, glut_display, \
                                               glut_idle, inputhook_glut
 
-        if GUI_GLUT not in self._apps:
+        if GUI_GLUT not in self.manager.apps:
             glut.glutInit( sys.argv )
             glut.glutInitDisplayMode( glut_display_mode )
             # This is specific to freeglut
             if bool(glut.glutSetOption):
                 glut.glutSetOption( glut.GLUT_ACTION_ON_WINDOW_CLOSE,
                                     glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS )
             glut.glutCreateWindow( sys.argv[0] )
             glut.glutReshapeWindow( 1, 1 )
             glut.glutHideWindow( )
             glut.glutWMCloseFunc( glut_close )
             glut.glutDisplayFunc( glut_display )
             glut.glutIdleFunc( glut_idle )
         else:
             glut.glutWMCloseFunc( glut_close )
             glut.glutDisplayFunc( glut_display )
             glut.glutIdleFunc( glut_idle)
-        self.set_inputhook( inputhook_glut )
-        self._current_gui = GUI_GLUT
-        self._apps[GUI_GLUT] = True
+        self.manager.set_inputhook( inputhook_glut )
+        self.manager.apps[GUI_GLUT] = True
 
 
-    def disable_glut(self):
+    def disable(self):
         """Disable event loop integration with glut.
         
         This sets PyOS_InputHook to NULL and set the display function to a
         dummy one and set the timer to a dummy timer that will be triggered
         very far in the future.
         """
         import OpenGL.GLUT as glut
         from glut_support import glutMainLoopEvent
 
         glut.glutHideWindow() # This is an event to be processed below
         glutMainLoopEvent()
-        self.clear_inputhook()
+        super(GlutInputHook, self).disable()
 
-    def enable_pyglet(self, app=None):
+@inputhook_manager.register('pyglet')
+class PygletInputHook(InputHookBase):
+    def enable(self, app=None):
         """Enable event loop integration with pyglet.
 
         Parameters
         ----------
         app : ignored
            Ignored, it's only a placeholder to keep the call signature of all
            gui activation methods consistent, which simplifies the logic of
            supporting magics.
 
         Notes
         -----
         This methods sets the ``PyOS_InputHook`` for pyglet, which allows
         pyglet to integrate with terminal based applications like
         IPython.
 
         """
         from IPython.lib.inputhookpyglet import inputhook_pyglet
-        self.set_inputhook(inputhook_pyglet)
-        self._current_gui = GUI_PYGLET
+        self.manager.set_inputhook(inputhook_pyglet)
         return app
 
-    def disable_pyglet(self):
-        """Disable event loop integration with pyglet.
 
-        This merely sets PyOS_InputHook to NULL.
-        """
-        self.clear_inputhook()
-
-    def enable_gtk3(self, app=None):
+@inputhook_manager.register('gtk3')
+class Gtk3InputHook(InputHookBase):
+    def enable(self, app=None):
         """Enable event loop integration with Gtk3 (gir bindings).
 
         Parameters
         ----------
         app : ignored
            Ignored, it's only a placeholder to keep the call signature of all
            gui activation methods consistent, which simplifies the logic of
            supporting magics.
 
         Notes
         -----
         This methods sets the PyOS_InputHook for Gtk3, which allows
         the Gtk3 to integrate with terminal based applications like
         IPython.
         """
         from IPython.lib.inputhookgtk3 import inputhook_gtk3
-        self.set_inputhook(inputhook_gtk3)
-        self._current_gui = GUI_GTK
+        self.manager.set_inputhook(inputhook_gtk3)
+        self.manager._current_gui = GUI_GTK
 
-    def disable_gtk3(self):
-        """Disable event loop integration with PyGTK.
 
-        This merely sets PyOS_InputHook to NULL.
-        """
-        self.clear_inputhook()
-
-    def current_gui(self):
-        """Return a string indicating the currently active GUI or None."""
-        return self._current_gui
-
-inputhook_manager = InputHookManager()
-
-enable_wx = inputhook_manager.enable_wx
-disable_wx = inputhook_manager.disable_wx
-enable_qt4 = inputhook_manager.enable_qt4
-disable_qt4 = inputhook_manager.disable_qt4
-enable_gtk = inputhook_manager.enable_gtk
-disable_gtk = inputhook_manager.disable_gtk
-enable_tk = inputhook_manager.enable_tk
-disable_tk = inputhook_manager.disable_tk
-enable_glut = inputhook_manager.enable_glut
-disable_glut = inputhook_manager.disable_glut
-enable_pyglet = inputhook_manager.enable_pyglet
-disable_pyglet = inputhook_manager.disable_pyglet
-enable_gtk3 = inputhook_manager.enable_gtk3
-disable_gtk3 = inputhook_manager.disable_gtk3
 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
-
-guis = {None: clear_inputhook,
-        GUI_NONE: clear_inputhook,
-        GUI_OSX: lambda app=False: None,
-        GUI_TK: enable_tk,
-        GUI_GTK: enable_gtk,
-        GUI_WX: enable_wx,
-        GUI_QT: enable_qt4, # qt3 not supported
-        GUI_QT4: enable_qt4,
-        GUI_GLUT: enable_glut,
-        GUI_PYGLET: enable_pyglet,
-        GUI_GTK3: enable_gtk3,
-}
-
-
-# Convenience function to switch amongst them
-def enable_gui(gui=None, app=None):
-    """Switch amongst GUI input hooks by name.
-
-    This is just a utility wrapper around the methods of the InputHookManager
-    object.
-
-    Parameters
-    ----------
-    gui : optional, string or None
-      If None (or 'none'), clears input hook, otherwise it must be one
-      of the recognized GUI names (see ``GUI_*`` constants in module).
-
-    app : optional, existing application object.
-      For toolkits that have the concept of a global app, you can supply an
-      existing one.  If not given, the toolkit will be probed for one, and if
-      none is found, a new one will be created.  Note that GTK does not have
-      this concept, and passing an app if ``gui=="GTK"`` will raise an error.
-
-    Returns
-    -------
-    The output of the underlying gui switch routine, typically the actual
-    PyOS_InputHook wrapper object or the GUI toolkit app created, if there was
-    one.
-    """
-    try:
-        gui_hook = guis[gui]
-    except KeyError:
-        e = "Invalid GUI request %r, valid ones are:%s" % (gui, guis.keys())
-        raise ValueError(e)
-    return gui_hook(app)
-
+enable_gui = inputhook_manager.enable_gui
+disable_gui = inputhook_manager.disable_gui
+register = inputhook_manager.register
+guis = inputhook_manager.guihooks
+
+# Deprecated methods: kept for backwards compatibility, do not use in new code
+def _make_deprecated_enable(name):
+    def enable_toolkit(app=None):
+        warn("This function is deprecated - use enable_gui(%r) instead" % name)
+        inputhook_manager.enable_gui(name, app)
+    
+enable_wx = _make_deprecated_enable('wx')
+enable_qt4 = _make_deprecated_enable('qt4')
+enable_gtk = _make_deprecated_enable('gtk')
+enable_tk = _make_deprecated_enable('tk')
+enable_glut = _make_deprecated_enable('glut')
+enable_pyglet = _make_deprecated_enable('pyglet')
+enable_gtk3 = _make_deprecated_enable('gtk3')
+
+def _deprecated_disable():
+    warn("This function is deprecated: use disable_gui() instead")
+    inputhook_manager.disable_gui()
+disable_wx = disable_qt4 = disable_gtk = disable_gtk3 = disable_glut = \
+        disable_pyglet = _deprecated_disable

docs/source/config/index.rst

@@ -1,32 +1,33 b''
 .. _config_index:
 
 ===============================
 Configuration and customization
 ===============================
 
 Configuring IPython
 -------------------
 
 .. toctree::
    :maxdepth: 2
 
    intro
    options/index
    details
 
 .. seealso::
 
    :doc:`/development/config`
       Technical details of the config system.
 
 Extending and integrating with IPython
 --------------------------------------
 
 .. toctree::
    :maxdepth: 2
 
    extensions/index
    integrating
    custommagics
    inputtransforms
    callbacks
+   eventloops

examples/IPython Kernel/gui/gui-gtk.py

@@ -1,39 +1,39 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")
 
 def delete_event(widget, event, data=None):
     return False
 
 def destroy(widget, data=None):
     gtk.main_quit()
 
 window = gtk.Window(gtk.WINDOW_TOPLEVEL)
 window.connect("delete_event", delete_event)
 window.connect("destroy", destroy)
 button = gtk.Button("Hello World")
 button.connect("clicked", hello_world, None)
 
 window.add(button)
 button.show()
 window.show()
 
 try:
-    from IPython.lib.inputhook import enable_gtk
-    enable_gtk()
+    from IPython.lib.inputhook import enable_gui
+    enable_gui('gtk')
 except ImportError:
     gtk.main()

examples/IPython Kernel/gui/gui-gtk3.py

@@ -1,37 +1,37 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 [1]: %gui gtk3
 
 In [2]: %run gui-gtk3.py
 """
 
 from gi.repository import Gtk
 
 
 def hello_world(wigdet, data=None):
     print("Hello World")
 
 def delete_event(widget, event, data=None):
     return False
 
 def destroy(widget, data=None):
     Gtk.main_quit()
 
 window = Gtk.Window(Gtk.WindowType.TOPLEVEL)
 window.connect("delete_event", delete_event)
 window.connect("destroy", destroy)
 button = Gtk.Button("Hello World")
 button.connect("clicked", hello_world, None)
 
 window.add(button)
 button.show()
 window.show()
 
 try:
-    from IPython.lib.inputhook import enable_gtk3
-    enable_gtk3()
+    from IPython.lib.inputhook import enable_gui
+    enable_gui('gtk3')
 except ImportError:
     Gtk.main()

examples/IPython Kernel/gui/gui-pyglet.py

@@ -1,33 +1,33 b''
 #!/usr/bin/env python
 """Simple pyglet example to manually test event loop integration.
 
 This is meant to run tests manually in ipython as:
 
 In [5]: %gui pyglet
 
 In [6]: %run gui-pyglet.py
 """
 
 import pyglet
 
 
 window = pyglet.window.Window()
 label = pyglet.text.Label('Hello, world',
                           font_name='Times New Roman',
                           font_size=36,
                           x=window.width//2, y=window.height//2,
                           anchor_x='center', anchor_y='center')
 @window.event
 def on_close():
     window.close()
 
 @window.event
 def on_draw():
     window.clear()
     label.draw()
 
 try:
-    from IPython.lib.inputhook import enable_pyglet
-    enable_pyglet()
+    from IPython.lib.inputhook import enable_gui
+    enable_gui('pyglet')
 except ImportError:
     pyglet.app.run()

examples/IPython Kernel/gui/gui-tk.py

@@ -1,35 +1,36 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
 """
 
 try:
     from tkinter import *  # Python 3
 except ImportError:
     from Tkinter import *  # Python 2
 
 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.lib.inputhook import enable_tk; enable_tk(root)
+    from IPython.lib.inputhook import enable_gui
+    enable_gui('tk', root)
 except ImportError:
     root.mainloop()

examples/IPython Kernel/gui/gui-wx.py

@@ -1,106 +1,106 b''
 #!/usr/bin/env python
 """
 A Simple wx example to test IPython's event loop integration.
 
 To run this do:
 
 In [5]: %gui wx  # or start IPython with '--gui wx'
 
 In [6]: %run gui-wx.py
 
 Ref: Modified from wxPython source code wxPython/samples/simple/simple.py
 """
 
 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
 
 
 if __name__ == '__main__':
 
     app = wx.GetApp()
     if app is None:
         app = MyApp(redirect=False, clearSigInt=False)
     else:
         frame = MyFrame(None, "Simple wxPython App")
         app.SetTopWindow(frame)
         print("Print statements go to this stdout window by default.")
         frame.Show(True)
 
     try:
-        from IPython.lib.inputhook import enable_wx
-        enable_wx(app)
+        from IPython.lib.inputhook import enable_gui
+        enable_gui('wx', app)
     except ImportError:
         app.MainLoop()