src/org/gel/mauve/gui/navigation/SearchResultPanel.java

Go to the documentation of this file.

package org.gel.mauve.gui.navigation;

import java.awt.Color;
import java.awt.Component;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.util.Collections;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.StringTokenizer;
import java.util.Vector;

import javax.swing.Icon;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.event.TreeModelListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.plaf.ColorUIResource;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

import org.biojava.bio.Annotation;
import org.biojava.bio.seq.Feature;
import org.biojava.bio.symbol.Location;
import org.gel.mauve.Genome;
import org.gel.mauve.MauveConstants;
import org.gel.mauve.SeqFeatureData;
import org.gel.mauve.gui.SequenceNavigator;

public class SearchResultPanel extends JPanel implements TreeModel,
                TreeCellRenderer, TreeSelectionListener, MauveConstants {

        protected JTree tree;

        protected DefaultTreeModel model;

        protected DefaultTreeCellRenderer renderer;

        protected SequenceNavigator navigator;

        protected DefaultMutableTreeNode root;

        protected JScrollPane scroller;

        protected int result_state;

        protected boolean searching;

        public static final String NO_RESULTS = "No results to display. . .";

        public static final String MATCHLESS = "No features found. . .";
        
        protected static final String SEARCHING = "Searching. . .";

        protected static final String ROOT = "Root";

        public static final Icon PLUS_ICON = SignedIcon.getSignedIcon (true);

        public static final Icon MINUS_ICON = SignedIcon.getSignedIcon (false);

        protected Hashtable genome_data;

        protected Object [] genome_indexes;

        public SearchResultPanel (Vector genomes, SequenceNavigator nav) {
                super (new FlowLayout (FlowLayout.LEFT));
                navigator = nav;
                genome_data = new Hashtable ();
                genome_indexes = new Object [genomes.size ()];
                for (int i = 0; i < genomes.size (); i++) {
                        genome_data.put (genomes.get (i), new LinkedList ());
                        genome_indexes[i] = genomes.get (i);
                }
                initGUI ();
        }

        protected void initGUI () {
                UIManager.put ("Tree.hash", new ColorUIResource (Color.BLACK));
                tree = new JTree ();
                tree.setRootVisible (false);
                tree.setBackground (navigator.getBackground ());
                tree.getSelectionModel ().setSelectionMode (
                                TreeSelectionModel.SINGLE_TREE_SELECTION);
                model = (DefaultTreeModel) tree.getModel ();
                renderer = (DefaultTreeCellRenderer) tree.getCellRenderer ();
                renderer.setBackgroundNonSelectionColor (navigator.getBackground ());
                renderer.setClosedIcon (PLUS_ICON);
                renderer.setOpenIcon (MINUS_ICON);
                renderer.setLeafIcon (null);
                tree.setCellRenderer (this);
                tree.setModel (this);
                tree.setEditable (false);
                tree.addTreeSelectionListener (this);
                tree.setToggleClickCount (1);
                root = new DefaultMutableTreeNode (ROOT);
                add (tree);
                scroller = new JScrollPane (this);
                scroller.getVerticalScrollBar ().setUnitIncrement (
                                renderer.getPreferredSize ().height);
        }

        public JScrollPane getScrollPane () {
                return scroller;
        }

        public void displayFeatures (Object [] data) {
                resetData (data);
                int prev_result = result_state;
                Object [] first = new Object [3];
                for (int i = 0; i < genome_indexes.length; i++) {
                        LinkedList list = (LinkedList) genome_data.get (genome_indexes[i]);
                        if (result_state == 0 && list.size () > 0) {
                                first[2] = (Feature) list.get (0);
                                first[1] = genome_indexes[i];
                                first[0] = ROOT;
                        }
                        result_state += list.size ();
                        if (result_state > 1)
                                break;
                }
                searching = false;
                model.nodeStructureChanged (root);
                Object [] path = new Object [(result_state == 0) ? 1 : 2];
                path[0] = ROOT;
                if (result_state > 0) {
                        for (int i = 0; i < getChildCount (ROOT); i++) {
                                Object kid = getChild (ROOT, i);
                                path[1] = kid;
                                tree.expandPath (new TreePath (path));
                        }
                        if (prev_result == 0)
                                tree.setSelectionPath (new TreePath (first));
                } else {
                        tree.expandPath (new TreePath (path));
                        try {
                                Thread.currentThread ().wait (100);
                        } catch (Exception e) {
                                // ok probably. . .
                        }
                }
                navigator.reloadGUI ();
        }

        public void waitForResults () {
                searching = true;
                                SwingUtilities.invokeLater(new Runnable(){
                        public void run(){
                                model.nodeStructureChanged (root);
                        }
                });
        }

        protected void resetData (Object [] data) {
                Enumeration keys = null;
                if (result_state != 0 && navigator.shouldClear ()) {
                        keys = genome_data.keys ();
                        while (keys.hasMoreElements ()) {
                                LinkedList remove = (LinkedList) genome_data.get (keys
                                                .nextElement ());
                                remove.clear ();
                        }
                        result_state = 0;
                }
                for (int i = 0; i < data.length; i++) {
                        LinkedList new_data = (LinkedList) data[i];
                        Object key = new_data.remove (0);
                        LinkedList old = (LinkedList) genome_data.get (key);
                        old.addAll (new_data);
                        SeqFeatureData.removeLocationDuplicates (old);
                }
        }

        public static String getDisplayText (Feature feat) {
                String data = "";
                Annotation note = feat.getAnnotation ();
                StringTokenizer fields = SeqFeatureData.separateFields (LOC_NAME);
                while (fields.hasMoreTokens () && data.length () == 0) {
                        String field = fields.nextToken ();
                        if (note.containsProperty (field))
                                data += (String) note.getProperty (field);
                }
                Location loci = feat.getLocation ();
                data += " (" + loci.getMin () + "-" + loci.getMax () + ")";
                data.trim ();
                return data;
        }

        public void valueChanged (TreeSelectionEvent event) {
                if (event.getNewLeadSelectionPath () != null) {
                        Object [] path = event.getNewLeadSelectionPath ().getPath ();
                        if (path != null && path.length == 3 && path[2] != MATCHLESS)
                                navigator.displayFeature ((Feature) path[2], (Genome) path[1]);
                }
        }

        public Component getTreeCellRendererComponent (JTree tree, Object val,
                        boolean selected, boolean expanded, boolean leaf, int row,
                        boolean focus) {
                JLabel label = (JLabel) renderer.getTreeCellRendererComponent (tree,
                                val, selected, expanded, leaf, row, focus);
                if (val instanceof Feature)
                        label.setText (getDisplayText ((Feature) val));
                return label;
        }

        public void addTreeModelListener (TreeModelListener listen) {
                model.addTreeModelListener (listen);
        }

        public Object getChild (Object parent, int index) {
                if (parent == ROOT) {
                        if (searching)
                                return SEARCHING;
                        else if (result_state == 0)
                                return NO_RESULTS;
                        else
                                return genome_indexes[index];
                }
                LinkedList children = (LinkedList) genome_data.get (parent);
                if (children != null) {
                        try {
                                return children.get (index);
                        } catch (IndexOutOfBoundsException e) {
                                return MATCHLESS;
                        }
                } else
                        return null;

        }

        public int getChildCount (Object parent) {
                if (parent == ROOT) {
                        if (searching || result_state == 0)
                                return 1;
                        else
                                return genome_data.size ();
                }
                LinkedList children = (LinkedList) genome_data.get (parent);
                if (children != null) {
                        int size = ((LinkedList) genome_data.get (parent)).size ();
                        if (size == 0)
                                return 1;
                        else
                                return size;
                } else
                        return 0;
        }

        public int getIndexOfChild (Object parent, Object child) {
                if (parent == ROOT) {
                        if (child == SEARCHING) {
                                if (searching)
                                        return 0;
                                else
                                        return -1;
                        }
                        if (child == NO_RESULTS) {
                                if (result_state == 0)
                                        return 0;
                                else
                                        return -1;
                        } else {
                                for (int i = 0; i < genome_indexes.length; i++) {
                                        if (genome_indexes[i].equals (child))
                                                return i;
                                }
                        }
                } else if (child == MATCHLESS)
                        return 0;
                else if (genome_data.contains (parent)) {
                        LinkedList kids = (LinkedList) genome_data.get (parent);
                        return kids.indexOf (child);
                }
                return -1;
        }

        public Object getRoot () {
                return ROOT;
        }

        public boolean isLeaf (Object node) {
                if (node != ROOT && !genome_data.containsKey (node))
                        return true;
                else
                        return false;
        }

        public void removeTreeModelListener (TreeModelListener list) {
                model.removeTreeModelListener (list);
        }

        public void valueForPathChanged (TreePath path, Object val) {
                model.valueForPathChanged (path, val);
        }

        public static class SignedIcon implements Icon {

                private boolean plus;

                private static SignedIcon PLUS = new SignedIcon (true);

                private static SignedIcon MINUS = new SignedIcon (false);

                private SignedIcon (boolean p) {
                        plus = p;
                }

                public static SignedIcon getSignedIcon (boolean plus) {
                        return plus ? PLUS : MINUS;
                }

                public int getIconHeight () {
                        return 16;
                }

                public int getIconWidth () {
                        return 16;
                }

                public void paintIcon (Component comp, Graphics g, int x, int y) {
                        g.drawRect (3, 3, 8, 8);
                        g.drawLine (5, 7, 9, 7);
                        if (plus)
                                g.drawLine (7, 5, 7, 9);
                }

        }
}

---