rcStatusMonitor.py

Go to the documentation of this file.

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

__facility__ = "Online"
__abstract__ = "Status Monitor for the Script Engine"
__author__   = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST I&T/Online"
__date__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2006/04/28 01:41:21 $"
__version__  = "$Revision: 1.9 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC


from qt import *
import logging as log

class ListViewToolTip(QToolTip):
  """!\brief A class to allow tooltips in a listview.

  """
  def __init__(self, view, column, truncatedOnly=0):
    """!\brief ListViewToolTip constructor.

    \param view          QListView instance
    \param column        Listview column
    \param truncatedOnly Only display the tooltip if the column data is truncated
    """
    QToolTip.__init__(self, view.viewport())
    self.__view = view
    self.__col  = column

  def maybeTip(self, pos):
    """!\brief Draw the tooltip.

    \param pos Tooltip position.
    """
    item = self.__view.itemAt(pos)
    if item is not None:
      #if self.__view.header().sectionSize(self.__col) >= \
      #    item.width(self.__view.fontMetrics(), self.__view, self.__col):
      #  return
      tipString = item.text(self.__col)
      cr = self.__view.itemRect(item)
      headerPos = self.__view.header().sectionPos(self.__col)
      cr.setLeft(headerPos)
      cr.setRight(headerPos + self.__view.header().sectionSize(self.__col))
      self.tip(cr, tipString)

class StatusItem(QListViewItem):
  """!\brief Custom QListViewItem for displaying the status panel items.

  """
  def __init__(self, *args):
    """!\brief StatusItem constructor.

    \param args QListViewItem arguments.
    """
    QListViewItem.__init__(self, *args)
    self.__alarmExpr = None
    self.__stale = False

  def paintCell(self, p, cg, column, width, align):
    """!\brief Draw the status panel item.

    Draw the item so that it appears to have line dividers between each item.

    If the item's alarm expression is true then paint the item in red.

    If the item's alarm expression starts with the character '@' then
    quote the value before adding it to the expression.

    \param p      Painter
    \param cg     Color group
    \param column Listview column
    \param width  Width of the cell
    \param align  Alignment of the cell data.
    """
    dg = qApp.palette().disabled()
    g = QColorGroup(cg)
    g.setColor( QColorGroup.Base, Qt.white)
    g.setColor( QColorGroup.Foreground, Qt.black)
    if self.__alarmExpr is not None:
      # If alarm expr starts with '@' then treat the monitored
      # value as a string in the expression.
      if self.__alarmExpr.startswith("@"):
        expr = "'"+str(self.text(1))+"'" + self.__alarmExpr[1:]
      else:
        expr = str(self.text(1)) + self.__alarmExpr
      try:
        if eval(expr):
          g.setColor( QColorGroup.Text, Qt.red)
        else:
          g.setColor( QColorGroup.Text, Qt.black)
      except:
        log.exception("Error evaluating expression \"%s\"" % expr)

    # Do the standard painting
    if self.__stale and column == 1:
      QListViewItem.paintCell(self,p,dg,column,width,align)
    else:
      QListViewItem.paintCell(self,p,g,column,width,align)

    p.setPen( QPen( cg.dark(), 1 ) )
    p.drawLine( 0, self.height() - 1, width, self.height() - 1 )
    p.drawLine( width - 1, 0, width - 1, self.height() )

  def setText(self, column, value):
    """!\brief Set the text of the item.

    \param column Listview column
    \param value  Listview item value
    """
    QListViewItem.setText(self, column, value)

  def setAlarmExpr(self, alarmExpr):
    """!\brief Set the alarm expression.

    \param alarmExpr Alarm expression
    """
    self.__alarmExpr = alarmExpr

  def setStale(self, stale):
    """!\brief Set stale flag.

    \param stale Stale flag
    """
    self.__stale = stale

  def isStale(self):
    """!\brief Check if the status item is stale or not.

    \return Boolean indicating whether the item is stale or not.
    """
    return self.__stale


class WatchItem(object):
  """!\brief Watch item class that keeps track of status panel items.

  """
  def __init__(self, accessor, key, label, alarmExpr, isStale=None):
    """!\brief WatchItem constructor.

    \param accessor  Accessor method
    \param key       Item key
    \param label     Item label
    \param alarmExpr Alarm expression
    \param isStale   Optional isStale method
    """
    self.__accessor = accessor
    self.__statusItem = None
    self.__key = key
    self.__label = label
    self.__alarmExpr = alarmExpr
    self.__inView = 0
    self.__isStale = isStale

  def evaluate(self):
    """!\brief Evaluate the expression by calling the accessor method.

    \return Accessor method return value or "N/A" if the return value is None
    """
    if self.__key is not None:
      if self.__accessor.has_key(self.__key):
        return self.__accessor[self.__key]
      else:
        return 'N/A'
    else:
      val = self.__accessor()
      if val is None:
        return 'N/A'
      else:
        return val

  def getLabel(self):
    """!\brief Retrieve the label.

    \return Watch item label
    """
    return self.__label

  def getAlarmExpr(self):
    """!\brief Retrieve the alarm expression.

    \return Alarm expression value
    """
    return self.__alarmExpr

  def getStatusItem(self):
    """!\brief Retrieve the status listview item that is
    associated with this watch item.

    \return StatusItem instance
    """
    return self.__statusItem

  def setStatusItem(self, si):
    """!\brief Set the status item.

    \param si StatusItem instance
    """
    self.__statusItem = si

  def isInView(self):
    """!\brief Check if the status item for this watch item has
    already been instantiated.

    \return True if the status item for this watch item has been created,
            False otherwise.
    """
    return self.__inView

  def setInView(self):
    """!\brief Set the watch item as being in view.

    """
    self.__inView = 1

  def setNotInView(self):
    """!\brief Set the watch item as not being in view.

    """
    self.__inView = 0


  def setAccessor(self, accessor, key):
    """!\brief Set the accessor for this watch item.

    \param accessor Accessor method
    \param key      Key that uniquely identifies the item
    """
    self.__accessor = accessor
    self.__key      = key

  def isStale(self):
    """!\brief Check if the watch item is stale or not.

    \return Boolean indicating whether the item is stale or not.
    """
    if self.__isStale is not None:
      return self.__isStale()
    else:
      return False


