import jalview.datamodel.CigarArray;
import jalview.datamodel.ColumnSelection;
import jalview.datamodel.HiddenSequences;
-import jalview.datamodel.SearchResults;
+import jalview.datamodel.ProfilesI;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
-import jalview.schemes.Blosum62ColourScheme;
+import jalview.renderer.ResidueShader;
+import jalview.renderer.ResidueShaderI;
import jalview.schemes.ColourSchemeI;
-import jalview.schemes.PIDColourScheme;
-import jalview.schemes.ResidueProperties;
import jalview.structure.CommandListener;
import jalview.structure.StructureSelectionManager;
import jalview.structure.VamsasSource;
import jalview.util.Comparison;
+import jalview.util.MapList;
import jalview.util.MappingUtils;
import jalview.viewmodel.styles.ViewStyle;
import jalview.workers.AlignCalcManager;
import jalview.workers.StrucConsensusThread;
import java.awt.Color;
+import java.beans.PropertyChangeSupport;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
-import java.util.Set;
/**
* base class holding visualization and analysis attributes and common logic for
public abstract class AlignmentViewport implements AlignViewportI,
CommandListener, VamsasSource
{
+ protected ViewportPositionProps posProps;
+
protected ViewStyleI viewStyle = new ViewStyle();
/**
* @param name
* @see jalview.api.ViewStyleI#setFontName(java.lang.String)
*/
+ @Override
public void setFontName(String name)
{
viewStyle.setFontName(name);
* @param style
* @see jalview.api.ViewStyleI#setFontStyle(int)
*/
+ @Override
public void setFontStyle(int style)
{
viewStyle.setFontStyle(style);
* @param size
* @see jalview.api.ViewStyleI#setFontSize(int)
*/
+ @Override
public void setFontSize(int size)
{
viewStyle.setFontSize(size);
* @return
* @see jalview.api.ViewStyleI#getFontStyle()
*/
+ @Override
public int getFontStyle()
{
return viewStyle.getFontStyle();
* @return
* @see jalview.api.ViewStyleI#getFontName()
*/
+ @Override
public String getFontName()
{
return viewStyle.getFontName();
* @return
* @see jalview.api.ViewStyleI#getFontSize()
*/
+ @Override
public int getFontSize()
{
return viewStyle.getFontSize();
* @param upperCasebold
* @see jalview.api.ViewStyleI#setUpperCasebold(boolean)
*/
+ @Override
public void setUpperCasebold(boolean upperCasebold)
{
viewStyle.setUpperCasebold(upperCasebold);
* @return
* @see jalview.api.ViewStyleI#isUpperCasebold()
*/
+ @Override
public boolean isUpperCasebold()
{
return viewStyle.isUpperCasebold();
* @return
* @see jalview.api.ViewStyleI#isSeqNameItalics()
*/
+ @Override
public boolean isSeqNameItalics()
{
return viewStyle.isSeqNameItalics();
* @param colourByReferenceSeq
* @see jalview.api.ViewStyleI#setColourByReferenceSeq(boolean)
*/
+ @Override
public void setColourByReferenceSeq(boolean colourByReferenceSeq)
{
viewStyle.setColourByReferenceSeq(colourByReferenceSeq);
* @param b
* @see jalview.api.ViewStyleI#setColourAppliesToAllGroups(boolean)
*/
+ @Override
public void setColourAppliesToAllGroups(boolean b)
{
viewStyle.setColourAppliesToAllGroups(b);
* @return
* @see jalview.api.ViewStyleI#getColourAppliesToAllGroups()
*/
+ @Override
public boolean getColourAppliesToAllGroups()
{
return viewStyle.getColourAppliesToAllGroups();
* @return
* @see jalview.api.ViewStyleI#getAbovePIDThreshold()
*/
+ @Override
public boolean getAbovePIDThreshold()
{
return viewStyle.getAbovePIDThreshold();
* @param inc
* @see jalview.api.ViewStyleI#setIncrement(int)
*/
+ @Override
public void setIncrement(int inc)
{
viewStyle.setIncrement(inc);
* @return
* @see jalview.api.ViewStyleI#getIncrement()
*/
+ @Override
public int getIncrement()
{
return viewStyle.getIncrement();
* @param b
* @see jalview.api.ViewStyleI#setConservationSelected(boolean)
*/
+ @Override
public void setConservationSelected(boolean b)
{
viewStyle.setConservationSelected(b);
* @param show
* @see jalview.api.ViewStyleI#setShowHiddenMarkers(boolean)
*/
+ @Override
public void setShowHiddenMarkers(boolean show)
{
viewStyle.setShowHiddenMarkers(show);
* @return
* @see jalview.api.ViewStyleI#getShowHiddenMarkers()
*/
+ @Override
public boolean getShowHiddenMarkers()
{
return viewStyle.getShowHiddenMarkers();
* @param b
* @see jalview.api.ViewStyleI#setScaleRightWrapped(boolean)
*/
+ @Override
public void setScaleRightWrapped(boolean b)
{
viewStyle.setScaleRightWrapped(b);
* @param b
* @see jalview.api.ViewStyleI#setScaleLeftWrapped(boolean)
*/
+ @Override
public void setScaleLeftWrapped(boolean b)
{
viewStyle.setScaleLeftWrapped(b);
* @param b
* @see jalview.api.ViewStyleI#setScaleAboveWrapped(boolean)
*/
+ @Override
public void setScaleAboveWrapped(boolean b)
{
viewStyle.setScaleAboveWrapped(b);
* @return
* @see jalview.api.ViewStyleI#getScaleLeftWrapped()
*/
+ @Override
public boolean getScaleLeftWrapped()
{
return viewStyle.getScaleLeftWrapped();
* @return
* @see jalview.api.ViewStyleI#getScaleAboveWrapped()
*/
+ @Override
public boolean getScaleAboveWrapped()
{
return viewStyle.getScaleAboveWrapped();
* @return
* @see jalview.api.ViewStyleI#getScaleRightWrapped()
*/
+ @Override
public boolean getScaleRightWrapped()
{
return viewStyle.getScaleRightWrapped();
* @param b
* @see jalview.api.ViewStyleI#setAbovePIDThreshold(boolean)
*/
+ @Override
public void setAbovePIDThreshold(boolean b)
{
viewStyle.setAbovePIDThreshold(b);
* @param thresh
* @see jalview.api.ViewStyleI#setThreshold(int)
*/
+ @Override
public void setThreshold(int thresh)
{
viewStyle.setThreshold(thresh);
* @return
* @see jalview.api.ViewStyleI#getThreshold()
*/
+ @Override
public int getThreshold()
{
return viewStyle.getThreshold();
* @return
* @see jalview.api.ViewStyleI#getShowJVSuffix()
*/
+ @Override
public boolean getShowJVSuffix()
{
return viewStyle.getShowJVSuffix();
* @param b
* @see jalview.api.ViewStyleI#setShowJVSuffix(boolean)
*/
+ @Override
public void setShowJVSuffix(boolean b)
{
viewStyle.setShowJVSuffix(b);
* @param state
* @see jalview.api.ViewStyleI#setWrapAlignment(boolean)
*/
+ @Override
public void setWrapAlignment(boolean state)
{
viewStyle.setWrapAlignment(state);
* @param state
* @see jalview.api.ViewStyleI#setShowText(boolean)
*/
+ @Override
public void setShowText(boolean state)
{
viewStyle.setShowText(state);
* @param state
* @see jalview.api.ViewStyleI#setRenderGaps(boolean)
*/
+ @Override
public void setRenderGaps(boolean state)
{
viewStyle.setRenderGaps(state);
* @return
* @see jalview.api.ViewStyleI#getColourText()
*/
+ @Override
public boolean getColourText()
{
return viewStyle.getColourText();
* @param state
* @see jalview.api.ViewStyleI#setColourText(boolean)
*/
+ @Override
public void setColourText(boolean state)
{
viewStyle.setColourText(state);
* @return
* @see jalview.api.ViewStyleI#getWrapAlignment()
*/
+ @Override
public boolean getWrapAlignment()
{
return viewStyle.getWrapAlignment();
* @return
* @see jalview.api.ViewStyleI#getShowText()
*/
+ @Override
public boolean getShowText()
{
return viewStyle.getShowText();
* @return
* @see jalview.api.ViewStyleI#getWrappedWidth()
*/
+ @Override
public int getWrappedWidth()
{
return viewStyle.getWrappedWidth();
* @param w
* @see jalview.api.ViewStyleI#setWrappedWidth(int)
*/
+ @Override
public void setWrappedWidth(int w)
{
viewStyle.setWrappedWidth(w);
* @return
* @see jalview.api.ViewStyleI#getCharHeight()
*/
+ @Override
public int getCharHeight()
{
return viewStyle.getCharHeight();
* @param h
* @see jalview.api.ViewStyleI#setCharHeight(int)
*/
+ @Override
public void setCharHeight(int h)
{
viewStyle.setCharHeight(h);
* @return
* @see jalview.api.ViewStyleI#getCharWidth()
*/
+ @Override
public int getCharWidth()
{
return viewStyle.getCharWidth();
* @param w
* @see jalview.api.ViewStyleI#setCharWidth(int)
*/
+ @Override
public void setCharWidth(int w)
{
viewStyle.setCharWidth(w);
* @return
* @see jalview.api.ViewStyleI#getShowBoxes()
*/
+ @Override
public boolean getShowBoxes()
{
return viewStyle.getShowBoxes();
* @return
* @see jalview.api.ViewStyleI#getShowUnconserved()
*/
+ @Override
public boolean getShowUnconserved()
{
return viewStyle.getShowUnconserved();
* @param showunconserved
* @see jalview.api.ViewStyleI#setShowUnconserved(boolean)
*/
+ @Override
public void setShowUnconserved(boolean showunconserved)
{
viewStyle.setShowUnconserved(showunconserved);
* @param default1
* @see jalview.api.ViewStyleI#setSeqNameItalics(boolean)
*/
+ @Override
public void setSeqNameItalics(boolean default1)
{
viewStyle.setSeqNameItalics(default1);
}
- private Map<SequenceI, SequenceCollectionI> hiddenRepSequences;
- protected ColumnSelection colSel = new ColumnSelection();
+ // protected ColumnSelection colSel = new ColumnSelection();
public boolean autoCalculateConsensus = true;
protected boolean ignoreGapsInConsensusCalculation = false;
- protected ColourSchemeI globalColourScheme = null;
-
+ protected ResidueShaderI residueShading;
@Override
public void setGlobalColourScheme(ColourSchemeI cs)
{
// TODO: logic refactored from AlignFrame changeColour -
- // autorecalc stuff should be changed to rely on the worker system
+ // TODO: autorecalc stuff should be changed to rely on the worker system
// check to see if we should implement a changeColour(cs) method rather than
- // put th logic in here
+ // put the logic in here
// - means that caller decides if they want to just modify state and defer
// calculation till later or to do all calculations in thread.
// via changecolour
- globalColourScheme = cs;
- boolean recalc = false;
+
+ /*
+ * only instantiate alignment colouring once, thereafter update it;
+ * this means that any conservation or PID threshold settings
+ * persist when the alignment colour scheme is changed
+ */
+ if (residueShading == null)
+ {
+ residueShading = new ResidueShader(viewStyle);
+ }
+ residueShading.setColourScheme(cs);
+
+ // TODO: do threshold and increment belong in ViewStyle or ResidueShader?
+ // ...problem: groups need these, but do not currently have a ViewStyle
+
if (cs != null)
{
- cs.setConservationApplied(recalc = getConservationSelected());
- if (getAbovePIDThreshold() || cs instanceof PIDColourScheme
- || cs instanceof Blosum62ColourScheme)
- {
- recalc = true;
- cs.setThreshold(viewStyle.getThreshold(),
- ignoreGapsInConsensusCalculation);
- }
- else
- {
- cs.setThreshold(0, ignoreGapsInConsensusCalculation);
- }
- if (recalc)
+ if (getConservationSelected())
{
- cs.setConsensus(hconsensus);
- cs.setConservation(hconservation);
+ residueShading.setConservation(hconservation);
}
- cs.alignmentChanged(alignment, hiddenRepSequences);
+ residueShading.alignmentChanged(alignment, getHiddenRepSequences());
}
+
+ /*
+ * if 'apply colour to all groups' is selected... do so
+ * (but don't transfer any colour threshold settings to groups)
+ */
if (getColourAppliesToAllGroups())
{
for (SequenceGroup sg : getAlignment().getGroups())
{
- if (cs == null)
- {
- sg.cs = null;
- continue;
- }
- sg.cs = cs.applyTo(sg, getHiddenRepSequences());
- sg.setConsPercGaps(ConsPercGaps);
- if (getAbovePIDThreshold() || cs instanceof PIDColourScheme
- || cs instanceof Blosum62ColourScheme)
- {
- sg.cs.setThreshold(viewStyle.getThreshold(),
- isIgnoreGapsConsensus());
- recalc = true;
- }
- else
- {
- sg.cs.setThreshold(0, isIgnoreGapsConsensus());
- }
-
- if (getConservationSelected())
+ /*
+ * retain any colour thresholds per group while
+ * changing choice of colour scheme (JAL-2386)
+ */
+ sg.setColourScheme(cs);
+ if (cs != null)
{
- sg.cs.setConservationApplied(true);
- recalc = true;
- }
- else
- {
- sg.cs.setConservation(null);
- // sg.cs.setThreshold(0, getIgnoreGapsConsensus());
- }
- if (recalc)
- {
- sg.recalcConservation();
- }
- else
- {
- sg.cs.alignmentChanged(sg, hiddenRepSequences);
+ sg.getGroupColourScheme()
+.alignmentChanged(sg,
+ getHiddenRepSequences());
}
}
}
-
}
@Override
public ColourSchemeI getGlobalColourScheme()
{
- return globalColourScheme;
+ return residueShading == null ? null : residueShading
+ .getColourScheme();
+ }
+
+ @Override
+ public ResidueShaderI getResidueShading()
+ {
+ return residueShading;
}
protected AlignmentAnnotation consensus;
/**
* results of alignment consensus analysis for visible portion of view
*/
- protected Hashtable[] hconsensus = null;
+ protected ProfilesI hconsensus = null;
/**
* results of cDNA complement consensus visible portion of view
}
@Override
- public void setSequenceConsensusHash(Hashtable[] hconsensus)
+ public void setSequenceConsensusHash(ProfilesI hconsensus)
{
this.hconsensus = hconsensus;
}
}
@Override
- public Hashtable[] getSequenceConsensusHash()
+ public ProfilesI getSequenceConsensusHash()
{
return hconsensus;
}
public void updateConservation(final AlignmentViewPanel ap)
{
// see note in mantis : issue number 8585
- if (alignment.isNucleotide() || conservation == null
+ if (alignment.isNucleotide()
+ || (conservation == null && quality == null)
|| !autoCalculateConsensus)
{
return;
/*
* A separate thread to compute cDNA consensus for a protein alignment
+ * which has mapping to cDNA
*/
final AlignmentI al = this.getAlignment();
if (!al.isNucleotide() && al.getCodonFrames() != null
&& !al.getCodonFrames().isEmpty())
{
- if (calculator
- .getRegisteredWorkersOfClass(ComplementConsensusThread.class) == null)
+ /*
+ * fudge - check first for protein-to-nucleotide mappings
+ * (we don't want to do this for protein-to-protein)
+ */
+ boolean doConsensus = false;
+ for (AlignedCodonFrame mapping : al.getCodonFrames())
{
- calculator.registerWorker(new ComplementConsensusThread(this, ap));
+ // TODO hold mapping type e.g. dna-to-protein in AlignedCodonFrame?
+ MapList[] mapLists = mapping.getdnaToProt();
+ // mapLists can be empty if project load has not finished resolving seqs
+ if (mapLists.length > 0 && mapLists[0].getFromRatio() == 3)
+ {
+ doConsensus = true;
+ break;
+ }
+ }
+ if (doConsensus)
+ {
+ if (calculator
+ .getRegisteredWorkersOfClass(ComplementConsensusThread.class) == null)
+ {
+ calculator
+ .registerWorker(new ComplementConsensusThread(this, ap));
+ }
}
}
}
return false;
}
+ public void setAlignment(AlignmentI align)
+ {
+ this.alignment = align;
+ }
+
+ /**
+ * Clean up references when this viewport is closed
+ */
+ @Override
+ public void dispose()
+ {
+ /*
+ * defensively null out references to large objects in case
+ * this object is not garbage collected (as if!)
+ */
+ consensus = null;
+ complementConsensus = null;
+ strucConsensus = null;
+ conservation = null;
+ quality = null;
+ groupConsensus = null;
+ groupConservation = null;
+ hconsensus = null;
+ hcomplementConsensus = null;
+ // colour scheme may hold reference to consensus
+ residueShading = null;
+ // TODO remove listeners from changeSupport?
+ changeSupport = null;
+ setAlignment(null);
+ }
+
@Override
public boolean isClosed()
{
*/
public boolean sortByTree = false;
-
/**
*
*
}
/**
- * Set the selection group for this window.
+ * Set the selection group for this window. Also sets the current alignment as
+ * the context for the group, if it does not already have one.
*
* @param sg
* - group holding references to sequences in this alignment view
public void setSelectionGroup(SequenceGroup sg)
{
selectionGroup = sg;
+ if (sg != null && sg.getContext() == null)
+ {
+ sg.setContext(alignment);
+ }
}
public void setHiddenColumns(ColumnSelection colsel)
{
- this.colSel = colsel;
+ posProps.setHiddenColumns(colsel);
+ // this.colSel = colsel;
}
@Override
public ColumnSelection getColumnSelection()
{
- return colSel;
+ return posProps.getColumnSelection();
+ // return colSel;
}
@Override
public void setColumnSelection(ColumnSelection colSel)
{
- this.colSel = colSel;
+ posProps.setColumnSelection(colSel);
+ /*this.colSel = colSel;
if (colSel != null)
{
updateHiddenColumns();
}
+ isColSelChanged(true);*/
}
/**
@Override
public Map<SequenceI, SequenceCollectionI> getHiddenRepSequences()
{
- return hiddenRepSequences;
+ return posProps.getHiddenRepSequences();
}
@Override
public void setHiddenRepSequences(
Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
{
- this.hiddenRepSequences = hiddenRepSequences;
+ posProps.getHiddenRepSequences();
+ }
+
+ @Override
+ public boolean hasSelectedColumns()
+ {
+ ColumnSelection columnSelection = getColumnSelection();
+ return columnSelection != null && columnSelection.hasSelectedColumns();
}
@Override
public boolean hasHiddenColumns()
{
- return colSel != null && colSel.hasHiddenColumns();
+ return posProps.hasHiddenColumns();
+ // return colSel != null && colSel.hasHiddenColumns();
}
public void updateHiddenColumns()
return alignment.getHiddenSequences().getSize() > 0;
}
-
protected SequenceGroup selectionGroup;
public void setSequenceSetId(String newid)
if (ap != null)
{
updateConsensus(ap);
- if (globalColourScheme != null)
+ if (residueShading != null)
{
- globalColourScheme.setThreshold(globalColourScheme.getThreshold(),
+ residueShading.setThreshold(residueShading.getThreshold(),
ignoreGapsInConsensusCalculation);
}
}
}
- private long sgrouphash = -1, colselhash = -1;
+ private long sgrouphash = -1;
/**
* checks current SelectionGroup against record of last hash value, and
*/
public boolean isColSelChanged(boolean b)
{
- int hc = (colSel == null || colSel.size() == 0) ? -1 : colSel
- .hashCode();
+ return posProps.isColSelChanged(b);
+ /*int hc = (colSel == null || colSel.isEmpty()) ? -1 : colSel.hashCode();
if (hc != -1 && hc != colselhash)
{
if (b)
}
return true;
}
- return false;
+ return false;*/
}
@Override
return ignoreGapsInConsensusCalculation;
}
- // / property change stuff
-
+ // property change stuff
// JBPNote Prolly only need this in the applet version.
- private final java.beans.PropertyChangeSupport changeSupport = new java.beans.PropertyChangeSupport(
+ private PropertyChangeSupport changeSupport = new PropertyChangeSupport(
this);
protected boolean showConservation = true;
*/
private boolean followHighlight = true;
- // TODO private with getters and setters?
- public int startRes;
+ /*private int startRes;
- public int endRes;
+ private int endRes;
- public int startSeq;
+ private int startSeq;
- public int endSeq;
+ private int endSeq;*/
/**
* Property change listener for changes in alignment
// common hide/show column stuff
- public void hideSelectedColumns()
- {
- if (colSel.size() < 1)
- {
- return;
- }
-
- colSel.hideSelectedColumns();
- setSelectionGroup(null);
-
- }
-
public void hideColumns(int start, int end)
{
- if (start == end)
- {
- colSel.hideColumns(start);
- }
- else
- {
- colSel.hideColumns(start, end);
- }
+ posProps.hideColumns(start, end);
}
public void showColumn(int col)
{
- colSel.revealHiddenColumns(col);
-
+ posProps.showColumn(col);
}
public void showAllHiddenColumns()
{
- colSel.revealAllHiddenColumns();
+ posProps.showAllHiddenColumns();
}
+ public void hideSelectedColumns()
+ {
+ if (colSel.isEmpty())
+ {
+ return;
+ }
+
+ colSel.hideSelectedColumns();
+ setSelectionGroup(null);
+ isColSelChanged(true);
+ }
+
+
+
// common hide/show seq stuff
public void showAllHiddenSeqs()
{
- if (alignment.getHiddenSequences().getSize() > 0)
- {
- if (selectionGroup == null)
- {
- selectionGroup = new SequenceGroup();
- selectionGroup.setEndRes(alignment.getWidth() - 1);
- }
- List<SequenceI> tmp = alignment.getHiddenSequences().showAll(
- hiddenRepSequences);
- for (SequenceI seq : tmp)
- {
- selectionGroup.addSequence(seq, false);
- setSequenceAnnotationsVisible(seq, true);
- }
+ selectionGroup = posProps.showAllHiddenSeqs(selectionGroup);
- hiddenRepSequences = null;
+ /* if (alignment.getHiddenSequences().getSize() > 0)
+ {
+ if (selectionGroup == null)
+ {
+ selectionGroup = new SequenceGroup();
+ selectionGroup.setEndRes(alignment.getWidth() - 1);
+ }
+ List<SequenceI> tmp = alignment.getHiddenSequences().showAll(
+ hiddenRepSequences);
+ for (SequenceI seq : tmp)
+ {
+ selectionGroup.addSequence(seq, false);
+ setSequenceAnnotationsVisible(seq, true);
+ }
- firePropertyChange("alignment", null, alignment.getSequences());
- // used to set hasHiddenRows/hiddenRepSequences here, after the property
- // changed event
- sendSelection();
- }
+ hiddenRepSequences = null;
+
+ firePropertyChange("alignment", null, alignment.getSequences());
+ // used to set hasHiddenRows/hiddenRepSequences here, after the property
+ // changed event
+ sendSelection();
+ }*/
}
public void showSequence(int index)
{
- List<SequenceI> tmp = alignment.getHiddenSequences().showSequence(
- index,
- hiddenRepSequences);
+ posProps.showSequence(index, selectionGroup);
+ /*List<SequenceI> tmp = alignment.getHiddenSequences().showSequence(
+ index, hiddenRepSequences);
if (tmp.size() > 0)
{
if (selectionGroup == null)
}
firePropertyChange("alignment", null, alignment.getSequences());
sendSelection();
- }
+ }*/
}
public void hideAllSelectedSeqs()
{
- if (selectionGroup == null || selectionGroup.getSize() < 1)
+ posProps.hideAllSelectedSeqs(selectionGroup);
+ /*if (selectionGroup == null || selectionGroup.getSize() < 1)
{
return;
}
hideSequence(seqs);
- setSelectionGroup(null);
+ setSelectionGroup(null);*/
}
public void hideSequence(SequenceI[] seq)
{
- if (seq != null)
+ posProps.hideSequence(seq);
+ /*if (seq != null)
{
for (int i = 0; i < seq.length; i++)
{
setSequenceAnnotationsVisible(seq[i], false);
}
firePropertyChange("alignment", null, alignment.getSequences());
- }
+ }*/
}
/**
- * Set visibility for any annotations for the given sequence.
+ * Hides the specified sequence, or the sequences it represents
*
- * @param sequenceI
+ * @param sequence
+ * the sequence to hide, or keep as representative
+ * @param representGroup
+ * if true, hide the current selection group except for the
+ * representative sequence
*/
- protected void setSequenceAnnotationsVisible(SequenceI sequenceI,
- boolean visible)
+ public void hideSequences(SequenceI sequence, boolean representGroup)
{
- for (AlignmentAnnotation ann : alignment.getAlignmentAnnotation())
+ posProps.hideSequences(sequence, representGroup, selectionGroup);
+ /*if (selectionGroup == null || selectionGroup.getSize() < 1)
{
- if (ann.sequenceRef == sequenceI)
- {
- ann.visible = visible;
- }
+ hideSequence(new SequenceI[] { sequence });
+ return;
+ }
+
+ if (representGroup)
+ {
+ hideRepSequences(sequence, selectionGroup);
+ setSelectionGroup(null);
+ return;
}
+
+ int gsize = selectionGroup.getSize();
+ SequenceI[] hseqs = selectionGroup.getSequences().toArray(
+ new SequenceI[gsize]);
+
+ hideSequence(hseqs);
+ setSelectionGroup(null);
+ sendSelection();*/
}
+
public void hideRepSequences(SequenceI repSequence, SequenceGroup sg)
{
- int sSize = sg.getSize();
+ posProps.hideRepSequences(repSequence, sg);
+ /*int sSize = sg.getSize();
if (sSize < 2)
{
return;
if (hiddenRepSequences == null)
{
- hiddenRepSequences = new Hashtable();
+ hiddenRepSequences = new Hashtable<SequenceI, SequenceCollectionI>();
}
hiddenRepSequences.put(repSequence, sg);
}
sg.setSeqrep(repSequence); // note: not done in 2.7applet
sg.setHidereps(true); // note: not done in 2.7applet
- hideSequence(seqs);
+ hideSequence(seqs);*/
+
+ }
+
+ /**
+ *
+ * @return null or the current reference sequence
+ */
+ public SequenceI getReferenceSeq()
+ {
+ return alignment.getSeqrep();
+ }
+ /**
+ * @param seq
+ * @return true iff seq is the reference for the alignment
+ */
+ public boolean isReferenceSeq(SequenceI seq)
+ {
+ return alignment.getSeqrep() == seq;
}
+ /**
+ *
+ * @param seq
+ * @return true if there are sequences represented by this sequence that are
+ * currently hidden
+ */
public boolean isHiddenRepSequence(SequenceI seq)
{
- return alignment.getSeqrep()==seq || (hiddenRepSequences != null
- && hiddenRepSequences.containsKey(seq));
+ return posProps.isHiddenRepSequence(seq);
+ // return (hiddenRepSequences != null && hiddenRepSequences
+ // .containsKey(seq));
}
+ /**
+ *
+ * @param seq
+ * @return null or a sequence group containing the sequences that seq
+ * represents
+ */
public SequenceGroup getRepresentedSequences(SequenceI seq)
{
- return (SequenceGroup) (hiddenRepSequences == null ? null
- : hiddenRepSequences.get(seq));
+ return posProps.getRepresentedSequences(seq);
+ // return (SequenceGroup) (hiddenRepSequences == null ? null
+ // : hiddenRepSequences.get(seq));
}
@Override
public int adjustForHiddenSeqs(int alignmentIndex)
{
- return alignment.getHiddenSequences().adjustForHiddenSeqs(
- alignmentIndex);
+ return posProps.adjustForHiddenSeqs(alignmentIndex);
+ // return alignment.getHiddenSequences().adjustForHiddenSeqs(
+ // alignmentIndex);
}
@Override
public void invertColumnSelection()
{
- colSel.invertColumnSelection(0, alignment.getWidth());
+ posProps.invertColumnSelection();
+ // colSel.invertColumnSelection(0, alignment.getWidth());
}
-
@Override
public SequenceI[] getSelectionAsNewSequence()
{
return sequences;
}
-
@Override
public SequenceI[] getSequenceSelection()
{
return sequences;
}
-
@Override
- public CigarArray getViewAsCigars(
- boolean selectedRegionOnly)
+ public CigarArray getViewAsCigars(boolean selectedRegionOnly)
{
- return new CigarArray(alignment, colSel,
+ return new CigarArray(alignment, posProps.getColumnSelection(),
(selectedRegionOnly ? selectionGroup : null));
}
-
@Override
public jalview.datamodel.AlignmentView getAlignmentView(
boolean selectedOnly)
return getAlignmentView(selectedOnly, false);
}
-
@Override
public jalview.datamodel.AlignmentView getAlignmentView(
boolean selectedOnly, boolean markGroups)
{
- return new AlignmentView(alignment, colSel, selectionGroup,
- colSel != null && colSel.hasHiddenColumns(), selectedOnly,
+ return new AlignmentView(alignment, posProps.getColumnSelection(),
+ selectionGroup, posProps.hasHiddenColumns(), selectedOnly,
markGroups);
}
-
@Override
public String[] getViewAsString(boolean selectedRegionOnly)
{
+ return getViewAsString(selectedRegionOnly, true);
+ }
+
+ @Override
+ public String[] getViewAsString(boolean selectedRegionOnly,
+ boolean exportHiddenSeqs)
+ {
String[] selection = null;
SequenceI[] seqs = null;
int i, iSize;
}
else
{
- iSize = alignment.getHeight();
- seqs = alignment.getSequencesArray();
- end = alignment.getWidth();
+ if (hasHiddenRows() && exportHiddenSeqs)
+ {
+ AlignmentI fullAlignment = alignment.getHiddenSequences()
+ .getFullAlignment();
+ iSize = fullAlignment.getHeight();
+ seqs = fullAlignment.getSequencesArray();
+ end = fullAlignment.getWidth();
+ }
+ else
+ {
+ iSize = alignment.getHeight();
+ seqs = alignment.getSequencesArray();
+ end = alignment.getWidth();
+ }
}
selection = new String[iSize];
- if (colSel != null && colSel.hasHiddenColumns())
+ if (posProps.hasHiddenColumns())
{
- selection = colSel.getVisibleSequenceStrings(start, end, seqs);
+ selection = posProps.getVisibleSequenceStrings(start, end, seqs);
}
else
{
return selection;
}
-
@Override
public List<int[]> getVisibleRegionBoundaries(int min, int max)
{
- ArrayList<int[]> regions = new ArrayList<int[]>();
- int start = min;
- int end = max;
+ return posProps.getVisibleRegionBoundaries(min, max);
+ /* ArrayList<int[]> regions = new ArrayList<int[]>();
+ int start = min;
+ int end = max;
- do
- {
- if (colSel != null && colSel.hasHiddenColumns())
- {
- if (start == 0)
+ do
{
- start = colSel.adjustForHiddenColumns(start);
- }
-
- end = colSel.getHiddenBoundaryRight(start);
- if (start == end)
- {
- end = max;
- }
- if (end > max)
- {
- end = max;
- }
- }
+ if (colSel != null && colSel.hasHiddenColumns())
+ {
+ if (start == 0)
+ {
+ start = colSel.adjustForHiddenColumns(start);
+ }
+
+ end = colSel.getHiddenBoundaryRight(start);
+ if (start == end)
+ {
+ end = max;
+ }
+ if (end > max)
+ {
+ end = max;
+ }
+ }
- regions.add(new int[]
- { start, end });
+ regions.add(new int[] { start, end });
- if (colSel != null && colSel.hasHiddenColumns())
- {
- start = colSel.adjustForHiddenColumns(end);
- start = colSel.getHiddenBoundaryLeft(start) + 1;
- }
- } while (end < max);
+ if (posProps.hasHiddenColumns())
+ {
+ start = colSel.adjustForHiddenColumns(end);
+ start = colSel.getHiddenBoundaryLeft(start) + 1;
+ }
+ } while (end < max);
- int[][] startEnd = new int[regions.size()][2];
+ int[][] startEnd = new int[regions.size()][2];
- return regions;
+ return regions;*/
}
@Override
- public List<AlignmentAnnotation> getVisibleAlignmentAnnotation(boolean selectedOnly)
+ public List<AlignmentAnnotation> getVisibleAlignmentAnnotation(
+ boolean selectedOnly)
{
- ArrayList<AlignmentAnnotation> ala = new ArrayList<AlignmentAnnotation>();
+ return posProps.getVisibleAlignmentAnnotation(selectedOnly,
+ selectionGroup);
+ /*ArrayList<AlignmentAnnotation> ala = new ArrayList<AlignmentAnnotation>();
AlignmentAnnotation[] aa;
- if ((aa=alignment.getAlignmentAnnotation())!=null)
+ if ((aa = alignment.getAlignmentAnnotation()) != null)
{
- for (AlignmentAnnotation annot:aa)
+ for (AlignmentAnnotation annot : aa)
{
AlignmentAnnotation clone = new AlignmentAnnotation(annot);
- if (selectedOnly && selectionGroup!=null)
+ if (selectedOnly && selectionGroup != null)
+ {
+ colSel.makeVisibleAnnotation(selectionGroup.getStartRes(),
+ selectionGroup.getEndRes(), clone);
+ }
+ else
{
- colSel.makeVisibleAnnotation(selectionGroup.getStartRes(), selectionGroup.getEndRes(),clone);
- } else {
colSel.makeVisibleAnnotation(clone);
}
ala.add(clone);
}
}
- return ala;
+ return ala;*/
}
-
@Override
public boolean isPadGaps()
{
return padGaps;
}
-
@Override
public void setPadGaps(boolean padGaps)
{
selectionGroup.setEndRes(alWidth - 1);
}
- resetAllColourSchemes();
+ updateAllColourSchemes();
calculator.restartWorkers();
// alignment.adjustSequenceAnnotations();
}
/**
* reset scope and do calculations for all applied colourschemes on alignment
*/
- void resetAllColourSchemes()
+ void updateAllColourSchemes()
{
- ColourSchemeI cs = globalColourScheme;
- if (cs != null)
+ ResidueShaderI rs = residueShading;
+ if (rs != null)
{
- cs.alignmentChanged(alignment, hiddenRepSequences);
+ rs.alignmentChanged(alignment, posProps.getHiddenRepSequences());
- cs.setConsensus(hconsensus);
- if (cs.conservationApplied())
+ rs.setConsensus(hconsensus);
+ if (rs.conservationApplied())
{
- cs.setConservation(Conservation.calculateConservation("All",
- ResidueProperties.propHash, 3, alignment.getSequences(), 0,
- alignment.getWidth(), false, getConsPercGaps(), false));
+ rs.setConservation(Conservation.calculateConservation("All",
+ alignment.getSequences(), 0, alignment.getWidth(), false,
+ getConsPercGaps(), false));
}
}
{
if (sg.cs != null)
{
- sg.cs.alignmentChanged(sg, hiddenRepSequences);
+ sg.cs.alignmentChanged(sg, posProps.getHiddenRepSequences());
}
sg.recalcConservation();
}
{
if (!alignment.isNucleotide())
{
- final Set<AlignedCodonFrame> codonMappings = alignment
+ final List<AlignedCodonFrame> codonMappings = alignment
.getCodonFrames();
if (codonMappings != null && !codonMappings.isEmpty())
{
- complementConsensus = new AlignmentAnnotation("cDNA Consensus",
- "PID for cDNA", new Annotation[1], 0f, 100f,
- AlignmentAnnotation.BAR_GRAPH);
- initConsensus(complementConsensus);
+ boolean doConsensus = false;
+ for (AlignedCodonFrame mapping : codonMappings)
+ {
+ // TODO hold mapping type e.g. dna-to-protein in AlignedCodonFrame?
+ MapList[] mapLists = mapping.getdnaToProt();
+ // mapLists can be empty if project load has not finished resolving
+ // seqs
+ if (mapLists.length > 0 && mapLists[0].getFromRatio() == 3)
+ {
+ doConsensus = true;
+ break;
+ }
+ }
+ if (doConsensus)
+ {
+ complementConsensus = new AlignmentAnnotation("cDNA Consensus",
+ "PID for cDNA", new Annotation[1], 0f, 100f,
+ AlignmentAnnotation.BAR_GRAPH);
+ initConsensus(complementConsensus);
+ }
}
}
}
}
oldrfs.clear();
}
+
@Override
public boolean isDisplayReferenceSeq()
{
@Override
public boolean areFeaturesDisplayed()
{
- return featuresDisplayed != null && featuresDisplayed.getRegisterdFeaturesCount()>0;
+ return featuresDisplayed != null
+ && featuresDisplayed.getRegisteredFeaturesCount() > 0;
}
/**
{
viewStyle.setShowSequenceFeatures(b);
}
+
@Override
public boolean isShowSequenceFeatures()
{
return viewStyle.isShowSequenceFeaturesHeight();
}
-
-
@Override
public void setShowAnnotation(boolean b)
{
* @return
* @see jalview.api.ViewStyleI#getTextColour()
*/
+ @Override
public Color getTextColour()
{
return viewStyle.getTextColour();
* @return
* @see jalview.api.ViewStyleI#getTextColour2()
*/
+ @Override
public Color getTextColour2()
{
return viewStyle.getTextColour2();
* @return
* @see jalview.api.ViewStyleI#getThresholdTextColour()
*/
+ @Override
public int getThresholdTextColour()
{
return viewStyle.getThresholdTextColour();
* @return
* @see jalview.api.ViewStyleI#isConservationColourSelected()
*/
+ @Override
public boolean isConservationColourSelected()
{
return viewStyle.isConservationColourSelected();
* @return
* @see jalview.api.ViewStyleI#isRenderGaps()
*/
+ @Override
public boolean isRenderGaps()
{
return viewStyle.isRenderGaps();
* @return
* @see jalview.api.ViewStyleI#isShowColourText()
*/
+ @Override
public boolean isShowColourText()
{
return viewStyle.isShowColourText();
* @param conservationColourSelected
* @see jalview.api.ViewStyleI#setConservationColourSelected(boolean)
*/
+ @Override
public void setConservationColourSelected(
boolean conservationColourSelected)
{
* @param showColourText
* @see jalview.api.ViewStyleI#setShowColourText(boolean)
*/
+ @Override
public void setShowColourText(boolean showColourText)
{
viewStyle.setShowColourText(showColourText);
* @param textColour
* @see jalview.api.ViewStyleI#setTextColour(java.awt.Color)
*/
+ @Override
public void setTextColour(Color textColour)
{
viewStyle.setTextColour(textColour);
* @param thresholdTextColour
* @see jalview.api.ViewStyleI#setThresholdTextColour(int)
*/
+ @Override
public void setThresholdTextColour(int thresholdTextColour)
{
viewStyle.setThresholdTextColour(thresholdTextColour);
* @param textColour2
* @see jalview.api.ViewStyleI#setTextColour2(java.awt.Color)
*/
+ @Override
public void setTextColour2(Color textColour2)
{
viewStyle.setTextColour2(textColour2);
public void setViewStyle(ViewStyleI settingsForView)
{
viewStyle = new ViewStyle(settingsForView);
+ if (residueShading != null)
+ {
+ residueShading.setConservationApplied(settingsForView
+ .isConservationColourSelected());
+ }
}
@Override
* @return
* @see jalview.api.ViewStyleI#getIdWidth()
*/
+ @Override
public int getIdWidth()
{
return viewStyle.getIdWidth();
* @param i
* @see jalview.api.ViewStyleI#setIdWidth(int)
*/
+ @Override
public void setIdWidth(int i)
{
viewStyle.setIdWidth(i);
* @return
* @see jalview.api.ViewStyleI#isCentreColumnLabels()
*/
+ @Override
public boolean isCentreColumnLabels()
{
return viewStyle.isCentreColumnLabels();
* @param centreColumnLabels
* @see jalview.api.ViewStyleI#setCentreColumnLabels(boolean)
*/
+ @Override
public void setCentreColumnLabels(boolean centreColumnLabels)
{
viewStyle.setCentreColumnLabels(centreColumnLabels);
* @param showdbrefs
* @see jalview.api.ViewStyleI#setShowDBRefs(boolean)
*/
+ @Override
public void setShowDBRefs(boolean showdbrefs)
{
viewStyle.setShowDBRefs(showdbrefs);
* @return
* @see jalview.api.ViewStyleI#isShowDBRefs()
*/
+ @Override
public boolean isShowDBRefs()
{
return viewStyle.isShowDBRefs();
* @return
* @see jalview.api.ViewStyleI#isShowNPFeats()
*/
+ @Override
public boolean isShowNPFeats()
{
return viewStyle.isShowNPFeats();
* @param shownpfeats
* @see jalview.api.ViewStyleI#setShowNPFeats(boolean)
*/
+ @Override
public void setShowNPFeats(boolean shownpfeats)
{
viewStyle.setShowNPFeats(shownpfeats);
protected void broadcastCommand(CommandI command, boolean undo)
{
- getStructureSelectionManager().commandPerformed(command, undo, getVamsasSource());
+ getStructureSelectionManager().commandPerformed(command, undo,
+ getVamsasSource());
}
/**
this.followHighlight = b;
}
+ @Override
+ public ViewportPositionProps getPosProps()
+ {
+ return posProps;
+ }
+
+ @Override
public int getStartRes()
{
- return startRes;
+ return posProps.getStartRes();
}
+ @Override
public int getEndRes()
{
- return endRes;
+ return posProps.getEndRes();
}
+ @Override
public int getStartSeq()
{
- return startSeq;
+ return posProps.getStartSeq();
}
public void setStartRes(int res)
{
- this.startRes = res;
+ posProps.setStartRes(res);
+ // this.startRes = res;
}
public void setStartSeq(int seq)
{
- this.startSeq = seq;
+ posProps.setStartSeq(seq);
+ // this.startSeq = seq;
}
public void setEndRes(int res)
{
- if (res > alignment.getWidth() - 1)
+ posProps.setEndRes(res);
+ /*if (res > alignment.getWidth() - 1)
{
// log.System.out.println(" Corrected res from " + res + " to maximum " +
// (alignment.getWidth()-1));
{
res = 0;
}
- this.endRes = res;
+ this.endRes = res;*/
}
public void setEndSeq(int seq)
{
- if (seq > alignment.getHeight())
+ posProps.setEndSeq(seq);
+ /*if (seq > alignment.getHeight())
{
seq = alignment.getHeight();
}
{
seq = 0;
}
- this.endSeq = seq;
+ this.endSeq = seq;*/
}
+ @Override
public int getEndSeq()
{
- return endSeq;
+ return posProps.getEndSeq();
+ // return endSeq;
}
/**
* the SearchResults to add to
* @return the offset (below top of visible region) of the matched sequence
*/
- protected int findComplementScrollTarget(SearchResults sr)
+ protected int findComplementScrollTarget(SearchResultsI sr)
{
final AlignViewportI complement = getCodingComplement();
if (complement == null || !complement.isFollowHighlight())
return 0;
}
boolean iAmProtein = !getAlignment().isNucleotide();
- AlignmentI proteinAlignment = iAmProtein ? getAlignment()
- : complement.getAlignment();
+ AlignmentI proteinAlignment = iAmProtein ? getAlignment() : complement
+ .getAlignment();
if (proteinAlignment == null)
{
return 0;
}
- final Set<AlignedCodonFrame> mappings = proteinAlignment
+ final List<AlignedCodonFrame> mappings = proteinAlignment
.getCodonFrames();
-
+
/*
* Heuristic: find the first mapped sequence (if any) with a non-gapped
* residue in the middle column of the visible region. Scroll the
int middleColumn = getStartRes() + (getEndRes() - getStartRes()) / 2;
final HiddenSequences hiddenSequences = getAlignment()
.getHiddenSequences();
- for (int seqNo = getStartSeq(); seqNo < getEndSeq(); seqNo++, seqOffset++)
+
+ /*
+ * searching to the bottom of the alignment gives smoother scrolling across
+ * all gapped visible regions
+ */
+ int lastSeq = alignment.getHeight() - 1;
+ List<AlignedCodonFrame> seqMappings = null;
+ for (int seqNo = getStartSeq(); seqNo < lastSeq; seqNo++, seqOffset++)
{
sequence = getAlignment().getSequenceAt(seqNo);
if (hiddenSequences != null && hiddenSequences.isHidden(sequence))
{
continue;
}
- List<AlignedCodonFrame> seqMappings = MappingUtils
- .findMappingsForSequence(sequence, mappings);
+ seqMappings = MappingUtils
+ .findMappingsForSequenceAndOthers(sequence, mappings,
+ getCodingComplement().getAlignment().getSequences());
if (!seqMappings.isEmpty())
{
- break;
+ break;
}
}
-
- if (sequence == null)
+
+ if (sequence == null || seqMappings == null || seqMappings.isEmpty())
{
/*
* No ungapped mapped sequence in middle column - do nothing
return 0;
}
MappingUtils.addSearchResults(sr, sequence,
- sequence.findPosition(middleColumn), mappings);
+ sequence.findPosition(middleColumn), seqMappings);
return seqOffset;
}
+
+ /**
+ * synthesize a column selection if none exists so it covers the given
+ * selection group. if wholewidth is false, no column selection is made if the
+ * selection group covers the whole alignment width.
+ *
+ * @param sg
+ * @param wholewidth
+ */
+ public void expandColSelection(SequenceGroup sg, boolean wholewidth)
+ {
+ if (!this.hasSelectedColumns())
+ {
+ posProps.expandColSelection(sg, wholewidth);
+ }
+ /*int sgs, sge;
+ if (sg != null && (sgs = sg.getStartRes()) >= 0
+ && sg.getStartRes() <= (sge = sg.getEndRes())
+ && !this.hasSelectedColumns())
+ {
+ if (!wholewidth && alignment.getWidth() == (1 + sge - sgs))
+ {
+ // do nothing
+ return;
+ }
+ if (colSel == null)
+ {
+ colSel = new ColumnSelection();
+ }
+ for (int cspos = sg.getStartRes(); cspos <= sg.getEndRes(); cspos++)
+ {
+ colSel.addElement(cspos);
+ }
+ }*/
+ }
+
+ /**
+ * hold status of current selection group - defined on alignment or not.
+ */
+ private boolean selectionIsDefinedGroup = false;
+
+
+ @Override
+ public boolean isSelectionDefinedGroup()
+ {
+ if (selectionGroup == null)
+ {
+ return false;
+ }
+ if (isSelectionGroupChanged(true))
+ {
+ selectionIsDefinedGroup = false;
+ List<SequenceGroup> gps = alignment.getGroups();
+ if (gps == null || gps.size() == 0)
+ {
+ selectionIsDefinedGroup = false;
+ }
+ else
+ {
+ selectionIsDefinedGroup = gps.contains(selectionGroup);
+ }
+ }
+ return selectionGroup.getContext() == alignment
+ || selectionIsDefinedGroup;
+ }
+
+ /**
+ * null, or currently highlighted results on this view
+ */
+ private SearchResultsI searchResults = null;
+
+ @Override
+ public boolean hasSearchResults()
+ {
+ return searchResults != null;
+ }
+
+ @Override
+ public void setSearchResults(SearchResultsI results)
+ {
+ searchResults = results;
+ }
+
+ @Override
+ public SearchResultsI getSearchResults()
+ {
+ return searchResults;
+ }
}
git://source.jalview.org / jalview.git / blobdiff