GOSEDPainter.py

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

__facility__ = "Online"
__abstract__ = "GLAST Online Single Event Display Painter"
__author__   = "A. Kavelaars <aliciak@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "11/20/2003"
__version__  = "$Revision: 1.18 $"
__credits__  = "SLAC"


import LATTE.copyright_SLAC

from   qt import *

import GOSED_LDF
import colorScale


# Important Constants
NUM_XY_TKR = 24
NUM_Z_TKR  = 36
NUM_Z_CAL  = 8
NUM_XY_CAL = 12

RANGE_TKR_X = [1,2,5,6,9,10,13,14,17,18,21,22,25,26,29,30,33,34]
RANGE1_TKR_X = [1, 5, 9, 13, 17, 21, 25, 29, 33]
RANGE2_TKR_X = [2, 6, 10, 14, 18, 22, 26, 30, 34]
RANGE_TKR_Y = [0,3,4,7,8,11,12,15,16,19,20,23,24,27,28,31,32,35]
RANGE1_TKR_Y = [4, 8, 12, 16, 20, 24, 28, 32, 35]
RANGE2_TKR_Y = [0, 3, 7, 11, 15, 19, 23, 27, 31]


class drawSide1ACD(QWidget):
  """ Draws background Pixmap for the ACD Side 1 projection and updates
  the custom widget with the final pixmap processed by GOSED_LDF.
  """

  def __init__(self, gui, parent = None,name = None,fl = 0):
    """ drawSide1ACD contructor

    \param parent        None
    \param name          None
    \param fl            0
    """

    # Initialize custom widget
    QWidget.__init__(self,parent,name,fl)
    self.__gui = gui
    custWidLayout = QGridLayout(self,1,1,0,6,"custWidLayout")
    self.clearWState(Qt.WState_Polished)
    self.setMinimumWidth(241)
    self.setMinimumHeight(81)
    self.setMaximumWidth(241)
    self.setMaximumHeight(81)
    #~ self.setSizePolicy(QSizePolicy(QSizePolicy(7,7,0,0,self.sizePolicy().hasHeightForWidth())))

    tileWidth   = (self.width()  - 1)/5
    tileHeight  = (self.height() - 1)/4
    towerWidth  = self.width()/4
    towerHeight = self.height()/4

    # Create a null final Pixmap that will indicate if there is
    # filtered ACD Side 1 data when it is filled in GOSED_LDF
    self.final      = QPixmap(241, 81)
    self.background = QPixmap(241, 81)#self.width(), self.height())

    pACD = QPainter(self.background)
    pACD.setBrush(QColor("gray"))
    pACD.setPen(QColor(140, 140, 140))
    pACD.drawRect(0, 0, self.width(), self.height())

    # Draw tile boundaries
    pACD.setPen(QColor(100, 100, 100))

    for j in range(3):
      for i in range(5):
        pACD.drawRect(tileWidth * i, tileHeight * j,
                      tileWidth + 1, tileHeight + 1
                      )

    pACD.drawRect(0, tileHeight * 3, tileWidth * 5 + 1, tileHeight + 1)

    # Draw tower boundaries
    pACD.setPen(QColor(166, 163, 157))

    for i in range(1,4):
      pACD.drawLine((towerWidth)*i, 1,(towerWidth)*i, self.height() - 1)

    pACD.end()

    # ATK-051110: Load the names in the background pixmap as default
    self.drawNames(self.background)

    self.paintFace()

  def drawNames(self, pixmap):
    tileWidth   = (self.width()  - 1)/5
    tileHeight  = (self.height() - 1)/4

    pACD = QPainter(pixmap)

    # Draw tile names
    pACD.setPen(QColor(50, 50, 50))

    lookupTile = GOSED_LDF.LOOKUP_ACD_TILE
    width = tileWidth
    for tile in GOSED_LDF.LOOKUP_ACD_YZM:
      tileSide = lookupTile[tile]
      if tileSide[2] == 3:  width = self.width()
      pACD.drawText(width * tileSide[1], tileHeight * tileSide[2],
                    width, tileHeight, Qt.AlignCenter, tile)

    pACD.end()

  def clear(self):
    # Pass the background to the final Pixmap
    self.final.fill()
    bitBlt(self.final, 0, 0, self.background, 0, 0)

  def showEvent(self, se):
    self.__gui.replot()

  def paintEvent(self, pe):
    """ Paint Event function for the Side 1 projection, paints its
    background and updates it with the current event pixmap (final)
    created in GOSED_LDF. If no data passed the filter for ACD, final
    will be updated as the background.

    \param pe            paint event
    """
    self.paintFace()

  def paintFace(self):
    # Load the custom widget with the final pixmap    
    #~ self.drawNames(self.final)# ATK-051110: See comment on drawHatACD
    bitBlt(self, 0, 0, self.final, 0, 0)

