import jalview.datamodel.AnnotatedCollectionI
import jalview.datamodel.SequenceI
import jalview.datamodel.SequenceCollectionI
+import jalview.api.AlignViewportI
import jalview.util.Comparison
/*
/*
* to make a new instance for each alignment view
*/
- getInstance: { AnnotatedCollectionI coll, Map<SequenceI, SequenceCollectionI> map -> conserved() },
+ getInstance: { AlignViewportI view, AnnotatedCollectionI coll, Map<SequenceI, SequenceCollectionI> map -> conserved() },
/*
* method only needed if colour scheme has to recalculate
import jalview.datamodel.AnnotatedCollectionI;
import jalview.datamodel.SequenceI;
import jalview.datamodel.SequenceCollectionI;
+import jalview.api.AlignViewportI
/*
* Example script that registers two new alignment colour schemes
/*
* to make a new instance for each alignment view
*/
- getInstance: { AnnotatedCollectionI coll, Map<SequenceI, SequenceCollectionI> map -> candy() },
+ getInstance: { AlignViewportI view, AnnotatedCollectionI coll, Map<SequenceI, SequenceCollectionI> map -> candy() },
/*
* method only needed if colour scheme has to recalculate
import jalview.datamodel.AnnotatedCollectionI
import jalview.datamodel.SequenceI
import jalview.datamodel.SequenceCollectionI
+import jalview.api.AlignViewportI
import jalview.util.Comparison
/*
</p>
<p>
<strong><em>Selecting Sequence Leaf Nodes</em></strong><br>
- Selecting sequence ids at the leaves of the tree selects the
+ Selecting sequence IDs at the leaves of the tree selects the
corresponding sequences in the original alignment. These selections
are also reflected in any other analysis windows associated with the
alignment, such as another tree viewer.
</p>
<p>
- <strong><em>Grouping sequences by partitioning the
- tree at a particular distanec</em></strong><br> Clicking anywhere along
+ <strong><em><a name="partitioning">Grouping sequences by partitioning</a> the
+ tree at a particular distance</em></strong><br> Clicking anywhere along
the extent of the tree (but not on a leaf or internal node) defines
a tree 'partition', by cutting every branch of the tree spanning the
depth where the mouse-click occurred. Groups are created containing
sequences at the leaves of each connected sub tree. These groups are
each given a different colour, which are reflected in other windows
- in the same way as if the sequence ids were selected, and can be
+ in the same way as if the sequence IDs were selected, and can be
edited in the same way as user defined sequence groups.
</p>
<p>
identifying specific patterns of conservation and mutation
corresponding to the overall phylogenetic structure, when combined
with the <a href="../colourSchemes/conservation.html">conservation
- based colour scheme</a>.
+ based colour scheme</a>.To distinguish parts of the alignment assigned
+ to different groups, you may also enable the Sequence ID colour
+ scheme via the <a href="../menus/alwcolour.html">Alignment
+ window's Colours menu</a> (<em>Since 2.11</em>).
</p>
<p>
<strong><em>Selecting Subtrees and changing the branch
<p>
<strong>Colour schemes</strong>
</p>
- <p>Jalview allows the user to set a background colour for the
+ <p>Jalview allows the user to set a colour scheme for the
whole alignment view or for each group defined on regions within it.</p>
- <p>To change the background colour, simply select the colour from
+ <p>To change the colour for a view, simply select a new colour scheme from
the "Colour" menu.</p>
<p>To change the colour of a group, right click on any residue
within a group and use the popup menu to define the group colour.</p>
- <p>At the top of the "Colour" menu the tick box
- "Apply Background Colour to all groups". This is ticked by
+ <p>At the top of the "Colour" menu you'll see a tick box
+ "Apply Colour to all groups". This is ticked by
default so that a chosen colour scheme will be applied to all
existing groups. If you wish to maintain the colour scheme for
- defined groups, make sure you deselect this option before changing
- the background colour.</p>
+ defined groups, make sure you deselect this option before selecting
+ a new scheme in the Colour menu.</p>
<p>
The <strong>"Colour→<a
href="../colourSchemes/textcolour.html">Colour Text...</a>"
</strong> <em>See <a href="../colourSchemes/index.html">colours</a>
for a description of all colour schemes.
</em><br></li>
- <li><strong>By Conservation<br>
+ <li><strong>Sequence ID<br></strong><em>Shades
+ sequences using their Sequence ID colour. Useful when
+ performing <a
+ href="../calculations/treeviewer.html#partitioning">tree
+ based subfamily analysis</a>.
+ </em></li>
+ <li><strong>By Conservation<br>
</strong><em>See <a href="../colourSchemes/conservation.html">Colouring
by Conservation</a>.
</em><br></li>
a description of all colour schemes.
</em><br>
</li>
+ <li><strong>Sequence ID<br></strong><em>Shades
+ sequences using their Sequence ID colour. Useful when performing
+ <a href="../calculations/treeviewer.html#partitioning">tree
+ based subfamily analysis</a>.
+ </em></li>
<li><strong>By Conservation<br>
</strong><em>See <a href="../colourSchemes/conservation.html">Colouring
by Conservation</a>.
label.colourScheme_nucleotide = Nucleotide
label.colourScheme_t-coffee_scores = T-Coffee Scores
label.colourScheme_rna_helices = By RNA Helices
+label.colourScheme_sequence_id = Sequence ID Colour
label.blc = BLC
label.fasta = Fasta
label.msf = MSF
label.colourScheme_nucleotide = Nucleótido
label.colourScheme_t-coffee_scores = Puntuación del T-Coffee
label.colourScheme_rna_helices = Por hélices de RNA
+label.colourScheme_sequence_id = Color de ID de secuencia
label.blc = BLC
label.fasta = Fasta
label.msf = MSF
public abstract TreeModel getCurrentTree();
public abstract void setCurrentTree(TreeModel tree);
+
+ /**
+ * @param update
+ * - set the flag for updating structures on next repaint
+ */
+ void setUpdateStructures(boolean update);
+
+ /**
+ *
+ * @return true if structure views will be updated on next refresh
+ */
+ boolean isUpdateStructures();
+
+ /**
+ * check if structure views need to be updated, and clear the flag afterwards.
+ *
+ * @return if an update is needed
+ */
+ boolean needToUpdateStructureViews();
+
+ /**
+ * Adds sequencegroup to the alignment in the view. Also adds a group to the
+ * complement view if one is defined.
+ *
+ * @param sequenceGroup
+ * - a group defined on sequences in the alignment held by the view
+ */
+ void addSequenceGroup(SequenceGroup sequenceGroup);
}
import jalview.bin.JalviewLite;
import jalview.commands.CommandI;
import jalview.datamodel.AlignmentI;
-import jalview.datamodel.Annotation;
import jalview.datamodel.ColumnSelection;
import jalview.datamodel.HiddenColumns;
import jalview.datamodel.SearchResults;
import jalview.datamodel.SearchResultsI;
-import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceGroup;
-import jalview.datamodel.SequenceI;
import jalview.renderer.ResidueShader;
import jalview.schemes.ColourSchemeProperty;
import jalview.schemes.UserColourScheme;
if (colour != null)
{
residueShading = new ResidueShader(
- ColourSchemeProperty.getColourScheme(alignment, colour));
+ ColourSchemeProperty.getColourScheme(this, alignment,
+ colour));
if (residueShading != null)
{
residueShading.setConsensus(hconsensus);
Vector<SequenceNode> l = tree.findLeaves(groups.get(i));
- Vector<SequenceI> sequences = new Vector<SequenceI>();
+ Vector<SequenceI> sequences = new Vector<>();
for (int j = 0; j < l.size(); j++)
{
SequenceI s1 = (SequenceI) l.elementAt(j).element();
}
else
{
- cs = ColourSchemeProperty.getColourScheme(sg, ColourSchemeProperty
+ cs = ColourSchemeProperty.getColourScheme(av, sg,
+ ColourSchemeProperty
.getColourName(av.getGlobalColourScheme()));
}
// cs is null if shading is an annotationColourGradient
data.replaceAll("%20", " ");
ColourSchemeI cs = ColourSchemeProperty
- .getColourScheme(af.getViewport().getAlignment(), data);
+ .getColourScheme(af.getViewport(),
+ af.getViewport().getAlignment(), data);
if (cs != null)
{
import jalview.datamodel.SequenceI;
import jalview.io.DataSourceType;
import jalview.io.FeaturesFile;
+import jalview.schemes.ColourSchemeI;
import jalview.util.MessageManager;
import java.awt.Color;
viewport.getAlignment().deleteAllGroups();
viewport.clearSequenceColours();
viewport.setSelectionGroup(null);
+ ColourSchemeI colours = viewport.getGlobalColourScheme();
// set view properties for each group
for (int g = 0; g < gps.length; g++)
{
// gps[g].setShowunconserved(viewport.getShowUnconserved());
gps[g].setshowSequenceLogo(viewport.isShowSequenceLogo());
viewport.getAlignment().addGroup(gps[g]);
- Color col = new Color((int) (Math.random() * 255),
- (int) (Math.random() * 255), (int) (Math.random() * 255));
- col = col.brighter();
- for (SequenceI sq : gps[g].getSequences(null))
+ if (colours != null)
{
- viewport.setSequenceColour(sq, col);
+ gps[g].setColourScheme(colours.getInstance(viewport, gps[g]));
}
+ Color col = new Color((int) (Math.random() * 255),
+ (int) (Math.random() * 255), (int) (Math.random() * 255));
+ gps[g].idColour = col;
+ viewport.setUpdateStructures(true);
+ viewport.addSequenceGroup(gps[g]);
}
return true;
}
ScGroup()
{
- seqs = new ArrayList<SeqCigar>();
+ seqs = new ArrayList<>();
}
/**
SequenceI[] selseqs;
if (selection != null && selection.getSize() > 0)
{
- List<SequenceI> sel = selection.getSequences(null);
this.selected = new ScGroup();
selseqs = selection.getSequencesInOrder(alignment,
selectedRegionOnly);
selseqs = alignment.getSequencesArray();
}
- List<List<SequenceI>> seqsets = new ArrayList<List<SequenceI>>();
+ List<List<SequenceI>> seqsets = new ArrayList<>();
// get the alignment's group list and make a copy
- List<SequenceGroup> grps = new ArrayList<SequenceGroup>();
+ List<SequenceGroup> grps = new ArrayList<>();
List<SequenceGroup> gg = alignment.getGroups();
grps.addAll(gg);
ScGroup[] sgrps = null;
// strip out any groups that do not actually intersect with the
// visible and selected region
int ssel = selection.getStartRes(), esel = selection.getEndRes();
- List<SequenceGroup> isg = new ArrayList<SequenceGroup>();
+ List<SequenceGroup> isg = new ArrayList<>();
for (SequenceGroup sg : grps)
{
if (!(sg.getStartRes() > esel || sg.getEndRes() < ssel))
{
if (scGroups == null)
{
- scGroups = new ArrayList<ScGroup>();
+ scGroups = new ArrayList<>();
}
addedgps[sg] = true;
scGroups.add(sgrps[sg]);
public interface SequenceCollectionI
{
+ /**
+ *
+ * @return (visible) sequences in this collection. This may be a direct
+ * reference to the collection so not thread safe
+ */
List<SequenceI> getSequences();
+ /**
+ * FIXME: AlignmentI.getSequences(hiddenReps) doesn't actually obey this
+ * contract!
+ *
+ * @param hiddenReps
+ * @return the full set of sequences in this collection, including any
+ * sequences represented by sequences in the collection.
+ */
List<SequenceI> getSequences(
Map<SequenceI, SequenceCollectionI> hiddenReps);
* otherwise set the chosen colour scheme (or null for 'None')
*/
ColourSchemeI cs = ColourSchemes.getInstance().getColourScheme(name,
+ viewport,
viewport.getAlignment(), viewport.getHiddenRepSequences());
changeColour(cs);
}
{
PaintRefresher.Refresh(this, viewport.getSequenceSetId());
alignPanel.updateAnnotation();
- alignPanel.paintAlignment(true, true);
+ alignPanel.paintAlignment(true,
+ viewport.needToUpdateStructureViews());
}
}
ResidueColourScheme.NONE);
}
ColourSchemeI colourScheme = ColourSchemeProperty
- .getColourScheme(alignment, schemeName);
+ .getColourScheme(this, alignment, schemeName);
residueShading = new ResidueShader(colourScheme);
if (colourScheme instanceof UserColourScheme)
addNotify();
// TODO: many places call this method and also paintAlignment with various
// different settings. this means multiple redraws are triggered...
- paintAlignment(true, false);
+ paintAlignment(true, av.needToUpdateStructureViews());
}
/**
{
setAnnotationVisibility(true);
- // copied from AnnotationLabel.actionPerformed (after show/hide row)...
- // TODO should drive this functionality into AlignmentPanel
ap.updateAnnotation();
- // this.ap.annotationPanel.adjustPanelHeight();
- // this.ap.alabels.setSize(this.ap.alabels.getSize().width,
- // this.ap.annotationPanel.getSize().height);
- // this.ap.validate();
- this.ap.paintAlignment(true, false);
}
/**
}
}
ap.updateAnnotation();
- // // this.ap.annotationPanel.adjustPanelHeight();
- // this.ap.alabels.setSize(this.ap.alabels.getSize().width,
- // this.ap.annotationPanel.getSize().height);
- // this.ap.validate();
- this.ap.paintAlignment(true, false);
}
/**
{
setAnnotationVisibility(false);
- this.ap.updateAnnotation();
- // this.ap.annotationPanel.adjustPanelHeight();
- this.ap.paintAlignment(true, false);
+ ap.updateAnnotation();
}
/**
continue;
}
sg.setColourScheme(
- acg.getInstance(sg, ap.av.getHiddenRepSequences()));
+ acg.getInstance(av, sg));
}
}
}
* switch to the chosen colour scheme (or null for None)
*/
ColourSchemeI colourScheme = ColourSchemes.getInstance()
- .getColourScheme(colourSchemeName, sg,
+ .getColourScheme(colourSchemeName, ap.av, sg,
ap.av.getHiddenRepSequences());
sg.setColourScheme(colourScheme);
if (colourScheme instanceof Blosum62ColourScheme
{
AlignmentI al = getAlignmentPanel().av.getAlignment();
ColourSchemeI cs = ColourSchemes.getInstance()
- .getColourScheme(colourSchemeName, al, null);
+ .getColourScheme(colourSchemeName, getAlignmentPanel().av, al,
+ null);
getBinding().setJalviewColourScheme(cs);
}
import jalview.datamodel.SequenceI;
import jalview.datamodel.SequenceNode;
import jalview.schemes.ColourSchemeI;
-import jalview.schemes.ColourSchemeProperty;
-import jalview.schemes.UserColourScheme;
import jalview.structure.SelectionSource;
import jalview.util.Format;
-import jalview.util.MappingUtils;
import jalview.util.MessageManager;
import java.awt.Color;
return;
}
- if ((node.left() == null) && (node.right() == null)) // TODO: internal node
+ node.color = c;
+ if (node.element() instanceof SequenceI)
{
- node.color = c;
-
- if (node.element() instanceof SequenceI)
+ final SequenceI seq = (SequenceI) node.element();
+ AlignmentPanel[] aps = getAssociatedPanels();
+ if (aps != null)
{
- AlignmentPanel[] aps = getAssociatedPanels();
- if (aps != null)
+ for (int a = 0; a < aps.length; a++)
{
- for (int a = 0; a < aps.length; a++)
- {
- final SequenceI seq = (SequenceI) node.element();
- aps[a].av.setSequenceColour(seq, c);
- }
+ aps[a].av.setSequenceColour(seq, c);
}
}
}
- else
- {
- node.color = c;
- setColor((SequenceNode) node.left(), c);
- setColor((SequenceNode) node.right(), c);
- }
+ setColor((SequenceNode) node.left(), c);
+ setColor((SequenceNode) node.right(), c);
}
/**
.deleteAllGroups();
aps[a].av.getCodingComplement().clearSequenceColours();
}
+ aps[a].av.setUpdateStructures(true);
}
colourGroups(groups);
}
ColourSchemeI cs = null;
- SequenceGroup sg = new SequenceGroup(sequences, null, cs, true, true,
+ SequenceGroup _sg = new SequenceGroup(sequences, null, cs, true, true,
false, 0, av.getAlignment().getWidth() - 1);
- if (av.getGlobalColourScheme() != null)
- {
- if (av.getGlobalColourScheme() instanceof UserColourScheme)
- {
- cs = new UserColourScheme(
- ((UserColourScheme) av.getGlobalColourScheme())
- .getColours());
-
- }
- else
- {
- cs = ColourSchemeProperty.getColourScheme(sg, ColourSchemeProperty
- .getColourName(av.getGlobalColourScheme()));
- }
- // cs is null if shading is an annotationColourGradient
- // if (cs != null)
- // {
- // cs.setThreshold(av.getViewportColourScheme().getThreshold(),
- // av.isIgnoreGapsConsensus());
- // }
- }
- sg.setColourScheme(cs);
- sg.getGroupColourScheme().setThreshold(
- av.getResidueShading().getThreshold(),
- av.isIgnoreGapsConsensus());
- // sg.recalcConservation();
- sg.setName("JTreeGroup:" + sg.hashCode());
- sg.setIdColour(col);
+ _sg.setName("JTreeGroup:" + _sg.hashCode());
+ _sg.setIdColour(col);
for (int a = 0; a < aps.length; a++)
{
- if (aps[a].av.getGlobalColourScheme() != null
- && aps[a].av.getResidueShading().conservationApplied())
- {
- Conservation c = new Conservation("Group", sg.getSequences(null),
- sg.getStartRes(), sg.getEndRes());
- c.calculate();
- c.verdict(false, aps[a].av.getConsPercGaps());
- sg.cs.setConservation(c);
- }
+ SequenceGroup sg = new SequenceGroup(_sg);
+ AlignViewport viewport = aps[a].av;
- aps[a].av.getAlignment().addGroup(new SequenceGroup(sg));
- // TODO can we push all of the below into AlignViewportI?
- final AlignViewportI codingComplement = aps[a].av
- .getCodingComplement();
- if (codingComplement != null)
+ // Propagate group colours in each view
+ if (viewport.getGlobalColourScheme() != null)
{
- SequenceGroup mappedGroup = MappingUtils.mapSequenceGroup(sg, av,
- codingComplement);
- if (mappedGroup.getSequences().size() > 0)
+ cs = viewport.getGlobalColourScheme().getInstance(viewport, sg);
+ sg.setColourScheme(cs);
+ sg.getGroupColourScheme().setThreshold(
+ viewport.getResidueShading().getThreshold(),
+ viewport.isIgnoreGapsConsensus());
+
+ if (viewport.getResidueShading().conservationApplied())
{
- codingComplement.getAlignment().addGroup(mappedGroup);
- for (SequenceI seq : mappedGroup.getSequences())
- {
- codingComplement.setSequenceColour(seq, col.brighter());
- }
+ Conservation c = new Conservation("Group",
+ sg.getSequences(null), sg.getStartRes(),
+ sg.getEndRes());
+ c.calculate();
+ c.verdict(false, viewport.getConsPercGaps());
+ sg.cs.setConservation(c);
}
}
+ // indicate that associated structure views will need an update
+ viewport.setUpdateStructures(true);
+ // propagate structure view update and sequence group to complement view
+ viewport.addSequenceGroup(sg);
}
}
- // notify the panel(s) to redo any group specific stuff.
+ // notify the panel(s) to redo any group specific stuff
+ // also updates structure views if necessary
for (int a = 0; a < aps.length; a++)
{
aps[a].updateAnnotation();
- // TODO: JAL-868 - need to ensure view colour change message is broadcast
- // to any Jmols listening in
final AlignViewportI codingComplement = aps[a].av
.getCodingComplement();
if (codingComplement != null)
}
else if (key.equalsIgnoreCase("colour"))
{
+ // TODO need to notify colourscheme of view reference once it is
+ // available
sg.cs.setColourScheme(
- ColourSchemeProperty.getColourScheme(al, value));
+ ColourSchemeProperty.getColourScheme(null, al, value));
}
else if (key.equalsIgnoreCase("pidThreshold"))
{
}
else
{
- cs = ColourSchemeProperty.getColourScheme(al,
+ cs = ColourSchemeProperty.getColourScheme(null, al,
jGroup.getColour());
}
}
}
else
{
- cs = ColourSchemeProperty.getColourScheme(al, view.getBgColour());
+ cs = ColourSchemeProperty.getColourScheme(af.getViewport(), al,
+ view.getBgColour());
}
}
else
{
cs = new AnnotationColourGradient(matchedAnnotation,
- ColourSchemeProperty.getColourScheme(al,
+ ColourSchemeProperty.getColourScheme(af.getViewport(), al,
viewAnnColour.getColourScheme()),
safeInt(viewAnnColour.getAboveThreshold()));
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.AnnotatedCollectionI;
private IdentityHashMap<SequenceI, AlignmentAnnotation> seqannot = null;
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI sg,
- Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI sg)
{
AnnotationColourGradient acg = new AnnotationColourGradient(annotation,
getColourScheme(), aboveAnnotationThreshold);
package jalview.schemes;
import jalview.analysis.scoremodels.ScoreModels;
+import jalview.api.AlignViewportI;
import jalview.api.analysis.PairwiseScoreModelI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceI;
import jalview.util.Comparison;
import java.awt.Color;
-import java.util.Map;
public class Blosum62ColourScheme extends ResidueColourScheme
{
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new Blosum62ColourScheme();
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
-import jalview.datamodel.SequenceI;
import java.awt.Color;
-import java.util.Map;
/**
* DOCUMENT ME!
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new BuriedColourScheme();
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceI;
}
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI sg,
- Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI sg)
{
ClustalxColourScheme css = new ClustalxColourScheme(sg,
- hiddenRepSequences);
+ view.getHiddenRepSequences());
css.includeGaps = includeGaps;
return css;
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceI;
* new instance for each call to this method, as different instances may have
* differing shading by consensus or percentage identity applied.
*
+ * @param viewport
+ * - the parent viewport
* @param sg
- * @param hiddenRepSequences
+ * - the collection of sequences to be coloured
* @return copy of current scheme with any inherited settings transferred
*/
- ColourSchemeI getInstance(AnnotatedCollectionI sg,
- Map<SequenceI, SequenceCollectionI> hiddenRepSequences);
+ ColourSchemeI getInstance(AlignViewportI viewport,
+ AnnotatedCollectionI sg);
/**
* Answers true if the colour scheme is suitable for the given data, else
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
import jalview.util.ColorUtils;
* @param name
* @return
*/
- public static ColourSchemeI getColourScheme(AnnotatedCollectionI forData,
+ public static ColourSchemeI getColourScheme(AlignViewportI view,
+ AnnotatedCollectionI forData,
String name)
{
if (ResidueColourScheme.NONE.equalsIgnoreCase(name))
* create a new instance of it
*/
ColourSchemeI scheme = ColourSchemes.getInstance().getColourScheme(name,
+ view,
forData, null);
if (scheme != null)
{
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceI;
* store in an order-preserving map, so items can be added to menus
* in the order in which they are 'discovered'
*/
- schemes = new LinkedHashMap<String, ColourSchemeI>();
+ schemes = new LinkedHashMap<>();
for (JalviewColourScheme cs : JalviewColourScheme.values())
{
{
System.err.println("Error instantiating colour scheme for "
+ cs.toString() + " " + e.getMessage());
+ e.printStackTrace();
}
}
}
*
* @param name
* name of the colour scheme
+ * @param viewport
* @param forData
* the data to be coloured
* @param optional
* @return
*/
public ColourSchemeI getColourScheme(String name,
- AnnotatedCollectionI forData,
+ AlignViewportI viewport, AnnotatedCollectionI forData,
Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
{
if (name == null)
return null;
}
ColourSchemeI cs = schemes.get(name.toLowerCase());
- return cs == null ? null : cs.getInstance(forData, hiddenRepSequences);
+ return cs == null ? null
+ : cs.getInstance(viewport, forData);
}
/**
public ColourSchemeI getColourScheme(String name,
AnnotatedCollectionI forData)
{
- return getColourScheme(name, forData, null);
+ return getColourScheme(name, null, forData, null);
}
/**
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
-import jalview.datamodel.SequenceI;
import jalview.util.ColorUtils;
import java.awt.Color;
*/
public class CovariationColourScheme extends ResidueColourScheme
{
- public Map<String, Color> helixcolorhash = new Hashtable<String, Color>();
+ public Map<String, Color> helixcolorhash = new Hashtable<>();
- public Map<Integer, String> positionsToHelix = new Hashtable<Integer, String>();
+ public Map<Integer, String> positionsToHelix = new Hashtable<>();
int numHelix = 0;
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new CovariationColourScheme(coll.getAlignmentAnnotation()[0]);
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
-import jalview.datamodel.SequenceI;
-
-import java.util.Map;
/**
* Colourscheme that takes its colours from some other colourscheme
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new FollowerColourScheme();
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
-import jalview.datamodel.SequenceI;
import java.awt.Color;
-import java.util.Map;
public class HelixColourScheme extends ScoreColourScheme
{
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new HelixColourScheme();
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
-import jalview.datamodel.SequenceI;
import java.awt.Color;
-import java.util.Map;
/**
* DOCUMENT ME!
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new HydrophobicColourScheme();
}
--- /dev/null
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
+ * Copyright (C) $$Year-Rel$$ 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.schemes;
+
+import jalview.api.AlignViewportI;
+import jalview.datamodel.AnnotatedCollectionI;
+import jalview.datamodel.SequenceCollectionI;
+import jalview.datamodel.SequenceI;
+
+import java.awt.Color;
+import java.util.Map;
+
+/**
+ * shade sequences using the colour shown in the ID panel. Useful to map
+ * sequence groupings onto residue data (eg tree subgroups visualised on
+ * structures or overview window)
+ *
+ * @author jprocter
+ */
+public class IdColourScheme implements ColourSchemeI
+{
+ AlignViewportI view = null;
+
+ public IdColourScheme()
+ {
+
+ }
+ public IdColourScheme(AlignViewportI view, AnnotatedCollectionI coll)
+ {
+ this.view = view;
+ }
+
+
+ @Override
+ public String getSchemeName()
+ {
+ return JalviewColourScheme.IdColour.toString();
+ }
+
+ /**
+ * Returns a new instance of this colour scheme with which the given data may
+ * be coloured
+ */
+ @Override
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
+ {
+ return new IdColourScheme(view, coll);
+ }
+
+ @Override
+ public void alignmentChanged(AnnotatedCollectionI alignment,
+ Map<SequenceI, SequenceCollectionI> hiddenReps)
+ {
+ }
+
+ @Override
+ public Color findColour(char symbol, int position, SequenceI seq,
+ String consensusResidue, float pid)
+ {
+ // rather than testing if coll is a sequence group, and if so looking at
+ // ((SequenceGroup)coll).idColour
+ // we always return the sequence ID colour, in case the user has customised
+ // the displayed Id colour by right-clicking an internal node in the tree.
+ if (view == null)
+ {
+ return Color.WHITE;
+ }
+ Color col = view.getSequenceColour(seq);
+ return Color.WHITE.equals(col) ? Color.WHITE : col.darker();
+ }
+
+ @Override
+ public boolean hasGapColour()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean isApplicableTo(AnnotatedCollectionI ac)
+ {
+ return true;
+ }
+
+ @Override
+ public boolean isSimple()
+ {
+ return false;
+ }
+}
Nucleotide("Nucleotide", NucleotideColourScheme.class),
PurinePyrimidine("Purine/Pyrimidine", PurinePyrimidineColourScheme.class),
RNAHelices("RNA Helices", RNAHelicesColour.class),
- TCoffee("T-Coffee Scores", TCoffeeColourScheme.class);
+ TCoffee("T-Coffee Scores", TCoffeeColourScheme.class),
+ IdColour("Sequence ID", IdColourScheme.class);
// RNAInteraction("RNA Interaction type", RNAInteractionColourScheme.class)
private String name;
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
-import jalview.datamodel.SequenceI;
-
-import java.util.Map;
/**
* DOCUMENT ME!
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new NucleotideColourScheme();
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
import jalview.util.Comparison;
import java.awt.Color;
-import java.util.Map;
public class PIDColourScheme extends ResidueColourScheme
{
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new PIDColourScheme();
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
-import jalview.datamodel.SequenceI;
-
-import java.util.Map;
/**
* Class is based off of NucleotideColourScheme
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new PurinePyrimidineColourScheme();
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.AnnotatedCollectionI;
* Maps sequence positions to the RNA helix they belong to. Key: position,
* Value: helix TODO: Revise or drop in favour of annotation position numbers
*/
- public Hashtable<Integer, String> positionsToHelix = new Hashtable<Integer, String>();
+ public Hashtable<Integer, String> positionsToHelix = new Hashtable<>();
/**
* Number of helices in the RNA secondary structure
annotation.getRNAStruc();
lastrefresh = annotation._rnasecstr.hashCode();
numHelix = 0;
- positionsToHelix = new Hashtable<Integer, String>();
+ positionsToHelix = new Hashtable<>();
// Figure out number of helices
// Length of rnasecstr is the number of pairs of positions that base pair
}
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI sg,
- Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI sg)
{
return new RNAHelicesColour(sg);
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceI;
import java.awt.Color;
-import java.util.Map;
public class RNAInteractionColourScheme extends ResidueColourScheme
{
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new RNAInteractionColourScheme();
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceI;
import jalview.util.Comparison;
import java.awt.Color;
-import java.util.Map;
/**
* DOCUMENT ME!
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new ScoreColourScheme(symbolIndex, scores, min, max);
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
-import jalview.datamodel.SequenceI;
import java.awt.Color;
-import java.util.Map;
/**
* DOCUMENT ME!
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new StrandColourScheme();
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.AnnotatedCollectionI;
// assume only one set of TCOFFEE scores - but could have more than one
// potentially.
- List<AlignmentAnnotation> annots = new ArrayList<AlignmentAnnotation>();
+ List<AlignmentAnnotation> annots = new ArrayList<>();
// Search alignment to get all tcoffee annotation and pick one set of
// annotation to use to colour seqs.
- seqMap = new IdentityHashMap<SequenceI, Color[]>();
+ seqMap = new IdentityHashMap<>();
AnnotatedCollectionI alcontext = alignment instanceof AlignmentI
? alignment
: alignment.getContext();
}
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI sg,
- Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI sg)
{
return new TCoffeeColourScheme(sg);
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
-import jalview.datamodel.SequenceI;
-
-import java.util.Map;
public class TaylorColourScheme extends ResidueColourScheme
{
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new TaylorColourScheme();
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
-import jalview.datamodel.SequenceI;
import java.awt.Color;
-import java.util.Map;
/**
* DOCUMENT ME!
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new TurnColourScheme();
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
-import jalview.datamodel.SequenceI;
import jalview.util.ColorUtils;
import jalview.util.StringUtils;
}
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI sg,
- Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI sg)
{
return new UserColourScheme(this);
}
*/
package jalview.schemes;
+import jalview.api.AlignViewportI;
import jalview.datamodel.AnnotatedCollectionI;
-import jalview.datamodel.SequenceCollectionI;
-import jalview.datamodel.SequenceI;
-
-import java.util.Map;
/**
* DOCUMENT ME!
* be coloured
*/
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI coll,
- Map<SequenceI, SequenceCollectionI> hrs)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI coll)
{
return new ZappoColourScheme();
}
* retain any colour thresholds per group while
* changing choice of colour scheme (JAL-2386)
*/
- sg.setColourScheme(cs.getInstance(sg, hiddenRepSequences));
+ sg.setColourScheme(cs.getInstance(this, sg));
if (cs != null)
{
sg.getGroupColourScheme().alignmentChanged(sg,
{
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);
+ }
+ }
}
DataSourceType.FILE);
assertNotNull(af, "Didn't read input file " + inFile);
af.loadJalviewDataFile(inAnnot, DataSourceType.FILE, null, null);
- assertSame(af.getViewport().getGlobalColourScheme().getClass(),
+ AlignViewport viewport = af.getViewport();
+ assertSame(viewport.getGlobalColourScheme().getClass(),
TCoffeeColourScheme.class, "Didn't set T-coffee colourscheme");
assertNotNull(
- ColourSchemeProperty.getColourScheme(
- af.getViewport().getAlignment(),
- af.getViewport().getGlobalColourScheme()
+ ColourSchemeProperty.getColourScheme(viewport,
+ viewport.getAlignment(),
+ viewport.getGlobalColourScheme()
.getSchemeName()),
"Recognise T-Coffee score from string");
af = new FileLoader().LoadFileWaitTillLoaded(tfile,
DataSourceType.FILE);
assertNotNull(af, "Failed to import new project");
- assertSame(af.getViewport().getGlobalColourScheme().getClass(),
+ assertSame(viewport.getGlobalColourScheme().getClass(),
TCoffeeColourScheme.class,
"Didn't set T-coffee colourscheme for imported project.");
System.out.println(
{
AnnotationColourGradient testee = new AnnotationColourGradient(ann,
minColour, maxColour, AnnotationColourGradient.ABOVE_THRESHOLD);
- testee = (AnnotationColourGradient) testee.getInstance(al, null);
+ testee = (AnnotationColourGradient) testee.getInstance(null, al);
for (int col = 0; col < WIDTH; col++)
{
{
AnnotationColourGradient testee = new AnnotationColourGradient(ann,
minColour, maxColour, AnnotationColourGradient.BELOW_THRESHOLD);
- testee = (AnnotationColourGradient) testee.getInstance(al, null);
+ testee = (AnnotationColourGradient) testee.getInstance(null, al);
for (int col = 0; col < WIDTH; col++)
{
{
AnnotationColourGradient testee = new AnnotationColourGradient(ann,
minColour, maxColour, AnnotationColourGradient.NO_THRESHOLD);
- testee = (AnnotationColourGradient) testee.getInstance(al, null);
+ testee = (AnnotationColourGradient) testee.getInstance(null, al);
for (int col = 0; col < WIDTH; col++)
{
{
AnnotationColourGradient testee = new AnnotationColourGradient(ann,
minColour, maxColour, AnnotationColourGradient.NO_THRESHOLD);
- testee = (AnnotationColourGradient) testee.getInstance(al, null);
+ testee = (AnnotationColourGradient) testee.getInstance(null, al);
/*
* flag corresponding to 'use original colours' checkbox
SequenceI seq = new Sequence("Seq1", "abcd");
AlignmentI al = new Alignment(new SequenceI[] { seq });
// the strings here correspond to JalviewColourScheme.toString() values
- ColourSchemeI cs = ColourSchemeProperty.getColourScheme(al, "Clustal");
+ ColourSchemeI cs = ColourSchemeProperty.getColourScheme(null, al,
+ "Clustal");
assertTrue(cs instanceof ClustalxColourScheme);
// not case-sensitive
- cs = ColourSchemeProperty.getColourScheme(al, "CLUSTAL");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "CLUSTAL");
assertTrue(cs instanceof ClustalxColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "clustal");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "clustal");
assertTrue(cs instanceof ClustalxColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "Blosum62");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "Blosum62");
assertTrue(cs instanceof Blosum62ColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "% Identity");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "% Identity");
assertTrue(cs instanceof PIDColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "Zappo");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "Zappo");
assertTrue(cs instanceof ZappoColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "Taylor");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "Taylor");
assertTrue(cs instanceof TaylorColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "Hydrophobic");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "Hydrophobic");
assertTrue(cs instanceof HydrophobicColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "Helix Propensity");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "Helix Propensity");
assertTrue(cs instanceof HelixColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "Strand Propensity");
+ cs = ColourSchemeProperty.getColourScheme(null, al,
+ "Strand Propensity");
assertTrue(cs instanceof StrandColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "Turn Propensity");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "Turn Propensity");
assertTrue(cs instanceof TurnColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "Buried Index");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "Buried Index");
assertTrue(cs instanceof BuriedColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "Nucleotide");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "Nucleotide");
assertTrue(cs instanceof NucleotideColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "Purine/Pyrimidine");
+ cs = ColourSchemeProperty.getColourScheme(null, al,
+ "Purine/Pyrimidine");
assertTrue(cs instanceof PurinePyrimidineColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "T-Coffee Scores");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "T-Coffee Scores");
assertTrue(cs instanceof TCoffeeColourScheme);
- cs = ColourSchemeProperty.getColourScheme(al, "RNA Helices");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "RNA Helices");
assertTrue(cs instanceof RNAHelicesColour);
// 'None' is a special value
- assertNull(ColourSchemeProperty.getColourScheme(al, "None"));
- assertNull(ColourSchemeProperty.getColourScheme(al, "none"));
+ assertNull(ColourSchemeProperty.getColourScheme(null, al, "None"));
+ assertNull(ColourSchemeProperty.getColourScheme(null, al, "none"));
// default is to convert the name into a fixed colour
- cs = ColourSchemeProperty.getColourScheme(al, "elephants");
+ cs = ColourSchemeProperty.getColourScheme(null, al, "elephants");
assertTrue(cs instanceof UserColourScheme);
/*
* explicit aa colours
*/
UserColourScheme ucs = (UserColourScheme) ColourSchemeProperty
- .getColourScheme(al,
+ .getColourScheme(null, al,
"R,G=red;C=blue;c=green;Q=10,20,30;S,T=11ffdd");
assertEquals(ucs.findColour('H'), Color.white);
assertEquals(ucs.findColour('R'), Color.red);
import static org.testng.Assert.assertSame;
import static org.testng.Assert.assertTrue;
+import jalview.api.AlignViewportI;
import jalview.bin.Cache;
import jalview.bin.Jalview;
import jalview.datamodel.AnnotatedCollectionI;
}
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI sg,
- Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI sg)
{
final ColourSchemeI cs1 = ColourSchemes.getInstance()
.getColourScheme(JalviewColourScheme.Taylor.toString(),
}
@Override
- public ColourSchemeI getInstance(AnnotatedCollectionI sg,
- Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
+ public ColourSchemeI getInstance(AlignViewportI view,
+ AnnotatedCollectionI sg)
{
- return new MyClustal(sg, hiddenRepSequences);
+ return new MyClustal(sg, view.getHiddenRepSequences());
}
@Override
assertTrue(JalviewColourScheme.PurinePyrimidine.getSchemeClass() == PurinePyrimidineColourScheme.class);
assertTrue(JalviewColourScheme.TCoffee.getSchemeClass() == TCoffeeColourScheme.class);
assertTrue(JalviewColourScheme.RNAHelices.getSchemeClass() == RNAHelicesColour.class);
+ assertTrue(JalviewColourScheme.IdColour
+ .getSchemeClass() == IdColourScheme.class);
}
@Test(groups = "Functional")
"Purine/Pyrimidine");
assertEquals(JalviewColourScheme.TCoffee.toString(), "T-Coffee Scores");
assertEquals(JalviewColourScheme.RNAHelices.toString(), "RNA Helices");
+ assertEquals(JalviewColourScheme.IdColour.toString(), "Sequence ID");
}
}