ScriptEngineMain.py

Go to the documentation of this file.

#!/usr/bin/env python
#
#                               Copyright 2005
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "GLAST LAT main script engine class - modified from RunControlMain for LICOS"
__author__   = "S. Tuvi <stuvi@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2006/04/26 20:44:40 $"
__version__  = "$Revision: 1.14 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import                              os
import                              sys
import                              atexit
import                              threading
import logging               as     log
import types
import time
import gc
import string

from   qt                    import *
import sip

from   Queue                 import Queue

from   LICOS.lib.LATconstants                     import *
from   LICOS.scriptEngine.ScriptEngineMainGUIImpl import ScriptEngineMainGUIImpl
from   LICOS.scriptEngine.rcEndRunDlgImpl         import rcEndRunDlgImpl
from   LICOS.lib.scriptEngine.TextMsgBox          import TextMsgBox

# Modules here are imported to prevent them from being reloaded
# See rcUtil for more info

import Pyana
import LDF

try:
  import cfitsio
except ImportError, e:
  pass

try:
  import Numeric
except ImportError, e:
  pass

import rcUtil

from rcReportGen   import rcReportGen
from rcRunIdHelper import rcRunIdHelper

from LICOS.core.thread.taskEngine   import TaskEngine
from LICOS.core.thread.guiBridges   import GUIbridge, QtThreadBridge, PyThreadBridge
from LICOS.util.gVersions           import Gversions, ROOT_DIRS


class ConnectState:
  Disconnected = 0
  Waiting      = 1
  Connected    = 2

