/*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
- * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.0b1)
+ * Copyright (C) 2014 The Jalview Authors
*
* This file is part of Jalview.
*
* Jalview is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
- *
+ *
* Jalview is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with Jalview. If not, see <http://www.gnu.org/licenses/>.
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
*/
package jalview.viewmodel;
+import jalview.analysis.AAFrequency;
import jalview.analysis.Conservation;
import jalview.api.AlignCalcManagerI;
import jalview.api.AlignViewportI;
import jalview.datamodel.Annotation;
import jalview.datamodel.ColumnSelection;
import jalview.datamodel.Sequence;
+import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
+import jalview.schemes.Blosum62ColourScheme;
import jalview.schemes.ClustalxColourScheme;
import jalview.schemes.ColourSchemeI;
+import jalview.schemes.PIDColourScheme;
import jalview.schemes.ResidueProperties;
import jalview.workers.AlignCalcManager;
import jalview.workers.ConsensusThread;
-import jalview.workers.ConservationThread;
import jalview.workers.StrucConsensusThread;
+import java.awt.Color;
+import java.util.ArrayList;
+import java.util.BitSet;
import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
import java.util.Vector;
/**
- * base class holding visualization and analysis attributes and common logic for an active alignment view displayed in the GUI
+ * base class holding visualization and analysis attributes and common logic for
+ * an active alignment view displayed in the GUI
+ *
* @author jimp
- *
+ *
*/
public abstract class AlignmentViewport implements AlignViewportI
{
protected String sequenceSetID;
/**
- * probably unused indicator that view is of a dataset rather than an alignment
+ * probably unused indicator that view is of a dataset rather than an
+ * alignment
*/
protected boolean isDataset = false;
- private Hashtable hiddenRepSequences;
+ private Map<SequenceI, SequenceCollectionI> hiddenRepSequences;
protected ColumnSelection colSel = new ColumnSelection();
-
public boolean autoCalculateConsensus = true;
protected boolean autoCalculateStrucConsensus = true;
protected boolean ignoreGapsInConsensusCalculation = false;
-
protected ColourSchemeI globalColourScheme = null;
+ /**
+ * gui state - changes to colour scheme propagated to all groups
+ */
+ private boolean colourAppliesToAllGroups;
+
+ /**
+ * @param value
+ * indicating if subsequent colourscheme changes will be propagated
+ * to all groups
+ */
+ public void setColourAppliesToAllGroups(boolean b)
+ {
+ colourAppliesToAllGroups = b;
+ }
+
+ /**
+ *
+ *
+ * @return flag indicating if colourchanges propagated to all groups
+ */
+ public boolean getColourAppliesToAllGroups()
+ {
+ return colourAppliesToAllGroups;
+ }
+
+ boolean abovePIDThreshold = false;
+
+ /**
+ * GUI state
+ *
+ * @return true if percent identity threshold is applied to shading
+ */
+ public boolean getAbovePIDThreshold()
+ {
+ return abovePIDThreshold;
+ }
+
+ /**
+ * GUI state
+ *
+ *
+ * @param b
+ * indicate if percent identity threshold is applied to shading
+ */
+ public void setAbovePIDThreshold(boolean b)
+ {
+ abovePIDThreshold = b;
+ }
+
+ int threshold;
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param thresh
+ * DOCUMENT ME!
+ */
+ public void setThreshold(int thresh)
+ {
+ threshold = thresh;
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @return DOCUMENT ME!
+ */
+ public int getThreshold()
+ {
+ return threshold;
+ }
+
+ int increment;
+
+ /**
+ *
+ * @param inc
+ * set the scalar for bleaching colourschemes according to degree of
+ * conservation
+ */
+ public void setIncrement(int inc)
+ {
+ increment = inc;
+ }
+
+ /**
+ * GUI State
+ *
+ * @return get scalar for bleaching colourschemes by conservation
+ */
+ public int getIncrement()
+ {
+ return increment;
+ }
+
+ boolean conservationColourSelected = false;
+ /**
+ * GUI state
+ *
+ * @return true if conservation based shading is enabled
+ */
+ public boolean getConservationSelected()
+ {
+ return conservationColourSelected;
+ }
+
+ /**
+ * GUI state
+ *
+ * @param b
+ * enable conservation based shading
+ */
+ public void setConservationSelected(boolean b)
+ {
+ conservationColourSelected = b;
+ }
+
+ @Override
public void setGlobalColourScheme(ColourSchemeI cs)
{
+ // TODO: logic refactored from AlignFrame changeColour -
+ // 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
+ // - 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;
+ if (cs!=null)
+ {
+ cs.setConservationApplied(recalc = getConservationSelected());
+ if (getAbovePIDThreshold() || cs instanceof PIDColourScheme || cs instanceof Blosum62ColourScheme)
+ {
+ recalc = true;
+ cs.setThreshold(threshold, ignoreGapsInConsensusCalculation);
+ } else {
+ cs.setThreshold(0, ignoreGapsInConsensusCalculation);
+ }
+ if (recalc)
+ {
+ cs.setConsensus(hconsensus);
+ cs.setConservation(hconservation);
+ }
+ cs.alignmentChanged(alignment, hiddenRepSequences);
+ }
+ 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(threshold, getIgnoreGapsConsensus());
+ recalc=true;
+ }
+ else
+ {
+ sg.cs.setThreshold(0, getIgnoreGapsConsensus());
+ }
+
+ if (getConservationSelected())
+ {
+ 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);
+ }
+ }
+ }
+
}
+ @Override
public ColourSchemeI getGlobalColourScheme()
{
return globalColourScheme;
}
-
protected AlignmentAnnotation consensus;
protected AlignmentAnnotation strucConsensus;
protected AlignmentAnnotation[] groupConservation;
- /**
- * results of alignment consensus analysis for visible portion of view
+ /**
+ * results of alignment consensus analysis for visible portion of view
*/
- protected Hashtable[] hconsensus=null;
+ protected Hashtable[] hconsensus = null;
/**
- * results of secondary structure base pair consensus for visible portion of view
+ * results of secondary structure base pair consensus for visible portion of
+ * view
*/
- protected Hashtable[] hStrucConsensus=null;
-
+ protected Hashtable[] hStrucConsensus = null;
+
+ protected Conservation hconservation = null;
+ @Override
+ public void setConservation(Conservation cons)
+ {
+ hconservation = cons;
+ }
/**
- * percentage gaps allowed in a column before all amino acid properties should be considered unconserved
+ * percentage gaps allowed in a column before all amino acid properties should
+ * be considered unconserved
*/
int ConsPercGaps = 25; // JBPNote : This should be a scalable property!
-
+ @Override
public int getConsPercGaps()
{
return ConsPercGaps;
}
+
@Override
public void setSequenceConsensusHash(Hashtable[] hconsensus)
{
- this.hconsensus=hconsensus;
-
+ this.hconsensus = hconsensus;
+
}
@Override
{
return hStrucConsensus;
}
+
@Override
public void setRnaStructureConsensusHash(Hashtable[] hStrucConsensus)
{
- this.hStrucConsensus=hStrucConsensus;
-
+ this.hStrucConsensus = hStrucConsensus;
+
}
+
@Override
public AlignmentAnnotation getAlignmentQualityAnnot()
{
{
return conservation;
}
+
@Override
public AlignmentAnnotation getAlignmentConsensusAnnotation()
{
return consensus;
}
+
@Override
public AlignmentAnnotation getAlignmentStrucConsensusAnnotation()
{
return strucConsensus;
}
-
- protected AlignCalcManagerI calculator=new AlignCalcManager();
-
- jalview.workers.ConsensusThread consensusThread;
-
- StrucConsensusThread strucConsensusThread;
-
- private ConservationThread conservationThread;
+ protected AlignCalcManagerI calculator = new AlignCalcManager();
/**
* trigger update of conservation annotation
{
return;
}
-
- calculator.startWorker(conservationThread=new jalview.workers.ConservationThread(this, ap));
+ if (calculator
+ .getRegisteredWorkersOfClass(jalview.workers.ConservationThread.class) == null)
+ {
+ calculator.registerWorker(new jalview.workers.ConservationThread(
+ this, ap));
+ }
}
/**
{
return;
}
- calculator.startWorker(consensusThread = new ConsensusThread(this, ap));
+ if (calculator.getRegisteredWorkersOfClass(ConsensusThread.class) == null)
+ {
+ calculator.registerWorker(new ConsensusThread(this, ap));
+ }
}
// --------START Structure Conservation
public void updateStrucConsensus(final AlignmentViewPanel ap)
{
- if (autoCalculateStrucConsensus && strucConsensus==null && alignment.isNucleotide() && alignment.hasRNAStructure())
+ if (autoCalculateStrucConsensus && strucConsensus == null
+ && alignment.isNucleotide() && alignment.hasRNAStructure())
{
-
+ // secondary structure has been added - so init the consensus line
+ initRNAStructure();
}
// see note in mantis : issue number 8585
{
return;
}
- calculator.startWorker(strucConsensusThread = new StrucConsensusThread(this,ap));
+ if (calculator.getRegisteredWorkersOfClass(StrucConsensusThread.class) == null)
+ {
+ calculator.registerWorker(new StrucConsensusThread(this, ap));
+ }
}
public boolean isCalcInProgress()
return calculator.isWorking();
}
+ @Override
public boolean isCalculationInProgress(
AlignmentAnnotation alignmentAnnotation)
{
if (!alignmentAnnotation.autoCalculated)
return false;
- if ((calculator.isWorking(consensusThread) && consensus==alignmentAnnotation)
- || (calculator.isWorking(conservationThread) && (conservation==alignmentAnnotation || quality==alignmentAnnotation))
- || (calculator.isWorking(strucConsensusThread) && strucConsensus==alignmentAnnotation)
- )
+ if (calculator.workingInvolvedWith(alignmentAnnotation))
{
+ // System.err.println("grey out ("+alignmentAnnotation.label+")");
return true;
}
return false;
}
+
@Override
public boolean isClosed()
{
- // TODO: check that this isClosed is only true after panel is closed, not before it is fully constructed.
- return alignment==null;
+ // TODO: check that this isClosed is only true after panel is closed, not
+ // before it is fully constructed.
+ return alignment == null;
}
@Override
* should consensus profile be rendered by default
*/
protected boolean showSequenceLogo = false;
+
/**
* should consensus profile be rendered normalised to row height
*/
protected boolean normaliseSequenceLogo = false;
+
/**
* should consensus histograms be rendered by default
*/
/**
* @return the showConsensusProfile
*/
+ @Override
public boolean isShowSequenceLogo()
{
return showSequenceLogo;
// TODO: decouple settings setting from calculation when refactoring
// annotation update method from alignframe to viewport
this.showSequenceLogo = showSequenceLogo;
- if (consensusThread != null)
- {
- consensusThread.updateAnnotation();
- }
- if (strucConsensusThread != null)
- {
- strucConsensusThread.updateAnnotation();
- }
+ calculator.updateAnnotationFor(ConsensusThread.class);
+ calculator.updateAnnotationFor(StrucConsensusThread.class);
}
this.showSequenceLogo = showSequenceLogo;
}
* @return flag to indicate if the consensus histogram should be rendered by
* default
*/
+ @Override
public boolean isShowConsensusHistogram()
{
return this.showConsensusHistogram;
*/
protected boolean showUnconserved = false;
-
/**
* when set, updateAlignment will always ensure sequences are of equal length
*/
*
* @return null or the currently selected sequence region
*/
+ @Override
public SequenceGroup getSelectionGroup()
{
return selectionGroup;
* - group holding references to sequences in this alignment view
*
*/
+ @Override
public void setSelectionGroup(SequenceGroup sg)
{
selectionGroup = sg;
}
}
+ @Override
public ColumnSelection getColumnSelection()
{
return colSel;
}
+
public void setColumnSelection(ColumnSelection colSel)
{
- this.colSel=colSel;
+ this.colSel = colSel;
}
- public Hashtable getHiddenRepSequences()
+
+ /**
+ *
+ * @return
+ */
+ @Override
+ public Map<SequenceI, SequenceCollectionI> getHiddenRepSequences()
{
return hiddenRepSequences;
}
- public void setHiddenRepSequences(Hashtable hiddenRepSequences)
+
+ @Override
+ public void setHiddenRepSequences(
+ Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
{
this.hiddenRepSequences = hiddenRepSequences;
}
+
protected boolean hasHiddenColumns = false;
public void updateHiddenColumns()
{
- hasHiddenColumns = colSel.getHiddenColumns() != null;
+ hasHiddenColumns = colSel.getHiddenColumns() != null;
}
-
+
protected boolean hasHiddenRows = false;
-
- public boolean hasHiddenRows() {
+
+ public boolean hasHiddenRows()
+ {
return hasHiddenRows;
}
public void setSequenceSetId(String newid)
{
- if (sequenceSetID!=null)
+ 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);
+ sequenceSetID = new String(newid);
}
+
public String getSequenceSetId()
{
if (sequenceSetID == null)
return sequenceSetID;
}
+
/**
* unique viewId for synchronizing state (e.g. with stored Jalview Project)
*
}
return viewId;
}
+
public void setIgnoreGapsConsensus(boolean b, AlignmentViewPanel ap)
{
ignoreGapsInConsensusCalculation = b;
- if (ap!=null) {updateConsensus(ap);
- if (globalColourScheme != null)
+ if (ap != null)
{
- globalColourScheme.setThreshold(globalColourScheme.getThreshold(),
- ignoreGapsInConsensusCalculation);
- }}
-
+ updateConsensus(ap);
+ if (globalColourScheme != null)
+ {
+ globalColourScheme.setThreshold(globalColourScheme.getThreshold(),
+ ignoreGapsInConsensusCalculation);
+ }
+ }
+
}
+
private long sgrouphash = -1, colselhash = -1;
/**
return false;
}
+ @Override
public boolean getIgnoreGapsConsensus()
{
return ignoreGapsInConsensusCalculation;
}
- /// property change stuff
+ // / property change stuff
// JBPNote Prolly only need this in the applet version.
- private java.beans.PropertyChangeSupport changeSupport = new java.beans.PropertyChangeSupport(
+ private final java.beans.PropertyChangeSupport changeSupport = new java.beans.PropertyChangeSupport(
this);
protected boolean showConservation = true;
protected boolean showConsensus = true;
+ Hashtable sequenceColours;
/**
* Property change listener for changes in alignment
}
// common hide/show column stuff
-
public void hideSelectedColumns()
{
hasHiddenColumns = false;
}
-
// common hide/show seq stuff
public void showAllHiddenSeqs()
{
hiddenRepSequences = null;
firePropertyChange("alignment", null, alignment.getSequences());
- // used to set hasHiddenRows/hiddenRepSequences here, after the property changed event
+ // used to set hasHiddenRows/hiddenRepSequences here, after the property
+ // changed event
sendSelection();
}
}
{
selectionGroup.addSequence((SequenceI) tmp.elementAt(t), false);
}
- // JBPNote: refactor: only update flag if we modified visiblity (used to do this regardless)
+ // JBPNote: refactor: only update flag if we modified visiblity (used to
+ // do this regardless)
if (alignment.getHiddenSequences().getSize() < 1)
{
hasHiddenRows = false;
}
}
-
-
public void hideAllSelectedSeqs()
{
if (selectionGroup == null || selectionGroup.getSize() < 1)
setSelectionGroup(null);
}
-
public void hideSequence(SequenceI[] seq)
{
seqs[index++] = sg.getSequenceAt(i);
}
}
- sg.setSeqrep(repSequence); // note: not done in 2.7applet
+ sg.setSeqrep(repSequence); // note: not done in 2.7applet
sg.setHidereps(true); // note: not done in 2.7applet
hideSequence(seqs);
public boolean isHiddenRepSequence(SequenceI seq)
{
return hiddenRepSequences != null
- && hiddenRepSequences.containsKey(seq);
+ && hiddenRepSequences.containsKey(seq);
}
+
public SequenceGroup getRepresentedSequences(SequenceI seq)
{
- return (SequenceGroup) (hiddenRepSequences == null ? null : hiddenRepSequences.get(seq));
+ return (SequenceGroup) (hiddenRepSequences == null ? null
+ : hiddenRepSequences.get(seq));
}
public int adjustForHiddenSeqs(int alignmentIndex)
* broadcast selection to any interested parties
*/
public abstract void sendSelection();
-
public void invertColumnSelection()
{
colSel.invertColumnSelection(0, alignment.getWidth());
}
-
/**
* This method returns an array of new SequenceI objects derived from the
* whole alignment or just the current selection with start and end points
public SequenceI[] getSelectionAsNewSequence()
{
SequenceI[] sequences;
- // JBPNote: Need to test jalviewLite.getSelectedSequencesAsAlignmentFrom - this was the only caller in the applet for this method
- // JBPNote: in applet, this method returned references to the alignment sequences, and it did not honour the presence/absence of annotation attached to the alignment (probably!)
- if (selectionGroup == null)
+ // JBPNote: Need to test jalviewLite.getSelectedSequencesAsAlignmentFrom -
+ // this was the only caller in the applet for this method
+ // JBPNote: in applet, this method returned references to the alignment
+ // sequences, and it did not honour the presence/absence of annotation
+ // attached to the alignment (probably!)
+ if (selectionGroup == null || selectionGroup.getSize() == 0)
{
sequences = alignment.getSequencesArray();
AlignmentAnnotation[] annots = alignment.getAlignmentAnnotation();
return sequences;
}
-
/**
* get the currently selected sequence objects or all the sequences in the
* alignment.
*
* @return array of references to sequence objects
*/
+ @Override
public SequenceI[] getSequenceSelection()
{
SequenceI[] sequences = null;
return sequences;
}
-
/**
* This method returns the visible alignment as text, as seen on the GUI, ie
* if columns are hidden they will not be returned in the result. Use this for
*
* @return String[]
*/
+ @Override
public jalview.datamodel.CigarArray getViewAsCigars(
boolean selectedRegionOnly)
{
* boolean true to just return the selected view
* @return AlignmentView
*/
+ @Override
public jalview.datamodel.AlignmentView getAlignmentView(
boolean selectedOnly)
{
* is true)
* @return AlignmentView
*/
+ @Override
public jalview.datamodel.AlignmentView getAlignmentView(
boolean selectedOnly, boolean markGroups)
{
hasHiddenColumns, selectedOnly, markGroups);
}
-
/**
* This method returns the visible alignment as text, as seen on the GUI, ie
* if columns are hidden they will not be returned in the result. Use this for
*
* @return String[]
*/
+ @Override
public String[] getViewAsString(boolean selectedRegionOnly)
{
String[] selection = null;
return selection;
}
-
/**
* return visible region boundaries within given column range
- * @param min first column (inclusive, from 0)
- * @param max last column (exclusive)
+ *
+ * @param min
+ * first column (inclusive, from 0)
+ * @param max
+ * last column (exclusive)
* @return int[][] range of {start,end} visible positions
*/
public int[][] getVisibleRegionBoundaries(int min, int max)
return startEnd;
}
+
/**
* @return the padGaps
*/
{
return padGaps;
}
+
/**
- * @param padGaps the padGaps to set
+ * @param padGaps
+ * the padGaps to set
*/
public void setPadGaps(boolean padGaps)
{
this.padGaps = padGaps;
}
+
/**
- * apply any post-edit constraints and trigger any calculations needed after an edit has been performed on the alignment
+ * apply any post-edit constraints and trigger any calculations needed after
+ * an edit has been performed on the alignment
+ *
* @param ap
*/
public void alignmentChanged(AlignmentViewPanel ap)
// Reset endRes of groups if beyond alignment width
int alWidth = alignment.getWidth();
- Vector groups = alignment.getGroups();
+ List<SequenceGroup> groups = alignment.getGroups();
if (groups != null)
{
- for (int i = 0; i < groups.size(); i++)
+ for (SequenceGroup sg : groups)
{
- SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
if (sg.getEndRes() > alWidth)
{
sg.setEndRes(alWidth - 1);
}
resetAllColourSchemes();
-
+ calculator.restartWorkers();
// alignment.adjustSequenceAnnotations();
}
-
/**
* reset scope and do calculations for all applied colourschemes on alignment
*/
ColourSchemeI cs = globalColourScheme;
if (cs != null)
{
- if (cs instanceof ClustalxColourScheme)
- {
- ((ClustalxColourScheme) cs).resetClustalX(alignment.getSequences(),
- alignment.getWidth());
- }
+ cs.alignmentChanged(alignment, hiddenRepSequences);
cs.setConsensus(hconsensus);
if (cs.conservationApplied())
}
}
- int s, sSize = alignment.getGroups().size();
- for (s = 0; s < sSize; s++)
+ for (SequenceGroup sg : alignment.getGroups())
{
- SequenceGroup sg = (SequenceGroup) alignment.getGroups().elementAt(s);
- if (sg.cs != null && sg.cs instanceof ClustalxColourScheme)
+ if (sg.cs != null)
{
- ((ClustalxColourScheme) sg.cs).resetClustalX(sg
- .getSequences(hiddenRepSequences), sg.getWidth());
+ sg.cs.alignmentChanged(sg, hiddenRepSequences);
}
sg.recalcConservation();
}
{
if (!alignment.isNucleotide())
{
- if (showConservation)
- {
- if (conservation==null)
- {
+ initConservation();
+ initQuality();
+ }
+ else
+ {
+ initRNAStructure();
+ }
+ initConsensus();
+ }
+ }
+
+ private void initConsensus()
+ {
+
+ consensus = new AlignmentAnnotation("Consensus", "PID",
+ new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
+ consensus.hasText = true;
+ consensus.autoCalculated = true;
+
+ if (showConsensus)
+ {
+ alignment.addAnnotation(consensus);
+ }
+ }
+
+ 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,
+ "Conservation of total alignment less than "
+ + getConsPercGaps() + "% gaps",
+ new Annotation[1], 0f, 11f,
AlignmentAnnotation.BAR_GRAPH);
conservation.hasText = true;
conservation.autoCalculated = true;
- alignment.addAnnotation(conservation);
+ alignment.addAnnotation(conservation);
+ }
+ }
+ }
+ private void initQuality()
+ {
+ if (showQuality)
+ {
+ if (quality == null)
+ {
+ quality = new AlignmentAnnotation("Quality",
+ "Alignment Quality based on Blosum62 scores",
+ new Annotation[1], 0f, 11f,
+ AlignmentAnnotation.BAR_GRAPH);
+ quality.hasText = true;
+ quality.autoCalculated = true;
+ alignment.addAnnotation(quality);
+ }
+ }
+ }
+ private void initRNAStructure()
+ {
+ if (alignment.hasRNAStructure() && strucConsensus==null)
+ {
+ strucConsensus = new AlignmentAnnotation("StrucConsensus", "PID",
+ new Annotation[1], 0f, 100f,
+ AlignmentAnnotation.BAR_GRAPH);
+ strucConsensus.hasText = true;
+ strucConsensus.autoCalculated = true;
+
+ if (showConsensus)
+ {
+ alignment.addAnnotation(strucConsensus);
+ }
+ }
+ }
+ /*
+ * (non-Javadoc)
+ *
+ * @see jalview.api.AlignViewportI#calcPanelHeight()
+ */
+ public int calcPanelHeight()
+ {
+ // setHeight of panels
+ AlignmentAnnotation[] aa = getAlignment().getAlignmentAnnotation();
+ int height = 0;
+ int charHeight = getCharHeight();
+ if (aa != null)
+ {
+ BitSet graphgrp = new BitSet();
+ for (int i = 0; i < aa.length; i++)
+ {
+ if (aa[i] == null)
+ {
+ System.err.println("Null annotation row: ignoring.");
+ continue;
}
+ if (!aa[i].visible)
+ {
+ continue;
}
- if (showQuality)
+ if (aa[i].graphGroup > -1)
{
- if (quality==null)
+ if (graphgrp.get(aa[i].graphGroup))
+ {
+ continue;
+ }
+ else
{
- quality = new AlignmentAnnotation("Quality",
- "Alignment Quality based on Blosum62 scores",
- new Annotation[1], 0f, 11f, AlignmentAnnotation.BAR_GRAPH);
- quality.hasText = true;
- quality.autoCalculated = true;
- alignment.addAnnotation(quality);
+ graphgrp.set(aa[i].graphGroup);
+ }
}
+ aa[i].height = 0;
+
+ if (aa[i].hasText)
+ {
+ aa[i].height += charHeight;
}
- } else {
- if (alignment.hasRNAStructure())
+
+ if (aa[i].hasIcons)
+ {
+ aa[i].height += 16;
+ }
+
+ if (aa[i].graph > 0)
+ {
+ aa[i].height += aa[i].graphHeight;
+ }
+
+ if (aa[i].height == 0)
{
- strucConsensus = new AlignmentAnnotation("StrucConsensus", "PID",
- new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
- strucConsensus.hasText = true;
- strucConsensus.autoCalculated = true;
+ aa[i].height = 20;
}
+
+ height += aa[i].height;
}
-
- consensus = new AlignmentAnnotation("Consensus", "PID",
- new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
- consensus.hasText = true;
- consensus.autoCalculated = true;
-
- if (showConsensus)
+ }
+ if (height == 0)
+ {
+ // set minimum
+ height = 20;
+ }
+ return height;
+ }
+
+ @Override
+ public void updateGroupAnnotationSettings(boolean applyGlobalSettings,
+ boolean preserveNewGroupSettings)
+ {
+ boolean updateCalcs = false;
+ boolean conv = isShowGroupConservation();
+ boolean cons = isShowGroupConsensus();
+ boolean showprf = isShowSequenceLogo();
+ boolean showConsHist = isShowConsensusHistogram();
+ boolean normLogo = isNormaliseSequenceLogo();
+
+ /**
+ * TODO reorder the annotation rows according to group/sequence ordering on
+ * alignment
+ */
+ boolean sortg = true;
+
+ // remove old automatic annotation
+ // add any new annotation
+
+ // intersect alignment annotation with alignment groups
+
+ AlignmentAnnotation[] aan = alignment.getAlignmentAnnotation();
+ List<SequenceGroup> oldrfs = new ArrayList<SequenceGroup>();
+ if (aan != null)
+ {
+ for (int an = 0; an < aan.length; an++)
{
- alignment.addAnnotation(consensus);
- if (strucConsensus!=null)
+ if (aan[an].autoCalculated && aan[an].groupRef != null)
{
- alignment.addAnnotation(strucConsensus);
+ oldrfs.add(aan[an].groupRef);
+ alignment.deleteAnnotation(aan[an],false);
}
}
}
+ if (alignment.getGroups() != null)
+ {
+ for (SequenceGroup sg : alignment.getGroups())
+ {
+ updateCalcs = false;
+ if (applyGlobalSettings
+ || (!preserveNewGroupSettings && !oldrfs.contains(sg)))
+ {
+ // set defaults for this group's conservation/consensus
+ sg.setshowSequenceLogo(showprf);
+ sg.setShowConsensusHistogram(showConsHist);
+ sg.setNormaliseSequenceLogo(normLogo);
+ }
+ if (conv)
+ {
+ updateCalcs = true;
+ alignment.addAnnotation(sg.getConservationRow(), 0);
+ }
+ if (cons)
+ {
+ updateCalcs = true;
+ alignment.addAnnotation(sg.getConsensus(), 0);
+ }
+ // refresh the annotation rows
+ if (updateCalcs)
+ {
+ sg.recalcConservation();
+ }
+ }
+ }
+ oldrfs.clear();
}
+ @Override
+ public Color getSequenceColour(SequenceI seq)
+ {
+ Color sqc=Color.white;
+ if (sequenceColours != null)
+ {
+ sqc = (Color) sequenceColours.get(seq);
+ if (sqc == null) {
+ sqc = Color.white;
+ }
+ }
+ return sqc;
+ }
+
+ @Override
+ public void setSequenceColour(SequenceI seq, Color col)
+ {
+ if (sequenceColours == null)
+ {
+ sequenceColours = new Hashtable();
+ }
+
+ if (col == null)
+ {
+ sequenceColours.remove(seq);
+ }
+ else
+ {
+ sequenceColours.put(seq, col);
+ }
+ }
+
+ @Override
+ public void updateSequenceIdColours()
+ {
+ if (sequenceColours == null)
+ {
+ sequenceColours = new Hashtable();
+ }
+ for (SequenceGroup sg : alignment.getGroups())
+ {
+ if (sg.idColour != null)
+ {
+ for (SequenceI s : sg.getSequences(getHiddenRepSequences()))
+ {
+ sequenceColours.put(s, sg.idColour);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void clearSequenceColours()
+ {
+ sequenceColours = null;
+ };
}
git://source.jalview.org / jalview.git / blobdiff