userAppLeaf.py

__version__  = "$Revision: 2.4 $"

from qt import *

class userAppLeaf(QListViewItem):
  """\brief userApp Gui Leaf
  This is the class of a leaf in the userApp Gui Tree
  It contains both basic functionality as a leaf (mainly input selection functions)
  and functionality as a manager of application windows
  """

  whitebox_pix = None
  greybox_pix = None
  whitecheckedbox_pix = None

  objects = {}
  def __init__(self, lat, node, parent):
    """ Init Function for the leaf
        \param lat_node pointer to the LAT structure
        \param self_node pointer to the "Gnode" device related to this leaf
        \param parent object to use as the QCheckListItem parent
    """
    userAppLeaf.objects[id(self)] = 1
    self.node = node
    self.lat = lat
    self.inputNodes = []

    QListViewItem.__init__(self, parent,self.name())
    self.setText(0, self.name())
    self.setOn(0)

    self.setEnabled(1)
    self.window = None
    self.subw_list = []
    self.window_scroller = None
    self.warning = 0
    self.pwarning = 0
#    self.AppWindowFiles = []
    self.guiClasses = []
    self.__generateCheckBoxDrawing()
    self.setPixmap(0, self.whitebox_pix)



  def __generateCheckBoxDrawing(self):
    if userAppLeaf.whitebox_pix is None:
      checkbox = QCheckBox(None,'')
      checkbox.setMaximumSize(checkbox.sizeHint())
      checkbox.setTristate(1)
      checkbox.setState(QCheckBox.Off)
      userAppLeaf.whitebox_pix = QPixmap.grabWidget(checkbox)
      checkbox.setState(QCheckBox.NoChange)
      userAppLeaf.greybox_pix = QPixmap.grabWidget(checkbox)
      checkbox.setState(QCheckBox.On)
      userAppLeaf.whitecheckedbox_pix = QPixmap.grabWidget(checkbox)
