src/org/gel/mauve/BaseViewerModel.java

Go to the documentation of this file.

package org.gel.mauve;

import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;

import javax.swing.event.EventListenerList;

import org.gel.mauve.contigs.DefaultContigHandler;

public class BaseViewerModel {
        // Genomes, stored in the order in which they are being viewed.
        protected Genome [] genomes;

        // Genomes, stored in the order in which they appear in the source file.
        private Genome [] sourceGenomes;

        // Current viewer mode.
        private ViewerMode mode = ViewerMode.NORMAL;

        // Listeners for changes to model, and event to use.
        protected EventListenerList listenerList = new EventListenerList ();

        protected ModelEvent modelEvent = new ModelEvent (this);

        // Length of longest genome.
        private long longestRange = -1;

        // Color scheme to be used.
        private ColorScheme colorScheme;

        // Set of matches.
        private Vector matchVector = new Vector ();

        // The list of boxes to highlight
        private LinkedList highBoxes = new LinkedList ();

        // The reference genome, for displaying reversals.
        private Genome referenceGenome;

        // The highlighted genome.
        private Genome highlightGenome;

        // The sequence coordinate for the current highlight.
        private long highlightCoordinate;

        // Whether to draw matches.
        private boolean drawMatches = true;

        // Whether to draw contig/chromosome boundary lines.
        private boolean drawChromosomeBoundaries = true;

        // Whether or not to draw the mouse cursor
        private boolean drawMouseHighlighting = true;
        
        // Original source file for this model.
        private File src;

        // Original source url for this model, if applicable.
        private URL sourceURL = null;

        // The genome in which a range of sequence has been highlighted
        private Genome rangeHighlightGenome = null;

        // the left end of the highlight range
        private long rangeHighlightLeft = -1;

        // the right end of the highlight range
        private long rangeHighlightRight = -1;
        
        //changes coordinates to and from contig to pseudogene system
        protected DefaultContigHandler contig_handler;

        public BaseViewerModel (File src) {
                this.src = src;
                contig_handler = new DefaultContigHandler (this);
        }

        public File getSrc () {
                return src;
        }

        public void setSourceURL (URL url) {
                this.sourceURL = url;
        }

        public URL getSourceURL () {
                return sourceURL;
        }

        public void setSequenceCount (int sequenceCount) {
                // NEWTODO Make the list of genomes simply a list
                genomes = new Genome [sequenceCount];
                sourceGenomes = new Genome [sequenceCount];
        }

        public int getSequenceCount () {
                return genomes.length;
        }

        public Genome getGenomeByViewingIndex (int viewIndex) {
                return genomes[viewIndex];
        }

        public Genome getGenomeBySourceIndex (int sourceIndex) {
                return sourceGenomes[sourceIndex];
        }

        public Vector<Genome> getGenomes () {
                Vector ret = new Vector ();
                for (int i = 0; i < genomes.length; i++)
                        ret.add (genomes[i]);
                return ret;
        }
        
        public int numGenomes(){
                return genomes.length;
        }

        public void setGenome (int viewIndex, Genome g) {
                genomes[viewIndex] = g;
                g.setViewIndex (viewIndex);

                sourceGenomes[g.getSourceIndex ()] = g;

                // Update longest range.
                if (longestRange < g.getLength ()) {
                        longestRange = g.getLength ();
                }

                // Set lengths.
                for (int i = 0; i < genomes.length; i++) {
                        Genome genome = genomes[i];
                        if (genome != null) {
                                genome.setViewLength (longestRange);
                        }
                }
        }

        public int getMatchCount () {
                return matchVector.size ();
        }

        public Match getMatch (int index) {
                return (Match) matchVector.elementAt (index);
        }

        public Vector sortedMatches (Comparator c) {
                Vector sorted = (Vector) matchVector.clone ();
                if (c != null)
                        Collections.sort (sorted, c);
                return sorted;
        }

        public void addMatch (Match m) {
                matchVector.add (m);
        }

        public void setColorScheme (ColorScheme colorScheme) {
                if (!colorScheme.equals (this.colorScheme)) {
                        this.colorScheme = colorScheme;
                        colorScheme.apply (this);

                        fireColorEvent ();
                }
        }

