Make gui support code and examples uniform and all working correctly.

Note that this has changed a little bit the API, as now all the
inputhook.enable* methods all take an optional app object instead of a
boolean flag.

IPython/lib/inputhook.py

@@ -1,339 +1,345 b''
 #!/usr/bin/env python
 # coding: utf-8
 """
 Inputhook management for GUI event loop integration.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  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 ctypes
 import sys
 import warnings
 
 #-----------------------------------------------------------------------------
 # 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'
 
 #-----------------------------------------------------------------------------
 # Utility classes
 #-----------------------------------------------------------------------------
 
 
 #-----------------------------------------------------------------------------
 # 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):
         self.PYFUNC = ctypes.PYFUNCTYPE(ctypes.c_int)
         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."""
         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
         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):
+    def enable_wx(self, app=None):
         """Enable event loop integration with wxPython.
 
         Parameters
         ----------
-        app : bool
-            Create a running application object or not.
+        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 True, we create an :class:`wx.App` as follows::
+        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)
-
-        Both options this constructor are important for things to work
-        properly in an interactive context.
-
-        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 = GUI_WX
         import wx
-        app = wx.GetApp()
+        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
         return app
 
     def disable_wx(self):
         """Disable event loop integration with wxPython.
 
         This merely sets PyOS_InputHook to NULL.
         """
         if self._apps.has_key(GUI_WX):
             self._apps[GUI_WX]._in_event_loop = False
         self.clear_inputhook()
 
-    def enable_qt4(self):
+    def enable_qt4(self, app=None):
         """Enable event loop integration with PyQt4.
         
         Parameters
         ----------
-        app : bool
-            Create a running application object or not.
+        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 True, we create an :class:`QApplication` as follows::
+        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)
-
-        But, we first check to see if an application has already been 
-        created.  If so, we simply return that instance.
         """
         from IPython.external.qt_for_kernel import QtCore, QtGui
 
         if 'pyreadline' in sys.modules:
             # see IPython GitHub Issue #281 for more info on this issue
             # Similar intermittent behavior has been reported on OSX,
             # but not consistently reproducible
             warnings.warn("""PyReadline's inputhook can conflict with Qt, causing delays
             in interactive input. If you do see this issue, we recommend using another GUI
             toolkit if you can, or disable readline with the configuration option
             'TerminalInteractiveShell.readline_use=False', specified in a config file or
             at the command-line""",
             RuntimeWarning)
         
         # PyQt4 has had this since 4.3.1.  In version 4.2, PyOS_InputHook
         # was set when QtCore was imported, but if it ever got removed,
         # you couldn't reset it.  For earlier versions we can
         # probably implement a ctypes version.
         try:
             QtCore.pyqtRestoreInputHook()
         except AttributeError:
             pass
 
         self._current_gui = GUI_QT4
-        app = QtCore.QCoreApplication.instance()
+        if app is None:
+            app = QtCore.QCoreApplication.instance()
         if app is None:
             app = QtGui.QApplication([" "])
         app._in_event_loop = True
         self._apps[GUI_QT4] = app
         return app
 
     def disable_qt4(self):
         """Disable event loop integration with PyQt4.
 
         This merely sets PyOS_InputHook to NULL.
         """
         if self._apps.has_key(GUI_QT4):
             self._apps[GUI_QT4]._in_event_loop = False
         self.clear_inputhook()
 
-    def enable_gtk(self, app=False):
+    def enable_gtk(self, app=None):
         """Enable event loop integration with PyGTK.
 
         Parameters
         ----------
-        app : bool
-            Create a running application object or not.  Because gtk does't
-            have an app class, this does nothing.
+        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
 
     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=False):
+    def enable_tk(self, app=None):
         """Enable event loop integration with Tk.
 
         Parameters
         ----------
-        app : bool
-            Create a running application object or not.
+        app : toplevel :class:`Tkinter.Tk` widget, 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
         -----
-        Currently this is a no-op as creating a :class:`Tkinter.Tk` object 
+        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:
+        if app is None:
             import Tkinter
             app = Tkinter.Tk()
             app.withdraw()
             self._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 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
 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
 
 
 # Convenience function to switch amongst them
-def enable_gui(gui=None):
+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, clears input hook, otherwise it must be one of the recognized
       GUI names (see ``GUI_*`` constants in module).
 
-    app : optional, bool
-      If true, create an app object and return it.
+    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.
     """
     guis = {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 }
     try:
         gui_hook = guis[gui]
     except KeyError:
-        e="Invalid GUI request %r, valid ones are:%s" % (gui, guis.keys())
+        e = "Invalid GUI request %r, valid ones are:%s" % (gui, guis.keys())
         raise ValueError(e)
-    return gui_hook()
+    return gui_hook(app)
 

docs/examples/lib/gui-gtk.py

@@ -1,43 +1,40 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()
 except ImportError:
     gtk.main()
-
-
-

docs/examples/lib/gui-qt.py

@@ -1,41 +1,49 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.lib.inputhook import enable_qt4
-        enable_qt4()
+        # Note: the following form allows this script to work both inside
+        # ipython and without it, but `%gui qt` MUST be run first (or
+        # equivalently, ipython could have been started with `--gui=qt`).
+        from IPython.lib.guisupport import start_event_loop_qt4
+        start_event_loop_qt4(app)
+
+        # This from doesn't require the gui support to have been enabled in
+        # advance, but it won't work if the script is run as a standalone app
+        # outside of IPython while the user does have IPython available.
+        #from IPython.lib.inputhook import enable_qt4; enable_qt4(app)
     except ImportError:
         app.exec_()

docs/examples/lib/gui-tk.py

@@ -1,32 +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 enable_tk; enable_tk(root)
+    from IPython.lib.inputhook import enable_tk; enable_tk(root)
 except ImportError:
     root.mainloop()

docs/examples/lib/gui-wx.py

@@ -1,109 +1,111 b''
+#!/usr/bin/env python
 """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 because when 
 the frame is closed, wx goes through its shutdown sequence, killing further
 attempts.  I am sure someone who knows wx can fix this issue.
 
 Furthermore, once this example is run, the Wx event loop is mostly dead, so
 even other new uses of Wx may not work correctly.  If you know how to better
 handle this, please contact the ipython developers and let us know.
 
 Note however that we will work with the Matplotlib and Enthought developers so
 that the main interactive uses of Wx we are aware of, namely these tools, will
 continue to work well with IPython interactively.
 """
 
 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)
+if __name__ == '__main__':
+    app = wx.GetApp()
+    if app is None:
+        app = MyApp(redirect=False, clearSigInt=False)
 
-try:
-    from IPython.lib.inputhook import enable_wx
-    enable_wx(app)
-except ImportError:
-    app.MainLoop()
+    try:
+        from IPython.lib.inputhook import enable_wx
+        enable_wx(app)
+    except ImportError:
+        app.MainLoop()