##      checkbox.hide()

  def rect(self):
    tree = self.getTree()
    rect = tree.itemRect(self)
    a = tree.treeStepSize()*(self.depth()+tree.rootIsDecorated())+tree.itemMargin() + self.pixmap(0).width()
    rect.setLeft(a)
    return rect

  def pressedEvent(self,pos, column):
    tree = self.getTree()
    pos = tree.mapFromGlobal(pos)
    a = tree.treeStepSize()*(self.depth()+tree.rootIsDecorated())+tree.itemMargin()
    ##b = a + 20
    b = a + self.pixmap(0).width()
    #~ print "%d, %d" %(a,b)
    if pos.x() > a and pos.x() < b:
      self.stateChangeClicked()

  def setOn(self, value):
    self.On = value

  def isOn(self):
    return self.On

  def __del__(self):
    del userAppLeaf.objects[id(self)]

  ## Leaf functionality
  def getTree(self):
    return self.listView()

  def stateChangeClicked(self):
    self.setOn(not self.isOn())
    self.__propagateTriggerInputsUpdate()
    self.getTree().emit(PYSIGNAL("leafStateChanged (userAppLeaf * )"), (self, ))

  def __propagateTriggerInputsUpdate(self,childrenToo = 0, parentToo = 1):
    if childrenToo:
      child = self.firstChild()
      while child is not None:
        child.__propagateTriggerInputsUpdate(childrenToo,0)
        child = child.nextSibling()
    self.triggerInputsUpdate()
    if parentToo and self.parent() is not None:
      self.parent().__propagateTriggerInputsUpdate(0, parentToo)

  def name(self):
    """ Function which returns the name of the leaf
        A parent of this leaf should not possibly have two leaves with the same name
        The leaf could have cousins with the same name
        \return name of node/leaf
    """
    name_with_id = "%s %2d" %(self.node.getName(), self.node.id())
    return name_with_id

  def module(self):
    """ Function which returns the name of the Gnode
        The parent might have more than one child with the same module name
        \return name of module type
    """
    return str(self.node.getName())

  def getLeaf(self,leaf):
    """ Function that finds the leaf in the hierarchical structure of leaves starting at this leaf
        A match only occur if there exist a leaf at depth k under self with all of its parents name up to self matching with the reference leaf kth first parents.
        Ex: ref_leaf = a->b->self->d->e->ref_leaf will match with self->d->e->ref_leaf
        This function is mostly use to port information between leaves of different implementation of the same ELX Tree
        \param leaf leaf object to find in the structure
        \return the leaf that matches with the searched leaf, None with no match
    """
    #Is it self?
    if leaf.name() == self.name():
      return self

    #Is self a parent?
    leaf_parent = leaf
    leaf_parent_parent = leaf.parent()
    while 1:
      if leaf_parent_parent.name() == self.name():
        break
      elif leaf_parent_parent == leaf.getTree():
        return None
      leaf_parent = leaf_parent_parent
      leaf_parent_parent = leaf_parent_parent.parent()

    # Can we get it from any of our child?
    us_child = self.firstChild()
    while us_child is not None:
      if us_child.name() == leaf_parent.name():
        return us_child.getLeaf(leaf)
      us_child = us_child.nextSibling()
    return None

  def __copyCheckedNodes(self, from_leaf):
    """ Function which copies all the checked information from the from_leaf structure to the self leaf structure
        The functions does not do anything if from_leaf and self do not match
        \from_leaf leaf to use as a reference to set the checked structure of this leaf
    """
    if self.name() == from_leaf.name():
      self.setOn(from_leaf.isOn())
      #~ self.setOnNoSignal(from_leaf.isOn())
      from_child = from_leaf.firstChild()

      ##assuming the same ordering of children
      to_child = self.firstChild()
      while from_child is not None:
        while to_child is not None:
          if to_child.name() == from_child.name():
            to_child.__copyCheckedNodes(from_child)
            to_child = to_child.nextSibling()
            break
          to_child = to_child.nextSibling()
        from_child = from_child.nextSibling()

      ## No prior assumption
      #~ while from_child is not None:
        #~ to_child = self.firstChild()
        #~ while to_child is not None:
          #~ to_child.copyCheckedNodes(from_child)
          #~ to_child = to_child.nextSibling()
        #~ from_child = from_child.nextSibling()

  def copyCheckedNodes(self, from_leaf):
    self.__copyCheckedNodes(from_leaf)
    self.__propagateTriggerInputsUpdate(True, True)
    self.__emitLeavesStateChanged()

  def select_family(self, value = 1):
    """ Function that checks/unchecks this leaf and all its children leaves and all their children...
        \value checks all leaves if 1, unchecks all if 0
    """
    self.setOn(value)
    child = self.firstChild()
    while child is not None:
      child.select_family(value)
      child = child.nextSibling()

  def unselect_family(self):
    """ Function that unchecks this leaf and all its children leaves and all their children...
    """
    self.select_family(0)

  def expand_family(self, value = 1):
    """ Function that expands/collapse the leaf node in the tree and all its children and their children...
        \value expands all leaves if 1, collapse if 0
    """
    self.setOpen(value)
    child = self.firstChild()
    while child is not None:
      child.expand_family(value)
      child = child.nextSibling()

  def collapse_family(self):
    """ Function that expands/collapse the leaf node in the tree and all its children and their children...
    """
    self.expand_family(0)

  def selectFamilyClicked(self, value = 1):
    self.select_family(value)
    self.__propagateTriggerInputsUpdate(1,1)
    self.__emitLeavesStateChanged()

  def __emitLeavesStateChanged(self):
    self.getTree().emit(PYSIGNAL("leavesStateChanged ( QListViewItem * )"), (self, ))

  def unselectFamilyClicked(self):
    self.selectFamilyClicked(0)

  def leafActionsTuples(self):
    """ Function which returns the possible actions that can be included in this leafs menu
        \return a list of tuples (name,method) where name is the name of the action and method is the method implements the action
    """
    actions = [('Select All',self.selectFamilyClicked),
                  ('Unselect All',self.unselectFamilyClicked),
                  ('Expand',self.expand_family),
                  ('Collapse',self.collapse_family)]
    return actions

  ## Application manager

  def loadAppWindows(self,leaf_window_list):
    """ Function which loads the list of application windows related to the leaf
        \param appfiles_list list of module names to use as application window (these module need to contain a class 'MainWindow')
    """
    if self.window is not None:
      self.window.close()
      self.window = None
      del(self.subw_list)
      del(self.app_list)
      self.subw_list = []
    self.guiClasses = leaf_window_list

  def createWindow(self,parent):
    """ Function that creates the window containing the applications managed by the leaf
        If the window exists already, the function returns the pointer to this window
        \parent pointer to the parent to use to create the window
        \return pointer to the window
    """
    if self.window is None:
      self.window = QVBox(parent)
      for guiclass in self.guiClasses:
        #look for gui, userId, debug
        subw = guiclass(self.lat, self.node, self.window, self)
        self.subw_list.append(subw)
    return self.window


  def getInputNodes(self, of_class_type = None):
    """ Function which extracts from all its child leaves the ones that are checked
        Builds a list of Gnodes for the application to use as inputs
        \return list of Gnodes
    """
    if of_class_type is None:
      return self.inputNodes

    inputs = []
    for node in self.inputNodes:
      if isinstance(node, of_class_type):
        inputs.append(node)
    return inputs

  def getLogDir(self):
    """ Function which returns the current log directory for the application
        \return a string containing the name of the directory to log in
    """
    return self.getTree().sys_comm.getLogDir()

  def getRC(self):
    return self.getTree().sys_comm.getRC()

  def setStatus(self, status_descr):
    if status_descr[0] == 'warning':
      self.setWarning(1)
    else:
      self.setWarning(0)
    self.getTree().setStatus(self, status_descr)

  def triggerPolling(self):
    if self.window is not None:
      for subw in self.subw_list:
        subw.triggerPolling()

  def triggerCmdCliUpdate(self):
    if self.window is not None:
      for subw in self.subw_list:
        subw.triggerCmdCliUpdate()

  def triggerInputsUpdate(self):
    ##This method assumes that all children of this leaf have been previously triggered
    in_nodes = []
    if self.isOn():
      in_nodes = [self.node]
    child = self.firstChild()
    while child is not None:
      in_nodes = in_nodes + child.getInputNodes()
      child = child.nextSibling()
    self.inputNodes = in_nodes
    if not self.isOn():
      if in_nodes != []:
       self.setPixmap(0,self.greybox_pix)
      else:
       self.setPixmap(0,self.whitebox_pix)
    else:
       self.setPixmap(0,self.whitecheckedbox_pix)

    if self.window is not None:
      for subw in self.subw_list:
        subw.triggerInputsUpdate()

  def close(self):
    if self.window is not None:
      for subw in self.subw_list:
        subw.close()
      self.window.close()


  ## Triggering Alerts section

  def paintCell(self, p, cg, column, width, align):
    """ Function that reimplements QCheckListItem.paintCell to show that warning is active
    """
    new_cg = QColorGroup(cg)
    if self.pwarning == 1:
      new_cg.setColor(QColorGroup.Text , QColor(200,0,0))
    QListViewItem.paintCell(self, p, new_cg, column, width, align)

  def paintFocus(self, p, cg, r):
    ## Removes the misaligned flashy rectangle around the selected item
    pass

  def paintWarning(self, value):
    """ Function that sets the Paint warning value for the leaf
        A paint warning means either the leaf or one of the leaf's child is in warning mode
        \param value warning is painted if 1, not painted if 0
    """
    self.pwarning = value
    self.repaint()

  def updatePWarning(self):
    """ Function which updates the paint warning for this leaf and triggers an update for this leaf's parent
    """
    warning = self.warning
    child = self.firstChild()
    while child is not None:
      warning |= child.pwarning
      child = child.nextSibling()
    if warning != self.pwarning:
      self.paintWarning(warning)
      if self.parent() is not None:
        self.parent().updatePWarning()

  def setWarning(self,value):
    """ Function that sets/clear the leaf in warning mode
        It also updates the paint warning information
        \param value sets if 1, clears if 0
    """
    if self.warning != value:
      self.warning = value
      self.paintWarning(value)
      self.updatePWarning()

---