class rcStatusPanel(QWidget):
  """!\brief Status Panel widget.

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

    \param parent Parent GUI
    \param name   GUI name
    \param fl     GUI flags
    """
    QWidget.__init__(self,parent,name,fl)

    self.contextMenu = QPopupMenu( self )
    self.contextMenu.insertItem( "&Copy", self.copyToClipboard, Qt.CTRL+Qt.Key_C)

    self.clip = QApplication.clipboard()

    if not name:
      self.setName("rcStatusPanel")


    rcStatusPanelLayout = QGridLayout(self,1,1,0,6,"rcStatusPanelLayout")

    self.statusView = QListView(self,"statusView")
    self.statusView.addColumn(self.tr("Data"))
    self.statusView.addColumn(self.tr("Value"))
    self.statusView.setAllColumnsShowFocus(1)
    self.statusViewTip = ListViewToolTip(view=self.statusView, column=1,
                                         truncatedOnly=1)

    rcStatusPanelLayout.addWidget(self.statusView,0,0)

    QObject.connect(self.statusView,
                    SIGNAL("contextMenuRequested(QListViewItem*,const QPoint&,int)"),
                    self.contextMenuShow
                   )

  def contextMenuShow(self, item, point, column):
    """!\brief Bring up the context menu on right mouse click.

    \param item   Listview item
    \param point  Position where the mouse was clicked
    \param column Listview column
    """
    self.selectedItem = item
    self.contextMenu.exec_loop(point)

  def copyToClipboard(self):
    """!\brief Copy the item value to the clipboard.

    """
    if self.statusView.selectedItem() is not None:
      self.clip.setText(self.statusView.selectedItem().text(1))


class rcStatusMonitor(object):
  """!\brief Monitoring class for the status panel.

  """
  def __init__(self, interval, gui=None):
    """!\brief rcStatusMonitor constructor.

    \param interval The interval that the watch items get updated
    \param gui      Parent GUI
    """
    self.__interval = interval
    self.__gui = gui
    self.__watchList = {}
    self.__labelSeq = []
    self.__timer = QTimer(gui)
    self.__lastItem = None
    QObject.connect(self.__timer, SIGNAL("timeout()"), self.updateWatchItems)

  def startWatch(self):
    """!\brief Start the watch.

    """
    if not self.__timer.isActive():
      self.__timer.start(self.__interval)

  def stopWatch(self):
    """!\brief Stop the watch.

    """
    if self.__timer.isActive():
      self.__timer.stop()

  def addWatchItem(self, label, accessor, key=None, alarmExpr=None, isStale=None):
    """!\brief Add the watch item to the list.

    \param label     Watch item label
    \param accessor  Accessor method
    \param key       Unique key for this watch item
    \param alarmExpr Alarm expression
    \param isStale   isStale method
    """
    if not self.__watchList.has_key(label):
      self.__watchList[label] = WatchItem(accessor, key, label, alarmExpr, isStale)
      self.__labelSeq.append(label)
    else:
      self.__watchList[label].setAccessor(accessor, key)

  def saveWatch(self):
    """!\brief Save watch items.

    """
    self.__saveWatchList = self.__watchList.copy()
    self.__saveLabelSeq = self.__labelSeq[:]

  def restoreWatch(self):
    """!\brief Restore watch items.

    """
    self.__watchList = self.__saveWatchList.copy()
    self.__labelSeq  = self.__saveLabelSeq[:]
    self.__gui.statusView.clear()
    self.__lastItem = None
    for watchItem in self.__watchList.values():
      watchItem.setNotInView()

  def updateWatchItems(self):
    """!\brief Watch item update loop which wakes up based on the interval.

    """
    for label in self.__labelSeq:
      wi = self.__watchList[label]
      if self.__gui is None:
        print label, wi.evaluate()
      else:
        if not wi.isInView():
          if self.__lastItem is None:
            si = StatusItem(self.__gui.statusView, label)
          else:
            si = StatusItem(self.__gui.statusView, self.__lastItem, label)
          si.setAlarmExpr(wi.getAlarmExpr())
          self.__lastItem = si
          wi.setStatusItem(si)
          wi.setInView()
        else:
          si = wi.getStatusItem()
        si.setText(1, str(wi.evaluate()))
        if si.isStale() != wi.isStale():
          si.setStale(wi.isStale())
          si.repaint()



#~ if __name__ == '__main__':

  #~ from random import random
  #~ import sys
  #~ from RunControlMainGUIImpl import *
  #~ from RunControlCommon import *

  #~ class Dummy(object):
    #~ def __init__(self):
      #~ pass

    #~ def getValue(self):
      #~ return random()

  #~ app = QApplication(sys.argv)

  #~ rcCommon = RunControlCommon()

  #~ gui = RunControlMainGUIImpl(rcCommon)

  #~ #statMon = rcStatusMonitor(1000)
  #~ statMon = rcStatusMonitor(1000, gui)
  #~ dummy = Dummy()
  #~ statMon.addWatchItem('TestValue', dummy.getValue)
  #~ statMon.startWatch()
  #~ app.setMainWidget(gui)
  #~ gui.show()
  #~ app.exec_loop()

---