import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
import jalview.analysis.Conservation;
+import jalview.analysis.TreeModel;
import jalview.api.AlignCalcManagerI;
import jalview.api.AlignViewportI;
import jalview.api.AlignmentViewPanel;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.AlignmentView;
import jalview.datamodel.Annotation;
-import jalview.datamodel.CigarArray;
import jalview.datamodel.ColumnSelection;
+import jalview.datamodel.HiddenColumns;
import jalview.datamodel.HiddenSequences;
import jalview.datamodel.ProfilesI;
import jalview.datamodel.SearchResultsI;
import jalview.util.Comparison;
import jalview.util.MapList;
import jalview.util.MappingUtils;
+import jalview.util.MessageManager;
import jalview.viewmodel.styles.ViewStyle;
import jalview.workers.AlignCalcManager;
import jalview.workers.ComplementConsensusThread;
import java.util.Deque;
import java.util.HashMap;
import java.util.Hashtable;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
* @author jimp
*
*/
-public abstract class AlignmentViewport implements AlignViewportI,
- CommandListener, VamsasSource
+public abstract class AlignmentViewport
+ implements AlignViewportI, CommandListener, VamsasSource
{
- protected ViewportPositionProps posProps;
+ protected ViewportRanges ranges;
protected ViewStyleI viewStyle = new ViewStyle();
FeaturesDisplayedI featuresDisplayed = null;
- protected Deque<CommandI> historyList = new ArrayDeque<CommandI>();
+ protected Deque<CommandI> historyList = new ArrayDeque<>();
- protected Deque<CommandI> redoList = new ArrayDeque<CommandI>();
+ protected Deque<CommandI> redoList = new ArrayDeque<>();
+
+ /**
+ * alignment displayed in the viewport. Please use get/setter
+ */
+ protected AlignmentI alignment;
+
+ public AlignmentViewport(AlignmentI al)
+ {
+ setAlignment(al);
+ ranges = new ViewportRanges(al);
+ }
/**
* @param name
public void setWrapAlignment(boolean state)
{
viewStyle.setWrapAlignment(state);
+ ranges.setWrappedMode(state);
}
/**
viewStyle.setSeqNameItalics(default1);
}
- /**
- * alignment displayed in the viewport. Please use get/setter
- */
- protected AlignmentI alignment;
-
@Override
public AlignmentI getAlignment()
{
return isDataset;
}
+ private Map<SequenceI, SequenceCollectionI> hiddenRepSequences;
-
- // protected ColumnSelection colSel = new ColumnSelection();
+ protected ColumnSelection colSel = new ColumnSelection();
public boolean autoCalculateConsensus = true;
protected boolean ignoreGapsInConsensusCalculation = false;
- protected ResidueShaderI residueShading;
+ protected ResidueShaderI residueShading = new ResidueShader();
@Override
public void setGlobalColourScheme(ColourSchemeI cs)
{
residueShading.setConservation(hconservation);
}
- residueShading.alignmentChanged(alignment, getHiddenRepSequences());
+ /*
+ * reset conservation flag in case just set to false if
+ * Conservation was null (calculation still in progress)
+ */
+ residueShading.setConservationApplied(getConservationSelected());
+ residueShading.alignmentChanged(alignment, hiddenRepSequences);
}
/*
* retain any colour thresholds per group while
* changing choice of colour scheme (JAL-2386)
*/
- sg.setColourScheme(cs);
+ sg.setColourScheme(
+ cs == null ? null : cs.getInstance(this, sg));
if (cs != null)
{
- sg.getGroupColourScheme()
-.alignmentChanged(sg,
- getHiddenRepSequences());
+ sg.getGroupColourScheme().alignmentChanged(sg,
+ hiddenRepSequences);
}
}
}
@Override
public ColourSchemeI getGlobalColourScheme()
{
- return residueShading == null ? null : residueShading
- .getColourScheme();
+ return residueShading == null ? null : residueShading.getColourScheme();
}
@Override
protected AlignmentAnnotation complementConsensus;
+ protected AlignmentAnnotation gapcounts;
+
protected AlignmentAnnotation strucConsensus;
protected AlignmentAnnotation conservation;
}
@Override
+ public AlignmentAnnotation getAlignmentGapAnnotation()
+ {
+ return gapcounts;
+ }
+
+ @Override
public AlignmentAnnotation getComplementConsensusAnnotation()
{
return complementConsensus;
{
return;
}
- if (calculator
- .getRegisteredWorkersOfClass(jalview.workers.ConservationThread.class) == null)
+ if (calculator.getRegisteredWorkersOfClass(
+ jalview.workers.ConservationThread.class) == null)
{
- calculator.registerWorker(new jalview.workers.ConservationThread(
- this, ap));
+ calculator.registerWorker(
+ new jalview.workers.ConservationThread(this, ap));
}
}
{
return;
}
- if (calculator.getRegisteredWorkersOfClass(ConsensusThread.class) == null)
+ if (calculator
+ .getRegisteredWorkersOfClass(ConsensusThread.class) == null)
{
calculator.registerWorker(new ConsensusThread(this, ap));
}
}
if (doConsensus)
{
- if (calculator
- .getRegisteredWorkersOfClass(ComplementConsensusThread.class) == null)
+ if (calculator.getRegisteredWorkersOfClass(
+ ComplementConsensusThread.class) == null)
{
calculator
.registerWorker(new ComplementConsensusThread(this, ap));
{
return;
}
- if (calculator.getRegisteredWorkersOfClass(StrucConsensusThread.class) == null)
+ if (calculator.getRegisteredWorkersOfClass(
+ StrucConsensusThread.class) == null)
{
calculator.registerWorker(new StrucConsensusThread(this, ap));
}
groupConsensus = null;
groupConservation = null;
hconsensus = null;
+ hconservation = null;
hcomplementConsensus = null;
- // colour scheme may hold reference to consensus
- residueShading = null;
- // TODO remove listeners from changeSupport?
+ gapcounts = null;
+ calculator = null;
+ residueShading = null; // may hold a reference to Consensus
changeSupport = null;
+ ranges = null;
+ currentTree = null;
+ selectionGroup = null;
+ colSel = null;
setAlignment(null);
}
}
}
- public void setHiddenColumns(ColumnSelection colsel)
+ public void setHiddenColumns(HiddenColumns hidden)
{
- posProps.setHiddenColumns(colsel);
- // this.colSel = colsel;
+ this.alignment.setHiddenColumns(hidden);
}
@Override
public ColumnSelection getColumnSelection()
{
- return posProps.getColumnSelection();
- // return colSel;
+ return colSel;
}
@Override
public void setColumnSelection(ColumnSelection colSel)
{
- posProps.setColumnSelection(colSel);
- /*this.colSel = colSel;
+ this.colSel = colSel;
if (colSel != null)
{
updateHiddenColumns();
}
- isColSelChanged(true);*/
+ isColSelChanged(true);
}
/**
@Override
public Map<SequenceI, SequenceCollectionI> getHiddenRepSequences()
{
- return posProps.getHiddenRepSequences();
+ return hiddenRepSequences;
}
@Override
public void setHiddenRepSequences(
Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
{
- posProps.getHiddenRepSequences();
+ this.hiddenRepSequences = hiddenRepSequences;
}
@Override
@Override
public boolean hasHiddenColumns()
{
- return posProps.hasHiddenColumns();
- // return colSel != null && colSel.hasHiddenColumns();
+ return alignment.getHiddenColumns() != null
+ && alignment.getHiddenColumns().hasHiddenColumns();
}
public void updateHiddenColumns()
{
if (sequenceSetID != null)
{
- System.err
- .println("Warning - overwriting a sequenceSetId for a viewport!");
+ System.err.println(
+ "Warning - overwriting a sequenceSetId for a viewport!");
}
sequenceSetID = new String(newid);
}
}
- private long sgrouphash = -1;
+ private long sgrouphash = -1, colselhash = -1;
/**
* checks current SelectionGroup against record of last hash value, and
*/
public boolean isColSelChanged(boolean b)
{
- return posProps.isColSelChanged(b);
- /*int hc = (colSel == null || colSel.isEmpty()) ? -1 : colSel.hashCode();
+ int hc = (colSel == null || colSel.isEmpty()) ? -1 : colSel.hashCode();
if (hc != -1 && hc != colselhash)
{
if (b)
}
return true;
}
- return false;*/
+ return false;
}
@Override
protected boolean showConsensus = true;
- private Map<SequenceI, Color> sequenceColours = new HashMap<SequenceI, Color>();
+ protected boolean showOccupancy = true;
+
+ private Map<SequenceI, Color> sequenceColours = new HashMap<>();
protected SequenceAnnotationOrder sortAnnotationsBy = null;
*/
private boolean followHighlight = true;
- /*private int startRes;
-
- private int endRes;
-
- private int startSeq;
-
- private int endSeq;*/
-
/**
* Property change listener for changes in alignment
*
public void removePropertyChangeListener(
java.beans.PropertyChangeListener listener)
{
- changeSupport.removePropertyChangeListener(listener);
+ if (changeSupport != null)
+ {
+ changeSupport.removePropertyChangeListener(listener);
+ }
}
/**
// common hide/show column stuff
- public void hideColumns(int start, int end)
- {
- posProps.hideColumns(start, end);
- }
-
- public void showColumn(int col)
- {
- posProps.showColumn(col);
- }
-
- public void showAllHiddenColumns()
- {
- posProps.showAllHiddenColumns();
- }
-
public void hideSelectedColumns()
{
if (colSel.isEmpty())
return;
}
- colSel.hideSelectedColumns();
+ colSel.hideSelectedColumns(alignment);
setSelectionGroup(null);
isColSelChanged(true);
}
+ public void hideColumns(int start, int end)
+ {
+ if (start == end)
+ {
+ colSel.hideSelectedColumns(start, alignment.getHiddenColumns());
+ }
+ else
+ {
+ alignment.getHiddenColumns().hideColumns(start, end);
+ }
+ isColSelChanged(true);
+ }
+ public void showColumn(int col)
+ {
+ alignment.getHiddenColumns().revealHiddenColumns(col, colSel);
+ isColSelChanged(true);
+ }
+
+ public void showAllHiddenColumns()
+ {
+ alignment.getHiddenColumns().revealAllHiddenColumns(colSel);
+ isColSelChanged(true);
+ }
// common hide/show seq stuff
public void showAllHiddenSeqs()
{
- selectionGroup = posProps.showAllHiddenSeqs(selectionGroup);
+ int startSeq = ranges.getStartSeq();
+ int endSeq = ranges.getEndSeq();
- /* 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);
- }
+ 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);
+ }
+
+ hiddenRepSequences = null;
- hiddenRepSequences = null;
+ ranges.setStartEndSeq(startSeq, endSeq + tmp.size());
- firePropertyChange("alignment", null, alignment.getSequences());
- // used to set hasHiddenRows/hiddenRepSequences here, after the property
- // changed event
- sendSelection();
- }*/
+ firePropertyChange("alignment", null, alignment.getSequences());
+ // used to set hasHiddenRows/hiddenRepSequences here, after the property
+ // changed event
+ sendSelection();
+ }
}
public void showSequence(int index)
{
- posProps.showSequence(index, selectionGroup);
- /*List<SequenceI> tmp = alignment.getHiddenSequences().showSequence(
- index, hiddenRepSequences);
+ int startSeq = ranges.getStartSeq();
+ int endSeq = ranges.getEndSeq();
+
+ List<SequenceI> tmp = alignment.getHiddenSequences().showSequence(index,
+ hiddenRepSequences);
if (tmp.size() > 0)
{
if (selectionGroup == null)
selectionGroup.addSequence(seq, false);
setSequenceAnnotationsVisible(seq, true);
}
+
+ ranges.setStartEndSeq(startSeq, endSeq + tmp.size());
+
firePropertyChange("alignment", null, alignment.getSequences());
sendSelection();
- }*/
+ }
}
public void hideAllSelectedSeqs()
{
- posProps.hideAllSelectedSeqs(selectionGroup);
- /*if (selectionGroup == null || selectionGroup.getSize() < 1)
+ if (selectionGroup == null || selectionGroup.getSize() < 1)
{
return;
}
hideSequence(seqs);
- setSelectionGroup(null);*/
+ setSelectionGroup(null);
}
public void hideSequence(SequenceI[] seq)
{
- posProps.hideSequence(seq);
- /*if (seq != null)
+ /*
+ * cache offset to first visible sequence
+ */
+ int startSeq = ranges.getStartSeq();
+
+ if (seq != null)
{
for (int i = 0; i < seq.length; i++)
{
alignment.getHiddenSequences().hideSequence(seq[i]);
setSequenceAnnotationsVisible(seq[i], false);
}
+ ranges.setStartSeq(startSeq);
firePropertyChange("alignment", null, alignment.getSequences());
- }*/
+ }
}
/**
*/
public void hideSequences(SequenceI sequence, boolean representGroup)
{
- posProps.hideSequences(sequence, representGroup, selectionGroup);
- /*if (selectionGroup == null || selectionGroup.getSize() < 1)
+ if (selectionGroup == null || selectionGroup.getSize() < 1)
{
hideSequence(new SequenceI[] { sequence });
return;
}
int gsize = selectionGroup.getSize();
- SequenceI[] hseqs = selectionGroup.getSequences().toArray(
- new SequenceI[gsize]);
+ SequenceI[] hseqs = selectionGroup.getSequences()
+ .toArray(new SequenceI[gsize]);
hideSequence(hseqs);
setSelectionGroup(null);
- sendSelection();*/
+ sendSelection();
}
+ /**
+ * Set visibility for any annotations for the given sequence.
+ *
+ * @param sequenceI
+ */
+ protected void setSequenceAnnotationsVisible(SequenceI sequenceI,
+ boolean visible)
+ {
+ AlignmentAnnotation[] anns = alignment.getAlignmentAnnotation();
+ if (anns != null)
+ {
+ for (AlignmentAnnotation ann : anns)
+ {
+ if (ann.sequenceRef == sequenceI)
+ {
+ ann.visible = visible;
+ }
+ }
+ }
+ }
public void hideRepSequences(SequenceI repSequence, SequenceGroup sg)
{
- posProps.hideRepSequences(repSequence, sg);
- /*int sSize = sg.getSize();
+ int sSize = sg.getSize();
if (sSize < 2)
{
return;
if (hiddenRepSequences == null)
{
- hiddenRepSequences = new Hashtable<SequenceI, SequenceCollectionI>();
+ hiddenRepSequences = new Hashtable<>();
}
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);
}
*/
public boolean isHiddenRepSequence(SequenceI seq)
{
- return posProps.isHiddenRepSequence(seq);
- // return (hiddenRepSequences != null && hiddenRepSequences
- // .containsKey(seq));
+ return (hiddenRepSequences != null
+ && hiddenRepSequences.containsKey(seq));
}
/**
*/
public SequenceGroup getRepresentedSequences(SequenceI seq)
{
- return posProps.getRepresentedSequences(seq);
- // return (SequenceGroup) (hiddenRepSequences == null ? null
- // : hiddenRepSequences.get(seq));
+ return (SequenceGroup) (hiddenRepSequences == null ? null
+ : hiddenRepSequences.get(seq));
}
@Override
public int adjustForHiddenSeqs(int alignmentIndex)
{
- return posProps.adjustForHiddenSeqs(alignmentIndex);
- // return alignment.getHiddenSequences().adjustForHiddenSeqs(
- // alignmentIndex);
+ return alignment.getHiddenSequences()
+ .adjustForHiddenSeqs(alignmentIndex);
}
@Override
public void invertColumnSelection()
{
- posProps.invertColumnSelection();
- // colSel.invertColumnSelection(0, alignment.getWidth());
+ colSel.invertColumnSelection(0, alignment.getWidth(), alignment);
+ isColSelChanged(true);
}
@Override
}
@Override
- public CigarArray getViewAsCigars(boolean selectedRegionOnly)
- {
- return new CigarArray(alignment, posProps.getColumnSelection(),
- (selectedRegionOnly ? selectionGroup : null));
- }
-
- @Override
public jalview.datamodel.AlignmentView getAlignmentView(
boolean selectedOnly)
{
public jalview.datamodel.AlignmentView getAlignmentView(
boolean selectedOnly, boolean markGroups)
{
- return new AlignmentView(alignment, posProps.getColumnSelection(),
- selectionGroup, posProps.hasHiddenColumns(), selectedOnly,
- markGroups);
+ return new AlignmentView(alignment, alignment.getHiddenColumns(),
+ selectionGroup,
+ alignment.getHiddenColumns() != null
+ && alignment.getHiddenColumns().hasHiddenColumns(),
+ selectedOnly, markGroups);
}
@Override
}
selection = new String[iSize];
- if (posProps.hasHiddenColumns())
+ if (alignment.getHiddenColumns() != null
+ && alignment.getHiddenColumns().hasHiddenColumns())
{
- selection = posProps.getVisibleSequenceStrings(start, end, seqs);
+ for (i = 0; i < iSize; i++)
+ {
+ Iterator<int[]> blocks = alignment.getHiddenColumns()
+ .getVisContigsIterator(start, end + 1, false);
+ selection[i] = seqs[i].getSequenceStringFromIterator(blocks);
+ }
}
else
{
@Override
public List<int[]> getVisibleRegionBoundaries(int min, int max)
{
- return posProps.getVisibleRegionBoundaries(min, max);
- /* ArrayList<int[]> regions = new ArrayList<int[]>();
- int start = min;
- int end = max;
+ ArrayList<int[]> regions = new ArrayList<>();
+ int start = min;
+ int end = max;
- do
+ do
+ {
+ HiddenColumns hidden = alignment.getHiddenColumns();
+ if (hidden != null && hidden.hasHiddenColumns())
+ {
+ if (start == 0)
{
- 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;
- }
- }
+ start = hidden.visibleToAbsoluteColumn(start);
+ }
+
+ end = hidden.getNextHiddenBoundary(false, start);
+ if (start == end)
+ {
+ end = max;
+ }
+ if (end > max)
+ {
+ end = max;
+ }
+ }
- regions.add(new int[] { start, end });
+ regions.add(new int[] { start, end });
- if (posProps.hasHiddenColumns())
- {
- start = colSel.adjustForHiddenColumns(end);
- start = colSel.getHiddenBoundaryLeft(start) + 1;
- }
- } while (end < max);
+ if (hidden != null && hidden.hasHiddenColumns())
+ {
+ start = hidden.visibleToAbsoluteColumn(end);
+ start = hidden.getNextHiddenBoundary(true, 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)
{
- return posProps.getVisibleAlignmentAnnotation(selectedOnly,
- selectionGroup);
- /*ArrayList<AlignmentAnnotation> ala = new ArrayList<AlignmentAnnotation>();
+ ArrayList<AlignmentAnnotation> ala = new ArrayList<>();
AlignmentAnnotation[] aa;
if ((aa = alignment.getAlignmentAnnotation()) != null)
{
AlignmentAnnotation clone = new AlignmentAnnotation(annot);
if (selectedOnly && selectionGroup != null)
{
- colSel.makeVisibleAnnotation(selectionGroup.getStartRes(),
- selectionGroup.getEndRes(), clone);
+ clone.makeVisibleAnnotation(
+ selectionGroup.getStartRes(), selectionGroup.getEndRes(),
+ alignment.getHiddenColumns());
}
else
{
- colSel.makeVisibleAnnotation(clone);
+ clone.makeVisibleAnnotation(alignment.getHiddenColumns());
}
ala.add(clone);
}
}
- return ala;*/
+ return ala;
}
@Override
ResidueShaderI rs = residueShading;
if (rs != null)
{
- rs.alignmentChanged(alignment, posProps.getHiddenRepSequences());
+ rs.alignmentChanged(alignment, hiddenRepSequences);
rs.setConsensus(hconsensus);
if (rs.conservationApplied())
{
if (sg.cs != null)
{
- sg.cs.alignmentChanged(sg, posProps.getHiddenRepSequences());
+ sg.cs.alignmentChanged(sg, hiddenRepSequences);
}
sg.recalcConservation();
}
{
initRNAStructure();
}
- consensus = new AlignmentAnnotation("Consensus", "PID",
+ consensus = new AlignmentAnnotation("Consensus",
+ MessageManager.getString("label.consensus_descr"),
new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
initConsensus(consensus);
+ initGapCounts();
initComplementConsensus();
}
}
/**
- * If this is a protein alignment and there are mappings to cDNA, add the cDNA
- * consensus annotation.
+ * If this is a protein alignment and there are mappings to cDNA, adds the
+ * cDNA consensus annotation and returns true, else returns false.
*/
- public void initComplementConsensus()
+ public boolean initComplementConsensus()
{
if (!alignment.isNucleotide())
{
if (doConsensus)
{
complementConsensus = new AlignmentAnnotation("cDNA Consensus",
- "PID for cDNA", new Annotation[1], 0f, 100f,
+ MessageManager
+ .getString("label.complement_consensus_descr"),
+ new Annotation[1], 0f, 100f,
AlignmentAnnotation.BAR_GRAPH);
initConsensus(complementConsensus);
+ return true;
}
}
}
+ return false;
}
private void initConsensus(AlignmentAnnotation aa)
}
}
+ // these should be extracted from the view model - style and settings for
+ // derived annotation
+ private void initGapCounts()
+ {
+ if (showOccupancy)
+ {
+ gapcounts = new AlignmentAnnotation("Occupancy",
+ MessageManager.getString("label.occupancy_descr"),
+ new Annotation[1], 0f, alignment.getHeight(),
+ AlignmentAnnotation.BAR_GRAPH);
+ gapcounts.hasText = true;
+ gapcounts.autoCalculated = true;
+ gapcounts.scaleColLabel = true;
+ gapcounts.graph = AlignmentAnnotation.BAR_GRAPH;
+
+ alignment.addAnnotation(gapcounts);
+ }
+ }
+
private void initConservation()
{
if (showConservation)
if (conservation == null)
{
conservation = new AlignmentAnnotation("Conservation",
- "Conservation of total alignment less than "
- + getConsPercGaps() + "% gaps", new Annotation[1],
- 0f, 11f, AlignmentAnnotation.BAR_GRAPH);
+ MessageManager.formatMessage("label.conservation_descr",
+ getConsPercGaps()),
+ new Annotation[1], 0f, 11f, AlignmentAnnotation.BAR_GRAPH);
conservation.hasText = true;
conservation.autoCalculated = true;
alignment.addAnnotation(conservation);
if (quality == null)
{
quality = new AlignmentAnnotation("Quality",
- "Alignment Quality based on Blosum62 scores",
+ MessageManager.getString("label.quality_descr"),
new Annotation[1], 0f, 11f, AlignmentAnnotation.BAR_GRAPH);
quality.hasText = true;
quality.autoCalculated = true;
{
if (alignment.hasRNAStructure() && strucConsensus == null)
{
- strucConsensus = new AlignmentAnnotation("StrucConsensus", "PID",
+ strucConsensus = new AlignmentAnnotation("StrucConsensus",
+ MessageManager.getString("label.strucconsensus_descr"),
new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
strucConsensus.hasText = true;
strucConsensus.autoCalculated = true;
// intersect alignment annotation with alignment groups
AlignmentAnnotation[] aan = alignment.getAlignmentAnnotation();
- List<SequenceGroup> oldrfs = new ArrayList<SequenceGroup>();
+ List<SequenceGroup> oldrfs = new ArrayList<>();
if (aan != null)
{
for (int an = 0; an < aan.length; an++)
viewStyle = new ViewStyle(settingsForView);
if (residueShading != null)
{
- residueShading.setConservationApplied(settingsForView
- .isConservationColourSelected());
+ residueShading.setConservationApplied(
+ settingsForView.isConservationColourSelected());
}
}
return sortAnnotationsBy;
}
- public void setSortAnnotationsBy(SequenceAnnotationOrder sortAnnotationsBy)
+ public void setSortAnnotationsBy(
+ SequenceAnnotationOrder sortAnnotationsBy)
{
this.sortAnnotationsBy = sortAnnotationsBy;
}
viewStyle.setScaleProteinAsCdna(b);
}
- /**
- * @return true if view should scroll to show the highlighted region of a
- * sequence
- * @return
- */
@Override
- public final boolean isFollowHighlight()
+ public boolean isProteinFontAsCdna()
{
- return followHighlight;
+ return viewStyle.isProteinFontAsCdna();
}
@Override
- public final void setFollowHighlight(boolean b)
+ public void setProteinFontAsCdna(boolean b)
{
- this.followHighlight = b;
+ viewStyle.setProteinFontAsCdna(b);
}
@Override
- public ViewportPositionProps getPosProps()
+ public void setShowComplementFeatures(boolean b)
{
- return posProps;
+ viewStyle.setShowComplementFeatures(b);
}
@Override
- public int getStartRes()
+ public boolean isShowComplementFeatures()
{
- return posProps.getStartRes();
+ return viewStyle.isShowComplementFeatures();
}
@Override
- public int getEndRes()
+ public void setShowComplementFeaturesOnTop(boolean b)
{
- return posProps.getEndRes();
+ viewStyle.setShowComplementFeaturesOnTop(b);
}
@Override
- public int getStartSeq()
- {
- return posProps.getStartSeq();
- }
-
- public void setStartRes(int res)
- {
- posProps.setStartRes(res);
- // this.startRes = res;
- }
-
- public void setStartSeq(int seq)
+ public boolean isShowComplementFeaturesOnTop()
{
- posProps.setStartSeq(seq);
- // this.startSeq = seq;
+ return viewStyle.isShowComplementFeaturesOnTop();
}
- public void setEndRes(int res)
+ /**
+ * @return true if view should scroll to show the highlighted region of a
+ * sequence
+ * @return
+ */
+ @Override
+ public final boolean isFollowHighlight()
{
- posProps.setEndRes(res);
- /*if (res > alignment.getWidth() - 1)
- {
- // log.System.out.println(" Corrected res from " + res + " to maximum " +
- // (alignment.getWidth()-1));
- res = alignment.getWidth() - 1;
- }
- if (res < 0)
- {
- res = 0;
- }
- this.endRes = res;*/
+ return followHighlight;
}
- public void setEndSeq(int seq)
+ @Override
+ public final void setFollowHighlight(boolean b)
{
- posProps.setEndSeq(seq);
- /*if (seq > alignment.getHeight())
- {
- seq = alignment.getHeight();
- }
- if (seq < 0)
- {
- seq = 0;
- }
- this.endSeq = seq;*/
+ this.followHighlight = b;
}
@Override
- public int getEndSeq()
+ public ViewportRanges getRanges()
{
- return posProps.getEndSeq();
- // return endSeq;
+ return ranges;
}
/**
return 0;
}
boolean iAmProtein = !getAlignment().isNucleotide();
- AlignmentI proteinAlignment = iAmProtein ? getAlignment() : complement
- .getAlignment();
+ AlignmentI proteinAlignment = iAmProtein ? getAlignment()
+ : complement.getAlignment();
if (proteinAlignment == null)
{
return 0;
* locate 'middle' column (true middle if an odd number visible, left of
* middle if an even number visible)
*/
- int middleColumn = getStartRes() + (getEndRes() - getStartRes()) / 2;
+ int middleColumn = ranges.getStartRes()
+ + (ranges.getEndRes() - ranges.getStartRes()) / 2;
final HiddenSequences hiddenSequences = getAlignment()
.getHiddenSequences();
*/
int lastSeq = alignment.getHeight() - 1;
List<AlignedCodonFrame> seqMappings = null;
- for (int seqNo = getStartSeq(); seqNo < lastSeq; seqNo++, seqOffset++)
+ for (int seqNo = ranges
+ .getStartSeq(); seqNo <= lastSeq; seqNo++, seqOffset++)
{
sequence = getAlignment().getSequenceAt(seqNo);
if (hiddenSequences != null && hiddenSequences.isHidden(sequence))
{
continue;
}
- seqMappings = MappingUtils
- .findMappingsForSequenceAndOthers(sequence, mappings,
- getCodingComplement().getAlignment().getSequences());
+ seqMappings = MappingUtils.findMappingsForSequenceAndOthers(sequence,
+ mappings,
+ getCodingComplement().getAlignment().getSequences());
if (!seqMappings.isEmpty())
{
break;
*/
public void expandColSelection(SequenceGroup sg, boolean wholewidth)
{
- if (!this.hasSelectedColumns())
- {
- posProps.expandColSelection(sg, wholewidth);
- }
- /*int sgs, sge;
+ int sgs, sge;
if (sg != null && (sgs = sg.getStartRes()) >= 0
&& sg.getStartRes() <= (sge = sg.getEndRes())
&& !this.hasSelectedColumns())
{
colSel.addElement(cspos);
}
- }*/
+ }
}
/**
*/
private boolean selectionIsDefinedGroup = false;
-
@Override
public boolean isSelectionDefinedGroup()
{
selectionIsDefinedGroup = gps.contains(selectionGroup);
}
}
- return selectionGroup.getContext() == alignment
- || selectionIsDefinedGroup;
+ return selectionGroup.isDefined() || selectionIsDefinedGroup;
}
/**
*/
private SearchResultsI searchResults = null;
+ protected TreeModel currentTree = null;
+
@Override
public boolean hasSearchResults()
{
{
return searchResults;
}
+
+ /**
+ * get the consensus sequence as displayed under the PID consensus annotation
+ * row.
+ *
+ * @return consensus sequence as a new sequence object
+ */
+ public SequenceI getConsensusSeq()
+ {
+ if (consensus == null)
+ {
+ updateConsensus(null);
+ }
+ if (consensus == null)
+ {
+ return null;
+ }
+ StringBuffer seqs = new StringBuffer();
+ for (int i = 0; i < consensus.annotations.length; i++)
+ {
+ Annotation annotation = consensus.annotations[i];
+ if (annotation != null)
+ {
+ String description = annotation.description;
+ if (description != null && description.startsWith("["))
+ {
+ // consensus is a tie - just pick the first one
+ seqs.append(description.charAt(1));
+ }
+ else
+ {
+ seqs.append(annotation.displayCharacter);
+ }
+ }
+ }
+
+ SequenceI sq = new Sequence("Consensus", seqs.toString());
+ sq.setDescription("Percentage Identity Consensus "
+ + ((ignoreGapsInConsensusCalculation) ? " without gaps" : ""));
+ return sq;
+ }
+
+ @Override
+ public void setCurrentTree(TreeModel tree)
+ {
+ currentTree = tree;
+ }
+
+ @Override
+ public TreeModel getCurrentTree()
+ {
+ return currentTree;
+ }
+
+ /**
+ * flag set to indicate if structure views might be out of sync with sequences
+ * in the alignment
+ */
+
+ private boolean needToUpdateStructureViews = false;
+
+ @Override
+ public boolean isUpdateStructures()
+ {
+ return needToUpdateStructureViews;
+ }
+
+ @Override
+ public void setUpdateStructures(boolean update)
+ {
+ needToUpdateStructureViews = update;
+ }
+
+ @Override
+ public boolean needToUpdateStructureViews()
+ {
+ boolean update = needToUpdateStructureViews;
+ needToUpdateStructureViews = false;
+ return update;
+ }
+
+ @Override
+ public void addSequenceGroup(SequenceGroup sequenceGroup)
+ {
+ alignment.addGroup(sequenceGroup);
+
+ Color col = sequenceGroup.idColour;
+ if (col != null)
+ {
+ col = col.brighter();
+
+ for (SequenceI sq : sequenceGroup.getSequences())
+ {
+ setSequenceColour(sq, col);
+ }
+ }
+
+ if (codingComplement != null)
+ {
+ SequenceGroup mappedGroup = MappingUtils
+ .mapSequenceGroup(sequenceGroup, this, codingComplement);
+ if (mappedGroup.getSequences().size() > 0)
+ {
+ codingComplement.getAlignment().addGroup(mappedGroup);
+
+ if (col != null)
+ {
+ for (SequenceI seq : mappedGroup.getSequences())
+ {
+ codingComplement.setSequenceColour(seq, col);
+ }
+ }
+ }
+ // propagate the structure view update flag according to our own setting
+ codingComplement.setUpdateStructures(needToUpdateStructureViews);
+ }
+ }
}
git://source.jalview.org / jalview.git / blobdiff