inputhook.py
559 lines
| 19.2 KiB
| text/x-python
|
PythonLexer
Fernando Perez
|
r2363 | # coding: utf-8 | |
Brian Granger
|
r2066 | """ | |
Inputhook management for GUI event loop integration. | |||
""" | |||
#----------------------------------------------------------------------------- | |||
Matthias BUSSONNIER
|
r5390 | # Copyright (C) 2008-2011 The IPython Development Team | |
Brian Granger
|
r2066 | # | |
# Distributed under the terms of the BSD License. The full license is in | |||
# the file COPYING, distributed as part of this software. | |||
#----------------------------------------------------------------------------- | |||
#----------------------------------------------------------------------------- | |||
# Imports | |||
#----------------------------------------------------------------------------- | |||
Bradley M. Froehle
|
r6100 | try: | |
import ctypes | |||
except ImportError: | |||
ctypes = None | |||
Doug Blank
|
r15208 | except SystemError: # IronPython issue, 2/8/2014 | |
Doug Blank
|
r15154 | ctypes = None | |
Christian Boos
|
r4913 | import os | |
Brian Granger
|
r2195 | import sys | |
MinRK
|
r7688 | from distutils.version import LooseVersion as V | |
Bradley M. Froehle
|
r6100 | ||
from IPython.utils.warn import warn | |||
Brian Granger
|
r2066 | ||
#----------------------------------------------------------------------------- | |||
Brian Granger
|
r2214 | # Constants | |
#----------------------------------------------------------------------------- | |||
# Constants for identifying the GUI toolkits. | |||
GUI_WX = 'wx' | |||
Fernando Perez
|
r2363 | GUI_QT = 'qt' | |
Brian Granger
|
r2214 | GUI_QT4 = 'qt4' | |
GUI_GTK = 'gtk' | |||
GUI_TK = 'tk' | |||
MinRK
|
r3462 | GUI_OSX = 'osx' | |
Nicolas Rougier
|
r4806 | GUI_GLUT = 'glut' | |
Nicolas Rougier
|
r4692 | GUI_PYGLET = 'pyglet' | |
Thomi Richards
|
r6459 | GUI_GTK3 = 'gtk3' | |
Christian Boos
|
r4943 | GUI_NONE = 'none' # i.e. disable | |
Brian Granger
|
r2214 | ||
#----------------------------------------------------------------------------- | |||
Christian Boos
|
r4913 | # Utilities | |
Brian Granger
|
r2066 | #----------------------------------------------------------------------------- | |
Christian Boos
|
r4930 | 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 # | |||
Christian Boos
|
r4944 | ||
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 | |||
Christian Boos
|
r4930 | if os.name == 'posix': | |
import select | |||
Christian Boos
|
r4944 | import signal | |
Christian Boos
|
r4930 | stdin_ready = _stdin_ready_posix | |
Christian Boos
|
r4944 | ignore_CTRL_C = _ignore_CTRL_C_posix | |
allow_CTRL_C = _allow_CTRL_C_posix | |||
Christian Boos
|
r4930 | elif os.name == 'nt': | |
import msvcrt | |||
stdin_ready = _stdin_ready_nt | |||
Christian Boos
|
r4944 | ignore_CTRL_C = _ignore_CTRL_C_other | |
allow_CTRL_C = _allow_CTRL_C_other | |||
Christian Boos
|
r4930 | else: | |
stdin_ready = _stdin_ready_other | |||
Christian Boos
|
r4944 | ignore_CTRL_C = _ignore_CTRL_C_other | |
allow_CTRL_C = _allow_CTRL_C_other | |||
Christian Boos
|
r4913 | ||
Fernando Perez
|
r2213 | ||
Brian Granger
|
r2214 | #----------------------------------------------------------------------------- | |
# Main InputHookManager class | |||
#----------------------------------------------------------------------------- | |||
Brian Granger
|
r2210 | ||
Brian Granger
|
r2066 | class InputHookManager(object): | |
Brian Granger
|
r2197 | """Manage PyOS_InputHook for different GUI toolkits. | |
This class installs various hooks under ``PyOSInputHook`` to handle | |||
GUI event loop integration. | |||
""" | |||
Thomi Richards
|
r6467 | ||
Brian Granger
|
r2066 | def __init__(self): | |
Bradley M. Froehle
|
r6100 | if ctypes is None: | |
Thomas Kluyver
|
r8223 | warn("IPython GUI event loop requires ctypes, %gui will not be available") | |
Bradley M. Froehle
|
r6100 | return | |
Brian Granger
|
r2066 | self.PYFUNC = ctypes.PYFUNCTYPE(ctypes.c_int) | |
Thomas Kluyver
|
r17889 | self.guihooks = {} | |
self.aliases = {} | |||
self.apps = {} | |||
Brian Granger
|
r2066 | self._reset() | |
def _reset(self): | |||
self._callback_pyfunctype = None | |||
self._callback = None | |||
self._installed = False | |||
Brian Granger
|
r2197 | self._current_gui = None | |
Brian Granger
|
r2066 | ||
def get_pyos_inputhook(self): | |||
Brian Granger
|
r2209 | """Return the current PyOS_InputHook as a ctypes.c_void_p.""" | |
Brian Granger
|
r2066 | return ctypes.c_void_p.in_dll(ctypes.pythonapi,"PyOS_InputHook") | |
def get_pyos_inputhook_as_func(self): | |||
Brian Granger
|
r2209 | """Return the current PyOS_InputHook as a ctypes.PYFUNCYPE.""" | |
Brian Granger
|
r2066 | return self.PYFUNC.in_dll(ctypes.pythonapi,"PyOS_InputHook") | |
Brian Granger
|
r2069 | def set_inputhook(self, callback): | |
Brian Granger
|
r2209 | """Set PyOS_InputHook to callback and return the previous one.""" | |
Christian Boos
|
r4944 | # 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() | |||
Brian Granger
|
r2066 | 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 | |||
Fernando Perez
|
r2363 | 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`.""" | |||
Brian Granger
|
r2066 | pyos_inputhook_ptr = self.get_pyos_inputhook() | |
original = self.get_pyos_inputhook_as_func() | |||
pyos_inputhook_ptr.value = ctypes.c_void_p(None).value | |||
Christian Boos
|
r4944 | allow_CTRL_C() | |
Brian Granger
|
r2066 | self._reset() | |
return original | |||
Brian Granger
|
r2208 | def clear_app_refs(self, gui=None): | |
"""Clear IPython's internal reference to an application instance. | |||
Brian Granger
|
r2209 | 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. | |||
Brian Granger
|
r2208 | 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: | |||
Thomas Kluyver
|
r17889 | self.apps = {} | |
elif gui in self.apps: | |||
del self.apps[gui] | |||
Brian Granger
|
r2208 | ||
Thomas Kluyver
|
r17889 | 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`. | |||
Examples | |||
-------- | |||
@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): | |||
Brian Granger
|
r2069 | """Enable event loop integration with wxPython. | |
Brian Granger
|
r2197 | ||
Parameters | |||
---------- | |||
Fernando Perez
|
r4419 | 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. | |||
Brian Granger
|
r2197 | ||
Notes | |||
----- | |||
Brian Granger
|
r2209 | This methods sets the ``PyOS_InputHook`` for wxPython, which allows | |
Brian Granger
|
r2069 | the wxPython to integrate with terminal based applications like | |
IPython. | |||
Brian Granger
|
r2209 | ||
Fernando Perez
|
r4419 | 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:: | |||
Brian Granger
|
r2209 | ||
import wx | |||
app = wx.App(redirect=False, clearSigInt=False) | |||
Brian Granger
|
r2069 | """ | |
MinRK
|
r7688 | 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__) | |||
Brian Granger
|
r2068 | from IPython.lib.inputhookwx import inputhook_wx | |
Eric Firing
|
r17669 | from IPython.external.appnope import nope | |
Thomas Kluyver
|
r17889 | self.manager.set_inputhook(inputhook_wx) | |
Eric Firing
|
r17669 | nope() | |
Thomas Kluyver
|
r17889 | ||
Brian Granger
|
r2918 | import wx | |
Fernando Perez
|
r4419 | if app is None: | |
app = wx.GetApp() | |||
Brian Granger
|
r2918 | if app is None: | |
app = wx.App(redirect=False, clearSigInt=False) | |||
app._in_event_loop = True | |||
Thomas Kluyver
|
r17889 | self.manager.apps[GUI_WX] = app | |
Brian Granger
|
r2918 | return app | |
Brian Granger
|
r2066 | ||
Thomas Kluyver
|
r17889 | def disable(self): | |
Brian Granger
|
r2069 | """Disable event loop integration with wxPython. | |
Brian Granger
|
r2209 | ||
Thomas Kluyver
|
r17889 | This restores appnapp on OS X | |
Brian Granger
|
r2069 | """ | |
Eric Firing
|
r17669 | from IPython.external.appnope import nap | |
nap() | |||
Brian Granger
|
r2066 | ||
Thomas Kluyver
|
r17889 | @inputhook_manager.register('qt', 'qt4') | |
class Qt4InputHook(InputHookBase): | |||
def enable(self, app=None): | |||
Brian Granger
|
r2069 | """Enable event loop integration with PyQt4. | |
Thomi Richards
|
r6467 | ||
Brian Granger
|
r2197 | Parameters | |
---------- | |||
Fernando Perez
|
r4419 | 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. | |||
Brian Granger
|
r2197 | ||
Notes | |||
----- | |||
Brian Granger
|
r2209 | This methods sets the PyOS_InputHook for PyQt4, which allows | |
Brian Granger
|
r2069 | the PyQt4 to integrate with terminal based applications like | |
IPython. | |||
Brian Granger
|
r2209 | ||
Fernando Perez
|
r4419 | 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:: | |||
Brian Granger
|
r2209 | ||
from PyQt4 import QtCore | |||
app = QtGui.QApplication(sys.argv) | |||
Brian Granger
|
r2069 | """ | |
Christian Boos
|
r4931 | from IPython.lib.inputhookqt4 import create_inputhook_qt4 | |
Eric Firing
|
r17669 | from IPython.external.appnope import nope | |
Christian Boos
|
r4931 | app, inputhook_qt4 = create_inputhook_qt4(self, app) | |
Thomas Kluyver
|
r17889 | self.manager.set_inputhook(inputhook_qt4) | |
Eric Firing
|
r17669 | nope() | |
Christian Boos
|
r4915 | ||
Brian Granger
|
r2918 | app._in_event_loop = True | |
Thomas Kluyver
|
r17889 | self.manager.apps[GUI_QT4] = app | |
Brian Granger
|
r2918 | return app | |
Brian Granger
|
r2066 | ||
def disable_qt4(self): | |||
Brian Granger
|
r2069 | """Disable event loop integration with PyQt4. | |
Brian Granger
|
r2209 | ||
Thomas Kluyver
|
r17889 | This restores appnapp on OS X | |
Brian Granger
|
r2069 | """ | |
Eric Firing
|
r17669 | from IPython.external.appnope import nap | |
nap() | |||
Brian Granger
|
r2066 | ||
Thomas Kluyver
|
r17889 | @inputhook_manager.register('gtk') | |
class GtkInputHook(InputHookBase): | |||
def enable(self, app=None): | |||
Brian Granger
|
r2069 | """Enable event loop integration with PyGTK. | |
Brian Granger
|
r2197 | ||
Parameters | |||
---------- | |||
Fernando Perez
|
r4419 | 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. | |||
Brian Granger
|
r2197 | ||
Notes | |||
----- | |||
Brian Granger
|
r2069 | This methods sets the PyOS_InputHook for PyGTK, which allows | |
the PyGTK to integrate with terminal based applications like | |||
IPython. | |||
""" | |||
Brian Granger
|
r2066 | import gtk | |
try: | |||
gtk.set_interactive(True) | |||
except AttributeError: | |||
# For older versions of gtk, use our own ctypes version | |||
Brian Granger
|
r2068 | from IPython.lib.inputhookgtk import inputhook_gtk | |
Thomas Kluyver
|
r17889 | self.manager.set_inputhook(inputhook_gtk) | |
Brian Granger
|
r2066 | ||
Thomas Kluyver
|
r17889 | @inputhook_manager.register('tk') | |
class TkInputHook(InputHookBase): | |||
def enable(self, app=None): | |||
Brian Granger
|
r2197 | """Enable event loop integration with Tk. | |
Parameters | |||
---------- | |||
Fernando Perez
|
r4419 | app : toplevel :class:`Tkinter.Tk` widget, optional. | |
Fernando Perez
|
r4421 | Running toplevel widget to use. If not given, we probe Tk for an | |
existing one, and create a new one if none is found. | |||
Brian Granger
|
r2197 | ||
Notes | |||
----- | |||
Fernando Perez
|
r4419 | 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 | |||
Brian Granger
|
r2197 | sets ``PyOS_InputHook``. | |
""" | |||
Fernando Perez
|
r4419 | if app is None: | |
Thomas Kluyver
|
r13376 | try: | |
from tkinter import Tk # Py 3 | |||
except ImportError: | |||
from Tkinter import Tk # Py 2 | |||
app = Tk() | |||
Brian Granger
|
r2214 | app.withdraw() | |
Thomas Kluyver
|
r17889 | self.manager.apps[GUI_TK] = app | |
Brian Granger
|
r2214 | return app | |
Brian Granger
|
r2066 | ||
Nicolas Rougier
|
r4819 | ||
Thomas Kluyver
|
r17889 | @inputhook_manager.register('glut') | |
class GlutInputHook(InputHookBase): | |||
def enable(self, app=None): | |||
"""Enable event loop integration with GLUT. | |||
Nicolas Rougier
|
r4692 | ||
Parameters | |||
---------- | |||
Nicolas Rougier
|
r4819 | ||
Nicolas Rougier
|
r4692 | app : ignored | |
Nicolas Rougier
|
r4819 | Ignored, it's only a placeholder to keep the call signature of all | |
gui activation methods consistent, which simplifies the logic of | |||
supporting magics. | |||
Nicolas Rougier
|
r4692 | ||
Notes | |||
----- | |||
Nicolas Rougier
|
r4812 | 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. | |||
Thomi Richards
|
r6467 | ||
Nicolas Rougier
|
r4812 | The default screen mode is set to: | |
Nicolas Rougier
|
r4819 | glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH | |
Nicolas Rougier
|
r4806 | """ | |
Nicolas Rougier
|
r4812 | ||
Nicolas Rougier
|
r4831 | import OpenGL.GLUT as glut | |
Nicolas Rougier
|
r4834 | from IPython.lib.inputhookglut import glut_display_mode, \ | |
glut_close, glut_display, \ | |||
glut_idle, inputhook_glut | |||
Nicolas Rougier
|
r4806 | ||
Thomas Kluyver
|
r17889 | if GUI_GLUT not in self.manager.apps: | |
Nicolas Rougier
|
r4834 | glut.glutInit( sys.argv ) | |
glut.glutInitDisplayMode( glut_display_mode ) | |||
Nicolas Rougier
|
r4831 | # This is specific to freeglut | |
if bool(glut.glutSetOption): | |||
Nicolas Rougier
|
r4834 | glut.glutSetOption( glut.GLUT_ACTION_ON_WINDOW_CLOSE, | |
glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS ) | |||
glut.glutCreateWindow( sys.argv[0] ) | |||
Nicolas Rougier
|
r4831 | glut.glutReshapeWindow( 1, 1 ) | |
Nicolas Rougier
|
r4834 | glut.glutHideWindow( ) | |
glut.glutWMCloseFunc( glut_close ) | |||
glut.glutDisplayFunc( glut_display ) | |||
glut.glutIdleFunc( glut_idle ) | |||
Nicolas Rougier
|
r4806 | else: | |
Nicolas Rougier
|
r4834 | glut.glutWMCloseFunc( glut_close ) | |
glut.glutDisplayFunc( glut_display ) | |||
Nicolas Rougier
|
r4831 | glut.glutIdleFunc( glut_idle) | |
Thomas Kluyver
|
r17889 | self.manager.set_inputhook( inputhook_glut ) | |
self.manager.apps[GUI_GLUT] = True | |||
Nicolas Rougier
|
r4806 | ||
Nicolas Rougier
|
r4819 | ||
Thomas Kluyver
|
r17889 | def disable(self): | |
Nicolas Rougier
|
r4806 | """Disable event loop integration with glut. | |
Thomi Richards
|
r6467 | ||
Nicolas Rougier
|
r4806 | 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. | |||
""" | |||
Nicolas Rougier
|
r4834 | import OpenGL.GLUT as glut | |
from glut_support import glutMainLoopEvent | |||
Nicolas Rougier
|
r4812 | ||
glut.glutHideWindow() # This is an event to be processed below | |||
glutMainLoopEvent() | |||
Thomas Kluyver
|
r17889 | super(GlutInputHook, self).disable() | |
Nicolas Rougier
|
r4812 | ||
Thomas Kluyver
|
r17889 | @inputhook_manager.register('pyglet') | |
class PygletInputHook(InputHookBase): | |||
def enable(self, app=None): | |||
Nicolas Rougier
|
r4812 | """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. | |||
Nicolas Rougier
|
r4692 | ||
Nicolas Rougier
|
r4812 | 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 | |||
Thomas Kluyver
|
r17889 | self.manager.set_inputhook(inputhook_pyglet) | |
Nicolas Rougier
|
r4812 | return app | |
Nicolas Rougier
|
r4692 | ||
Thomas Kluyver
|
r17889 | @inputhook_manager.register('gtk3') | |
class Gtk3InputHook(InputHookBase): | |||
def enable(self, app=None): | |||
Thomi Richards
|
r6459 | """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 | |||
Thomas Kluyver
|
r17889 | self.manager.set_inputhook(inputhook_gtk3) | |
self.manager._current_gui = GUI_GTK | |||
Thomi Richards
|
r6459 | ||
Brian Granger
|
r2069 | clear_inputhook = inputhook_manager.clear_inputhook | |
Brian Granger
|
r2197 | set_inputhook = inputhook_manager.set_inputhook | |
Brian Granger
|
r2208 | current_gui = inputhook_manager.current_gui | |
clear_app_refs = inputhook_manager.clear_app_refs | |||
Thomas Kluyver
|
r17889 | enable_gui = inputhook_manager.enable_gui | |
disable_gui = inputhook_manager.disable_gui | |||
guis = inputhook_manager.guihooks | |||
# Deprecated methods: kept for backwards compatibility, do not use in new code | |||
enable_wx = lambda app=None: inputhook_manager.enable_gui('wx', app) | |||
enable_qt4 = lambda app=None: inputhook_manager.enable_gui('qt4', app) | |||
enable_gtk = lambda app=None: inputhook_manager.enable_gui('gtk', app) | |||
enable_tk = lambda app=None: inputhook_manager.enable_gui('tk', app) | |||
enable_glut = lambda app=None: inputhook_manager.enable_gui('glut', app) | |||
enable_pyglet = lambda app=None: inputhook_manager.enable_gui('pyglet', app) | |||
enable_gtk3 = lambda app=None: inputhook_manager.enable_gui('gtk3', app) | |||
disable_wx = disable_qt4 = disable_gtk = disable_gtk3 = disable_glut = \ | |||
disable_pyglet = inputhook_manager.disable_gui |