package triggertool.HLTRecords;
 
 import java.awt.Color;
 import java.awt.Graphics2D;
 import java.awt.Point;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Iterator;
 import java.util.TreeMap;
 import java.util.Vector;
 import java.util.logging.Logger;
 import javax.swing.JMenuItem;
 import javax.swing.JPopupMenu;
 import javax.swing.JTextField;
 import javax.swing.tree.DefaultMutableTreeNode;
 import triggertool.Components.AbstractTable;
 import triggertool.Components.ConnectionManager;
 import triggertool.Components.NewJPanel;
 import triggertool.Components.SearchDialog;
 import triggertool.Components.TriggerInfo;
 
 ///HLT Trigger Element.
 /**
  * HLT Trigger Element object.
  *
  * @author Paul Bell
  * @author Simon Head
  */
 public class HLTTriggerElement extends AbstractTable {
 
     ///Message Log.
     protected static Logger logger = Logger.getLogger(HLTTriggerElement.class.getName());
     ///Vector of input trigger elements.
     private Vector<HLTTE_TE> tete = null;
     ///Vector of components that belong to a trigger element.
     private Vector<HLTComponent> algorithms = null;
     ///So the tree knows what to display.
     private boolean needtoadd_tete = true;
     ///Useful for the tree.
     private Vector<DefaultMutableTreeNode> tree_data = new Vector<DefaultMutableTreeNode>();
     ///Held in a link table.
     private Integer element_counter = -1;
     ///Panel that we draw components to.
     private NewJPanel pan = null;
     ///So the name of the trigger element can be changed.
     private TriggerInfo nameBtn = null;
     ///Probably shouldn't be here.
     private JTextField textName = new JTextField();
 
     ///Default constructor.
     public HLTTriggerElement(int input_id) {
         super(input_id);
 
         tableName = "HLT_TRIGGER_ELEMENT";
         tablePrefix = "HTE_";
 
         if (input_id > 0) {
             forceLoad();
         }
 
         nameBtn = new TriggerInfo("NAME", keyValue, textName);
     }
 
     ///Trick the class into thinking that the children have been loaded.
     public void confuseLoader() {
         tete = new Vector<HLTTE_TE>();
         algorithms = new Vector<HLTComponent>();
     }
 
     ///After an edit we need to force the record to read from the database.
     @Override
     public void forceLoad() {
         needtoadd_tete = true;
         algorithms = null;
         tete = null;
         ConnectionManager.getInstance().forceLoad(this);
     }
 
     ///Left click if something was pressed, otherwise do nothing.
     public boolean leftClickIfPossible(Point p, boolean expand_only) {
     
         boolean maybeedited = false;
         boolean clicked = false;
         
         checkClickArrow(p);
         
         if(!expand_only) {
             
             boolean clickedcross = checkClickCross(p);    
             if(clickedcross&&maybeedited==false) maybeedited=true;
             
             clicked = nameBtn.leftClickIfPossible(p);  
             if(clicked&&maybeedited==false) maybeedited=true;
             
         }
         
         if(!clicked){
             for (HLTComponent algorithm : getAlgorithms()) {
                 algorithm.leftClickIfPossible(p, expand_only);
             }
             for (HLTTE_TE inputele : getInputElements()) {
                 inputele.leftClickIfPossible(p, expand_only);
             }
         }
         
         if(maybeedited){
             //System.out.println("Setting ele id negative for " + get_name());
             set_id(-1);
         }
         return maybeedited;
     }
      
 
     ///Probably not a good idea, fiddles with numbers in links?
     public void renumberAlgorithms() {
         if (algorithms != null) {
             int i = 0;
             for (HLTComponent component : getAlgorithms()) {
                 component.set_algorithm_counter(i);
                 ++i;
             }
         }
     }
 
     ///Add components to the tree view.
     @Override
     public void addToTree(DefaultMutableTreeNode treeNode, int counter) {
         --counter;
         if (counter >= 0) {
 
             //inputs
             Vector<HLTTE_TE> inputs = getInputElements();
             Iterator<HLTTE_TE> inputs_it = inputs.iterator();
 
             if (needtoadd_tete) {
                 while (inputs_it.hasNext()) {
                     HLTTE_TE test = (HLTTE_TE) inputs_it.next();
                     DefaultMutableTreeNode anotherLayer = new DefaultMutableTreeNode(test);
                     treeNode.add(anotherLayer);
                 }
                 needtoadd_tete = false;
             }
 
             if (tree_data.size() == 0) {
                 for (HLTComponent comp : getAlgorithms()) {
                     DefaultMutableTreeNode anotherLayer = new DefaultMutableTreeNode(comp);
                     treeNode.add(anotherLayer);
                     tree_data.add(anotherLayer);
                 }
             } else {
                 int i = 0;
                 for (HLTComponent comp : getAlgorithms()) {
                     comp.addToTree(tree_data.get(i), counter);
                     ++i;
                 }
             }
         }
     }
 
     ///Make a deep copy of a trigger element.
     /**
      * When the user clicks the copy button we copy the class. This contains the
      * code to set all the variables in the new class to the correct values
      * 
      * Don't increment the version this will be done automagically
      */
     public Object clone() {
         HLTTriggerElement copy = new HLTTriggerElement(-1);
         copy.set_name(get_name());
         copy.set_version(get_version());
         //copy.add_gui(pan);
         //copy.setX(getX());
         //copy.setY(getY());
         for (HLTTE_TE tetelink : getInputElements()) {
             HLTTE_TE newtete = (HLTTE_TE) tetelink.clone();
             copy.getInputElements().add(newtete);
         }
         for (HLTComponent comp : getAlgorithms()) {
             HLTComponent newcomp = (HLTComponent) comp.clone();
             copy.getAlgorithms().add(newcomp);
         }
         return copy;
     }
 
     ///Save the trigger element, check input TE and components.
     /**
      * Contains the code that saves the record to the database Again, see LVL1
      * for an implementation.
      * 
      * @throws SQLException Stop on SQL problems.
      */
     public int save() throws SQLException {
 
         logger.fine("In HLT TE Save for TE: " + get_name());
         //logger.info("Num of input TEs = " + getInputElements().size());
         //logger.info("Num of algorithms: " + getAlgorithms().size());
 
         //Map of comp IDs with their counters - for comparison late
         TreeMap<Integer, Integer> comp_ids = new TreeMap<Integer, Integer>();
         for (HLTComponent comp : getAlgorithms()) {
             comp_ids.put(comp.get_id(), comp.get_algorithm_counter());
         }
         //NB treemaps are sorted by key, so should be able to compare them!
         
         //PJB 25/4/08 want a better way to do this - if the name matches, start comparing inputs, 
         //then if the input matches start comparing algorithms
         //also need to do this in types and groups etc!
         int matchingID = -1;
         //FIRST STEP - find list of candidated by matching the name and used
 
         Vector<Integer> hteName_ids = ConnectionManager.getInstance().get_IDs(tableName, tablePrefix, keyValue, null, "ID");
         logger.fine("Number of candidate TEs (with matching name) : " + hteName_ids.size());
         //
         //Now loop over the candidates
         //
         HLTTriggerElement matchTETE = null;
         for (Integer iTE : hteName_ids) {
           
             //FIRST STEP - match the components
             String query = "SELECT HTE2CP_COMPONENT_ID, HTE2CP_ALGORITHM_COUNTER FROM HLT_TE_TO_CP WHERE HTE2CP_TRIGGER_ELEMENT_ID=?";
             TreeMap<Integer, Integer> compresults = ConnectionManager.getInstance().getConstrainedItemList(query, iTE);
             if (!compresults.equals(comp_ids)) {
                 logger.fine("PJB different components so going to next candidate");
                 continue;
             }
             
             //SECOND STEP - match the input TEs
             //get one of the candidate TEs with matching name
             matchTETE = new HLTTriggerElement(iTE);
             logger.fine("PJB potential match has this many input TEs: " + matchTETE.getInputElements().size());
             //if the size is different we can stop here
             if (matchTETE.getInputElements().size() != getInputElements().size()) {
                 logger.fine("PJB different number of inputs so going to next candidate");
                 continue;
             }
             matchTETE = null;
             logger.fine("PJB potential match " + iTE + " has same number of inputs (" + getInputElements().size() + ")");
             //if same number of inputs, are they the same ones? loop over inputs and see if the match has them
             //
             Vector<String> Inputs_Found = new Vector<String>();
             for (HLTTE_TE Input : getInputElements()) {
 
                 TreeMap<String, Object> fields_values2 = new TreeMap<String, Object>();
                 fields_values2.put("TE_ID", iTE);
                 fields_values2.put("TE_INP_ID", Input.get_element_inp_id());
                 fields_values2.put("TE_INP_TYPE", Input.get_element_inp_type());
                 fields_values2.put("TE_COUNTER", Input.get_element_counter());
                 fields_values2.put("USED", Input.get_used());
                 //ids of TETEs belonging to candidate which match what we are trying to save
                 //logger.info("PJB this TE has input " + )
                 Vector<Integer> te2teIDs = ConnectionManager.getInstance().get_IDs("HLT_TE_TO_TE", "HTE2TE_", fields_values2, null, "ID");
                 if (te2teIDs.size() > 0) {
                     Inputs_Found.add(Input.get_element_inp_id());
                 }
             }
             //now, TEInputs_Found will have same size as getInputElements if the match is the same!
             if (Inputs_Found.size() != getInputElements().size()) {
                 logger.fine("PJB same number of inputs but not identical so going to next candidate");
                 continue;
             }
             Inputs_Found.clear();
             
             logger.fine("PJB TE candidate matches exactly: " + iTE);
             //  
             //if we got to here, we have a match so stop
             matchingID = iTE;
             break;
         }
 
         if (matchingID < 0) {
             logger.fine("Saving new TE");
 
             int version = 1 + ConnectionManager.getInstance().getMaxVersion(tableName, tablePrefix, get_name());
             keyValue.put("VERSION", version);
             set_id(ConnectionManager.getInstance().save(tableName, tablePrefix, get_id(), keyValue));
 
             for (HLTComponent comp : getAlgorithms()) {
                 TreeMap<String, Object> link = new TreeMap<String, Object>();
                 link.put("TRIGGER_ELEMENT_ID", get_id());
                 link.put("COMPONENT_ID", comp.get_id());
                 link.put("ALGORITHM_COUNTER", comp.get_algorithm_counter());
                 link.put("USED", false);
                 ConnectionManager.getInstance().save("HLT_TE_TO_CP", "HTE2CP_", -1, link);
             }
             
             for (HLTTE_TE link : getInputElements()) {
                 link.set_id(-1);
                 link.set_trigger_element_id(get_id());
                 logger.fine("PJB going to save TETE with id " + link.get_id() + " for TE id " + link.get_element_inp_id());
                 link.save();
             }
 
             logger.fine("[SAVE TE :: new id = " + get_id() + " ] " + get_name());
         } else {
             ////id = hteNameInputAlg_ids.get(0);
             set_id(matchingID);
             logger.fine("[SAVE TE :: returned id = " + get_id() + " ] " + get_name());
         }
 
         logger.fine("TE id as selected by save: " + get_id());
 
         return get_id();
     }
 
     ///Set the element counter in the link table.
     public void set_element_counter(int iTE) {
         element_counter = iTE;
     }
 
     ///Get the element counter from the link table.
     public Integer get_element_counter() {
         return element_counter;
     }
 
     ///String representation of the object.
     @Override
     public String toString() {
         if (get_id() == -1) {
             return "HLT Trigger Element";
         }
         return "HLT TRIGGER ELEMENT: ID=" + get_id() +
                 ", Name=" + get_name() +
                 ", Input TE(s)=" + get_input_trigger_element_names();
     }
 
     ///Minimum names for search results.
     @Override
     public Vector<String> get_min_names() {
         Vector<String> info = new Vector<String>();
         info.add("ID");
         info.add("Name");
         info.add("Input TE Name(Type)");
         return info;
     }
 
     ///Minimum info for search result.
     @Override
     public Vector<Object> get_min_info() {
         Vector<Object> info = new Vector<Object>();
         info.add(get_id());
         info.add(get_name());
         info.add(get_input_trigger_element_names_and_counters());
         return info;
     }
 
     ///Returns a string of names of all the input trigger elements.
     public String get_input_trigger_element_names() {
         String inp_te_names = "";
         getInputElements();
         Iterator<HLTTE_TE> myIterator = tete.iterator();
         while (myIterator.hasNext()) {
             HLTTE_TE link_TETE = (HLTTE_TE) myIterator.next();
             if (inp_te_names.length() == 0) {
                 inp_te_names = link_TETE.get_element_inp_id() + "(" + link_TETE.get_element_inp_type() + ")";
             } else {
                 inp_te_names = inp_te_names + ", " + link_TETE.get_element_inp_id() + "(" + link_TETE.get_element_inp_type() + ")";
             }
         }
         return inp_te_names;
     }
 
     ///Returns a string of names of all the input trigger elements also with counter information.
     public String get_input_trigger_element_names_and_counters() {
         String inp_te_names = "";
         getInputElements();
         Iterator<HLTTE_TE> myIterator = tete.iterator();
         while (myIterator.hasNext()) {
             HLTTE_TE link_TETE = (HLTTE_TE) myIterator.next();
             if (inp_te_names.length() == 0) {
                 inp_te_names = link_TETE.get_element_counter() + ": " + link_TETE.get_element_inp_id() + "(" + link_TETE.get_element_inp_type() + ")";
             } else {
                 inp_te_names = inp_te_names + ", " + link_TETE.get_element_counter() + ": " + link_TETE.get_element_inp_id() + "(" + link_TETE.get_element_inp_type() + ")";
             }
         }
         return inp_te_names;
     }
 
     ///Returns a string of types of all the input trigger elements.
     public String get_input_trigger_element_types() {
         String inp_te_types = "";
         Vector<HLTTE_TE> links = getInputElements();
         Iterator<HLTTE_TE> It_TETE = links.iterator();
         while (It_TETE.hasNext()) {
             HLTTE_TE link_TETE = (HLTTE_TE) It_TETE.next();
             if (inp_te_types.length() == 0) {
                 inp_te_types = link_TETE.get_element_inp_type();
             } else {
                 inp_te_types = inp_te_types + ", " + link_TETE.get_element_inp_type();
             }
         }
         return inp_te_types;
     }
 
     
     
     //get the components (ie the algorithms (and with them their tools) from the TE-CP link)
     public Vector<HLTComponent> getAlgorithms() {
         
         if (algorithms == null) {
             algorithms = new Vector<HLTComponent>();
 
             if (get_id() > 0) {
                 
                 HLTComponent tmp = new HLTComponent(-1);
 
                 String query = tmp.getQueryString();
 
                 query = query.replace("FROM ", "FROM HLT_TRIGGER_ELEMENT, HLT_TE_TO_CP, ");
 
                 String and = " WHERE " +
                         "HTE_ID=? " +
                         "AND " +
                         "HTE2CP_TRIGGER_ELEMENT_ID=HTE_ID " +
                         "AND " +
                         "HTE2CP_COMPONENT_ID=HCP_ID ";
 
                 query = ConnectionManager.getInstance().fix_schema_name(query + and);
 
                 //System.out.println(query);
 
                 try {
                     PreparedStatement ps = ConnectionManager.getInstance().getConnection().prepareStatement(query);
                     ps.setInt(1, get_id());
                     ResultSet rset = ps.executeQuery();
 
                     while (rset.next()) {
                         HLTComponent comp = new HLTComponent(-1);
                         comp.loadFromRset(rset);
                         algorithms.add(comp);
                     }
 
                     rset.close();
                     ps.close();
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             }
 
         }
         return algorithms;
     }
                 
     
     ///Load all the input trigger elements.
     public Vector<HLTTE_TE> getInputElements() {
         if (tete == null) {
             tete = new Vector<HLTTE_TE>();
 
             if (get_id() > 0) {
                 String query = "SELECT HTE2TE_ID " +
                         "FROM HLT_TE_TO_TE " +
                         "WHERE HTE2TE_TE_ID=? " +
                         "ORDER BY HTE2TE_TE_COUNTER";
 
                 query = ConnectionManager.getInstance().fix_schema_name(query);
                 Vector<Integer> ids = new Vector<Integer>();
 
                 try {
                     PreparedStatement ps = ConnectionManager.getInstance().getConnection().prepareStatement(query);
                     ps.setInt(1, get_id());
                     ResultSet rset = ps.executeQuery();
 
                     while (rset.next()) {
                         int idn = rset.getInt(1);
                         ids.addElement(idn);
                     }
                     rset.close();
                     ps.close();
                 } catch (SQLException e) {
                     e.printStackTrace();
                 }
 
                 Iterator<Integer> it = ids.iterator();
 
                 while (it.hasNext()) {
                     tete.addElement(new HLTTE_TE((Integer) it.next()));
                 }
             }
         }
         return tete;
     }
 
 
     ///Add components to the panel.
     public void add_gui(NewJPanel o) {
         nameBtn.addGui(o);
         pan = o;
     }
 
     ///User performed a right click.
     public JPopupMenu rightClickIfPossible(Point p, 
                                            HLTTriggerSignature parentsig, 
                                            HLTTriggerChain parentchain,
                                            HLTTriggerMenu parentmenu) {
         
         if(contains(p)){
             //logger.info("Right clicked element " + get_name());
             //logger.info("Parent signature is " + parentsig.get_name());
             //logger.info("Parent chain is     " + parentchain.get_name());
             
             JPopupMenu jPopupMenu1 = new JPopupMenu();
             JMenuItem menuAddAlgo = new JMenuItem("Add algorithm");
 
             menuAddAlgo.addActionListener(new ActionListener() {
 
                 public void actionPerformed(ActionEvent e) {
                     SearchDialog dialog = new SearchDialog(new HLTComponent(-1));
                     HLTComponent newalgo = (HLTComponent) dialog.getchild();
                     newalgo.add_gui(pan);
                     
                     newalgo.set_id(-1);
                     //System.out.println("Adding new algo to element " + get_name() + 
                     //                   " and setting id of element, parent sig and parent chain to -1");
                     set_id(-1);
                     getAlgorithms().add(newalgo);
                     
                     pan.repaint();
                 }
             });
             if(get_id()==-1){
                 parentsig.set_id(-1);
                 parentchain.set_id(-1);
                 parentmenu.set_id(-1);
             }
             
             jPopupMenu1.add(menuAddAlgo);
         
             return jPopupMenu1;
         
         }else{
             return null;
         }
     }
 
     ///Calculate the height of this thing on the screen.
     @Override
     protected void calculateHeight() {
         if (expanded) {
             int h = 45;
             h += 5;
             for (HLTComponent comp : getAlgorithms()) {
                 comp.calculateHeight();
                 h += comp.getHeight() + 5;
             }
             h += 5;
             for (HLTTE_TE inputte: getInputElements()) {
                 inputte.calculateHeight();
                 h += inputte.getHeight() + 5;
             }
             setSize(250, h);
         } else {
             setSize(250, 20);
         }
     }
 
     ///Draw this to the screen.
     @Override
     public void paintSquare(Graphics2D g2) {
         calculateHeight();
 
         int iX = (int) getX();
         int iY = (int) getY();
         int iW = (int) getWidth();
 
         setArrow(getLocation()); //< put the arrow in the top left
 
         drawBackground(g2);      //< draw the background and border
 
         drawArrow(g2);           //< draw the expand / retract arrow
 
         nameBtn.draw(g2, iX + 20, iY - 3, iW - 50, 20);
 
         drawCross(g2);           //< draw the cross to remove
 
         showDBInfo(g2);          //< show the db info
 
         drawHighlight(g2);       //< highlight if we did a search
 
         
         if (expanded) {
             g2.setColor(border);
             g2.drawLine(iX, iY + 20, iX + iW, iY + 20);
 
             //draw input elements
             int h = iY + 25;
             for (HLTTE_TE input : getInputElements()) {
                  input.setLocation(iX + 5, h);
                  input.paintSquare(g2);
                  //h += input.getHeight();
                  h += 75;
             }
 
             //draw a string here
             Color keep = g2.getColor();
             g2.setColor(Color.BLACK);
             g2.drawString("ALGORITHMS:", iX+5, h+11);
             g2.setColor(keep);
             
             //draw algorithms
             h += 15;
             for (HLTComponent algorithm : getAlgorithms()) {
                 algorithm.setLocation(iX + 5, h);
                 algorithm.paintSquare(g2);
                 // h += algorithm.getHeight();
                 h += 25;
             }
 
         } else {
             //nothing to do?
         }
 
     }
 
     ///Set this as expanded, short cut from other things.
     public void setExpanded(boolean ex) {
         expanded = ex;
     }
 }

Due to the LXR bug, the updates fail sometimes to remove references to deleted files. The Saturday's full rebuilds fix these problems
This page was automatically generated by the LXR engine.