Navigation

Source code for qarbon.qt.gui.x11

# ----------------------------------------------------------------------------
# This file is part of qarbon (http://qarbon.rtfd.org/)
#
# Copyright (c) 2013 European Synchrotron Radiation Facility, Grenoble, France
#
# Distributed under the terms of the GNU Lesser General Public License,
# either version 3 of the License, or (at your option) any later version.
# See LICENSE.txt for more info.
# ----------------------------------------------------------------------------

"""A X11 widget that may run any command and an XTermWidget runs a xterm.

.. note:: this widget only works on X11 systems.

Example::

    from qarbon.external.qt import QtGui
    from qarbon.qt.gui.application import Application
    from qarbon.qt.gui.x11terminal import XTermWindow

    app = Application()
    term = XTermWindow()
    term.start()
    term.show()
    app.exec_()"""

__all__ = ["XCommandWidget", "XTermWidget",
           "XCommandWindow", "XTermWindow"]

import weakref

from qarbon import log
from qarbon.external.qt import QtCore, QtGui
from qarbon.qt.gui.application import Application
from qarbon.qt.gui.action import Action
from qarbon.qt.gui.icon import Icon



[docs]class XCommandWidget(QtGui.QWidget):
    """A widget displaying an X11 window inside from a command.

    Example::

        from qarbon.external.qt import QtGui
        from qarbon.qt.gui.application import Application
        from qarbon.qt.gui.x11 import XCommandWidget

        app = Application()
        w = QtGui.QMainWindow()
        cmdWidget = XCommandWidget(parent=w)
        cmdWidget.command = 'xterm'
        cmdWidget.winIdParam = '-into'
        cmdWidget.start()
        w.setCentralWidget(cmdWidget)
        w.show()
        app.exec_()"""

    DefaultAutoRestart = False
    DefaultWinIdParam = '-into'

    def __init__(self, parent=None):
        super(XCommandWidget, self).__init__(parent)
        self.__process = QtCore.QProcess(self)
        self.__x11_widget = x11_widget = QtGui.QX11EmbedContainer(self)
        layout = QtGui.QVBoxLayout(self)
        layout.setMargin(0)
        layout.setSpacing(0)
        layout.addWidget(x11_widget)
        x11_widget.error.connect(self.__onError)
        self.resetCommand()
        self.resetAutoRestart()
        self.resetWinIdParam()
        self.resetExtraParams()

    def __onError(self, error):
        log.error("XEmbedContainer: Error")

    def __convert_wait(self, wait):
        if wait:
            if wait < 0:
                wait = -1
            else:
                wait = int(wait * 1000)
        return wait

    def __finish(self, finish_func, wait=0):
        process = self.__process
        wait = self.__convert_wait(wait)
        finish_func()
        if wait:
            return process.waitForFinished(msecs=wait)


[docs]    def getX11WinId(self):
        return self.getX11Widget().winId()



[docs]    def getX11Widget(self):
        return self.__x11_widget



[docs]    def getProcess(self):
        return self.__process



[docs]    def getCommand(self):
        return self.__command



[docs]    def setCommand(self, command):
        self.__command = command
        if command is None:
            self.setWindowTitle("<None>")
        else:
            self.setWindowTitle(command)



[docs]    def resetCommand(self):
        self.setCommand(None)



[docs]    def getWinIdParam(self):
        return self.__winIdParam



[docs]    def setWinIdParam(self, winIdParam):
        self.__winIdParam = winIdParam



[docs]    def resetWinIdParam(self):
        self.setWinIdParam(self.DefaultWinIdParam)



[docs]    def setExtraParams(self, params):
        if params is None:
            params = []
        self.__extraParams = params



[docs]    def getExtraParams(self):
        return self.__extraParams



[docs]    def resetExtraParams(self):
        self.setExtraParams(None)



[docs]    def setAutoRestart(self, yesno):
        self.__autoRestart = yesno



[docs]    def getAutoRestart(self):
        return self.__autoRestart



[docs]    def resetAutoRestart(self):
        return self.setAutoRestart(self.DefaultAutoRestart)



[docs]    def setWorkingDirectory(self, wd):
        if wd is not None:
            self.getProcess().setWorkingDirectory(wd)



[docs]    def getWorkingDirectory(self):
        return self.getProcess().workingDirectory()



[docs]    def start(self, wait=0):
        """wait < 0 -> wait forever,
           wait == 0 -> not wait,
           wait > 0 -> wait amount in seconds"""
        if self.__command is None:
            raise Exception("Cannot start: no command")
        if self.__winIdParam is None:
            raise Exception("Cannot start: no winIdParam")
        process = self.__process
        params = [self.__winIdParam, str(self.getX11WinId())] + \
                 self.__extraParams
        process.start(self.__command, params)
        wait = self.__convert_wait(wait)
        if wait:
            return process.waitForStarted(msecs=wait)



[docs]    def restart(self, wait=0):
        self.terminate(wait=-1)
        return self.start(wait=wait)



[docs]    def kill(self, wait=0):
        return self.__finish(self.__process.kill, wait=wait)



[docs]    def terminate(self, wait=0):
        return self.__finish(self.__process.terminate, wait=wait)


    def __del__(self):
        import sip
        if not sip.isdeleted(self.__process):
            log.debug("X11CommandWidget: __del__ terminates x11...")
            self.terminate()
        else:
            log.debug("X11CommandWidget: __del__ does nothing...")


[docs]    def deleteLater(self):
        log.debug("X11CommandWidget: deleteLater...")
        self.terminate(wait=-1)
        return super(XCommandWidget, self).deleteLater()


    @classmethod