        public ColorScheme getColorScheme () {
                return colorScheme;
        }

        public void addModelListener (ModelListener l) {
                listenerList.add (ModelListener.class, l);
        }

        public void removeModelListener (ModelListener l) {
                listenerList.remove (ModelListener.class, l);
        }

        public void addHighlightListener (HighlightListener l) {
                listenerList.add (HighlightListener.class, l);
        }

        public void removeHighlightListener (HighlightListener l) {
                listenerList.remove (HighlightListener.class, l);
        }

        protected void fireHighlightEvent () {
                Object [] listeners = listenerList.getListenerList ();
                for (int i = listeners.length - 2; i >= 0; i -= 2) {
                        if (listeners[i] == HighlightListener.class) {
                                ((HighlightListener) listeners[i + 1])
                                                .highlightChanged (modelEvent);
                        }
                }
        }

        protected void fireColorEvent () {
                Object [] listeners = listenerList.getListenerList ();
                for (int i = listeners.length - 2; i >= 0; i -= 2) {
                        if (listeners[i] == ModelListener.class) {
                                ((ModelListener) listeners[i + 1]).colorChanged (modelEvent);
                        }
                }
        }

        protected void fireWeightEvent () {
                Object [] listeners = listenerList.getListenerList ();
                for (int i = listeners.length - 2; i >= 0; i -= 2) {
                        if (listeners[i] == ModelListener.class) {
                                ((ModelListener) listeners[i + 1]).weightChanged (modelEvent);
                        }
                }
        }

        protected void fireDrawingSettingsEvent () {
                Object [] listeners = listenerList.getListenerList ();
                for (int i = listeners.length - 2; i >= 0; i -= 2) {
                        if (listeners[i] == ModelListener.class) {
                                ((ModelListener) listeners[i + 1])
                                                .drawingSettingsChanged (modelEvent);
                        }
                }
        }

        protected void fireModeEvent () {
                Object [] listeners = listenerList.getListenerList ();
                for (int i = listeners.length - 2; i >= 0; i -= 2) {
                        if (listeners[i] == ModelListener.class) {
                                ((ModelListener) listeners[i + 1]).modeChanged (modelEvent);
                        }
                }
        }

        public void firePrintingStartEvent() {
                Object [] listeners = listenerList.getListenerList ();
                for (int i = listeners.length - 2; i >= 0; i -= 2) {
                        if (listeners[i] == ModelListener.class) {
                                ((ModelListener) listeners[i + 1])
                                                .printingStart (modelEvent);
                        }
                }
        }

        public void firePrintingEndEvent() {
                Object [] listeners = listenerList.getListenerList ();
                for (int i = listeners.length - 2; i >= 0; i -= 2) {
                        if (listeners[i] == ModelListener.class) {
                                ((ModelListener) listeners[i + 1])
                                                .printingEnd (modelEvent);
                        }
                }
        }

        public void fireViewableRangeEvent () {
                Object [] listeners = listenerList.getListenerList ();
                for (int i = listeners.length - 2; i >= 0; i -= 2) {
                        if (listeners[i] == ModelListener.class) {
                                ((ModelListener) listeners[i + 1])
                                                .viewableRangeChanged (modelEvent);
                        }
                }
        }

        protected void fireViewableRangeStartEvent () {
                Object [] listeners = listenerList.getListenerList ();
                for (int i = listeners.length - 2; i >= 0; i -= 2) {
                        if (listeners[i] == ModelListener.class) {
                                ((ModelListener) listeners[i + 1])
                                                .viewableRangeChangeStart (modelEvent);
                        }
                }
        }

        protected void fireViewableRangeEndEvent () {
                Object [] listeners = listenerList.getListenerList ();
                for (int i = listeners.length - 2; i >= 0; i -= 2) {
                        if (listeners[i] == ModelListener.class) {
                                ((ModelListener) listeners[i + 1])
                                                .viewableRangeChangeEnd (modelEvent);
                        }
                }
        }

