First draft of full inputhook management.

IPython/lib/guiloop/inputhook.py

@@ -0,0 +1,109 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
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+
+class InputHookManager(object):
+    
+    def __init__(self):
+        self.PYFUNC = ctypes.PYFUNCTYPE(ctypes.c_int)
+        self._reset()
+
+    def _reset(self):
+        self._callback_pyfunctype = None
+        self._callback = None
+        self._installed = False
+
+    def get_pyos_inputhook(self):
+        return ctypes.c_void_p.in_dll(ctypes.pythonapi,"PyOS_InputHook")
+
+    def get_pyos_inputhook_as_func(self):
+        return self.PYFUNC.in_dll(ctypes.pythonapi,"PyOS_InputHook")
+
+    def set_inputhook(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 enable_wx(self):
+        from IPython.lib.guiloop.inputhookwx import inputhook_wx
+        self.set_inputhook(inputhook_wx)
+
+    def disable_wx(self):
+        self.clear_inputhook()
+
+    def enable_qt4(self):
+        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
+
+    def disable_qt4(self):
+        self.clear_inputhook()
+
+    def enable_gtk(self):
+        import gtk
+        try:
+            gtk.set_interactive(True)
+        except AttributeError:
+            # For older versions of gtk, use our own ctypes version
+            from IPython.lib.guiloop.inputhookgtk import inputhook_gtk
+            add_inputhook(inputhook_gtk)
+
+    def disable_gtk(self):
+        self.clear_inputhook()
+
+    def enable_tk(self):
+        # Creating a Tkinter.Tk object sets PyOS_InputHook()
+        pass
+
+    def disable_tk(self):
+        self.clear_inputhook()
+
+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

IPython/lib/guiloop/inputhookgtk.py

@@ -0,0 +1,28 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+Enable pygtk to be used interacive by setting PyOS_InputHook.
+
+Authors: Brian Granger
+"""
+
+#-----------------------------------------------------------------------------
+#  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.
+#-----------------------------------------------------------------------------
+
+import sys
+import gtk, gobject
+
+
+def _main_quit(*args, **kwargs):
+    gtk.main_quit()
+    return False
+
+def inputhook_gtk():
+    gobject.io_add_watch(sys.stdin, gobject.IO_IN, _main_quit)
+    gtk.main()
+    return 0
+

IPython/lib/guiloop/inputhookwx.py

@@ -0,0 +1,153 b''
+#!/usr/bin/env python
+# encoding: utf-8
+
+"""
+Enable wxPython to be used interacive by setting PyOS_InputHook.
+
+Authors:  Robin Dunn, Brian Granger, Ondrej Certik
+"""
+
+#-----------------------------------------------------------------------------
+#  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 os
+import sys
+import time
+from timeit import default_timer as clock
+import wx
+
+if os.name == 'posix':
+    import select
+elif sys.platform == 'win32':
+    import msvcrt
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+def stdin_ready():
+    if os.name == 'posix':
+        infds, outfds, erfds = select.select([sys.stdin],[],[],0)
+        if infds:
+            return True
+        else:
+            return False
+    elif sys.platform == 'win32':
+        return msvcrt.kbhit()
+
+
+def inputhook_wx1():
+    """Run the wx event loop by processing pending events only.
+    
+    This approach seems to work, but its performance is not great as it 
+    relies on having PyOS_InputHook called regularly.
+    """
+    app = wx.GetApp()
+    if app is not None:
+        assert wx.Thread_IsMain()
+
+        # Make a temporary event loop and process system events until
+        # there are no more waiting, then allow idle events (which
+        # will also deal with pending or posted wx events.)
+        evtloop = wx.EventLoop()
+        ea = wx.EventLoopActivator(evtloop)
+        while evtloop.Pending():
+            evtloop.Dispatch()
+        app.ProcessIdle()
+        del ea
+    return 0
+
+class EventLoopTimer(wx.Timer):
+
+    def __init__(self, func):
+        self.func = func
+        wx.Timer.__init__(self)
+
+    def Notify(self):
+        self.func()
+
+class EventLoopRunner(object):
+
+    def Run(self, time):
+        self.evtloop = wx.EventLoop()
+        self.timer = EventLoopTimer(self.check_stdin)
+        self.timer.Start(time)
+        self.evtloop.Run()
+
+    def check_stdin(self):
+        if stdin_ready():
+            self.timer.Stop()
+            self.evtloop.Exit()
+
+def inputhook_wx2():
+    """Run the wx event loop, polling for stdin.
+    
+    This version runs the wx eventloop for an undetermined amount of time,
+    during which it periodically checks to see if anything is ready on
+    stdin.  If anything is ready on stdin, the event loop exits.
+    
+    The argument to elr.Run controls how often the event loop looks at stdin.
+    This determines the responsiveness at the keyboard.  A setting of 1000
+    enables a user to type at most 1 char per second.  I have found that a
+    setting of 10 gives good keyboard response.  We can shorten it further, 
+    but eventually performance would suffer from calling select/kbhit too 
+    often.
+    """
+    app = wx.GetApp()
+    if app is not None:
+        assert wx.Thread_IsMain()
+        elr = EventLoopRunner()
+        # As this time is made shorter, keyboard response improves, but idle
+        # CPU load goes up.  10 ms seems like a good compromise.
+        elr.Run(time=10)  # CHANGE time here to control polling interval
+    return 0
+
+def inputhook_wx3():
+    """Run the wx event loop by processing pending events only.
+    
+    This is like inputhook_wx1, but it keeps processing pending events
+    until stdin is ready.  After processing all pending events, a call to 
+    time.sleep is inserted.  This is needed, otherwise, CPU usage is at 100%.
+    This sleep time should be tuned though for best performance.
+    """
+    app = wx.GetApp()
+    if app is not None:
+        assert wx.Thread_IsMain()
+
+        evtloop = wx.EventLoop()
+        ea = wx.EventLoopActivator(evtloop)
+        t = clock()
+        while not stdin_ready():
+            while evtloop.Pending():
+                t = clock()
+                evtloop.Dispatch()
+            app.ProcessIdle()
+            # We need to sleep at this point to keep the idle CPU load
+            # low.  However, if sleep to long, GUI response is poor.  As 
+            # a compromise, we watch how often GUI events are being processed
+            # and switch between a short and long sleep time.  Here are some
+            # stats useful in helping to tune this.
+            # time    CPU load
+            # 0.001   13%
+            # 0.005   3%
+            # 0.01    1.5%
+            # 0.05    0.5%            
+            if clock()-t > 0.1:
+                # Few GUI events coming in, so we can sleep longer
+                time.sleep(0.05)
+            else:
+                # Many GUI events coming in, so sleep only very little
+                time.sleep(0.001)
+        del ea
+    return 0
+
+# This is our default implementation
+inputhook_wx = inputhook_wx3
  No newline at end of file