"ebL dZddlZddlZdZdZdZdZdZdZd Z d Z d Z d Z d Z dZdZGddeZeZej&Zej(Zej*Zej,Zej.Zej0Zej2Zej4Zej6Zej8Zej:Zej<Zej>Zej@Z ejBZ!ejDZ"ejFZ#ejHZ$ejJZ%ejLZ&ejNZ'ejPZ(ejRZ)ejTZ+ejXZ,ejZZ-ej\Z.ddZ/gdZ0y)z6 Inputhook management for GUI event loop integration. Nwxqtqt4qt5gtktkosxglutpygletgtk3nonecy)z Ignore CTRL+C (not implemented).Nr9/usr/lib/python3/dist-packages/pydev_ipython/inputhook.py ignore_CTRL_Cr*rcy)z+Take CTRL+C into account (not implemented).Nrrrr allow_CTRL_Cr/rrceZdZdZdZdZdZdZdZdZ dZ d d Z d d Z d d Z d Zd dZd dZdZd dZdZd dZdZd dZdZd dZdZd dZdZd dZdZd dZdZdZ y )!InputHookManagerzManage PyOS_InputHook for different GUI toolkits. This class installs various hooks under ``PyOSInputHook`` to handle GUI event loop integration. cNd|_i|_|jd|_yNF)_return_control_callback_apps_resetpyplot_importedselfs r__init__zInputHookManager.__init__?s"(,%  $rc.d|_d|_d|_yN)_callback_pyfunctype _callback _current_guirs rrzInputHookManager._resetEs$(! rc||_yr"r)rreturn_control_callbacks rset_return_control_callbackz,InputHookManager.set_return_control_callbackJs (?%rc|jSr"r'rs rget_return_control_callbackz,InputHookManager.get_return_control_callbackMs,,,rc"|jSr"r'rs rreturn_controlzInputHookManager.return_controlPs,,..rc|jSr"r$rs r get_inputhookzInputHookManager.get_inputhookSs ~~rc||_y)zSet inputhook to callback.Nr/)rcallbacks r set_inputhookzInputHookManager.set_inputhookVs "rNc$|jy)aClear input hook. 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`.N)r)rapps rclear_inputhookz InputHookManager.clear_inputhook\s  rcP|i|_y||jvr|j|=yy)a{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. N)r)rguis rclear_app_refszInputHookManager.clear_app_refsis, ;DJ DJJ  3rcVddl}ddlm}||jj}|ddgkrt d|jzddlm}|j|t|_ ||j}||jdd }d |_ ||jt<|S) aEnable 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) rN) LooseVersionz)requires wxPython >= 2.8, but you have %s) inputhook_wxF)redirect clearSigIntT)rdistutils.versionr; __version__version ValueErrorpydev_ipython.inputhookwxr>r3GUI_WXr%GetAppApp_in_event_loopr)rr5rV wx_versionr>s r enable_wxzInputHookManager.enable_wx}s, 7r~~&.. A H2>>YZ Z: <(" ;))+C ;&&%U&;C!  6 rcxt|jvrd|jt_|jy)zhDisable event loop integration with wxPython. This merely sets PyOS_InputHook to NULL. FN)rFrrIr6rs r disable_wxzInputHookManager.disable_wxs- TZZ 05DJJv  - rcdddlm}m}||k(r|j|y|j |y)Nr)QT_API QT_API_PYQT5)pydev_ipython.qt_for_kernelrPrQ enable_qt5 enable_qt4)rr5rPrQs r enable_qtzInputHookManager.enable_qts%D \ ! OOC OOC rcddlm}|||\}}|j|t|_d|_||j t<|S)aEnable 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) r)create_inputhook_qt4T)pydev_ipython.inputhookqt4rWr3GUI_QT4r%rIr)rr5rW inputhook_qt4s rrTzInputHookManager.enable_qt4sJ, D1$<] =)#!! 7 rcxt|jvrd|jt_|jy)zeDisable event loop integration with PyQt4. This merely sets PyOS_InputHook to NULL. FN)rYrrIr6rs r disable_qt4zInputHookManager.disable_qt4s- djj 16DJJw  . rcddlm}|||\}}|j|t|_d|_||j t<|S)Nr)create_inputhook_qt5T)pydev_ipython.inputhookqt5r^r3GUI_QT5r%rIr)rr5r^ inputhook_qt5s rrSzInputHookManager.enable_qt5sGC1$<] =)#!! 7 rcxt|jvrd|jt_|jyr)r`rrIr6rs r disable_qt5zInputHookManager.disable_qt5s+ djj 16DJJw  . rchddlm}|j||jt|_y)aEnable 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. r)create_inputhook_gtkN)pydev_ipython.inputhookgtkrer3 _stdin_fileGUI_GTKr%)rr5res r enable_gtkzInputHookManager.enable_gtks* D /0@0@AB#rc$|jyzeDisable event loop integration with PyGTK. This merely sets PyOS_InputHook to NULL. Nr6rs r disable_gtkzInputHookManager.disable_gtk rct|_|8 ddl}|j }|j ||j t<ddlm}|j|||S#ddl}YZxYw)a1Enable 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``. Nr)create_inputhook_tk) GUI_TKr%TkintertkinterTkwithdrawrpydev_ipython.inputhooktkrpr3)rr5_TKrps r enable_tkzInputHookManager.enable_tksc # ; &%&&(C LLN!$DJJv A .s34  &%s A%%A-c$|jy)zgDisable event loop integration with Tkinter. This merely sets PyOS_InputHook to NULL. Nrlrs r disable_tkzInputHookManager.disable_tk'rnrcddlm}ddlm}m}m}m}m}t|jvrttdg}|j||j|t|jr&|j|j |j"|j%t'|dkDr|dnd|j)dd|j+|j-||j/||j1|n3|j-||j/||j1||j3|t|_d|jt<y)aR 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 rN)glut_display_mode glut_close glut_display glut_idleinputhook_glutargvT) OpenGL.GLUTGLUTpydev_ipython.inputhookglutr|r}r~rrGUI_GLUTrgetattrsysglutInitglutInitDisplayModebool glutSetOptionGLUT_ACTION_ON_WINDOW_CLOSE GLUT_ACTION_GLUTMAINLOOP_RETURNSglutCreateWindowlenglutReshapeWindowglutHideWindowglutWMCloseFuncglutDisplayFunc glutIdleFuncr3r%) rr5r r|r}r~rrrs r enable_glutzInputHookManager.enable_glut.s*2 # H H 4:: %3+D MM$   $ $%6 7D&&'""4#C#C$($I$IK  ! !SY]$q' C  " "1a (    !   ,   .   i (   ,   .   i ( >*$# 8rcjddlm}ddlm}|j ||j y)zDisable 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. rN)glutMainLoopEvent)rr glut_supportrrr6)rr rs r disable_glutzInputHookManager.disable_glutbs( #2  rcJddlm}|j|t|_|S)aEnable 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. r)inputhook_pyglet)pydev_ipython.inputhookpygletrr3 GUI_PYGLETr%)rr5rs r enable_pygletzInputHookManager.enable_pygletps$" C +,& rc$|jy)zfDisable event loop integration with pyglet. This merely sets PyOS_InputHook to NULL. Nrlrs rdisable_pygletzInputHookManager.disable_pygletrnrchddlm}|j||jt|_y)aEnable 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. r)create_inputhook_gtk3N)pydev_ipython.inputhookgtk3rr3rgrhr%)rr5rs r enable_gtk3zInputHookManager.enable_gtk3s* F 01A1ABC#rc$|jyrkrlrs r disable_gtk3zInputHookManager.disable_gtk3rnrcJdfd }j|t_y)a Enable event loop integration with MacOSX. We call function pyplot.pause, which updates and displays active figure during pause. It's not MacOSX-specific, but it enables to avoid inputhooks in native MacOSX backend. Also we shouldn't import pyplot, until user does it. Cause it's possible to choose backend before importing pyplot for the first time only. Ncjr&tjd} |jdydtjvrd_yy#YyxYw)Nzmatplotlib.pyplotg{Gz?T)rrmodulespause)r5pyplotrs r inputhook_macz2InputHookManager.enable_mac..inputhook_macsQ##%89LL&'#++5+/D(6s AAr")r3GUI_OSXr%)rr5rs` r enable_maczInputHookManager.enable_macs  0 =)#rc$|jyr"rlrs r disable_maczInputHookManager.disable_macs rc|jS)z $(>2$h ,$($2!rrct tdtttt t tttttttttt t"t$t&t(t*t,t.i } ||}||S#t0$r;||dk(rt}n*d|dt3|j5}t|YKwxYw)aySwitch 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. zUA return_control_callback must be supplied as a reference before a gui can be enabledrzInvalid GUI request z, valid ones are:)r+rDGUI_NONEr6rrrqrxrhrirFrLGUI_QTrUrYrTr`rSrrrrGUI_GTK3rKeyErrorlistkeys)r8r5guisgui_hookes r enable_guirs2#$,pqq o Z I Z I I Z Z k  k D 9 C=  ;#)&H$@CDDUVAQ-   sBACC)+rFrrYr`rhrqrrrrrrrrinputhook_managerrLrNrUrTr\rSrcrirmrxrzrrrrrrrrr6r3rr9 stdin_readyr)r+r0r)NN)1rrselectrFrrYr`rhrqrrrrrrrobjectrrrLrNrUrTr\rSrcrirmrxrzrrrrrrrrr6r3rr9r-rr)r+r0r__all__rrrrs              N!vN!b %&  ' '  ) )  ' '  ) ) ++  ) ) ++  ) ) ++  ' '  ) ) ++  -- !// "11++  --  ) ) ++ #33!// ++ "11 .. /KK/KK!// 0f1 r