        protected void fireReorderGenomeEvent () {
                Object [] listeners = listenerList.getListenerList ();
                for (int i = listeners.length - 2; i >= 0; i -= 2) {
                        if (listeners[i] == ModelListener.class) {
                                ((ModelListener) listeners[i + 1])
                                                .genomesReordered (modelEvent);
                        }
                }
        }

        protected void fireReferenceChangedEvent () {
                Object [] listeners = listenerList.getListenerList ();
                for (int i = listeners.length - 2; i >= 0; i -= 2) {
                        if (listeners[i] == ModelListener.class) {
                                ((ModelListener) listeners[i + 1])
                                                .referenceChanged (modelEvent);
                        }
                }
        }

        public ViewerMode getMode () {
                return mode;
        }

        public void setMode (ViewerMode mode) {
                if (this.mode != mode) {
                        this.mode = mode;
                        fireModeEvent ();
                }
        }

        public void reorderSequences (int [] new_order) {
                // Reorder genomes
                Genome [] newGenomes = new Genome [genomes.length];
                for (int seqI = 0; seqI < genomes.length; seqI++) {
                        newGenomes[seqI] = genomes[new_order[seqI]];
                        newGenomes[seqI].setViewIndex (seqI);
                }
                genomes = newGenomes;

                fireReorderGenomeEvent ();
        }

        public void setReference (Genome g) {
                referenceGenome = g;
                referenceUpdated ();
                fireReferenceChangedEvent ();
        }

        public Genome getReference () {
                return referenceGenome;
        }

        protected void referenceUpdated () {
                // Hook for subclasses.
        }

    public void setVisible(Genome g, boolean visible)
    {
        if(g.getVisible() != visible )
        {
                g.setVisible(visible);
                fireGenomeVisibilityChangedEvent();
        }
    }
    
    public void fireGenomeVisibilityChangedEvent()
    {
        Object[] listeners = listenerList.getListenerList();
        for (int i = listeners.length-2; i>=0; i-=2) {
            if (listeners[i]==ModelListener.class) {
                ((ModelListener)listeners[i+1]).genomeVisibilityChanged(modelEvent);
            }
        }
    }

        private void correctMatchReversals () {
                // Correct the orientation due to reversals.
                for (int matchI = 0; matchI < getMatchCount (); matchI++) {
                        Match m = getMatch (matchI);

                        // Find the first genome with something to show for each match
                        // and make that the reference orientation.
                        for (int seqI = 0; seqI < genomes.length; seqI++) {
                                Genome g = getGenomeByViewingIndex (seqI);

                                if (m.getStart (g) != 0) {
                                        if (m.getReverse (g)) {
                                                for (int seqJ = seqI; seqJ < genomes.length; seqJ++) {
                                                        Genome g2 = getGenomeByViewingIndex (seqJ);
                                                        m.setReverse (g2, !m.getReverse (g2));
                                                }
                                        }
                                        break;
                                }
                        }
                }
        }

        public void getMatchRange (Genome g, long start_coord, long end_coord,
                        int [] match_range) {
                Vector sortedMatches = g.getSortedMatches ();

                if (sortedMatches.size () == 0) {
                        match_range[0] = -1;
                        match_range[1] = -1;
                        return;
                }

                MatchStartComparator matchComparator = new MatchStartComparator (g);
                Match f_match = new Match ((Match) sortedMatches.get (0));

                f_match.setStart (g, start_coord);
                if (f_match.getStart (g) < 1)
                        f_match.setStart (g, 1);

                int match_startI = Collections.binarySearch (sortedMatches, f_match,
                                matchComparator);
                match_startI = match_startI >= 0 ? match_startI : -match_startI - 1;

                f_match.setStart (g, end_coord + 1);
                int match_endI = Collections.binarySearch (sortedMatches, f_match,
                                matchComparator);
                match_endI = match_endI >= 0 ? match_endI : -match_endI - 1;

                // now look backwards 1 match for an intersection
                if (match_startI > 0) {
                        Match prev_match = (Match) sortedMatches.get (match_startI - 1);

                        if (prev_match.getStart (g) + prev_match.getLength (g) > start_coord
                                        && prev_match.getStart (g) != Match.NO_MATCH)
                                match_startI--;
                }
                match_range[0] = match_startI;
                match_range[1] = match_endI;
        }