class drawSide2ACD(QWidget):
  """ Draws background Pixmap for the ACD Side 2 projection and updates
  the custom widget with the final pixmap processed by GOSED_LDF.
  """

  def __init__(self, gui, parent = None,name = None,fl = 0):
    """ drawSide2ACD contructor

    \param parent        None
    \param name          None
    \param fl            0
    """

    # Initialize custom widget
    QWidget.__init__(self,parent,name,fl)
    self.__gui = gui
    custWidLayout = QGridLayout(self,1,1,0,6,"custWidLayout")
    #~ self.setSizePolicy(QSizePolicy(QSizePolicy(7,7,0,0,self.sizePolicy().hasHeightForWidth())))
    self.clearWState(Qt.WState_Polished)
    self.setMinimumWidth(81)
    self.setMinimumHeight(241)
    self.setMaximumWidth(81)
    self.setMaximumHeight(241)

    tileWidth   = (self.width() - 1)/4
    tileHeight  = (self.height()- 1)/5
    towerWidth  = self.width()/4
    towerHeight = self.height()/4

    # Create a null final Pixmap that will indicate if there is
    # filtered ACD Side 2 data when it is filled in GOSED_LDF
    self.final      = QPixmap(81, 241)#self.width(), self.height())
    self.background = QPixmap(81, 241)#self.width(), self.height())

    pACD = QPainter(self.background)
    pACD.setBrush(QColor("gray"))
    pACD.setPen(QColor(140, 140, 140))
    pACD.drawRect(0, 0, self.width(), self.height())

    # Draw tile boundaries
    pACD.setPen(QColor(100, 100, 100))

    for i in range(3):
      for j in range(5):
        pACD.drawRect(tileWidth * i, tileHeight * j,
                      tileWidth + 1, tileHeight + 1
                      )
    pACD.drawRect(tileWidth * 3, 0, tileWidth + 1, self.height())

    # Draw tower boundaries
    pACD.setPen(QColor(166, 163, 157))

    for i in range(1,4):
      pACD.drawLine(1, (towerHeight)*i, self.width() - 1, (towerHeight)*i)

    pACD.end()

    # ATK-051110: Load the names in the background pixmap as default
    self.drawNames(self.background)

    self.paintFace()

  def drawNames(self, pixmap):
    tileWidth   = (self.width() - 1)/4
    tileHeight  = (self.height()- 1)/5

    pACD = QPainter(pixmap)

    # Draw tile name
    pACD.setPen(QColor(50, 50, 50))

    lookupTile = GOSED_LDF.LOOKUP_ACD_TILE
    height = tileHeight
    for tile in GOSED_LDF.LOOKUP_ACD_XZM:
      tileSide = lookupTile[tile]
      if tileSide[1] == 3:  height = self.height()
      x = tileWidth * tileSide[1] + (tileWidth/2 - 5) # I don't understand ...
      y = height    * tileSide[2] + (height/2 + 10)   # ...these offsets
      pACD.translate(x, y)
      pACD.rotate(-90.0)
      pACD.drawText(0, 0, tileWidth, height, Qt.AlignAuto, tile)
      pACD.rotate(90.0)
      pACD.translate(-x, -y)

    pACD.end()

  def clear(self):
    # Pass the background to the final Pixmap
    self.final.fill()
    bitBlt(self.final, 0, 0, self.background, 0, 0)

  def showEvent(self, se):
    self.__gui.replot()

  def paintEvent(self, pe):
    """ Paint Event function for the Side 2 projection, paints its
    background and updates it with the current event pixmap (final)
    created in GOSED_LDF. If no data passed the filter for ACD, final
    will be updated as the background.

    \param pe            paint event
    """

    self.paintFace()

  def paintFace(self):
    # Load the custom widget with the final pixmap
    #~ self.drawNames(self.final)# ATK-051110: See comment on drawHatACD
    bitBlt(self, 0, 0, self.final, 0, 0)


