rcParamVerifyGUIImpl.py

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

__facility__ = "Online"
__abstract__ = "Parameter verifier dialog"
__author__   = "S. Tuvi <STuvi@SLAC.Stanford.edu>"
__date__     = "2005/01/27 23:00:27"
__updated__  = "$Date: 2006/01/31 17:36:54 $"
__version__  = "$Revision: 2.6 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

from qt import *
from qttable import *
import sys
from rcParamVerifyGUI import rcParamVerifyGUI

class rcParamVerifyGUIImpl(rcParamVerifyGUI):
  """!\brief Parameter verifier GUI

  """
  class ParamCheckTableItem(QTableItem):
    """!\brief Checkbox table item for the parameter verifier.

    """
    RTTI = 1000

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

      """
      QTableItem.__init__(self, *args)
      self.__cb = None
      self.__checked = 0

    #def alignment(self):
    #  return Qt.AlignRight

    def rtti(self):
      """!\brief Return the runtime type information value.

      \return RTTI
      """
      return self.RTTI

    def isChecked(self):
      """!\brief Find out if the item is checked.

      \return 1: Checked, 0: Is not checked
      """
      return self.__cb.isChecked()

#    def paint(self, p, cg, cr, selected):
#      if selected:
#        br = QColorGroup.Highlight
#      else:
#        br = QColorGroup.Base
#      p.fillRect(0, 0, cr.width(), cr.height(), cg.brush(br))

#      c = QColorGroup(cg);
#      c.setBrush(QColorGroup.Background, c.brush(QColorGroup.Base));
#      flags = QStyle.Style_Default;
#      if self.isEnabled():
#         flags |= QStyle.Style_Enabled
#      if self.isChecked():
#         flags |= QStyle.Style_On
#      else:
#         flags |= QStyle.Style_Off
#      if self.isEnabled() and self.table().isEnabled():
#         flags |= QStyle.Style_Enabled

#      sz = QSize(self.table().style().pixelMetric( QStyle.PM_IndicatorWidth ),
#             self.table().style().pixelMetric( QStyle.PM_IndicatorHeight ) )

##      self.table().style().drawPrimitive( QStyle.PE_Indicator, p,
##                  QRect(0, (cr.height() - sz.height()) / 2, sz.width(), sz.height() ), c, flags )

#      intCenterGap = ( self.table().cellGeometry( self.row(), self.col() ).width() - sz.width())/2
#      #self.table().style().drawPrimitive( QStyle.PE_Indicator, p,
#      #  QRect(intCenterGap, ( cr.height() - sz.height() ) / 2,
#      #  sz.width(), sz.height()), c, flags )

    def createEditor(self):
      """!\brief Create an editor for the checkbox table item.

      """
      self.__pwdg = QWidget(self.table().viewport(), "wdg_checkparent")
      self.__cb = QCheckBox(self.__pwdg, "qt_editor_checkbox" )
      #self.__cb = QCheckBox(self.table().viewport(), "qt_editor_checkbox" )
      self.__pwdg.setFocusProxy(self.__cb)
      self.__cb.setChecked( self.__checked )
      self.__cb.adjustSize()
      self.__cb.setText(self.text())
      self.__cb.move( ( (self.table().cellGeometry( self.row(), self.col() ).width() - self.__cb.size().width() )/2) , ( self.table().cellGeometry( self.row(), self.col() ).height() - self.__cb.size().height() )/2 )
      self.__cb.setEraseColor(self.table().viewport().eraseColor())
      self.__pwdg.setEraseColor(self.table().viewport().eraseColor())
      QObject.connect(self.__cb, SIGNAL("toggled(bool)"), self.doValueChanged)
      #return self.__cb
      return self.__pwdg

    def setContentFromEditor(self, w):
      """!\brief Set content from the editor.

      \param w Widget
      """
      if self.__cb:
        self.__checked = self.__cb.isChecked()

    def doValueChanged(self):
      """!\brief Emit a valueChanged signal.

      """
      self.table().setCurrentCell(self.row(), self.col())
      self.table().emit(SIGNAL('valueChanged'), (self.row(), self.col()))

  class ParamTextTableItem(QTableItem):
    """!\brief Text table item for the parameter verifier.

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

      \param *args Parameters
      """
      QTableItem.__init__(self, *args)
      self.__bold = 0

    def alignment(self):
      """!\brief Set alignment to left and center.

      """
      return Qt.AlignLeft | Qt.AlignVCenter

    def paint(self, p, cg, rect, selected):
      """!\brief Paint the table item.

      \param p        Painter
      \param cg       Color group
      \param rect     Rectangle
      \param selected Selected
      """
      f = p.font()
      f.setBold(self.__bold)
      p.setFont(f)
      # Do the standard painting
      QTableItem.paint(self,p,cg,rect,selected)

    def setBold(self, bold):
      """!\brief Set the text item in bold.

      \param bold Boolean
      """
      self.__bold = bold


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

    \param common ScriptEngineCommon instance.
    \param parent Parent GUI
    \param name   GUI name
    \param fl     GUI flags
    """
    rcParamVerifyGUI.__init__(self, parent, name, fl)
    self.__common = common
    self.parTable.setLeftMargin(0)
    self.parTable.setNumCols(3)
    colLabels = QStringList("Parameter")
    colLabels.append("Value")
    colLabels.append("")
    self.parTable.setColumnLabels(colLabels)
    self.parTable.setColumnReadOnly(0, 1)
    self.parTable.setColumnReadOnly(1, 1)
    self.parTable.setColumnReadOnly(2, 0)
    self.parTable.setColumnWidth(0,200)
    self.parTable.setColumnWidth(1,50)
    self.parTable.setColumnWidth(2,20)
    self.parTable.horizontalHeader().setResizeEnabled(0, 2)
    self.parTable.setColumnStretchable(0, 1)
    self.parTable.setColumnStretchable(1, 1)
    #self.parTable.horizontalHeader().setClickEnabled(0, 2)
    self.__paramCount = 0
    QObject.connect(self.parTable,
                SIGNAL("valueChanged(int,int)"), self.parameterClicked)
    QObject.connect(self.buttonCancel,SIGNAL("clicked()"),self.cancel)
    QObject.connect(self.buttonConfirm,SIGNAL("clicked()"),self.confirm)
    self.__certifyText = str(self.textCertify.text())

    # Dummy up some entries
    #self.textCertify.setText(str(self.textCertify.text()) % ("Selim Tuvi", "testAppCal"))
    #self.__paramCount = 6
    #ti = self.addParameter("Layers Selection", "(X0,Y0)")
    #ti = self.addParameter("No. of strobes per setting", 1)
    #ti = self.addParameter("Thr DAC", 30)
    #ti = self.addParameter("Thr Range", 0)
    #ti = self.addParameter("Cal DAC", 20)
    #ti = self.addParameter("Cal Range", 1)

  def initialize(self, testName):
    """!\brief Initialize the GUI.

    \param testName Name of the test script
    """
    prefs = self.__common.prefMan().preferences()
    user = prefs['operatorobj']
    self.textTestName.setText(testName)
    self.textUserName.setText(user.getName())
    self.textCertify.setText(self.__certifyText % (user.getName(), testName))
    self.buttonConfirm.setEnabled(0)
    self.txtPassword.setEnabled(0)
    self.__paramCount = 0
    self.txtPassword.setText("")
    self.clearAllRows()

  def clearAllRows(self):
    """!\brief Clear all rows.

    """
    for row in range(self.parTable.numRows()):
      self.parTable.removeRow(row)

  def cancel(self):
    """!\brief Cancel button is clicked.

    """
    QDialog.done(self, QDialog.Rejected)

  def confirm(self):
    """!\brief Confirm button is clicked.

    """
    prefs = self.__common.prefMan().preferences()
    secMan = self.__common.getSecurityMan()
    if secMan is None:
      QDialog.done(self, QDialog.Accepted)
    else:
      user = prefs['operatorobj']
      if secMan.authenticateUser(user.getLoginId(), str(self.txtPassword.text())) == 0:
        QDialog.done(self, QDialog.Accepted)
      else:
        QMessageBox.critical( None, "Authentication Error",
                                    "Incorrect Password",
                                    QMessageBox.Ok + QMessageBox.Default )
        self.txtPassword.selectAll()

  def addParameter(self, name, value):
    """!\brief Add parameter.

    \param name  Parameter name
    \param value Parameter value
    """
    self.parTable.setNumRows(self.__paramCount+1)
    ti = self.ParamTextTableItem(self.parTable, QTableItem.Never, name)
    self.parTable.setItem(self.__paramCount, 0, ti)
    ti = self.ParamTextTableItem(self.parTable, QTableItem.Never, str(value))
    self.parTable.setItem(self.__paramCount, 1, ti)
    ti = self.ParamCheckTableItem(self.parTable, QTableItem.Always, "")
    self.parTable.setItem(self.__paramCount, 2, ti)
    self.__paramCount+=1
    return ti

  def parameterClicked(self, row, col):
    """!\brief Signal that a table item has been changed.

    \param row Table row
    \param col Table column
    """
    if col == 2:
      chk = self.parTable.item(row, col)
      if chk.isChecked():
        self.parTable.item(row, 0).setBold(1)
        self.parTable.item(row, 1).setBold(1)
        self.parTable.repaintSelections()
      else:
        self.parTable.item(row, 0).setBold(0)
        self.parTable.item(row, 1).setBold(0)
        self.parTable.repaintSelections()

      if self.allParametersChecked():
        self.buttonConfirm.setEnabled(1)
        self.txtPassword.setEnabled(1)
      else:
        self.buttonConfirm.setEnabled(0)
        self.txtPassword.setEnabled(0)

  def allParametersChecked(self):
    """!\brief Check if all parameters have been checked.

    \return True:  If all parameters have been checked.
            False: Not all parameters have been checked.
    """
    for row in range(self.__paramCount):
      chk = self.parTable.item(row, 2)
      if not chk.isChecked():
        return False
    return True

if __name__ == "__main__":
  a = QApplication(sys.argv)
  QObject.connect(a,SIGNAL("lastWindowClosed()"),a,SLOT("quit()"))
  w = rcParamVerifyGUIImpl(None)
  a.setMainWidget(w)
  w.show()
  a.exec_loop()

---