        public void addMatchHighlight (Match highlighted_box) {
                ListIterator high_iter = highBoxes.listIterator ();
                while (high_iter.hasNext ()) {
                        if (high_iter.next () == highlighted_box) {
                                return;
                        }
                }
                highlighted_box.highlighted = true;
                highBoxes.addLast (highlighted_box);

                fireHighlightEvent ();
        }

        public Match lastMatchHighlight () {
                if (highBoxes.isEmpty ())
                        return null;

                return (Match) highBoxes.getLast ();

        }

        public void clearMatchHighlights () {
                ListIterator high_iter = highBoxes.listIterator ();
                while (high_iter.hasNext ()) {
                        Match next_box = (Match) high_iter.next ();
                        next_box.highlighted = false;
                }
                highBoxes.clear ();

                fireHighlightEvent ();
        }

        public long getHighlightCoordinate () {
                return highlightCoordinate;
        }

        public Genome getHighlightGenome () {
                return highlightGenome;
        }

        public long getRangeHighlightLeft () {
                return rangeHighlightLeft;
        }

        public long getRangeHighlightRight () {
                return rangeHighlightRight;
        }

        public Genome getRangeHighlightGenome () {
                return rangeHighlightGenome;
        }

        public void updateHighlight (Genome g, long coordinate) {
                highlightGenome = g;
                highlightCoordinate = coordinate;
                fireHighlightEvent ();
        }

        public void setDrawMatches (boolean value) {
                if (value != drawMatches) {
                        this.drawMatches = value;
                        this.fireDrawingSettingsEvent ();
                }
        }

        public boolean getDrawMatches () {
                return drawMatches;
        }

        public void setDrawChromosomeBoundaries (boolean value) {
                if (value != drawChromosomeBoundaries) {
                        this.drawChromosomeBoundaries = value;
                        this.fireDrawingSettingsEvent ();
                }
        }

        public boolean getDrawChromosomeBoundaries () {
                return drawChromosomeBoundaries;
        }

        public void setDrawMouseCursor (boolean value) {
                if (value != drawMouseHighlighting) {
                        this.drawMouseHighlighting = value;
                        this.fireDrawingSettingsEvent ();
                }
        }

        public boolean getDrawMouseHighlighting () {
                return drawMouseHighlighting;
        }

        public void setFocus (String sequenceID, long start, long end, String contig) {
                Genome g = null;
                for (int i = 0; i < genomes.length; i++) {
                        if (sequenceID.equals (genomes[i].getID ())) {
                                g = genomes[i];
                                break;
                        }
                }
                if (g == null) {
                        System.err
                                        .println ("Received focus request for nonexistent sequence id "
                                                        + sequenceID);
                        return;
                }
                if (contig != null) {
                        start = contig_handler.getPseudoCoord(g.getSourceIndex(), start, contig);
                        end = contig_handler.getPseudoCoord(g.getSourceIndex(), end, contig);
                }
                long len = (end - start) * 5;
                int zoom = (int) (100 * g.getViewLength () / (double) len);
                long center = start + ((end - start) / 2);
                zoomAndCenter (g, zoom, center);
                // highlight this part of the display
                highlightRange (g, start, end);
        }

        public void alignView (long [] align_coords, Genome selected) {
                fireViewableRangeStartEvent ();

                // adjust everything to the same zoom level as the selected sequence

                long start_offset = align_coords[selected.getSourceIndex ()]
                                - selected.getViewStart ();
                for (int seqI = 0; seqI < getSequenceCount (); seqI++) {
                        if (seqI != selected.getSourceIndex ()
                                        && align_coords[seqI] != Match.NO_MATCH) {
                                Genome g = getGenomeBySourceIndex (seqI);
                                g.setViewStart (align_coords[seqI] - start_offset);
                                g.setViewLength (selected.getViewLength ());
                        }
                }
                fireViewableRangeEvent ();

                fireViewableRangeEndEvent ();
        }