class drawSide3ACD(QWidget):
  """ Draws background Pixmap for the ACD Side 3 projection and updates
  the custom widget with the final pixmap processed by GOSED_LDF.
  """

  def __init__(self, gui, parent = None,name = None,fl = 0):
    """ drawSide3ACD contructor

    \param parent        None
    \param name          None
    \param fl            0
    """

    # Initialize custom widget
    QWidget.__init__(self,parent,name,fl)
    self.__gui = gui
    custWidLayout = QGridLayout(self,1,1,0,6,"custWidLayout")
    #~ self.setSizePolicy(QSizePolicy(QSizePolicy(7,7,0,0,self.sizePolicy().hasHeightForWidth())))
    self.clearWState(Qt.WState_Polished)
    self.setMinimumWidth(241)
    self.setMinimumHeight(81)
    self.setMaximumWidth(241)
    self.setMaximumHeight(81)

    tileWidth   = (self.width()  - 1)/5
    tileHeight  = (self.height() - 1)/4
    towerWidth  = self.width()/4
    towerHeight = self.height()/4

    # Create a null final Pixmap that will indicate if there is
    # filtered ACD Side 3 data when it is filled in GOSED_LDF
    self.final      = QPixmap(241, 81)#self.width(), self.height())
    self.background = QPixmap(241, 81)#self.width(), self.height())

    pACD = QPainter(self.background)
    pACD.setBrush(QColor("gray"))
    pACD.setPen(QColor(140, 140, 140))
    pACD.drawRect(0, 0, self.width(), self.height())

    # Draw tile boundaries
    pACD.setPen(QColor(100, 100, 100))

    for i in range(5):
      for j in range(1, 4):
        pACD.drawRect(tileWidth *i,  tileHeight * j,
                      tileWidth + 1, tileHeight + 1
                      )
    pACD.drawRect(0, 0, self.width(), tileHeight + 1)

    # Draw tower boundaries
    pACD.setPen(QColor(166, 163, 157))

    for i in range(1,4):
      pACD.drawLine((towerWidth)*i, 1, (towerWidth)*i, self.height() - 1)

    pACD.end()

    # ATK-051110: Load the names in the background pixmap as default
    self.drawNames(self.background)

    self.paintFace()

  def drawNames(self, pixmap):
    tileWidth   = (self.width()  - 1)/5
    tileHeight  = (self.height() - 1)/4

    pACD = QPainter(pixmap)

    # Draw tile name
    pACD.setPen(QColor(50, 50, 50))

    lookupTile = GOSED_LDF.LOOKUP_ACD_TILE
    width = tileWidth
    for tile in GOSED_LDF.LOOKUP_ACD_YZP:
      tileSide = lookupTile[tile]
      if tileSide[2] == 0:  width = self.width()
      pACD.drawText(width * tileSide[1], tileHeight * tileSide[2],
                    width, tileHeight, Qt.AlignCenter, tile)

    pACD.end()

  def clear(self):
    # Pass the background to the final Pixmap
    self.final.fill()
    bitBlt(self.final, 0, 0, self.background, 0, 0)

  def showEvent(self, se):
    self.__gui.replot()

  def paintEvent(self, pe):
    """ Paint Event function for the Side 3 projection, paints its
    background and updates it with the current event pixmap (final)
    created in GOSED_LDF. If no data passed the filter for ACD, final
    will be updated as the background.

    \param pe            paint event
    """

    self.paintFace()

  def paintFace(self):
    # Load the custom widget with the final pixmap
    #~ self.drawNames(self.final) # ATK-051110: See comment on drawHatACD
    bitBlt(self, 0, 0, self.final, 0, 0)


