userAppTree.py

__version__  = "$Revision: 2.4 $"

from qt import QListView, QPoint, QPopupMenu, QCursor, SIGNAL

from userAppLeaf import userAppLeaf

class userAppTree(object):
  def __init__(self, view):
    self.view = view
    self.clearLeaves()
    self.leaf_type_module_dict = {}
    self.oldItem = None
    self.copyFromMenu = None

    self.view.connect(self.view, SIGNAL('rightButtonClicked ( QListViewItem *, const QPoint &, int)'), self.rightMouseClicked)
    self.view.connect(self.view, SIGNAL("pressed ( QListViewItem *, const QPoint &, int )"), self.pressedEvent)
    
#    self.view.setSelectionMode(QListView.NoSelection)

  def pressedEvent(self, leaf, pos, column):
    if leaf is not None:
      leaf.pressedEvent(pos, column)

  def rightMouseClicked(self, leaf):
    """ Function that is triggered by a right click of the mouse over the tree
        This lauches a pop-up menu with actions that can be taken on the
        leaf where the cursor is
        \param leaf leaf that the mouse is pointing at
    """
    if leaf is not None:
      popup = QPopupMenu(self.view,'Options')
      if self.copyFromMenu is not None:
        popup.insertItem('Copy selection from', self.copyFromMenu)
      actions = leaf.leafActionsTuples()
      for (name,method) in actions:
        popup.insertItem(name, method)
      popup.popup(QCursor.pos())

  def setCopyFromMenu(self, from_list, method):
    """ Function that creates the popup menu that is launched when
        'Copy from' is highlighted
        based on a list describing the names that describes the origins
        and on a method that will execute the copying given the origin's index
        \param from_list list of name for the possible origins
        \param method that execute the copying from the specified origin to this leaf
    """
    if self.copyFromMenu is None:
      self.copyFromMenu = QPopupMenu(self.view, 'Copy from')
    else:
       self.copyFromMenu.clear()
    for k in range(len(from_list)):
      name = from_list[k]
      id = self.copyFromMenu.insertItem(name, method)
      self.copyFromMenu.setItemParameter(id,k)

  def AddLeaf(self,leaf):
    """ Function that adds the leaf to a local list of the leafs in this tree
        Locally the list is organized according to module types
        \param leaf leaf to add to the tree leaves list
    """
    self.leaf_list.append(leaf)
    if leaf.module() in self.leaf_dict.keys():
      self.leaf_dict[leaf.module()].append(leaf)
    else:
      self.leaf_dict[leaf.module()] = [leaf]

  def clearLeaves(self):
    self.leaf_list = []
    self.leaf_dict = {}
    self.view.clear()

  def getAllLeaves(self):
    return self.leaf_list

  def getInputNodes(self, of_class_type = None):
    """ Function which extracts from all the tree the leafs that are checked,
        it builds a list of Gnodes that are considered checked
        \return list of Gnodes
    """
    inputs = []
    child = self.view.firstChild()
    while child is not None:
      if child.isOn() and isinstance(child.node, of_class_type):
        inputs.append(child.node)
      inputs += child.getInputNodes(of_class_type)
      child = child.nextSibling()
    return inputs

  def getLeaf(self,leaf):
    """ Function that retrieves a leaf in the tree structure
        \param leaf leaf to search for
        \return leaf matching leaf found in the tree
    """
    # The tree is designed with only one first generation child
    return self.view.firstChild().getLeaf(leaf)

  def copyCheckedNodes(self, from_tree):
    """ Function that copies all the checked status of nodes in the from_tree to the nodes in this tree
        \param from_tree tree object from which to copy the checked information for the leaves
    """
    # The tree is designed with only one first generation child
    if (self.view.firstChild() is not None) and (from_tree.firstChild() is not None):
      self.view.firstChild().copyCheckedNodes(from_tree.firstChild())


  def loadNodes(self, lat, leaf_class = None):
    """ Function that populate the tree by converting nodes in the LAT structure into leaves of leaf_class
        \param lat LAT pointer
        \param leaf_class class object which will be used to populate the tree
    """
    ## Clear the hierarchy first
    if leaf_class == None:
      leaf_class = userAppLeaf

    for leaf in self.leaf_list:
      leaf.close()
      del(leaf)
    self.clearLeaves()
    if lat == None:
      return

    self.view.setEnabled(1)

    lat_leaf = leaf_class(lat, lat, self.view)
    lat_leaf.setOpen(1)
    self.AddLeaf(lat_leaf)

    if lat.existsAEM():
      aem = lat.AEM
      aem_leaf = leaf_class(lat, aem, lat_leaf)
      self.AddLeaf(aem_leaf)
      for arc in aem.ARC.values():
        arc_leaf = leaf_class(lat, arc, aem_leaf)
        self.AddLeaf(arc_leaf)
        for afe in arc.AFE.values():
          self.AddLeaf(leaf_class(lat, afe, arc_leaf))

      if aem.existsAEQ():
        self.AddLeaf(leaf_class(lat, aem.AEQ, aem_leaf))

    for pdu in lat.PDU.values():
      pdu_leaf = leaf_class(lat, pdu, lat_leaf)
      self.AddLeaf(pdu_leaf)
      if pdu.existsPEQ():
        self.AddLeaf(leaf_class(lat, pdu.PEQ, pdu_leaf))

    if lat.existsCRU():
      self.AddLeaf(leaf_class(lat, lat.CRU, lat_leaf))

    if lat.existsEBM():
      ebm = lat.EBM
      ebm_leaf = leaf_class(lat, ebm, lat_leaf)
      self.AddLeaf(ebm_leaf)
      if ebm.existsEBMC():
        self.AddLeaf(leaf_class(lat, ebm.EBMC, ebm_leaf))
      if ebm.existsEBMST():
        self.AddLeaf(leaf_class(lat, ebm.EBMST, ebm_leaf))

    if lat.existsGEM():
      gem = lat.GEM
      gem_leaf = leaf_class(lat, gem, lat_leaf)
      self.AddLeaf(gem_leaf)
      if gem.existsGEMC():
        self.AddLeaf(leaf_class(lat, gem.GEMC, gem_leaf))
      if gem.existsGEMMG():
        self.AddLeaf(leaf_class(lat, gem.GEMMG, gem_leaf))
      if gem.existsGEMST():
        self.AddLeaf(leaf_class(lat, gem.GEMST, gem_leaf))
      if gem.existsGEMSC():
        self.AddLeaf(leaf_class(lat, gem.GEMSC, gem_leaf))
      if gem.existsGEMVG():
        self.AddLeaf(leaf_class(lat, gem.GEMVG, gem_leaf))
      if gem.existsGEMIE():
        self.AddLeaf(leaf_class(lat, gem.GEMIE, gem_leaf))
      if gem.existsGEMW():
        self.AddLeaf(leaf_class(lat, gem.GEMW, gem_leaf))

    for tem in lat.TEM.values():
      tem_leaf = leaf_class(lat, tem, lat_leaf)
      self.AddLeaf(tem_leaf)
      if tem.existsTIC():
        self.AddLeaf(leaf_class(lat, tem.TIC, tem_leaf))

      for ccc in tem.CCC.values():
        ccc_leaf = leaf_class(lat, ccc, tem_leaf)
        self.AddLeaf(ccc_leaf)
        for crc in ccc.CRC.values():
          crc_leaf = leaf_class(lat, crc, ccc_leaf)
          self.AddLeaf(crc_leaf)
          for cfe in crc.CFE.values():
            self.AddLeaf(leaf_class(lat, cfe, crc_leaf))

      for tcc in tem.TCC.values():
        tcc_leaf = leaf_class(lat, tcc, tem_leaf)
        self.AddLeaf(tcc_leaf)
        for trc in tcc.TRC.values():
          trc_leaf = leaf_class(lat, trc, tcc_leaf)
          self.AddLeaf(trc_leaf)
          for tfe in trc.TFE.values():
            self.AddLeaf(leaf_class(lat, tfe, trc_leaf))

  def setStatus(self, leaf, descr):
    leaf.setText(self.columns_dict['Status'], descr[1])

  def close(self):
    for leaf in self.leaf_list:
      leaf.close()

---