        public void alignView (Match align_match, Genome g) {
                long [] align_coords = new long [getSequenceCount ()];

                for (int i = 0; i < getSequenceCount (); i++) {
                        align_coords[i] = align_match.getStart (getGenomeBySourceIndex (i));
                }

                alignView (align_coords, g);
        }

        public void zoomAndMove (int zoom_percent, int move_percent) {
                for (int i = 0; i < genomes.length; i++) {
                        zoomAndMove (genomes[i], zoom_percent, move_percent);
                }
        }

        public void zoomAndMove (int zoom_percent, long offset) {
                for (int i = 0; i < genomes.length; i++) {
                        zoomAndMove (genomes[i], zoom_percent, offset);
                }
        }

        public void zoomAndMove (Genome g, int zoom_percent, int move_percent) {

                if (move_percent != 0) {
                        double move = ((double) g.getViewLength ()) * (move_percent / 100d);
                        if (Math.abs (move) < 1) {
                                move = (move < 0) ? -1 : 1;
                        }
                        zoomAndMove (g, zoom_percent, (long) move);
                } else {
                        zoomAndMove (g, zoom_percent, 0L);
                }
        }

        private void zoomAndMove (Genome g, int zoom_percent, long offset) {
                fireViewableRangeStartEvent ();

                // move before zooming so that we end up on the right coordinates!
                if (offset != 0) {
                        // calculate the new viewable coordinates.
                        long new_view_start = g.getViewStart () + offset;

                        // don't let the sequence get completely out of range
                        if (new_view_start + g.getViewLength () < 1) {
                                new_view_start = 1 - g.getViewLength ();
                        } else if (new_view_start > g.getLength ()) {
                                new_view_start = g.getLength ();
                        }
                        g.setViewStart (new_view_start);
                }

                if (zoom_percent == 0) {
                        // zoom all the way out.
                        g.setViewStart (1);
                        g.setViewLength (longestRange);
                } else if (zoom_percent != 100) {
                        // calculate the new viewable coordinates.
                        long new_view_length = (long) ((100d * g.getViewLength ()) / zoom_percent);
                        // don't let the view length get too big or small
                        if (new_view_length < 5)
                                new_view_length = 5;
                        if (new_view_length > longestRange)
                                new_view_length = longestRange;

                        long new_view_start = g.getViewStart ()
                                        + ((g.getViewLength () - new_view_length) / 2);

                        // don't let the sequence get completely out of range
                        if (new_view_start + new_view_length < 1)
                                new_view_start = 1 - g.getViewLength ();
                        else if (new_view_start > g.getLength ())
                                new_view_start = g.getLength ();

                        g.setViewStart (new_view_start);
                        g.setViewLength (new_view_length);
                }

                fireViewableRangeEvent ();

                fireViewableRangeEndEvent ();
        }

        public void zoomAndCenter (Genome g, int zoom_percent, long coord) {
                long offset = coord - (g.getViewStart () + (g.getViewLength () / 2));
                zoomAndMove (zoom_percent, offset);
        }

        public void highlightRange (Genome g, long left_end, long right_end) {
                rangeHighlightGenome = g;
                rangeHighlightLeft = left_end;
                rangeHighlightRight = right_end;
                fireHighlightEvent ();
        }

        private HashMap<Genome,List> attributes = new HashMap<Genome,List>();
        public void addGenomeAttribute(Genome g, Object o){
                List l = attributes.get(g);
                if(l==null){
                        l = new ArrayList();
                        attributes.put(g,l);
                }
                l.add(o);
                fireAttributesEvent();
        }
        public List getGenomeAttributes(Genome g){
                return attributes.get(g);
        }
        boolean drawAttributes = false;
        public boolean getDrawAttributes() {
                return drawAttributes;
        }
        public void setDrawAttributes(boolean drawAttributes) {
                this.drawAttributes = drawAttributes;
                fireAttributesEvent();
        }

        protected void fireAttributesEvent () {
                Object [] listeners = listenerList.getListenerList ();
                for (int i = listeners.length - 2; i >= 0; i -= 2) {
                        if (listeners[i] == ModelListener.class) {
                                ((ModelListener) listeners[i + 1]).attributesChanged (modelEvent);
                        }
                }
        }

}

---