class drawSide4ACD(QWidget):
  """ Draws background Pixmap for the ACD Side 4 projection and updates
  the custom widget with the final pixmap processed by GOSED_LDF.
  """

  def __init__(self, gui, parent = None,name = None,fl = 0):
    """ drawSide4ACD contructor

    \param parent        None
    \param name          None
    \param fl            0
    """

    # Initialize custom widget
    QWidget.__init__(self,parent,name,fl)
    self.__gui = gui
    custWidLayout = QGridLayout(self,1,1,0,6,"custWidLayout")
    #~ self.setSizePolicy(QSizePolicy(QSizePolicy(7,7,0,0,self.sizePolicy().hasHeightForWidth())))
    self.clearWState(Qt.WState_Polished)
    self.setMinimumWidth(81)
    self.setMinimumHeight(241)
    self.setMaximumWidth(81)
    self.setMaximumHeight(241)

    tileWidth   = (self.width()  - 1)/4
    tileHeight  = (self.height() - 1)/5
    towerWidth  = self.width()/4
    towerHeight = self.height()/4

    # Create a null final Pixmap that will indicate if there is
    # filtered ACD Side 4 data when it is filled in GOSED_LDF
    self.final      = QPixmap(self.width(), self.height())
    self.background = QPixmap(self.width(), self.height())

    pACD = QPainter(self.background)
    pACD.setBrush(QColor("gray"))
    pACD.setPen(QColor(140, 140, 140))
    pACD.drawRect(0, 0, self.width(), self.height())

    # Draw tile boundaries
    pACD.setPen(QColor(100, 100, 100))

    for i in range(1,4):
      for j in range(5):
        pACD.drawRect(tileWidth * i, tileHeight * j,
                      tileWidth + 1, tileHeight + 1
                      )
    pACD.drawRect(0, 0, tileWidth + 1, self.height())

    # Draw tower boundaries
    pACD.setPen(QColor(166, 163, 157))

    for i in range(1,4):
      pACD.drawLine(1, (towerHeight)*i, self.width() - 1, (towerHeight)*i)

    pACD.end()

    # ATK-051110: Load the names in the background pixmap as default
    self.drawNames(self.background)

    self.paintFace()

  def drawNames(self, pixmap):
    tileWidth   = (self.width()  - 1)/4
    tileHeight  = (self.height() - 1)/5

    pACD = QPainter(pixmap)
    #pACD.setRasterOp(Qt.XorROP)         # Set pen color to background...

    # Draw tile name
    #pACD.setPen(QColor("gray"))         # Same as brush color for background
    pACD.setPen(QColor(50, 50, 50))

    lookupTile = GOSED_LDF.LOOKUP_ACD_TILE
    height = tileHeight
    for tile in GOSED_LDF.LOOKUP_ACD_XZP:
      tileSide = lookupTile[tile]
      if tileSide[1] == 0:  height = self.height()
      x = tileWidth * tileSide[1] + (tileWidth - 2) # I don't understand ...
      y = height    * tileSide[2] + (height/2 - 9)  # ...these offsets
      pACD.translate(x, y)
      pACD.rotate(90.0)
      pACD.drawText(0, 0, tileWidth, height, Qt.AlignAuto, tile)
      pACD.rotate(-90.0)
      pACD.translate(-x, -y)

    pACD.end()

  def clear(self):
    # Pass the background to the final Pixmap
    self.final.fill()
    bitBlt(self.final, 0, 0, self.background, 0, 0)

  def showEvent(self, se):
    self.__gui.replot()

  def paintEvent(self, pe):
    """ Paint Event function for the Side 4 projection, paints its
    background and updates it with the current event pixmap (final)
    created in GOSED_LDF. If no data passed the filter for ACD, final
    will be updated as the background.

    \param pe            paint event
    """

    self.paintFace()

  def paintFace(self):    
    # Load the custom widget with the final pixmap
    #~ self.drawNames(self.final) # ATK-051110: See comment on drawHatACD
    bitBlt(self, 0, 0, self.final, 0, 0)