[docs]    def getQtDesignerPluginInfo(cls):
        return dict(icon=":/designer/xorg.png",
                    tooltip="XTerm widget")


    command = QtCore.Property(str, getCommand, setCommand, resetCommand)

    winIdParam = QtCore.Property(str, getWinIdParam, setWinIdParam,
                                 resetWinIdParam)

    extraParams = QtCore.Property("QStringList", getExtraParams,
                                  setExtraParams, resetExtraParams)

    autoRestart = QtCore.Property(bool, getAutoRestart, setAutoRestart,
                                  resetAutoRestart)

    workingDirectory = QtCore.Property(str, getWorkingDirectory,
                                       setWorkingDirectory)




[docs]class XCommandWindow(QtGui.QMainWindow):
    """The QMainWindow version of :class:`XCommandWidget`.

    Example::

        from qarbon.external.qt import QtGui
        from qarbon.qt.gui.application import Application
        from qarbon.qt.gui.x11 import XCommandWindow

        app = Application()
        w = XCommandWindow()
        w.command = 'xterm'
        w.winIdParam = '-into'
        w.start()
        w.show()
        app.exec_()"""

    Widget = XCommandWidget

    def __init__(self, **kwargs):
        parent = kwargs.pop('parent', None)
        flags = kwargs.pop('flags', QtCore.Qt.WindowFlags())
        super(XCommandWindow, self).__init__(parent=parent, flags=flags)
        x11 = self.Widget(parent=self, **kwargs)
        self.setCentralWidget(x11)
        toolBar = self.addToolBar("Actions")
        self.__actionsToolBar = weakref.ref(toolBar)
        self.__restartAction = Action("Restart", parent=self,
                                      icon=Icon("view-refresh"),
                                      tooltip="restart the current command",
                                      triggered=self.restart)
        toolBar.addAction(self.__restartAction)


[docs]    def XWidget(self):
        return self.centralWidget()



[docs]    def start(self, wait=0):
        self.XWidget().start(wait=wait)



[docs]    def restart(self, wait=0):
        self.XWidget().restart(wait=wait)



[docs]    def terminate(self, wait=0):
        self.XWidget().terminate(wait=wait)



[docs]    def getCommand(self):
        return self.XWidget().command



[docs]    def setCommand(self, command):
        self.XWidget().command = command



[docs]    def resetCommand(self):
        self.XWidget().resetCommand()



[docs]    def getWinIdParam(self):
        return self.XWidget().winIdParam



[docs]    def setWinIdParam(self, winIdParam):
        self.XWidget().winIdParam = winIdParam



[docs]    def resetWinIdParam(self):
        self.XWidget().resetWinIdParam()



[docs]    def setExtraParams(self, params):
        self.XWidget().extraParams = params



[docs]    def getExtraParams(self):
        return self.XWidget().extraParams



[docs]    def resetExtraParams(self):
        self.XWidget().resetExtraParams()



[docs]    def setAutoRestart(self, yesno):
        self.XWidget().autoRestart = yesno



[docs]    def getAutoRestart(self):
        return self.XWidget().autoRestart



[docs]    def resetAutoRestart(self):
        self.XWidget().resetAutoRestart()



[docs]    def setWorkingDirectory(self, wd):
        self.XWidget().workingDirectory = wd



[docs]    def getWorkingDirectory(self):
        return self.XWidget().workingDirectory


    command = QtCore.Property(str, getCommand, setCommand, resetCommand)

    winIdParam = QtCore.Property(str, getWinIdParam, setWinIdParam,
                                 resetWinIdParam)

    extraParams = QtCore.Property("QStringList", getExtraParams,
                                  setExtraParams, resetExtraParams)

    autoRestart = QtCore.Property(bool, getAutoRestart, setAutoRestart,
                                        resetAutoRestart)

    workingDirectory = QtCore.Property(str, getWorkingDirectory,
                                       setWorkingDirectory)




[docs]class XTermWidget(XCommandWidget):
    """A widget with an xterm console inside.

    Example::

        from qarbon.external.qt import QtGui
        from qarbon.qt.gui.application import Application
        from qarbon.qt.gui.x11 import XTermWidget

        app = Application()
        w = QtGui.QMainWindow()
        term = XTermWidget(parent=w)
        term.extraParams = ["-e", "python"]
        w.setCentralWidget(term)
        w.start()
        w.show()
        app.exec_()"""

    def __init__(self, auto_start=False, parent=None):
        super(XTermWidget, self).__init__(parent=parent)
        self.command = 'xterm'
        if auto_start:
            self.start()


[docs]    def sizeHint(self):
        return QtCore.QSize(800, 600)


    @classmethod

[docs]    def getQtDesignerPluginInfo(cls):
        return dict(icon=":/designer/xterm.png",
                    tooltip="XTerm widget")




[docs]class XTermWindow(XCommandWindow):
    """The QMainWindow version of :class:`XTermWidget`

        from qarbon.external.qt import QtGui
        from qarbon.qt.gui.application import Application
        from qarbon.qt.gui.x11 import XTermWidget

        app = Application()
        term = XTermWindow()
        term.start()
        term.show()
        app.exec_()"""

    Widget = XTermWidget



def main():
    log.initialize(log_level='debug')
    app = Application()
    w = XTermWindow()
    w.extraParams = ["-e", "ipython"]
    w.start()
    w.show()
    app.exec_()


if __name__ == "__main__":
    main()

Navigation

© Copyright Except where otherwise noted, content on this site is licensed under a Creative Commons Attribution 3.0 License. Created using Sphinx 1.2.2.