/*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
- * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
+ * 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.
+ * 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/>.
+ * 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.api.AlignmentViewPanel;
+import jalview.api.FeaturesDisplayedI;
+import jalview.api.ViewStyleI;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.AlignmentView;
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.viewmodel.styles.ViewStyle;
import jalview.workers.AlignCalcManager;
import jalview.workers.ConsensusThread;
import jalview.workers.StrucConsensusThread;
* @author jimp
*
*/
-public abstract class AlignmentViewport implements AlignViewportI
+public abstract class AlignmentViewport implements AlignViewportI,
+ ViewStyleI
{
+ protected ViewStyleI viewStyle = new ViewStyle();
+
+
/**
- * alignment displayed in the viewport. Please use get/setter
+ * @param name
+ * @see jalview.api.ViewStyleI#setFontName(java.lang.String)
*/
- protected AlignmentI alignment;
+ public void setFontName(String name)
+ {
+ viewStyle.setFontName(name);
+ }
- protected String sequenceSetID;
+ /**
+ * @param style
+ * @see jalview.api.ViewStyleI#setFontStyle(int)
+ */
+ public void setFontStyle(int style)
+ {
+ viewStyle.setFontStyle(style);
+ }
/**
- * probably unused indicator that view is of a dataset rather than an
- * alignment
+ * @param size
+ * @see jalview.api.ViewStyleI#setFontSize(int)
*/
- protected boolean isDataset = false;
+ public void setFontSize(int size)
+ {
+ viewStyle.setFontSize(size);
+ }
- private Map<SequenceI, SequenceCollectionI> hiddenRepSequences;
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getFontStyle()
+ */
+ public int getFontStyle()
+ {
+ return viewStyle.getFontStyle();
+ }
- protected ColumnSelection colSel = new ColumnSelection();
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getFontName()
+ */
+ public String getFontName()
+ {
+ return viewStyle.getFontName();
+ }
- public boolean autoCalculateConsensus = true;
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getFontSize()
+ */
+ public int getFontSize()
+ {
+ return viewStyle.getFontSize();
+ }
- protected boolean autoCalculateStrucConsensus = true;
+ /**
+ * @param upperCasebold
+ * @see jalview.api.ViewStyleI#setUpperCasebold(boolean)
+ */
+ public void setUpperCasebold(boolean upperCasebold)
+ {
+ viewStyle.setUpperCasebold(upperCasebold);
+ }
- protected boolean ignoreGapsInConsensusCalculation = false;
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#isUpperCasebold()
+ */
+ public boolean isUpperCasebold()
+ {
+ return viewStyle.isUpperCasebold();
+ }
- protected ColourSchemeI globalColourScheme = null;
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#isSeqNameItalics()
+ */
+ public boolean isSeqNameItalics()
+ {
+ return viewStyle.isSeqNameItalics();
+ }
/**
- * gui state - changes to colour scheme propagated to all groups
+ * @param colourByReferenceSeq
+ * @see jalview.api.ViewStyleI#setColourByReferenceSeq(boolean)
*/
- private boolean colourAppliesToAllGroups;
+ public void setColourByReferenceSeq(boolean colourByReferenceSeq)
+ {
+ viewStyle.setColourByReferenceSeq(colourByReferenceSeq);
+ }
/**
- * @param value
- * indicating if subsequent colourscheme changes will be propagated
- * to all groups
+ * @param b
+ * @see jalview.api.ViewStyleI#setColourAppliesToAllGroups(boolean)
*/
public void setColourAppliesToAllGroups(boolean b)
{
- colourAppliesToAllGroups = b;
+ viewStyle.setColourAppliesToAllGroups(b);
}
/**
- *
- *
- * @return flag indicating if colourchanges propagated to all groups
+ * @return
+ * @see jalview.api.ViewStyleI#getColourAppliesToAllGroups()
*/
public boolean getColourAppliesToAllGroups()
{
- return colourAppliesToAllGroups;
+ return viewStyle.getColourAppliesToAllGroups();
}
- boolean abovePIDThreshold = false;
-
/**
- * GUI state
- *
- * @return true if percent identity threshold is applied to shading
+ * @return
+ * @see jalview.api.ViewStyleI#getAbovePIDThreshold()
*/
public boolean getAbovePIDThreshold()
{
- return abovePIDThreshold;
+ return viewStyle.getAbovePIDThreshold();
+ }
+
+ /**
+ * @param inc
+ * @see jalview.api.ViewStyleI#setIncrement(int)
+ */
+ public void setIncrement(int inc)
+ {
+ viewStyle.setIncrement(inc);
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getIncrement()
+ */
+ public int getIncrement()
+ {
+ return viewStyle.getIncrement();
}
/**
- * GUI state
- *
- *
* @param b
- * indicate if percent identity threshold is applied to shading
+ * @see jalview.api.ViewStyleI#setConservationSelected(boolean)
*/
- public void setAbovePIDThreshold(boolean b)
+ public void setConservationSelected(boolean b)
+ {
+ viewStyle.setConservationSelected(b);
+ }
+
+ /**
+ * @param show
+ * @see jalview.api.ViewStyleI#setShowHiddenMarkers(boolean)
+ */
+ public void setShowHiddenMarkers(boolean show)
{
- abovePIDThreshold = b;
+ viewStyle.setShowHiddenMarkers(show);
}
- int threshold;
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getShowHiddenMarkers()
+ */
+ public boolean getShowHiddenMarkers()
+ {
+ return viewStyle.getShowHiddenMarkers();
+ }
+
+ /**
+ * @param b
+ * @see jalview.api.ViewStyleI#setScaleRightWrapped(boolean)
+ */
+ public void setScaleRightWrapped(boolean b)
+ {
+ viewStyle.setScaleRightWrapped(b);
+ }
+
+ /**
+ * @param b
+ * @see jalview.api.ViewStyleI#setScaleLeftWrapped(boolean)
+ */
+ public void setScaleLeftWrapped(boolean b)
+ {
+ viewStyle.setScaleLeftWrapped(b);
+ }
+
+ /**
+ * @param b
+ * @see jalview.api.ViewStyleI#setScaleAboveWrapped(boolean)
+ */
+ public void setScaleAboveWrapped(boolean b)
+ {
+ viewStyle.setScaleAboveWrapped(b);
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getScaleLeftWrapped()
+ */
+ public boolean getScaleLeftWrapped()
+ {
+ return viewStyle.getScaleLeftWrapped();
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getScaleAboveWrapped()
+ */
+ public boolean getScaleAboveWrapped()
+ {
+ return viewStyle.getScaleAboveWrapped();
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getScaleRightWrapped()
+ */
+ public boolean getScaleRightWrapped()
+ {
+ return viewStyle.getScaleRightWrapped();
+ }
+
+ /**
+ * @param b
+ * @see jalview.api.ViewStyleI#setAbovePIDThreshold(boolean)
+ */
+ public void setAbovePIDThreshold(boolean b)
+ {
+ viewStyle.setAbovePIDThreshold(b);
+ }
/**
- * DOCUMENT ME!
- *
* @param thresh
- * DOCUMENT ME!
+ * @see jalview.api.ViewStyleI#setThreshold(int)
*/
public void setThreshold(int thresh)
{
- threshold = thresh;
+ viewStyle.setThreshold(thresh);
}
/**
- * DOCUMENT ME!
- *
- * @return DOCUMENT ME!
+ * @return
+ * @see jalview.api.ViewStyleI#getThreshold()
*/
public int getThreshold()
{
- return threshold;
+ return viewStyle.getThreshold();
}
- int increment;
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getShowJVSuffix()
+ */
+ public boolean getShowJVSuffix()
+ {
+ return viewStyle.getShowJVSuffix();
+ }
/**
- *
- * @param inc
- * set the scalar for bleaching colourschemes according to degree of
- * conservation
+ * @param b
+ * @see jalview.api.ViewStyleI#setShowJVSuffix(boolean)
*/
- public void setIncrement(int inc)
+ public void setShowJVSuffix(boolean b)
{
- increment = inc;
+ viewStyle.setShowJVSuffix(b);
}
/**
- * GUI State
- *
- * @return get scalar for bleaching colourschemes by conservation
+ * @param state
+ * @see jalview.api.ViewStyleI#setWrapAlignment(boolean)
*/
- public int getIncrement()
+ public void setWrapAlignment(boolean state)
{
- return increment;
+ viewStyle.setWrapAlignment(state);
}
- boolean conservationColourSelected = false;
+ /**
+ * @param state
+ * @see jalview.api.ViewStyleI#setShowText(boolean)
+ */
+ public void setShowText(boolean state)
+ {
+ viewStyle.setShowText(state);
+ }
/**
- * GUI state
- *
- * @return true if conservation based shading is enabled
+ * @param state
+ * @see jalview.api.ViewStyleI#setRenderGaps(boolean)
*/
- public boolean getConservationSelected()
+ public void setRenderGaps(boolean state)
{
- return conservationColourSelected;
+ viewStyle.setRenderGaps(state);
}
/**
- * GUI state
- *
- * @param b
- * enable conservation based shading
+ * @return
+ * @see jalview.api.ViewStyleI#getColourText()
*/
- public void setConservationSelected(boolean b)
+ public boolean getColourText()
+ {
+ return viewStyle.getColourText();
+ }
+
+ /**
+ * @param state
+ * @see jalview.api.ViewStyleI#setColourText(boolean)
+ */
+ public void setColourText(boolean state)
+ {
+ viewStyle.setColourText(state);
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getWrapAlignment()
+ */
+ public boolean getWrapAlignment()
{
- conservationColourSelected = b;
+ return viewStyle.getWrapAlignment();
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getShowText()
+ */
+ public boolean getShowText()
+ {
+ return viewStyle.getShowText();
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getWrappedWidth()
+ */
+ public int getWrappedWidth()
+ {
+ return viewStyle.getWrappedWidth();
+ }
+
+ /**
+ * @param w
+ * @see jalview.api.ViewStyleI#setWrappedWidth(int)
+ */
+ public void setWrappedWidth(int w)
+ {
+ viewStyle.setWrappedWidth(w);
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getCharHeight()
+ */
+ public int getCharHeight()
+ {
+ return viewStyle.getCharHeight();
+ }
+
+ /**
+ * @param h
+ * @see jalview.api.ViewStyleI#setCharHeight(int)
+ */
+ public void setCharHeight(int h)
+ {
+ viewStyle.setCharHeight(h);
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getCharWidth()
+ */
+ public int getCharWidth()
+ {
+ return viewStyle.getCharWidth();
+ }
+
+ /**
+ * @param w
+ * @see jalview.api.ViewStyleI#setCharWidth(int)
+ */
+ public void setCharWidth(int w)
+ {
+ viewStyle.setCharWidth(w);
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getShowBoxes()
+ */
+ public boolean getShowBoxes()
+ {
+ return viewStyle.getShowBoxes();
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getShowUnconserved()
+ */
+ public boolean getShowUnconserved()
+ {
+ return viewStyle.getShowUnconserved();
+ }
+
+ /**
+ * @param showunconserved
+ * @see jalview.api.ViewStyleI#setShowUnconserved(boolean)
+ */
+ public void setShowUnconserved(boolean showunconserved)
+ {
+ viewStyle.setShowUnconserved(showunconserved);
+ }
+
+ /**
+ * @param default1
+ * @see jalview.api.ViewStyleI#setSeqNameItalics(boolean)
+ */
+ public void setSeqNameItalics(boolean default1)
+ {
+ viewStyle.setSeqNameItalics(default1);
+ }
+
+ /**
+ * @param selected
+ * @see jalview.api.ViewStyleI#setShowSeqFeaturesHeight(boolean)
+ */
+ public void setShowSeqFeaturesHeight(boolean selected)
+ {
+ viewStyle.setShowSeqFeaturesHeight(selected);
+ }
+
+ /**
+ * alignment displayed in the viewport. Please use get/setter
+ */
+ protected AlignmentI alignment;
+
+ @Override
+ public AlignmentI getAlignment()
+ {
+ return alignment;
}
@Override
+ public char getGapCharacter()
+ {
+ return alignment.getGapCharacter();
+ }
+
+ protected String sequenceSetID;
+
+ /**
+ * probably unused indicator that view is of a dataset rather than an
+ * alignment
+ */
+ protected boolean isDataset = false;
+
+ public void setDataset(boolean b)
+ {
+ isDataset = b;
+ }
+
+ public boolean isDataset()
+ {
+ return isDataset;
+ }
+
+
+ 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;
+
+
+ @Override
public void setGlobalColourScheme(ColourSchemeI cs)
{
// TODO: logic refactored from AlignFrame changeColour -
// 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(viewStyle.getThreshold(),
+ 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())
sg.cs = null;
continue;
}
- if (cs instanceof ClustalxColourScheme)
+ sg.cs = cs.applyTo(sg, getHiddenRepSequences());
+ sg.setConsPercGaps(ConsPercGaps);
+ if (getAbovePIDThreshold() || cs instanceof PIDColourScheme
+ || cs instanceof Blosum62ColourScheme)
{
- sg.cs = new ClustalxColourScheme(sg, getHiddenRepSequences());
+ sg.cs.setThreshold(viewStyle.getThreshold(),
+ isIgnoreGapsConsensus());
+ recalc = true;
}
else
{
- try
- {
- sg.cs = cs.getClass().newInstance();
- } catch (Exception ex)
- {
- ex.printStackTrace();
- sg.cs = cs;
- }
+ sg.cs.setThreshold(0, isIgnoreGapsConsensus());
}
- if (getAbovePIDThreshold() || cs instanceof PIDColourScheme
- || cs instanceof Blosum62ColourScheme)
+ if (getConservationSelected())
{
- sg.cs.setThreshold(threshold, getIgnoreGapsConsensus());
- sg.cs.setConsensus(AAFrequency.calculate(
- sg.getSequences(getHiddenRepSequences()), 0,
- sg.getWidth()));
+ sg.cs.setConservationApplied(true);
+ recalc = true;
}
else
{
- sg.cs.setThreshold(0, getIgnoreGapsConsensus());
+ sg.cs.setConservation(null);
+ // sg.cs.setThreshold(0, getIgnoreGapsConsensus());
}
-
- if (getConservationSelected())
+ if (recalc)
{
- Conservation c = new Conservation("Group",
- ResidueProperties.propHash, 3,
- sg.getSequences(getHiddenRepSequences()), 0,
- getAlignment().getWidth() - 1);
- c.calculate();
- c.verdict(false, getConsPercGaps());
- sg.cs.setConservation(c);
+ sg.recalcConservation();
}
else
{
- sg.cs.setConservation(null);
- sg.cs.setThreshold(0, getIgnoreGapsConsensus());
+ sg.cs.alignmentChanged(sg, hiddenRepSequences);
}
-
}
}
*/
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
AlignmentAnnotation alignmentAnnotation)
{
if (!alignmentAnnotation.autoCalculated)
+ {
return false;
+ }
if (calculator.workingInvolvedWith(alignmentAnnotation))
{
// System.err.println("grey out ("+alignmentAnnotation.label+")");
}
/**
- * show non-conserved residues only
- */
- protected boolean showUnconserved = false;
-
- /**
* when set, updateAlignment will always ensure sequences are of equal length
*/
private boolean padGaps = false;
*/
public boolean sortByTree = false;
- public boolean getShowUnconserved()
- {
- return showUnconserved;
- }
-
- public void setShowUnconserved(boolean showunconserved)
- {
- showUnconserved = showunconserved;
- }
-
- /**
- * @param showNonconserved
- * the showUnconserved to set
- */
- public void setShowunconserved(boolean displayNonconserved)
- {
- this.showUnconserved = displayNonconserved;
- }
/**
*
public void setHiddenColumns(ColumnSelection colsel)
{
this.colSel = colsel;
- if (colSel.getHiddenColumns() != null)
- {
- hasHiddenColumns = true;
- }
}
@Override
return colSel;
}
+ @Override
public void setColumnSelection(ColumnSelection colSel)
{
this.colSel = colSel;
+ if (colSel != null)
+ {
+ updateHiddenColumns();
+ }
}
/**
this.hiddenRepSequences = hiddenRepSequences;
}
- protected boolean hasHiddenColumns = false;
+ @Override
+ public boolean hasHiddenColumns()
+ {
+ return colSel != null && colSel.hasHiddenColumns();
+ }
public void updateHiddenColumns()
{
- hasHiddenColumns = colSel.getHiddenColumns() != null;
+ // this method doesn't really do anything now. But - it could, since a
+ // column Selection could be in the process of modification
+ // hasHiddenColumns = colSel.hasHiddenColumns();
}
protected boolean hasHiddenRows = false;
+ @Override
public boolean hasHiddenRows()
{
return hasHiddenRows;
sequenceSetID = new String(newid);
}
+ @Override
public String getSequenceSetId()
{
if (sequenceSetID == null)
}
@Override
- public boolean getIgnoreGapsConsensus()
+ public boolean isIgnoreGapsConsensus()
{
return ignoreGapsInConsensusCalculation;
}
colSel.hideSelectedColumns();
setSelectionGroup(null);
- hasHiddenColumns = true;
}
public void hideColumns(int start, int end)
{
colSel.hideColumns(start, end);
}
-
- hasHiddenColumns = true;
}
public void showColumn(int col)
{
colSel.revealHiddenColumns(col);
- if (colSel.getHiddenColumns() == null)
- {
- hasHiddenColumns = false;
- }
+
}
public void showAllHiddenColumns()
{
colSel.revealAllHiddenColumns();
- hasHiddenColumns = false;
}
// common hide/show seq stuff
selectionGroup = new SequenceGroup();
selectionGroup.setEndRes(alignment.getWidth() - 1);
}
- Vector tmp = alignment.getHiddenSequences().showAll(
+ List<SequenceI> tmp = alignment.getHiddenSequences().showAll(
hiddenRepSequences);
- for (int t = 0; t < tmp.size(); t++)
+ for (SequenceI seq : tmp)
{
- selectionGroup.addSequence((SequenceI) tmp.elementAt(t), false);
+ selectionGroup.addSequence(seq, false);
+ setSequenceAnnotationsVisible(seq, true);
}
hasHiddenRows = false;
public void showSequence(int index)
{
- Vector tmp = alignment.getHiddenSequences().showSequence(index,
+ List<SequenceI> tmp = alignment.getHiddenSequences().showSequence(
+ index,
hiddenRepSequences);
if (tmp.size() > 0)
{
selectionGroup.setEndRes(alignment.getWidth() - 1);
}
- for (int t = 0; t < tmp.size(); t++)
+ for (SequenceI seq : tmp)
{
- selectionGroup.addSequence((SequenceI) tmp.elementAt(t), false);
+ selectionGroup.addSequence(seq, false);
+ setSequenceAnnotationsVisible(seq, true);
}
// JBPNote: refactor: only update flag if we modified visiblity (used to
// do this regardless)
{
if (seq != null)
{
- for (int i = 0; i < seq.length; i++)
+ for (int i = 0; i < seq.length; i++)
+ {
+ alignment.getHiddenSequences().hideSequence(seq[i]);
+ setSequenceAnnotationsVisible(seq[i], false);
+ }
+ hasHiddenRows = true;
+ firePropertyChange("alignment", null, alignment.getSequences());
+ }
+ }
+
+ /**
+ * Set visibility for any annotations for the given sequence.
+ *
+ * @param sequenceI
+ */
+ protected void setSequenceAnnotationsVisible(SequenceI sequenceI,
+ boolean visible)
+ {
+ for (AlignmentAnnotation ann : alignment.getAlignmentAnnotation())
+ {
+ if (ann.sequenceRef == sequenceI)
{
- alignment.getHiddenSequences().hideSequence(seq[i]);
+ ann.visible = visible;
}
- hasHiddenRows = true;
- firePropertyChange("alignment", null, alignment.getSequences());
}
}
public boolean isHiddenRepSequence(SequenceI seq)
{
- return hiddenRepSequences != null
- && hiddenRepSequences.containsKey(seq);
+ return alignment.getSeqrep()==seq || (hiddenRepSequences != null
+ && hiddenRepSequences.containsKey(seq));
}
public SequenceGroup getRepresentedSequences(SequenceI seq)
: hiddenRepSequences.get(seq));
}
+ @Override
public int adjustForHiddenSeqs(int alignmentIndex)
{
return alignment.getHiddenSequences().adjustForHiddenSeqs(
alignmentIndex);
}
- // Selection manipulation
- /**
- * broadcast selection to any interested parties
- */
+ @Override
public abstract void sendSelection();
+ @Override
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
- * adjusted
- *
- * @note if you need references to the actual SequenceI objects in the
- * alignment or currently selected then use getSequenceSelection()
- * @return selection as new sequenceI objects
- */
+
+ @Override
public SequenceI[] getSelectionAsNewSequence()
{
SequenceI[] sequences;
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()
{
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
- * calculating trees, PCA, redundancy etc on views which contain hidden
- * columns.
- *
- * @return String[]
- */
+
@Override
public jalview.datamodel.CigarArray getViewAsCigars(
boolean selectedRegionOnly)
{
- return new jalview.datamodel.CigarArray(alignment,
- (hasHiddenColumns ? colSel : null),
+ return new jalview.datamodel.CigarArray(alignment, colSel,
(selectedRegionOnly ? selectionGroup : null));
}
- /**
- * return a compact representation of the current alignment selection to pass
- * to an analysis function
- *
- * @param selectedOnly
- * boolean true to just return the selected view
- * @return AlignmentView
- */
+
@Override
public jalview.datamodel.AlignmentView getAlignmentView(
boolean selectedOnly)
return getAlignmentView(selectedOnly, false);
}
- /**
- * return a compact representation of the current alignment selection to pass
- * to an analysis function
- *
- * @param selectedOnly
- * boolean true to just return the selected view
- * @param markGroups
- * boolean true to annotate the alignment view with groups on the
- * alignment (and intersecting with selected region if selectedOnly
- * is true)
- * @return AlignmentView
- */
+
@Override
public jalview.datamodel.AlignmentView getAlignmentView(
boolean selectedOnly, boolean markGroups)
{
return new AlignmentView(alignment, colSel, selectionGroup,
- hasHiddenColumns, selectedOnly, markGroups);
+ colSel != null && colSel.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
- * calculating trees, PCA, redundancy etc on views which contain hidden
- * columns.
- *
- * @return String[]
- */
+
@Override
public String[] getViewAsString(boolean selectedRegionOnly)
{
}
selection = new String[iSize];
- if (hasHiddenColumns)
+ if (colSel != null && colSel.hasHiddenColumns())
{
selection = colSel.getVisibleSequenceStrings(start, end, seqs);
}
return selection;
}
- /**
- * return visible region boundaries within given column range
- *
- * @param min
- * first column (inclusive, from 0)
- * @param max
- * last column (exclusive)
- * @return int[][] range of {start,end} visible positions
- */
+
+ @Override
public int[][] getVisibleRegionBoundaries(int min, int max)
{
Vector regions = new Vector();
do
{
- if (hasHiddenColumns)
+ if (colSel != null && colSel.hasHiddenColumns())
{
if (start == 0)
{
regions.addElement(new int[]
{ start, end });
- if (hasHiddenColumns)
+ if (colSel != null && colSel.hasHiddenColumns())
{
start = colSel.adjustForHiddenColumns(end);
start = colSel.getHiddenBoundaryLeft(start) + 1;
}
- /**
- * @return the padGaps
- */
+ @Override
+ public List<AlignmentAnnotation> getVisibleAlignmentAnnotation(boolean selectedOnly)
+ {
+ ArrayList<AlignmentAnnotation> ala = new ArrayList<AlignmentAnnotation>();
+ AlignmentAnnotation[] aa;
+ if ((aa=alignment.getAlignmentAnnotation())!=null)
+ {
+ for (AlignmentAnnotation annot:aa)
+ {
+ AlignmentAnnotation clone = new AlignmentAnnotation(annot);
+ if (selectedOnly && selectionGroup!=null)
+ {
+ colSel.makeVisibleAnnotation(selectionGroup.getStartRes(), selectionGroup.getEndRes(),clone);
+ } else {
+ colSel.makeVisibleAnnotation(clone);
+ }
+ ala.add(clone);
+ }
+ }
+ return ala;
+ }
+
+
+ @Override
public boolean isPadGaps()
{
return padGaps;
}
- /**
- * @param padGaps
- * the padGaps to set
- */
+
+ @Override
public void setPadGaps(boolean padGaps)
{
this.padGaps = padGaps;
*
* @param ap
*/
+ @Override
public void alignmentChanged(AlignmentViewPanel ap)
{
if (isPadGaps())
ColourSchemeI cs = globalColourScheme;
if (cs != null)
{
- cs.alignmentChanged(alignment, null);
+ cs.alignmentChanged(alignment, hiddenRepSequences);
cs.setConsensus(hconsensus);
if (cs.conservationApplied())
{
conservation = new AlignmentAnnotation("Conservation",
"Conservation of total alignment less than "
- + getConsPercGaps() + "% gaps",
- new Annotation[1], 0f, 11f,
- AlignmentAnnotation.BAR_GRAPH);
+ + getConsPercGaps() + "% gaps", new Annotation[1],
+ 0f, 11f, AlignmentAnnotation.BAR_GRAPH);
conservation.hasText = true;
conservation.autoCalculated = true;
alignment.addAnnotation(conservation);
}
}
}
+
private void initQuality()
{
if (showQuality)
{
quality = new AlignmentAnnotation("Quality",
"Alignment Quality based on Blosum62 scores",
- new Annotation[1], 0f, 11f,
- AlignmentAnnotation.BAR_GRAPH);
+ 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)
+ if (alignment.hasRNAStructure() && strucConsensus == null)
{
strucConsensus = new AlignmentAnnotation("StrucConsensus", "PID",
- new Annotation[1], 0f, 100f,
- AlignmentAnnotation.BAR_GRAPH);
+ new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
strucConsensus.hasText = true;
strucConsensus.autoCalculated = true;
}
}
}
+
/*
* (non-Javadoc)
*
* @see jalview.api.AlignViewportI#calcPanelHeight()
*/
+ @Override
public int calcPanelHeight()
{
// setHeight of panels
if (aan[an].autoCalculated && aan[an].groupRef != null)
{
oldrfs.add(aan[an].groupRef);
- alignment.deleteAnnotation(aan[an]);
- aan[an] = null;
+ alignment.deleteAnnotation(aan[an], false);
}
}
}
}
oldrfs.clear();
}
+ @Override
+ public boolean isDisplayReferenceSeq()
+ {
+ return alignment.hasSeqrep() && viewStyle.isDisplayReferenceSeq();
+ }
+
+ @Override
+ public void setDisplayReferenceSeq(boolean displayReferenceSeq)
+ {
+ viewStyle.setDisplayReferenceSeq(displayReferenceSeq);
+ }
+
+ public boolean isColourByReferenceSeq()
+ {
+ return alignment.hasSeqrep() && viewStyle.isColourByReferenceSeq();
+ }
+
@Override
public Color getSequenceColour(SequenceI seq)
{
- Color sqc=Color.white;
+ Color sqc = Color.white;
if (sequenceColours != null)
{
sqc = (Color) sequenceColours.get(seq);
- if (sqc == null) {
+ if (sqc == null)
+ {
sqc = Color.white;
}
}
{
sequenceColours = null;
};
+
+ FeaturesDisplayedI featuresDisplayed = null;
+
+ @Override
+ public FeaturesDisplayedI getFeaturesDisplayed()
+ {
+ return featuresDisplayed;
+ }
+
+ @Override
+ public void setFeaturesDisplayed(FeaturesDisplayedI featuresDisplayedI)
+ {
+ featuresDisplayed = featuresDisplayedI;
+ }
+
+ @Override
+ public boolean areFeaturesDisplayed()
+ {
+ return featuresDisplayed != null && featuresDisplayed.getRegisterdFeaturesCount()>0;
+ }
+
+ /**
+ * set the flag
+ *
+ * @param b
+ * features are displayed if true
+ */
+ @Override
+ public void setShowSequenceFeatures(boolean b)
+ {
+ viewStyle.setShowSequenceFeatures(b);
+ }
+ @Override
+ public boolean isShowSequenceFeatures()
+ {
+ return viewStyle.isShowSequenceFeatures();
+ }
+
+ @Override
+ public void setShowSequenceFeaturesHeight(boolean selected)
+ {
+ viewStyle.setShowSeqFeaturesHeight(selected);
+ }
+
+ @Override
+ public boolean isShowSequenceFeaturesHeight()
+ {
+ return viewStyle.isShowSequenceFeaturesHeight();
+ }
+
+
+
+ @Override
+ public void setShowAnnotation(boolean b)
+ {
+ viewStyle.setShowAnnotation(b);
+ }
+
+ @Override
+ public boolean isShowAnnotation()
+ {
+ return viewStyle.isShowAnnotation();
+ }
+
+ @Override
+ public boolean isRightAlignIds()
+ {
+ return viewStyle.isRightAlignIds();
+ }
+
+ @Override
+ public void setRightAlignIds(boolean rightAlignIds)
+ {
+ viewStyle.setRightAlignIds(rightAlignIds);
+ }
+
+ @Override
+ public boolean getConservationSelected()
+ {
+ return viewStyle.getConservationSelected();
+ }
+
+ @Override
+ public void setShowBoxes(boolean state)
+ {
+ viewStyle.setShowBoxes(state);
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getTextColour()
+ */
+ public Color getTextColour()
+ {
+ return viewStyle.getTextColour();
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getTextColour2()
+ */
+ public Color getTextColour2()
+ {
+ return viewStyle.getTextColour2();
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getThresholdTextColour()
+ */
+ public int getThresholdTextColour()
+ {
+ return viewStyle.getThresholdTextColour();
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#isConservationColourSelected()
+ */
+ public boolean isConservationColourSelected()
+ {
+ return viewStyle.isConservationColourSelected();
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#isRenderGaps()
+ */
+ public boolean isRenderGaps()
+ {
+ return viewStyle.isRenderGaps();
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#isShowColourText()
+ */
+ public boolean isShowColourText()
+ {
+ return viewStyle.isShowColourText();
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#isShowSeqFeaturesHeight()
+ */
+ public boolean isShowSeqFeaturesHeight()
+ {
+ return viewStyle.isShowSeqFeaturesHeight();
+ }
+
+ /**
+ * @param conservationColourSelected
+ * @see jalview.api.ViewStyleI#setConservationColourSelected(boolean)
+ */
+ public void setConservationColourSelected(
+ boolean conservationColourSelected)
+ {
+ viewStyle.setConservationColourSelected(conservationColourSelected);
+ }
+
+ /**
+ * @param showColourText
+ * @see jalview.api.ViewStyleI#setShowColourText(boolean)
+ */
+ public void setShowColourText(boolean showColourText)
+ {
+ viewStyle.setShowColourText(showColourText);
+ }
+
+ /**
+ * @param textColour
+ * @see jalview.api.ViewStyleI#setTextColour(java.awt.Color)
+ */
+ public void setTextColour(Color textColour)
+ {
+ viewStyle.setTextColour(textColour);
+ }
+
+ /**
+ * @param thresholdTextColour
+ * @see jalview.api.ViewStyleI#setThresholdTextColour(int)
+ */
+ public void setThresholdTextColour(int thresholdTextColour)
+ {
+ viewStyle.setThresholdTextColour(thresholdTextColour);
+ }
+
+ /**
+ * @param textColour2
+ * @see jalview.api.ViewStyleI#setTextColour2(java.awt.Color)
+ */
+ public void setTextColour2(Color textColour2)
+ {
+ viewStyle.setTextColour2(textColour2);
+ }
+
+ @Override
+ public ViewStyleI getViewStyle()
+ {
+ return new ViewStyle(viewStyle);
+ }
+
+ @Override
+ public void setViewStyle(ViewStyleI settingsForView)
+ {
+ viewStyle = new ViewStyle(settingsForView);
+ }
+
+ @Override
+ public boolean sameStyle(ViewStyleI them)
+ {
+ return viewStyle.sameStyle(them);
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#getIdWidth()
+ */
+ public int getIdWidth()
+ {
+ return viewStyle.getIdWidth();
+ }
+
+ /**
+ * @param i
+ * @see jalview.api.ViewStyleI#setIdWidth(int)
+ */
+ public void setIdWidth(int i)
+ {
+ viewStyle.setIdWidth(i);
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#isCentreColumnLabels()
+ */
+ public boolean isCentreColumnLabels()
+ {
+ return viewStyle.isCentreColumnLabels();
+ }
+
+ /**
+ * @param centreColumnLabels
+ * @see jalview.api.ViewStyleI#setCentreColumnLabels(boolean)
+ */
+ public void setCentreColumnLabels(boolean centreColumnLabels)
+ {
+ viewStyle.setCentreColumnLabels(centreColumnLabels);
+ }
+
+ /**
+ * @param showdbrefs
+ * @see jalview.api.ViewStyleI#setShowDBRefs(boolean)
+ */
+ public void setShowDBRefs(boolean showdbrefs)
+ {
+ viewStyle.setShowDBRefs(showdbrefs);
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#isShowDBRefs()
+ */
+ public boolean isShowDBRefs()
+ {
+ return viewStyle.isShowDBRefs();
+ }
+
+ /**
+ * @return
+ * @see jalview.api.ViewStyleI#isShowNPFeats()
+ */
+ public boolean isShowNPFeats()
+ {
+ return viewStyle.isShowNPFeats();
+ }
+
+ /**
+ * @param shownpfeats
+ * @see jalview.api.ViewStyleI#setShowNPFeats(boolean)
+ */
+ public void setShowNPFeats(boolean shownpfeats)
+ {
+ viewStyle.setShowNPFeats(shownpfeats);
+ }
}
git://source.jalview.org / jalview.git / blobdiff