class drawHatACD(QWidget):
  """ Draws background Pixmap for the ACD Hat projection and updates
  the custom widget with the final pixmap processed by GOSED_LDF.
  """

  def __init__(self, gui, parent = None,name = None,fl = 0):
    """ drawHatACD contructor

    \param parent        None
    \param name          None
    \param fl            0
    """

    # Initialize custom widget
    QWidget.__init__(self,parent,name,fl)
    self.__gui = gui
    custWidLayout = QGridLayout(self,1,1,0,6,"custWidLayout")
    #~ self.setSizePolicy(QSizePolicy(QSizePolicy(7,7,0,0,self.sizePolicy().hasHeightForWidth())))
    self.clearWState(Qt.WState_Polished)
    self.setMinimumWidth(241)
    self.setMinimumHeight(241)
    self.setMaximumWidth(241)
    self.setMaximumHeight(241)

    tileWidth   = (self.width()  - 1)/5
    tileHeight  = (self.height() - 1)/5
    towerWidth  = self.width()/4
    towerHeight = self.height()/4

    # Create a null final Pixmap that will indicate if there is
    # filtered ACD Hat (top) data when it is filled in GOSED_LDF
    self.final      = QPixmap(self.width(), self.height())
    self.background = QPixmap(self.width(), self.height())
    

    pACD = QPainter(self.background)
    pACD.setBrush(QColor("gray"))
    pACD.setPen(QColor(140, 140, 140))
    pACD.drawRect(0, 0, self.width(), self.height())

    # Draw tile boundaries
    pACD.setPen(QColor(100, 100, 100))

    for j in range(5):
      for i in range(5):
        pACD.drawRect(tileWidth * i, tileHeight * j,
                      tileWidth + 1, tileHeight + 1
                      )

    # Draw tower boundaries
    pACD.setPen(QColor(166, 163, 157))

    for i in range(1,4):
      pACD.drawLine((towerWidth)*i, 1,
                       (towerWidth)*i, self.height() - 1
                       )
      pACD.drawLine(1, (towerHeight)*i,
                       self.width() - 1, (towerHeight)*i
                       )

    pACD.end()

    # ATK-051110: Load the names in the background pixmap as default
    self.drawNames(self.background)

    self.paintFace()

  def drawNames(self, pixmap):
    tileWidth   = (self.width()  - 1)/5
    tileHeight  = (self.height() - 1)/5

    pACD = QPainter(pixmap)

    # Draw tile name
    pACD.setPen(QColor(50, 50, 50))

    lookupTile = GOSED_LDF.LOOKUP_ACD_TILE
    for tile in GOSED_LDF.LOOKUP_ACD_XY:
      tileSide = lookupTile[tile]
      pACD.drawText(tileWidth * tileSide[1], tileHeight * tileSide[2],
                         tileWidth, tileHeight, Qt.AlignCenter, tile)

    pACD.end()

  def clear(self):
    # Pass the background to the final Pixmap
    self.final.fill()
    bitBlt(self.final, 0, 0, self.background, 0, 0)

  def showEvent(self, se):
    self.__gui.replot()

  def paintEvent(self, pe):
    """ Paint Event function for the Hat projection, paints its
    background and updates it with the current event pixmap (final)
    created in GOSED_LDF. If no data passed the filter for ACD, final
    will be updated as the background.

    \param pe            paint event
    """
    self.paintFace()

  def paintFace(self):
    # Load the custom widget with the final pixmap
    # ATK-051110: The names can't be loaded here. The operation takes 
    # time and makes the display flicker. Instead 1. drawNames to the 
    # background pixmap as default.
    # If the pixmap gets populated in GOSED_LDF, drawNames to the final
    # pixmap there as part of the iteration process.
    #~ self.drawNames(self.final)
    bitBlt(self, 0 , 0, self.final, 0, 0)


class drawXZ_TKR(QWidget):
  """ Draws background Pixmap for the XZ TKR projection and updates
  the custom widget with the final pixmap processed by GOSED_LDF.
  """

  def __init__(self, gui, parent = None,name = None,fl = 0):
    """ drawXZ_TKR contructor

    \param parent        None
    \param name          None
    \param fl            0
    """

    # Initialize custom widget
    QWidget.__init__(self,parent,name,fl)
    self.__gui = gui
    custWidLayout = QGridLayout(self,1,1,0,6,"custWidLayout")
    self.clearWState(Qt.WState_Polished)

    # Create a null final Pixmap that will indicate if there is
    # filtered TKR data when it is filled in GOSED_LDF
    self.final      = QPixmap(145, 254)
    self.background = QPixmap(145, 254)

    # Initialize painter
    pTKR = QPainter(self.background)
    pTKR.setBrush(QColor("gray"))#110, 110, 110)) #"white"))
    pTKR.setPen(QColor(170, 170, 160))
    #~ pTKR.setPen(QColor("lightgray"))

    # Draw background
    pTKR.drawRect(0, 0, 145, 254)
    for y in range(36):
      if y in RANGE1_TKR_X:
        pTKR.setPen(QColor(140,140,150))
        pTKR.drawRect( 0, y*7, 145, 8)

      elif y in RANGE2_TKR_X:
        pTKR.setPen(QColor(140,140,150))
        pTKR.drawRect(0, y*7 + 1, 145, 8)

      elif y != 0 and y in range (0, 36, 2):
        pTKR.setPen(QColor("lightgray"))
        pTKR.drawLine( 0, y*7 + 1, 145, y*7 + 1)
        #~ pTKR.drawRect( 1, y*7 - 8, 145, 9)

    pTKR.end() # TBErased if implemented directly in frame

    self.paintFace()

  def clear(self):
    # Pass the background to the final Pixmap
    self.final.fill()
    bitBlt(self.final, 0, 0, self.background)
    #~ self.paintFace()

  def showEvent(self, se):
    self.__gui.replot()

  def paintEvent(self, pe):
    """ Paint Event function for the XZ TKR projection, paints its
    background and updates it with the current event pixmap (final)
    created in GOSED_LDF. If no data passed the filter for TKR, final
    will be updated as the background.

    \param pe            paint event
    """

    self.paintFace()

  def paintFace(self):
    # Load the custom widget with the final pixmap
    bitBlt(self, 0, 0, self.final)