class ScriptEngineMain(ScriptEngineMainGUIImpl):
  """!\brief Class for providing a script engine framework.

  """

  def __init__(self, common, parent = None, name = "RunControl", fl = 0):
    """!\brief ScriptEngineMain constructor.

    \param common ScriptEngineCommon instance
    \param parent Parent GUI
    \param name   GUI name
    \param fl     GUI flags
    """
    ScriptEngineMainGUIImpl.__init__(self, common, parent, name, fl)

    self.__common       = common
    self.__currentState = None
    self.__actionEngine = None
    self.__app          = None
    self.__browser      = None
    self.__hwVersions   = None
    self.__queue        = None
    self.__engine       = None
    self.__guiThread    = threading.currentThread()
    self.__guiBridge    = GUIbridge(self.__guiThread)

    # Set this object to be the client handler
    #common.getCmdCli().handler(self)
    self.__connection_state = ConnectState.Disconnected
    self.ResetButton.setEnabled(False)
    self.RunButton.setEnabled(False)
    self.StopButton.setEnabled(False)
    self.PauseButton.setEnabled(False)

    self.__actionEngine = TaskEngine("FSMactionEngine")
    self.__actionEngine.start()

    self.__scriptEngine = TaskEngine("ScriptEngine")
    self.__scriptEngine.start()

    # Pick an operator
    operator = common.prefMan().preferences()["operatorobj"]
    self.cmbOperator.setCurrentText(operator.getName())

    self.__endRunDlg = rcEndRunDlgImpl(parent=self)

    # Clean up at exit
    self.inShutdown = False
    atexit.register(self.__shutdown)

    # Preload modules specified in preferences
    preload = common.prefMan().preferences()["preload"]
    if preload.strip() != "":
      preloadList = map(string.strip, preload.split(','))
      for m in preloadList:
        exec 'import ' + m
    self.__common.setGUI(self)

  def connectClicked(self): # GUI thread
    """!\brief Slot for the connect menu option.

    """
    self.__common.connect()

  def applyPermissions(self, operator):
    """!\brief Apply the permissions for the current operator.

    \param operator rcUser instance
    """
    adminOverride = operator.isAdministrator()
    if adminOverride:
      self.fileExitAction.setEnabled(1)
    else:
      self.fileExitAction.setEnabled(0)
    if 'allow_python_shell' in operator.getPermissions() or adminOverride:
      self.viewPythonShell.setEnabled(1)
    else:
      self.viewPythonShell.setEnabled(0)
    if 'set_particle_type' in operator.getPermissions() or adminOverride:
      self.comboParticleType.setEnabled(1)
    else:
      self.comboParticleType.setEnabled(0)
    if 'set_orientation' in operator.getPermissions() or adminOverride:
      self.comboOrientation.setEnabled(1)
    else:
      self.comboOrientation.setEnabled(0)

    if 'edit_preferences' in operator.getPermissions() or adminOverride:
      self.editPreferencesAction.setEnabled(1)
    else:
      self.editPreferencesAction.setEnabled(0)

    for (panelLabel, panel) in self.panels().items():
      if 'enable_' + panelLabel.lower() + '_panel' in operator.getPermissions() or adminOverride:
        self.setEnabledTabPage(panelLabel, 1)
      else:
        self.setEnabledTabPage(panelLabel, 0)
      if "applyPermissions" in dir(panel):
        panel.applyPermissions(operator)

    if self.__common.getMSGLogger() is not None:
      if adminOverride:
        self.__common.getMSGLogger().setSecure(0)
      else:
        self.__common.getMSGLogger().setSecure(1)
      self.__common.getMSGLogger().show()

    self.__common.prefGUI().applyPermissions(operator)


  def setEnabledTabPage(self, panelLabel, enable):
    """!\brief Find the tabPage belonging to panel identified by \a panelLabel.

    \param panelLabel Panel label
    \param enable     Enable/disable flag
    """
    for i in range(self.ScriptEngineTab.count()):
      tabPage = self.ScriptEngineTab.page(i)
      if panelLabel == str(self.ScriptEngineTab.tabLabel(tabPage)):
        tabPage.setEnabled(enable)
        break

  def setOperator(self, operator):
    """!\brief Set the current operator.

    \param operator rcUser instance
    """
    self.cmbOperator.setCurrentText(operator)
    self.__common.prefMan().setOperator(operator)

  def setParticleType(self, particleType):
    """!\brief Set the particle type.

    \param particleType Particle type
    """
    self.__common.prefMan().setParticleType(particleType)

  def setOrientation(self, orientation):
    """!\brief Set the orientation.

    \param orientation Orientation
    """
    self.__common.prefMan().setOrientation(orientation)

  def getName(self):
    """!\brief Retrieve the name of the main script engine class.

    \return Main script engine class name
    """
    return "ScriptEngineMain"

  def __statusMsg(self, msg, tmo):
    """!\brief Update the status bar with the message \a msg

    \param msg Message
    \param tmo Display duration
    """
    self.execGUImethodNR(self.statusBar().message, msg, tmo)

  def __shutdown(self):
    """!\brief Clean up and shut down the various threads.

    """
    # This method expects to be executed from the GUI thread.

    self.inShutdown = True

    self.__currentState = "RESET"

    # Use the following non-NR call to wait for the reset to finish
    self.execGUImethod(self.statusBar().message, "Exiting")

    # Shut down the task engines
    self.__actionEngine.shutdown()
    self.__scriptEngine.shutdown()

    # Disconnect from the command and event servers
    self.__common.disconnect()

    # Stop the data distribution server
    dds = self.__common.getDDS()
    if dds is not None:
      dds.disconnect()

    # Stop the GUI bridge
    #self.__qtBridge.terminate()
    self.__guiBridge.shutdown()

    archiver = self.__common.getCmdCli().getArchiver()
    if archiver is not None:
      archiver.abort()


  def initApp(self):
    """!\brief Method usually invoked by the GUI to load a new application.

    """
    applName = self.OpenAppl.currentText()
    if str(applName) == "":  return     # Operator cancelled
    self.loadApp(str(applName))

  def loadApp(self, applName):
    """!\brief Method that can be invoked from code to load a new application.

    \param applName  Name of an application to load
    """
    if applName is None:
      self.__statusMsg('Loading aborted', 0)
      return

    # Start the application in its own thread after the reset from above
    # (if any) completes.
    self.__actionEngine.spawn(self.__startApp, str(applName))

    self.RunButton.setEnabled(True)

    self.__currentState = "RESET"
    self.execGUImethodNR(self.State.setText, self.__currentState)
    self.execGUImethodNR(self.handleComments, self.__currentState)

  def loadModule(self, module):
    """!\brief Method that can be invoked from code to load a new module.

    \param module  Pointer to module to load
    """
    self.__actionEngine.spawn(self.__startModule, module)

  def __initAppCommon(self, app, appName, filename):
    """!\brief Initialize the GUI based on the loaded application.

    \param app      Application module object
    \param appName  Application name
    \param filename Filename for the loaded application module

    \return Application loaded message
    """
    msg = "%s %s loaded from %s" % (app.getType(), app.getName(), filename)
    log.info(msg)

    # Update the application history list box.
    self.execGUImethod(self.__updateAppListBox, appName)
    if self.__common.options().securedir is None and self.__common.options().norcoverride is None:
      self.execGUImethod(self.__updateRunConditions, 'NOT-DEFINED')

    return msg

  def __updateRunConditions(self, undef):
    """!\brief Set the run conditions to the NOT-DEFINED value.

    \param undef Undefined value string
    """
    prefMan = self.__common.prefMan()
    self.cmbOperator.setCurrentText(undef)
    prefMan.setOperator(undef)
    self.comboParticleType.setCurrentText(undef)
    prefMan.setParticleType(undef)
    self.comboOrientation.setCurrentText(undef)
    prefMan.setOrientation(undef)
    prefMan.setSite(undef)
    prefMan.setPhase(undef)
    prefMan.setInstrumentType(undef)

  def __updateAppListBox(self, appName):
    """!\brief Update the application combo box with the loaded application.

    \brief appName Full path for the application.
    """
    if self.OpenAppl.listBox().findItem(appName) is None:
      self.OpenAppl.insertItem(appName)

  def __startApp(self, appName):
    """!\brief Load and instantiate the application.

    \param appName Full path for the application.
    """
    try:
      self.execGUImethod(self.statusMonitor().stopWatch)
      self.execGUImethod(self.statusMonitor().restoreWatch)
      (module, filename, app) = rcUtil.scriptLoad(appName, self.__common)
      self.updateState(app.current_state)
    except Exception, e:
      log.exception(e)
      if type(e) == types.ListType:
        self.__statusMsg(e[0], 0)
      else:
        self.__statusMsg(str(e), 0)
      return
    self.__clearPreviousApp()
    self.__setupApp(app, appName, filename)

  def __startModule(self, module):
    """!\brief Clear previous app, force garbage collection and setup the GUI.

    \param module Module object for the loaded application.
    """
    self.__clearPreviousApp()
    appName = module.userModuleName
    filename = module.__file__
    self.__setupApp(module, filename, filename)

  def __clearPreviousApp(self):
    """!\brief Delete the previous app and force garbage collection.

    """
    del self.__app
    self.__app = None
    gc.collect()
    if len(gc.garbage) != 0:
      log.error("ScriptEngineMain: Found garbage: %s" % gc.garbage)

  def __setupApp(self, app, appName, filename):
    """!\brief Setup the GUI for the loaded app.

    \param app      Application object
    \param appName  Full path for the application Python source
    \param filename Name of the file that the module is loaded from
    """
    self.StopButton.setEnabled(True)
    if 'doPause' in dir(app):
      self.PauseButton.setEnabled(True)
    else:
      self.PauseButton.setEnabled(False)
    if 'doReset' in dir(app):
      self.ResetButton.setEnabled(True)
    else:
      self.ResetButton.setEnabled(False)
    self.__app = app
    msg = self.__initAppCommon(self.__app, appName, filename)
    self.execGUImethodNR(self.__updateGUI, False)
    self.execGUImethodNR(self.handleComments, self.__currentState)
    self.execGUImethod(self.statusMonitor().startWatch)
    self.__common.getDBN()['_app'] = self.__app
    self.__statusMsg(msg, 0)

  def __updateGUI(self, enabled):
    """!\brief Method for updating the GUI.

    \param enabled Run conditions enabled/disabled flag.
    """
    # This method may complete asynchronously to the application's activities
    # since the application doesn't depend on the results.  Should this ever
    # change, be sure to change the execGUImethodNR() calls below to
    # execGUImethod() calls so that the fsmActionEngine waits for __updateGUI()
    # to complete before continuing.
    prefGUI = self.__common.prefGUI()
    operator = self.__common.preferences()["operatorobj"]
    if self.__common.options().securedir is not None and 'administrator' not in operator.getRoles():
      permissions = operator.getPermissions()
      self.cmbOperator.setEnabled(0)
      if 'set_particle_type' in permissions:
        self.comboParticleType.setEnabled(enabled)
      if 'set_orientation' in permissions:
        self.comboOrientation.setEnabled(enabled)
      if 'set_site_run_condition' in permissions:
        prefGUI.comboSite.setEnabled(enabled)
      if 'set_instrument_type_run_condition' in permissions:
        prefGUI.comboInstrumentType.setEnabled(enabled)
      if 'set_phase_run_condition' in permissions:
        prefGUI.comboPhase.setEnabled(enabled)
    else:
      self.cmbOperator.setEnabled(enabled)
      self.comboParticleType.setEnabled(enabled)
      self.comboOrientation.setEnabled(enabled)
      prefGUI.comboSite.setEnabled(enabled)
      prefGUI.comboInstrumentType.setEnabled(enabled)
      prefGUI.comboPhase.setEnabled(enabled)

  def updateState(self, state):
    """!\brief Update the GUI to reflect the state of the current application.

    \param state State string from the application's FSM
    """
    self.execGUImethodNR(self.State.setText, state)

  def RunClicked(self):
    """!\brief Slot for the run button.

    """
    ScriptEngineMainGUIImpl.RunClicked(self)
    if 'doResume' in dir(self.__app) and self.__app.isPaused():
      self.__actionEngine.spawn(self.__resume)
    else:
      self.waitCursor()
      self.__scriptEngine.spawn(self.__run)
      self.normalCursor()

  def __run(self):
    """!\brief Start the execution of the application.

    """
    rcUtil.scriptRun(self.__app)
    self.execGUImethodNR(self.updateState, self.__app.current_state)

  def __resume(self):
    """!\brief Resume the paused script.

    """
    self.__app.doResume()

  def ResetClicked(self):
    """!\brief Slot for the reset button.

    """
    ScriptEngineMainGUIImpl.ResetClicked(self)
    self.waitCursor()
    self.__actionEngine.spawn(self.__reset)
    self.normalCursor()

  def __reset(self):
    """!\brief Reset the script.

    """
    if self.__app is not None and 'doReset' in dir(self.__app):
      self.__app.doReset()

  def StopClicked(self):
    """!\brief Slot for the stop button.

    """
    ScriptEngineMainGUIImpl.StopClicked(self)
    self.waitCursor()
    self.__actionEngine.spawn(self.__abort)
    self.normalCursor()

  def __abort(self):
    """!\brief Abort the running script.

    """
    if self.__app is not None:
      self.__app.doAbort()

  def PauseClicked(self):
    """!\brief Slot for the pause button.

    """
    ScriptEngineMainGUIImpl.PauseClicked(self)
    self.waitCursor()
    self.__actionEngine.spawn(self.__pause)
    self.normalCursor()

  def __pause(self):
    """!\brief Pause the running script (if supported).

    """
    if self.__app is not None:
      if 'doPause' in dir(self.__app):
        self.__app.doPause()

  def doRun(self):
    """!\brief Emit a Run button click under program control.

    Can be done from a subthread.
    """
    self.doEmit(self.RunButton)

  def doReset(self):
    """!\brief Emit a Reset button click under program control.

    Can be done from a subthread.
    """
    self.doEmit(self.ResetButton)

  def doEmit(self, obj, signal = SIGNAL("clicked()"), args = ()):
    """!\brief Emit a signal, possibly from a subthread.

    By default the signal is 'clicked()' with no arguments.

    \param obj    GUI widget that will receive the signal
    \param signal Signal
    \param args   Arguments to the slot method
    """
    if self.isGUIthread():
      obj.emit(signal, args)
    else:
      self.execGUImethodNR(obj.emit, signal, args)

  def normalCursor(self):
    """!\brief Set the mouse cursor to normal.

    """
    self.execGUImethodNR(self.setCursor, QCursor(QWidget.ArrowCursor))

  def waitCursor(self):
    """!\brief Set the mouse cursor to hourglass.

    """
    self.execGUImethodNR(self.setCursor, QCursor(QWidget.WaitCursor))

  def getEndRunComments(self):
    """!\brief Retrieve the end run comments widget.

    \return rcCommentPanel instance
    """
    return self.__endRunDlg.comments.getWidget()

  def handleComments(self, currentState):
    """!\brief Based on the current state hide or show the comment panel.

    \param currentState Script run state.
    """
    cw = self.getCommentWidget()
    if currentState == 'STOPPED':
      if cw.isReadOnly():
        cw.setReadOnly(0)
        self.showComments()
        cw.enterComment("Comment entry enabled.")
      cw.enterComment("Note: Comments entered after this point will apply to the next run",0)
      cw.clearHistory()
    elif currentState == 'RUNNING':
      if cw.isReadOnly():
        cw.setReadOnly(0)
        self.showComments()
        cw.enterComment("Comment entry enabled.")
    elif currentState == 'RESET':
      cw.clearHistory()
      cw.setReadOnly(0)
      self.showComments()
      cw.enterComment("Comment entry enabled.")

  def showHidePythonShell(self):
    """!\brief Toggle the Python shell window.

    """
    if self.viewPythonShell.isOn():
      self.showPythonShell()
      self.getPythonShellWidget().redirectIO()
    else:
      self.hidePythonShell()
      self.getPythonShellWidget().restoreIO()

  def verifySoftware(self):
    """!\brief Perform software verification.

    """
    mb = TextMsgBox(self)
    mb.setCaption("Verify Software")
    mb.labelData.setText("Software Verification Results:")
    for rootDir in ROOT_DIRS:
      if os.path.exists(os.path.join(ONLINE_ROOT, rootDir)):
        qApp.setOverrideCursor(QCursor(QWidget.WaitCursor))
        qApp.processEvents()
        (release, failedFiles) = Gversions.verifyFileDigests(rootDir)
        qApp.restoreOverrideCursor()
        qApp.processEvents()
        strFailed = ""
        i = 0
        for filename in failedFiles:
          i += 1
          #if i % 5 == 0:
          if i % 1 == 0:
            strFailed += '\n'
          strFailed += filename + ' '
        if len(failedFiles) == 0:
          msg = "%s Release = %s\n\n" % (rootDir, release) + \
                               "Verification completed successfully"
          log.info(msg)
          #mb = QMessageBox.information( None, "Software Verification Results",
          #                              "%s Release = %s\n\n" % (rootDir, release) +
          #                              "Verification completed successfully",
          #                              QMessageBox.Ok + QMessageBox.Default,
          #                              QMessageBox.Cancel)
        else:
          #mb = QMessageBox.warning    ( None, "Software Verification Results",
          #                              "%s release = %s\n\n" % (rootDir, release) +
          #                              "Verification found the following " +
          #                              "inconsistent files:\n" + strFailed,
          #                              QMessageBox.Ok + QMessageBox.Default,
          #                              QMessageBox.Cancel)
          msg = "%s release = %s\n\n" % (rootDir, release) + \
                              "Verification found the following " + \
                              "inconsistent files:\n" + strFailed
          log.warn(msg)
        mb.textData.setText(msg)
        result = mb.exec_loop()
        if not result:
          break
    mb.deleteLater()

  def elogWebsite(self):
    """!\brief Launch the E-Logbook web site.

    """
    self.__common.elogWebsite()

  def warnFreeSpace(self, warn_level):
    """!\brief Display a low disk space warning.

    \param warn_level Disk space in bytes.

    """
    mess = "Low Disk Space Warning!\n" + \
           "The space available for data writing\n" + \
           "is below %u Megabytes.  Continue?" % (warn_level / (1024*1024))
    mb = QMessageBox.warning(None, '', mess,
                             QMessageBox.Yes | QMessageBox.Default,
                             QMessageBox.No  | QMessageBox.Escape,
                             QMessageBox.NoButton );
    return mb is not QMessageBox.No

  def warnDirectoryExist(self, directory):
    """!\brief Warn if a directory does not exist.

    \param directory Non-existant directory.
    """
    mess = "Directory write error!\n" + \
           "The directory chosen for data writing:\n" + \
           "%s does not exist.  Continue?" % (directory)
    mb = QMessageBox.warning(None, '', mess,
                             QMessageBox.Yes | QMessageBox.Default,
                             QMessageBox.No  | QMessageBox.Escape,
                             QMessageBox.NoButton );
    return mb is not QMessageBox.No

  def aboutScriptEngine(self):
    """!\brief The About dialog box for the Script Engine.

    Displays version information for Hippo, Qt, PyQt, SIP and
    subsystem releases.

    """
    release = Gversions.getReleaseFromDigest()
    message = "ScriptEngine System\n\nLICOS Release: %s" % release
    if sys.modules.has_key('sihippo'):
      message = message + "\n\nHippoDraw Release: %s" % sys.modules['sihippo'].__version__
    message = message + "\n\nQt Version: %s" % qVersion()
    message = message + "\n\nPyQt Version: %s" % PYQT_VERSION_STR
    if 'SIP_VERSION_STR' in dir(sip):
      message = message + "\n\nSIP Version: %s" % sip.SIP_VERSION_STR
    elif 'SIP_VERSION' in dir(sip):
      message = message + "\n\nSIP Version: %s" % hex(sip.SIP_VERSION)
    subsysReleases = {}
    for rootDir in ROOT_DIRS:
      if rootDir != 'LICOS' and os.path.exists(os.path.join(ONLINE_ROOT, rootDir)):
        release = Gversions.getReleaseFromDigest(digestDataFile=None, rootDir=rootDir)
        subsysReleases[rootDir] = release
    if len(subsysReleases) > 0:
      message = message + "\n\nSubsystem Releases:"
      subSysList = subsysReleases.keys()
      subSysList.sort()
      for subSys in subSysList:
        message = message + "\n  %s\t%s" % (subSys, subsysReleases[subSys])
    QMessageBox.about(self,'LICOS ScriptEngine', message)


  def fileLogout(self):
    """!\brief Log the current user off.

    """
    if not self.login():
      self.inShutdown = True
      self.close()

  def closeEvent(self, e):
    """!\brief Trap the close event of the main GUI.

    In secure mode, only administrators can close the main GUI while logged in.
    Other users need to logout first in order to exit the Script Engine.

    \param e A QEvent object.
    """
    if self.__common.options().securedir is not None and not self.inShutdown and \
       not self.__common.prefMan().preferences()["operatorobj"].isAdministrator():
      e.ignore()
    else:
      ScriptEngineMainGUIImpl.closeEvent(self, e)

  def login(self):
    """!\brief Login to the script engine.

    """
    # Write the modified preferences to the cfg file
    loginResult = -1
    while loginResult == -1:
      loginResult = self.__common.showLogin(self)
      if loginResult == -1:
        QMessageBox.critical(self, "Authentication Failed",
                                   "Invalid user id or password")
      elif loginResult == -2:
        QMessageBox.critical(self, "Authentication Failed",
                                   "Password database is not available")
      if loginResult == -1:
        continue
      elif loginResult != 1:
        return loginResult
      # Set the operator based on login
      operator = self.__common.prefMan().preferences()["users"].getUserByLoginId(self.__common.getLoginId())
      if operator is None:
        QMessageBox.critical(self, "Authentication Failed",
                                  "Can not find the user under preferences")
        log.error("User authentication failed, can not find the user %s under preferences"
                  % self.__common.getLoginId())
        loginResult = -1
        continue
      else:
        self.cmbOperator.setCurrentText(operator.getName())
        self.cmbOperator.setEnabled(0)
        self.__common.prefMan().setOperator(operator.getName())
        self.applyPermissions(operator)
        return 1

  def isGUIthread(self):
    """!\brief Returns True if this method is being called from the GUI thread.

    \return Boolean indicating whether the current thread is the GUI thread.
    """
    return threading.currentThread() == self.__guiThread

  def customEvent(self, e):
    """!\brief Post an event to the GUI thread.

    This method overrides the QObject base class's.  There is generally
    no reason to call this method directly.  It is called by the Qt
    infrastructure whenever the custom event is posted, e.g. by the following
    three methods of this class: createGUI, execGUImethodNR and execGUImethod.

    \param e A QEvent object
    """
    self.__guiBridge.handleCustomEvent(e)

  def createGUI(self, obj, *args, **kwargs):
    """!\brief Method used for instantiating a GUI from a non-GUI subthread

    \param obj    Class of the object that is being created
    \param args   Positional arguments to the constructor of the object
    \param kwargs Keyword arguments to the constructor of the object

    \return Object instance
    """
    resp = self.__guiBridge.createGUI(self, obj, *args, **kwargs)
    return resp

  def execGUImethodNR(self, func, *args, **kwargs):
    """!\brief Method used for executing a GUI function from a non-GUI thread.

    Use this method when no (useful) response is expected or
    when waiting for one could cause a deadlock.  Any response from the
    function is lost.

    \param func The method whose execution in the GUI thread is being requested
    \param args   Positional arguments to the constructor of the object
    \param kwargs Keyword arguments to the constructor of the object

    \return None
    """
    if self.inShutdown:  return # Don't try to update the GUI during shutdown

    return self.__guiBridge.execGUImethodNR(self, func, *args, **kwargs)

  def execGUImethod(self, func, *args, **kwargs):
    """!\brief Method used for executing a GUI function from a non-GUI thread.

    Use this method when a response is expected from the function and
    when it is appropriate to wait for it (no deadlock arises)

    \param func The method whose execution in the GUI thread is being requested
    \param args   Positional arguments to the constructor of the object
    \param kwargs Keyword arguments to the constructor of the object

    \return None if in shut down otherwise
            the return value from the method
    """
    if self.inShutdown:  return # Don't try to update the GUI during shutdown

    return self.__guiBridge.execGUImethod(self, func, *args, **kwargs)

  def getEndRunDlg(self):
    """!\brief Retrieve reference to the End Run Dialog.

    \return rcEndRunDlgImpl instance
    """
    return self.__endRunDlg

---