More work on the Tk and GTK gui integration.

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-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()

IPython/__init__.py

@@ -1,86 +1,87 b''
  # -*- coding: utf-8 -*-
 """
 IPython -- An enhanced Interactive Python
 
 One of Python's nicest features is its interactive interpreter. This allows
 very fast testing of ideas without the overhead of creating test files as is
 typical in most programming languages. However, the interpreter supplied with
 the standard Python distribution is fairly primitive (and IDLE isn't really
 much better).
 
 IPython tries to:
 
   i - provide an efficient environment for interactive work in Python
   programming. It tries to address what we see as shortcomings of the standard
   Python prompt, and adds many features to make interactive work much more
   efficient.
 
   ii - offer a flexible framework so that it can be used as the base
   environment for other projects and problems where Python can be the
   underlying language. Specifically scientific environments like Mathematica,
   IDL and Mathcad inspired its design, but similar ideas can be useful in many
   fields. Python is a fabulous language for implementing this kind of system
   (due to its dynamic and introspective features), and with suitable libraries
   entire systems could be built leveraging Python's power.
 
   iii - serve as an embeddable, ready to go interpreter for your own programs.
 
 IPython requires Python 2.4 or newer.
 """
 
 #*****************************************************************************
 #       Copyright (C) 2008-2009 The IPython Development Team
 #       Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
 # Enforce proper version requirements
 import sys
 
 if sys.version[0:3] < '2.4':
     raise ImportError('Python Version 2.4 or above is required for IPython.')
 
 # Make it easy to import extensions - they are always directly on pythonpath.
 # Therefore, non-IPython modules can be added to extensions directory
 import os
 sys.path.append(os.path.join(os.path.dirname(__file__), "extensions"))
 
 # Define what gets imported with a 'from IPython import *'
 __all__ = ['IPython.core.ipapi','utils.generics','utils.ipstruct',
     'core.release','core.shell']
 
 # Load __all__ in IPython namespace so that a simple 'import IPython' gives
 # access to them via IPython.<name>
 glob,loc = globals(),locals()
 for name in __all__:
     #print 'Importing: ',name # dbg
     __import__(name,glob,loc,[])
 
 from IPython.core import shell
 Shell = shell
 from IPython.core import ipapi
 from IPython.core import iplib
 
 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_qt4, appstart_wx,
+    appstart_gtk, appstart_tk
 )
 
 # Release data
 from IPython.core import release # do it explicitly so pydoc can see it - pydoc bug
 __author__   = '%s <%s>\n%s <%s>\n%s <%s>' % \
                ( release.authors['Fernando'] + release.authors['Janko'] + \
                  release.authors['Nathan'] )
 __license__  = release.license
 __version__  = release.version
 __revision__ = release.revision
 
 # Namespace cleanup
 del name,glob,loc

IPython/lib/__init__.py

@@ -1,30 +1,31 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 Extra capabilities for IPython
 """
 
 #-----------------------------------------------------------------------------
 #  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
 #-----------------------------------------------------------------------------
 
 from IPython.lib.inputhook 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_qt4, appstart_wx,
+    appstart_gtk, appstart_tk
 )
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
  No newline at end of file

IPython/lib/inputhook.py

@@ -1,470 +1,525 b''
 #!/usr/bin/env python
 # encoding: 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
 
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 
 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._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):
         self._callback_pyfunctype = None
         self._callback = None
         self._installed = False
         self._current_gui = None
 
     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.
         """
-        pass
+        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 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):
         """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.
 
         Parameters
         ----------
         app : bool
             Create a running application object or not.
 
         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::
 
             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
         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):
         """Disable event loop integration with wxPython.
 
         This merely sets PyOS_InputHook to NULL.
         """
         self.clear_inputhook()
 
     def enable_qt4(self, app=False):
         """Enable event loop integration with PyQt4.
         
         Parameters
         ----------
         app : bool
             Create a running application object or not.
 
         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::
 
             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
         # 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
         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):
         """Disable event loop integration with PyQt4.
 
         This merely sets PyOS_InputHook to NULL.
         """
         self.clear_inputhook()
 
     def enable_gtk(self, app=False):
         """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.
 
         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):
         """Enable event loop integration with Tk.
 
         Parameters
         ----------
         app : bool
             Create a running application object or not.
 
         Notes
         -----
         Currently this is a no-op as creating a :class:`Tkinter.Tk` object 
         sets ``PyOS_InputHook``.
         """
         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.
         
         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
 spin = inputhook_manager.spin