class drawYZ_TKR(QWidget):
  """ Draws background Pixmap for the YZ TKR projection and updates
  the custom widget with the final pixmap processed by GOSED_LDF.
  """

  def __init__(self, gui, parent = None,name = None,fl = 0):
    """ drawYZ_TKR constructor

    \param parent        None
    \param name          None
    \param fl            0
    """

    # Initialize custom widget
    QWidget.__init__(self,parent,name,fl)
    self.__gui = gui
    custWidLayout = QGridLayout(self,1,1,0,6,"custWidLayout")
    self.clearWState(Qt.WState_Polished)

    # Initialize pixmaps
    self.final      = QPixmap(145, 254)
    self.background = QPixmap(145, 254)

    # Initialize painter
    pTKR = QPainter(self.background)
    pTKR.setBrush(QColor("gray"))#110, 110, 110)) #"white"))
    pTKR.setPen(QColor(170, 170, 160))
    #~ pTKR.setBrush(QColor(110, 110, 110)) #"white"))
    #~ pTKR.setPen(QColor("lightgray"))

    # Draw background
    pTKR.drawRect(0, 0, 145, 254)
    for y in range(36):
      if y in RANGE1_TKR_Y:
        pTKR.setPen(QColor(140,140,150))
        pTKR.drawRect( 0, y*7 + 1, 145, 8)
        #~ pTKR.drawRect( 0, y*7 + 2, 145, 8) #more symm but taller map

      elif y in RANGE2_TKR_Y:
        pTKR.setPen(QColor(140,140,150))
        pTKR.drawRect(0, y*7, 145, 8)
        #~ pTKR.drawRect(0, y*7 + 1, 145, 8)

      #~ elif y == 2:
        #~ pTKR.setPen(QColor("lightgray"))
        #~ pTKR.drawLine( 1, y*7, 145, y*7)

      elif y in range (0, 36, 2):
        pTKR.setPen(QColor("lightgray"))
        if y == 2:
          pTKR.drawLine( 0, y*7, 145, y*7)
        else:
          pTKR.drawLine( 0, y*7 + 1, 145, y*7 + 1)

    pTKR.end()

    self.paintFace()

  def clear(self):
    # Pass the background to the final Pixmap
    self.final.fill()
    bitBlt(self.final, 0, 0, self.background)
    #~ self.paintFace()

  def showEvent(self, se):
    self.__gui.replot()

  def paintEvent(self, pe):
    """ Paint Event function for the YZ TKR projection, paints its
    background and updates it with the current event pixmap (final)
    created in GOSED_LDF. If no data passed the filter for TKR, final
    will be updated as the background.

    \param pe            paint event
    """

    self.paintFace()

  def paintFace(self):
    # Load the custom widget with the final pixmap
    bitBlt(self, 0, 0, self.final)


class drawXZ_CAL(QWidget):
  """ Draws background Pixmap for the XZ CAL projection and updates
  the custom widget with the final pixmap processed by GOSED_LDF.
  """

  def __init__(self, gui, parent = None,name = None,fl = 0):
    """ drawXZ_CAL constructor

    \param parent        None
    \param name          None
    \param fl            0
    """

    # Initialize custom widget
    QWidget.__init__(self,parent,name,fl)
    self.__gui = gui
    custWidLayout = QGridLayout(self,1,1,0,6,"custWidLayout")
    self.clearWState(Qt.WState_Polished)

    # Initialize pixmaps
    self.final      = QPixmap(145, 80)
    self.background = QPixmap(145, 80)

    # Initialize painter
    pXZ_CAL = QPainter(self.background)
    r, g, b = colorScale.colorScale(0.0)
    #~ pXZ_CAL.setBrush(QColor(r, g, b))  #"white"))
    #~ pXZ_CAL.setBrush(QColor(110, 110, 110))
    #~ pXZ_CAL.setPen(QColor(160,160,170))
    pXZ_CAL.setBrush(QColor("gray"))#110, 110, 110)) #"white"))
    pXZ_CAL.setPen(QColor(140,140,150))

    # Paint background
    for y in range(NUM_Z_CAL):
      if y in range(0, NUM_Z_CAL, 2):
        pXZ_CAL.drawRect(0, y*10, 145, 10)
      else:
        for x in range(NUM_XY_CAL):
          pXZ_CAL.drawRect(x*12, y*10, 13, 10)

    pXZ_CAL.end()

    self.paintFace()

  def clear(self):
    # Pass the background to the final Pixmap
    self.final.fill()
    bitBlt(self.final, 0, 0, self.background)
    #~ self.paintFace()

  def showEvent(self, se):
    self.__gui.replot()

  def paintEvent(self, pe):
    """ Paint Event function for the XZ CAL projection, paints its
    background and updates it with the current event pixmap (final)
    created in GOSED_LDF. If no data passed the filter for TKR, final
    will be updated as the background.

    \param pe            paint event
    """

    self.paintFace()

  def paintFace(self):
    # Load the custom widget with the final pixmap
    bitBlt(self, 0, 0, self.final)


class drawYZ_CAL(QWidget):
  """ Draws background Pixmap for the YZ TKR projection and updates
  the custom widget with the final pixmap processed by GOSED_LDF.
  """

  def __init__(self, gui, parent = None,name = None,fl = 0):
    """ drawYZ_CAL constructor

    \param parent        None
    \param name          None
    \param fl            0
    """

    # Custom Widget setup
    QWidget.__init__(self,parent,name,fl)
    self.__gui = gui
    custWidLayout = QGridLayout(self,1,1,0,6,"custWidLayout")
    self.clearWState(Qt.WState_Polished)

    # Create a null final Pixmap that will indicate if there is
    # filtered CAL data when it is filled in GOSED_LDF
    #CELLVERTPITCH = int( 21.35 / 2.0)
    #CELLHORPITCH  = int( 27.84 / 2.0)
    #CSILENGTH     = int(326.00 / 2.0)
    #CSIWIDTH      = int( 26.70 / 2.0)
    #CSIHEIGHT     = int( 19.90 / 2.0)

    self.final      = QPixmap(145, 80)
    self.background = QPixmap(145, 80)
    #self.setMinimumWidth(NUM_XY_CAL * CELLHORPITCH)
    #self.setMinimumHeight(NUM_Z_CAL * CELLVERTPITCH)
    #self.setMaximumWidth(NUM_XY_CAL * CELLHORPITCH)
    #self.setMaximumHeight(NUM_Z_CAL * CELLVERTPITCH)

    #self.final      = QPixmap(NUM_XY_CAL * CELLHORPITCH, NUM_Z_CAL * CELLVERTPITCH)
    #self.background = QPixmap(NUM_XY_CAL * CELLHORPITCH, NUM_Z_CAL * CELLVERTPITCH)

    # Start painter
    pYZ_CAL = QPainter(self.background)
    r, g, b = colorScale.colorScale(0.0)
    #~ pYZ_CAL.setBrush(QColor(r, g, b))  #"white"))
    #~ pYZ_CAL.setBrush(QColor(110, 110, 110))
    #~ pYZ_CAL.setPen(QColor(160,160,170))
    pYZ_CAL.setBrush(QColor("gray"))#110, 110, 110)) #"white"))
    pYZ_CAL.setPen(QColor(140,140,150))

    # Paint background in background Pixmap
    for y in range(NUM_Z_CAL):
      if y in range(1, NUM_Z_CAL, 2):
        pYZ_CAL.drawRect(0, y*10, 145, 10)
        #pYZ_CAL.drawRect(0, y*CELLVERTPITCH, NUM_XY_CAL * CELLHORPITCH, CELLVERTPITCH)
      else:
        for x in range(NUM_XY_CAL):
          pYZ_CAL.drawRect(x*12, y*10, 13, 10)
          #pYZ_CAL.drawRect(x*CELLHORPITCH, y*CELLVERTPITCH, CELLHORPITCH, CELLVERTPITCH)

    pYZ_CAL.end()

    self.paintFace()

  def clear(self):
    # Pass the background to the final Pixmap
    self.final.fill()
    bitBlt(self.final, 0, 0, self.background)
    #~ self.paintFace()

  def showEvent(self, se):
    self.__gui.replot()

  def paintEvent(self, pe):
    """ Paint Event function for the YZ CAL projection, paints its
    background and updates it with the current event pixmap (final)
    created in GOSED_LDF. If no data passed the filter for TKR, final
    will be updated as the background.

    \param pe            paint event
    """

    self.paintFace()

  def paintFace(self):
    # Load the custom widget with the final pixmap
    bitBlt(self, 0, 0, self.final)
  
class drawRainbowACD(QWidget):  
  """ Draws background Pixmap for the ACD Rainbow and updates
  the custom widget with the final pixmap.
  """

  def __init__(self, gui, parent = None,name = None,fl = 0):
    """ drawRainbowACD constructor

    \param parent        None
    \param name          None
    \param fl            0
    """

    # Custom Widget setup
    QWidget.__init__(self,parent,name,fl)
    self.__gui = gui
    custWidLayout = QGridLayout(self,1,1,0,6,"custWidLayout")
    self.clearWState(Qt.WState_Polished)

    self.rainbowACD = QPixmap(440, 15) 
    p = QPainter(self.rainbowACD)

    minV  = 1.0e-15
    maxV  = 1.0 - minV
    value = minV

    # Divide length of the frame (440) in intervals of 1
    dV = (maxV - minV) / float(440)
    tileWidth  = 1
    tileHeight = 15
    for i in range(0, 440):
      r, g, b = colorScale.colorScale(value)
      p.setBrush(QColor(r, g, b))
      p.setPen(QColor(r, g, b))
      p.drawRect(i*tileWidth,                0,
                 (i + 1)*tileWidth, tileHeight
                 )
      value += dV
    p.end()
    
    self.paintRainbowACD()

  def paintEvent(self, pe):
    """ Paint Event function for the ACD rainbow.

    \param pe            paint event
    """

    self.paintRainbowACD()

  def paintRainbowACD(self):
    # Load the custom widget with the final pixmap
    bitBlt(self, 0, 0, self.rainbowACD)

class drawRainbowCAL(QWidget):  
  """ Draws background Pixmap for the CAL Rainbow and updates
  the custom widget with the final pixmap.
  """

  def __init__(self, gui, parent = None,name = None,fl = 0):
    """ drawRainbowCAL constructor

    \param parent        None
    \param name          None
    \param fl            0
    """

    # Custom Widget setup
    QWidget.__init__(self,parent,name,fl)
    self.__gui = gui
    custWidLayout = QGridLayout(self,1,1,0,6,"custWidLayout")
    self.clearWState(Qt.WState_Polished)

    self.rainbowCAL = QPixmap(410, 15) 
    p = QPainter(self.rainbowCAL)

    minV  = 1.0e-15
    maxV  = 1.0 - minV
    value = minV

    # Divide length of the frame (410) in intervals of 1
    dV = (maxV - minV) / float(410)
    tileWidth  = 1
    tileHeight = 15
    for i in range(0, 410):
      r, g, b = colorScale.colorScale(value)
      p.setBrush(QColor(r, g, b))
      p.setPen(QColor(r, g, b))
      p.drawRect(i*tileWidth,                0,
                 (i + 1)*tileWidth, tileHeight
                 )
      value += dV
    p.end()
    
    self.paintRainbowCAL()
  
  def paintEvent(self, pe):
    """ Paint Event function for the CAL rainbow.

    \param pe            paint event
    """

    self.paintRainbowCAL()

  def paintRainbowCAL(self):
    # Load the custom widget with the final pixmap
    bitBlt(self, 0, 0, self.rainbowCAL)

---