public static final String PROFILE = "P";
- public static final Hashtable[] calculate(Vector sequences, int start,
+ public static final Hashtable[] calculate(List<SequenceI> list, int start,
int end)
{
- return calculate(sequences, start, end, false);
+ return calculate(list, start, end, false);
}
- public static final Hashtable[] calculate(Vector sequences, int start,
+ public static final Hashtable[] calculate(List<SequenceI> sequences, int start,
int end, boolean profile)
{
SequenceI[] seqs = new SequenceI[sequences.size()];
int width = 0;
+ synchronized (sequences) {
for (int i = 0; i < sequences.size(); i++)
{
- seqs[i] = (SequenceI) sequences.elementAt(i);
+ seqs[i] = sequences.get(i);
if (seqs[i].getLength() > width)
{
width = seqs[i].getLength();
}
calculate(seqs, start, end, reply, profile);
-
return reply;
}
+ }
public static final void calculate(SequenceI[] sequences, int start,
int end, Hashtable[] result)
// SORTS GROUPS BY SIZE
// ////////////////////
- for (int i = 0; i < align.getGroups().size(); i++)
+ for (SequenceGroup sg:align.getGroups())
{
- SequenceGroup sg = (SequenceGroup) align.getGroups().elementAt(i);
-
for (int j = 0; j < groups.size(); j++)
{
SequenceGroup sg2 = (SequenceGroup) groups.elementAt(j);
import java.util.Enumeration;
import java.util.Hashtable;
+import java.util.List;
import java.util.Vector;
/**
*
* @param sequences
* @param selectedChars
- * @param exgroups
+ * @param list
* @return
*/
public static SequenceGroup[] makeGroupsFrom(SequenceI[] sequences,
- String[] selectedChars, Vector exgroups)
+ String[] selectedChars, List<SequenceGroup> list)
{
// TODO: determine how to get/recover input data for group generation
Hashtable gps = new Hashtable();
int width = 0, i;
Hashtable pgroup = new Hashtable();
- if (exgroups != null)
+ if (list != null)
{
- SequenceGroup sg;
- for (Enumeration g = exgroups.elements(); g.hasMoreElements();)
+ for (SequenceGroup sg:list)
{
- sg = (SequenceGroup) g.nextElement();
- for (Enumeration sq = sg.getSequences(null).elements(); sq
- .hasMoreElements();)
- pgroup.put(sq.nextElement().toString(), sg);
+ for (SequenceI sq :sg.getSequences(null))
+ {
+ pgroup.put(sq.toString(), sg);
+ }
}
}
for (i = 0; i < sequences.length; i++)
package jalview.api;
import java.util.Hashtable;
+import java.util.Map;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.AlignmentI;
+import jalview.datamodel.AnnotatedCollectionI;
import jalview.datamodel.ColumnSelection;
+import jalview.datamodel.SequenceCollectionI;
+import jalview.datamodel.SequenceI;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.RNAHelicesColour;
*/
void setGlobalColourScheme(ColourSchemeI rhc);
+ Map<SequenceI, SequenceCollectionI> getHiddenRepSequences();
+
+ void setHiddenRepSequences(
+ Map<SequenceI, SequenceCollectionI> hiddenRepSequences);
+
}
{
SequenceGroup sg = getGroup();
sg.cs = new ClustalxColourScheme(
- sg.getSequences(ap.av.getHiddenRepSequences()),
- ap.av.getAlignment().getWidth());
+ sg,ap.av.getHiddenRepSequences());
refresh();
}
import java.net.URLEncoder;\r
import java.util.Enumeration;\r
import java.util.Hashtable;\r
+import java.util.List;\r
import java.util.StringTokenizer;\r
import java.util.Vector;\r
\r
else if (source == clustalColour)\r
{\r
abovePIDThreshold.setState(false);\r
- changeColour(new ClustalxColourScheme(\r
- viewport.getAlignment().getSequences(),\r
- viewport.getAlignment().getWidth()));\r
+ changeColour(new ClustalxColourScheme(viewport.getAlignment(),null));\r
}\r
else if (source == zappoColour)\r
{\r
\r
synchronized void slideSequences(boolean right, int size)\r
{\r
- Vector sg = new Vector();\r
+ List<SequenceI>sg = new Vector<SequenceI>();\r
if (viewport.cursorMode)\r
{\r
- sg.addElement(viewport.getAlignment()\r
+ sg.add(viewport.getAlignment()\r
.getSequenceAt(alignPanel.seqPanel.seqCanvas.cursorY));\r
}\r
else if (viewport.getSelectionGroup() != null\r
return;\r
}\r
\r
- Vector invertGroup = new Vector();\r
+ Vector<SequenceI> invertGroup = new Vector();\r
\r
for (int i = 0; i < viewport.getAlignment().getHeight(); i++)\r
{\r
invertGroup.addElement(viewport.getAlignment().getSequenceAt(i));\r
}\r
\r
- SequenceI[] seqs1 = new SequenceI[sg.size()];\r
- for (int i = 0; i < sg.size(); i++)\r
- seqs1[i] = (SequenceI) sg.elementAt(i);\r
+ SequenceI[] seqs1 = sg.toArray(new SequenceI[sg.size()]);\r
\r
- SequenceI[] seqs2 = new SequenceI[invertGroup.size()];\r
+ SequenceI[] seqs2 = invertGroup.toArray(new SequenceI[invertGroup.size()]);\r
for (int i = 0; i < invertGroup.size(); i++)\r
seqs2[i] = (SequenceI) invertGroup.elementAt(i);\r
\r
Color col = new Color((int) (Math.random() * 255),\r
(int) (Math.random() * 255), (int) (Math.random() * 255));\r
col = col.brighter();\r
- for (Enumeration sq = gps[g].getSequences(null).elements(); sq\r
- .hasMoreElements(); viewport.setSequenceColour(\r
- (SequenceI) sq.nextElement(), col))\r
+ for (SequenceI sq : gps[g].getSequences(null))\r
+ viewport.setSequenceColour(\r
+ sq, col)\r
;\r
}\r
PaintRefresher.Refresh(this, viewport.getSequenceSetId());\r
\r
addHistoryItem(trimRegion);\r
\r
- Vector groups = viewport.getAlignment().getGroups();\r
\r
- for (int i = 0; i < groups.size(); i++)\r
- {\r
- SequenceGroup sg = (SequenceGroup) groups.elementAt(i);\r
\r
+ for (SequenceGroup sg:viewport.getAlignment().getGroups())\r
+ {\r
if ((trimLeft && !sg.adjustForRemoveLeft(column))\r
|| (!trimLeft && !sg.adjustForRemoveRight(column)))\r
{\r
public void updateSequenceIdColours()
{
- Vector groups = alignment.getGroups();
- for (int ig = 0, igSize = groups.size(); ig < igSize; ig++)
+
+ for (SequenceGroup sg:alignment.getGroups())
{
- SequenceGroup sg = (SequenceGroup) groups.elementAt(ig);
if (sg.idColour != null)
{
- Vector sqs = sg.getSequences(getHiddenRepSequences());
- for (int s = 0, sSize = sqs.size(); s < sSize; s++)
+ for (SequenceI s:sg.getSequences(getHiddenRepSequences()))
{
- this.setSequenceColour((SequenceI) sqs.elementAt(s), sg.idColour);
+ this.setSequenceColour(s, sg.idColour);
}
}
}
// remove old automatic annotation
// add any new annotation
- Vector gr = av.getAlignment().getGroups(); // OrderedBy(av.alignment.getSequencesArray());
+ ; // OrderedBy(av.alignment.getSequencesArray());
// intersect alignment annotation with alignment groups
AlignmentAnnotation[] aan = av.getAlignment().getAlignmentAnnotation();
}
}
}
- SequenceGroup sg;
- if (gr != null)
+ if (av.getAlignment().getGroups()!= null)
{
- for (int g = 0; g < gr.size(); g++)
+ for (SequenceGroup sg:av.getAlignment().getGroups())
{
updateCalcs = false;
- sg = (SequenceGroup) gr.elementAt(g);
if (applyGlobalSettings || !oldrfs.containsKey(sg))
{
// set defaults for this group's conservation/consensus
if (av.getAlignment().getGroups() != null)
{
oldgroupColours = new Hashtable();
- Vector allGroups = ap.av.getAlignment().getGroups();
- SequenceGroup sg;
- for (int g = 0; g < allGroups.size(); g++)
+ for (SequenceGroup sg: ap.av.getAlignment().getGroups())
{
- sg = (SequenceGroup) allGroups.elementAt(g);
if (sg.cs != null)
{
oldgroupColours.put(sg, sg.cs);
if (av.getAlignment().getGroups() != null)
{
- Vector allGroups = ap.av.getAlignment().getGroups();
- SequenceGroup sg;
- for (int g = 0; g < allGroups.size(); g++)
+ for (SequenceGroup sg:ap.av.getAlignment().getGroups())
{
- sg = (SequenceGroup) allGroups.elementAt(g);
-
+
if (sg.cs == null)
{
continue;
av.setGlobalColourScheme(oldcs);
if (av.getAlignment().getGroups() != null)
{
- Vector allGroups = ap.av.getAlignment().getGroups();
- SequenceGroup sg;
- for (int g = 0; g < allGroups.size(); g++)
+ for (SequenceGroup sg:ap.av.getAlignment().getGroups())
{
- sg = (SequenceGroup) allGroups.elementAt(g);
Object cs = oldgroupColours.get(sg);
if (cs instanceof ColourSchemeI)
{
package jalview.appletgui;
import java.awt.*;
+import java.util.List;
import jalview.datamodel.*;
boolean fastPaint = false;
- java.util.Vector searchResults;
+ List<SequenceI> searchResults;
public IdCanvas(AlignViewport av)
{
}
}
- public void setHighlighted(java.util.Vector found)
+ public void setHighlighted(List<SequenceI> list)
{
- searchResults = found;
+ searchResults = list;
repaint();
}
import java.awt.*;
import java.awt.event.*;
+import java.util.List;
import java.util.Vector;
import jalview.datamodel.*;
av.sendSelection();
}
- public void highlightSearchResults(java.util.Vector found)
+ public void highlightSearchResults(List<SequenceI> list)
{
- idCanvas.setHighlighted(found);
+ idCanvas.setHighlighted(list);
- if (found == null)
+ if (list == null)
{
return;
}
- int index = av.getAlignment().findIndex((SequenceI) found.elementAt(0));
+ int index = av.getAlignment().findIndex(list.get(0));
// do we need to scroll the panel?
if (av.getStartSeq() > index || av.getEndSeq() < index)
if ((group == null) && (av.getAlignment().getGroups().size() > 0))
{
- group = (SequenceGroup) av.getAlignment().getGroups().elementAt(0);
+ group = (SequenceGroup) av.getAlignment().getGroups().get(0);
groupIndex = 0;
}
break;
}
- group = (SequenceGroup) av.getAlignment().getGroups().elementAt(
+ group = (SequenceGroup) av.getAlignment().getGroups().get(
groupIndex);
} while (groupIndex < av.getAlignment().getGroups().size());
else
{
// Now add any sequences between min and max
- sg.getSequences(null).removeAllElements();
+ sg.clear();
for (int i = min; i < max; i++)
{
sg.addSequence(av.getAlignment().getSequenceAt(i), false);
if (groupEditing)
{
- Vector vseqs = sg.getSequences(av.getHiddenRepSequences());
- int g, groupSize = vseqs.size();
- SequenceI[] groupSeqs = new SequenceI[groupSize];
- for (g = 0; g < groupSeqs.length; g++)
- {
- groupSeqs[g] = (SequenceI) vseqs.elementAt(g);
- }
+ SequenceI[] groupSeqs = sg.getSequences(av.getHiddenRepSequences()).toArray(new SequenceI[0]);
// drag to right
if (insertGap)
{
blank = true;
- for (g = 0; g < groupSize; g++)
+ for (SequenceI gs:groupSeqs)
{
for (int j = 0; j < startres - lastres; j++)
{
- if (!jalview.util.Comparison.isGap(groupSeqs[g]
+ if (!jalview.util.Comparison.isGap(gs
.getCharAt(fixedRight - j)))
{
blank = false;
// / Are we able to delete?
// ie are all columns blank?
- for (g = 0; g < groupSize; g++)
+ for (SequenceI gs:groupSeqs)
{
for (int j = startres; j < lastres; j++)
{
- if (groupSeqs[g].getLength() <= j)
+ if (gs.getLength() <= j)
{
continue;
}
- if (!jalview.util.Comparison.isGap(groupSeqs[g].getCharAt(j)))
+ if (!jalview.util.Comparison.isGap(gs.getCharAt(j)))
{
// Not a gap, block edit not valid
endEditing();
{
if (stretchGroup.cs instanceof ClustalxColourScheme)
{
- ((ClustalxColourScheme) stretchGroup.cs).resetClustalX(
- stretchGroup.getSequences(av.getHiddenRepSequences()),
- stretchGroup.getWidth());
+ ((ClustalxColourScheme) stretchGroup.cs).alignmentChanged(
+stretchGroup,av.getHiddenRepSequences());
}
if (stretchGroup.cs instanceof Blosum62ColourScheme
package jalview.appletgui;
import java.util.*;
+import java.util.List;
import java.awt.*;
import java.awt.event.*;
}
ColourSchemeI toChange = null;
- Vector allGroups = null;
- int groupIndex = 0;
+ Iterator<SequenceGroup> allGroups = null;
if (allGroupsCheck.getState())
{
- allGroups = ap.av.getAlignment().getGroups();
- groupIndex = allGroups.size() - 1;
+ allGroups = ap.av.getAlignment().getGroups().listIterator();
}
else
{
toChange = cs;
}
- while (groupIndex > -1)
+ do
{
if (allGroups != null)
{
- toChange = ((SequenceGroup) allGroups.elementAt(groupIndex)).cs;
+ toChange = allGroups.next().cs;
}
if (forConservation)
toChange.setThreshold(i, ap.av.getIgnoreGapsConsensus());
}
- groupIndex--;
- }
+ } while (allGroups!=null && allGroups.hasNext());
ap.seqPanel.seqCanvas.repaint();
ColourSchemeI cs = null;
+ SequenceGroup sg = new SequenceGroup(sequences, "", cs, true, true,
+ false, 0, av.getAlignment().getWidth() - 1);
+
if (av.getGlobalColourScheme() != null)
{
if (av.getGlobalColourScheme() instanceof UserColourScheme)
}
else
{
- cs = ColourSchemeProperty.getColour(sequences, av.getAlignment()
- .getWidth(), ColourSchemeProperty.getColourName(av
+ cs = ColourSchemeProperty.getColour(sg, ColourSchemeProperty.getColourName(av
.getGlobalColourScheme()));
}
// cs is null if shading is an annotationColourGradient
av.getIgnoreGapsConsensus());
}
}
-
- SequenceGroup sg = new SequenceGroup(sequences, "", cs, true, true,
- false, 0, av.getAlignment().getWidth() - 1);
+ // TODO: cs used to be initialized with a sequence collection and recalcConservation called automatically
+ // instead we set it manually - recalc called after updateAnnotation
+ sg.cs=cs;
sg.setName("JTreeGroup:" + sg.hashCode());
sg.setIdColour(col);
{
return sequences;
}
+ @Override
+ public List<SequenceI> getSequences(
+ Map<SequenceI, SequenceCollectionI> hiddenReps)
+ {
+ // TODO: in jalview 2.8 we don't do anything with hiddenreps - fix design to work on this.
+ return sequences;
+ }
public SequenceI[] getSequencesArray()
{
{
this.addCodonFrame(acod[a]);
}
- Vector sg = toappend.getGroups();
+ List<SequenceGroup> sg = toappend.getGroups();
if (sg != null)
{
- Enumeration el = sg.elements();
- while (el.hasMoreElements())
+ for (SequenceGroup _sg:sg)
{
- addGroup((SequenceGroup) el.nextElement());
+ addGroup(_sg);
}
}
if (toappend.getHiddenSequences() != null)
/**
* Get all the groups associated with this alignment.
*
- * @return All groups as a Vector.
+ * @return All groups as a list.
*/
- public Vector getGroups();
+ public List<SequenceGroup> getGroups();
/**
* Deletes all groups from this alignment.
\r
import java.io.PrintStream;\r
import java.util.Enumeration;\r
+import java.util.List;\r
import java.util.Vector;\r
\r
/**\r
SequenceI[] selseqs;\r
if (selection != null)\r
{\r
- Vector sel = selection.getSequences(null);\r
+ List<SequenceI> sel = selection.getSequences(null);\r
this.selected = new Vector();\r
selseqs = selection.getSequencesInOrder(alignment, selectedRegionOnly);\r
}\r
\r
// get the alignment's group list and make a copy\r
Vector grps = new Vector();\r
- Vector gg = alignment.getGroups();\r
- Enumeration gge = gg.elements();\r
- while (gge.hasMoreElements())\r
- {\r
- grps.addElement(gge.nextElement());\r
- }\r
+ List<SequenceGroup> gg = alignment.getGroups();\r
+ grps.addAll(gg);\r
ScGroup[] sgrps = null;\r
boolean addedgps[] = null;\r
if (grps != null)\r
+ " wide and has " + visal.getHeight() + " seqs.");\r
if (visal.getGroups() != null && visal.getGroups().size() > 0)\r
{\r
- SequenceGroup sg;\r
- Enumeration en = visal.getGroups().elements();\r
+ \r
int i = 1;\r
- while (en.hasMoreElements())\r
+ for (SequenceGroup sg:visal.getGroups())\r
{\r
- sg = (SequenceGroup) en.nextElement();\r
os.println("Group " + (i++) + " begins at column "\r
+ sg.getStartRes() + " and ends at " + sg.getEndRes());\r
}\r
package jalview.datamodel;
-public interface AnnotatedCollectionI
+public interface AnnotatedCollectionI extends SequenceCollectionI
{
/**
alignment.deleteSequence(sequence);
}
- public Vector showAll(Hashtable hiddenReps)
+ public Vector showAll(Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
{
Vector revealedSeqs = new Vector();
for (int i = 0; i < hiddenSequences.length; i++)
{
if (hiddenSequences[i] != null)
{
- Vector tmp = showSequence(i, hiddenReps);
+ Vector tmp = showSequence(i, hiddenRepSequences);
for (int t = 0; t < tmp.size(); t++)
{
revealedSeqs.addElement(tmp.elementAt(t));
return revealedSeqs;
}
- public Vector showSequence(int alignmentIndex, Hashtable hiddenReps)
+ public Vector showSequence(int alignmentIndex, Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
{
Vector revealedSeqs = new Vector();
SequenceI repSequence = alignment.getSequenceAt(alignmentIndex);
- if (repSequence != null && hiddenReps != null
- && hiddenReps.containsKey(repSequence))
+ if (repSequence != null && hiddenRepSequences != null
+ && hiddenRepSequences.containsKey(repSequence))
{
- hiddenReps.remove(repSequence);
+ hiddenRepSequences.remove(repSequence);
revealedSeqs.addElement(repSequence);
}
--- /dev/null
+package jalview.datamodel;
+
+import java.util.List;
+import java.util.Map;
+
+public interface SequenceCollectionI
+{
+ List<SequenceI> getSequences();
+ List<SequenceI> getSequences(Map<SequenceI,SequenceCollectionI> hiddenReps);
+ int getWidth();
+
+}
package jalview.datamodel;
import java.util.*;
+import java.util.List;
import java.awt.*;
/**
* group members
*/
- private Vector sequences = new Vector();
+ private Vector<SequenceI> sequences = new Vector<SequenceI>();
/**
* representative sequence for this group (if any)
if (seqsel != null)
{
sequences = new Vector();
- Enumeration sq = seqsel.sequences.elements();
+ Enumeration<SequenceI> sq = seqsel.sequences.elements();
while (sq.hasMoreElements())
{
sequences.addElement(sq.nextElement());
return eres;
}
-
- public Vector getSequences(Hashtable hiddenReps)
+ public List<SequenceI> getSequences()
+ {
+ return sequences;
+ }
+ public List<SequenceI> getSequences(Map<SequenceI, SequenceCollectionI> hiddenReps)
{
if (hiddenReps == null)
{
else
{
Vector allSequences = new Vector();
- SequenceI seq, seq2;
+ SequenceI seq;
for (int i = 0; i < sequences.size(); i++)
{
seq = (SequenceI) sequences.elementAt(i);
allSequences.addElement(seq);
if (hiddenReps.containsKey(seq))
{
- SequenceGroup hsg = (SequenceGroup) hiddenReps.get(seq);
- for (int h = 0; h < hsg.getSize(); h++)
+ SequenceCollectionI hsg = hiddenReps.get(seq);
+ for (SequenceI seq2:hsg.getSequences())
{
- seq2 = hsg.getSequenceAt(h);
if (seq2 != seq && !allSequences.contains(seq2))
{
allSequences.addElement(seq2);
}
}
- public SequenceI[] getSequencesAsArray(Hashtable hiddenReps)
+ public SequenceI[] getSequencesAsArray(Map<SequenceI, SequenceCollectionI> map)
{
- Vector tmp = getSequences(hiddenReps);
- if (tmp == null)
+ List<SequenceI> tmp = getSequences(map);
+ if (tmp==null)
{
return null;
}
- SequenceI[] result = new SequenceI[tmp.size()];
- for (int i = 0; i < result.length; i++)
- {
- result[i] = (SequenceI) tmp.elementAt(i);
- }
-
- return result;
+ return tmp.toArray(new SequenceI[tmp.size()]);
}
/**
}
if (cs!=null)
{
- cs.alignmentChanged(this);
+ cs.alignmentChanged(this,null);
}
try
{
if (cs != null)
{
cs.setConsensus(cnsns);
-
- if (cs instanceof ClustalxColourScheme)
- {
- ((ClustalxColourScheme) cs).resetClustalX(sequences, getWidth());
- }
+ cs.alignmentChanged(this,null);
}
if ((conservation != null)
if (cs.conservationApplied())
{
cs.setConservation(c);
-
- if (cs instanceof ClustalxColourScheme)
- {
- ((ClustalxColourScheme) cs).resetClustalX(sequences,
- getWidth());
- }
+ cs.alignmentChanged(this,null);
}
}
}
*
* @param alignment
* (may not be null)
- * @param hashtable
+ * @param map
* (may be null)
* @return new group containing sequences common to this group and alignment
*/
- public SequenceGroup intersect(AlignmentI alignment, Hashtable hashtable)
+ public SequenceGroup intersect(AlignmentI alignment, Map<SequenceI, SequenceCollectionI> map)
{
SequenceGroup sgroup = new SequenceGroup(this);
SequenceI[] insect = getSequencesInOrder(alignment);
sgroup.sequences = new Vector();
for (int s = 0; insect != null && s < insect.length; s++)
{
- if (hashtable == null || hashtable.containsKey(insect[s]))
+ if (map == null || map.containsKey(insect[s]))
{
sgroup.sequences.addElement(insect[s]);
}
}
return aa;
}
+
+ public void clear()
+ {
+ sequences.clear();
+ }
}
synchronized void slideSequences(boolean right, int size)
{
- Vector sg = new Vector();
+ List<SequenceI> sg = new Vector();
if (viewport.cursorMode)
{
- sg.addElement(viewport.getAlignment().getSequenceAt(
+ sg.add(viewport.getAlignment().getSequenceAt(
alignPanel.seqPanel.seqCanvas.cursorY));
}
else if (viewport.getSelectionGroup() != null
invertGroup.add(viewport.getAlignment().getSequenceAt(i));
}
- SequenceI[] seqs1 = new SequenceI[sg.size()];
- for (int i = 0; i < sg.size(); i++)
- seqs1[i] = (SequenceI) sg.elementAt(i);
-
+ SequenceI[] seqs1 = sg.toArray(new SequenceI[0]);
+
SequenceI[] seqs2 = new SequenceI[invertGroup.size()];
for (int i = 0; i < invertGroup.size(); i++)
seqs2[i] = (SequenceI) invertGroup.elementAt(i);
addHistoryItem(trimRegion);
- Vector groups = viewport.getAlignment().getGroups();
-
- for (int i = 0; i < groups.size(); i++)
+ for (SequenceGroup sg :viewport.getAlignment().getGroups())
{
- SequenceGroup sg = (SequenceGroup) groups.get(i);
-
if ((trimLeft && !sg.adjustForRemoveLeft(column))
|| (!trimLeft && !sg.adjustForRemoveRight(column)))
{
*/
public void clustalColour_actionPerformed(ActionEvent e)
{
- changeColour(new ClustalxColourScheme(viewport.getAlignment()
- .getSequences(), viewport.getAlignment().getWidth()));
+ changeColour(new ClustalxColourScheme(viewport.getAlignment(), viewport.getHiddenRepSequences()));
}
/**
if (viewport.getColourAppliesToAllGroups())
{
- Vector groups = viewport.getAlignment().getGroups();
- for (int i = 0; i < groups.size(); i++)
- {
- SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
+ for (SequenceGroup sg:viewport.getAlignment().getGroups())
+ {
if (cs == null)
{
sg.cs = null;
if (cs instanceof ClustalxColourScheme)
{
- sg.cs = new ClustalxColourScheme(sg.getSequences(viewport
- .getHiddenRepSequences()), sg.getWidth());
+ sg.cs = new ClustalxColourScheme(sg, viewport
+ .getHiddenRepSequences());
}
else if (cs instanceof UserColourScheme)
{
return;
}
- int s = 0;
SequenceGroup sg = viewport.getSelectionGroup();
/* Decide if the selection is a column region */
- while (s < sg.getSize())
+ for (SequenceI _s:sg.getSequences())
{
- if (((SequenceI) sg.getSequences(null).elementAt(s++)).getLength() < sg
+ if (_s.getLength() < sg
.getEndRes())
{
JOptionPane
Color col = new Color((int) (Math.random() * 255),
(int) (Math.random() * 255), (int) (Math.random() * 255));
col = col.brighter();
- for (Enumeration sq = gps[g].getSequences(null).elements(); sq
- .hasMoreElements(); viewport.setSequenceColour(
- (SequenceI) sq.nextElement(), col))
+ for (SequenceI s:gps[g].getSequences())
+ viewport.setSequenceColour(
+ s, col)
;
}
PaintRefresher.Refresh(this, viewport.getSequenceSetId());
public void updateSequenceIdColours()
{
- Vector groups = alignment.getGroups();
if (sequenceColours == null)
{
sequenceColours = new Hashtable();
}
- for (int ig = 0, igSize = groups.size(); ig < igSize; ig++)
+ for (SequenceGroup sg:alignment.getGroups())
{
- SequenceGroup sg = (SequenceGroup) groups.elementAt(ig);
if (sg.idColour != null)
{
- Vector sqs = sg.getSequences(getHiddenRepSequences());
- for (int s = 0, sSize = sqs.size(); s < sSize; s++)
+ for (SequenceI s:sg.getSequences(getHiddenRepSequences()))
{
- sequenceColours.put(sqs.elementAt(s), sg.idColour);
+ sequenceColours.put(s, sg.idColour);
}
}
}
// remove old automatic annotation
// add any new annotation
- Vector gr = av.getAlignment().getGroups(); // OrderedBy(av.getAlignment().getSequencesArray());
// intersect alignment annotation with alignment groups
AlignmentAnnotation[] aan = av.getAlignment().getAlignmentAnnotation();
}
}
}
- SequenceGroup sg;
- if (gr != null)
+ if (av.getAlignment().getGroups()!=null)
{
- for (int g = 0; g < gr.size(); g++)
+ for (SequenceGroup sg:av.getAlignment().getGroups())
{
updateCalcs = false;
- sg = (SequenceGroup) gr.elementAt(g);
if (applyGlobalSettings || !oldrfs.containsKey(sg))
{
// set defaults for this group's conservation/consensus
if (av.getAlignment().getGroups() != null)
{
oldgroupColours = new Hashtable();
- Vector allGroups = ap.av.getAlignment().getGroups();
- SequenceGroup sg;
- for (int g = 0; g < allGroups.size(); g++)
+ for (SequenceGroup sg:ap.av.getAlignment().getGroups())
{
- sg = (SequenceGroup) allGroups.get(g);
if (sg.cs != null)
{
oldgroupColours.put(sg, sg.cs);
if (av.getAlignment().getGroups() != null)
{
- Vector allGroups = ap.av.getAlignment().getGroups();
- SequenceGroup sg;
- for (int g = 0; g < allGroups.size(); g++)
+
+ for (SequenceGroup sg:ap.av.getAlignment().getGroups())
{
- sg = (SequenceGroup) allGroups.get(g);
-
if (sg.cs == null)
{
continue;
av.setGlobalColourScheme(oldcs);
if (av.getAlignment().getGroups() != null)
{
- Vector allGroups = ap.av.getAlignment().getGroups();
- SequenceGroup sg;
- for (int g = 0; g < allGroups.size(); g++)
+
+ for (SequenceGroup sg:ap.av.getAlignment().getGroups())
{
- sg = (SequenceGroup) allGroups.get(g);
sg.cs = (ColourSchemeI) oldgroupColours.get(sg);
}
}
package jalview.gui;\r
\r
import java.util.*;\r
+import java.util.List;\r
\r
import java.awt.*;\r
import java.awt.event.*;\r
\r
AlignmentAnnotation[] annotations;\r
\r
- Vector sequenceGroups;\r
+ List<SequenceGroup> sequenceGroups;\r
\r
Hashtable alignmentProperties;\r
\r
}\r
\r
public void exportAnnotations(AlignmentPanel ap,\r
- AlignmentAnnotation[] annotations, Vector sequenceGroups,\r
+ AlignmentAnnotation[] annotations, List<SequenceGroup> list,\r
Hashtable alProperties)\r
{\r
this.ap = ap;\r
GFFFormat.setVisible(false);\r
CSVFormat.setVisible(true);\r
this.annotations = annotations;\r
- this.sequenceGroups = sequenceGroups;\r
+ this.sequenceGroups = list;\r
this.alignmentProperties = alProperties;\r
frame.setTitle("Export Annotations");\r
}\r
import java.awt.*;
import java.awt.image.*;
+import java.util.List;
+
import javax.swing.*;
import jalview.datamodel.*;
boolean fastPaint = false;
- java.util.Vector searchResults;
+ List<SequenceI> searchResults;
FontMetrics fm;
/**
* DOCUMENT ME!
*
- * @param found
+ * @param list
* DOCUMENT ME!
*/
- public void setHighlighted(java.util.Vector found)
+ public void setHighlighted(List<SequenceI> list)
{
- searchResults = found;
+ searchResults = list;
repaint();
}
}
import java.awt.*;
import java.awt.event.*;
+import java.util.List;
import java.util.Vector;
import javax.swing.*;
/**
* DOCUMENT ME!
*
- * @param found
+ * @param list
* DOCUMENT ME!
*/
- public void highlightSearchResults(java.util.Vector found)
+ public void highlightSearchResults(List<SequenceI> list)
{
- idCanvas.setHighlighted(found);
+ idCanvas.setHighlighted(list);
- if (found == null)
+ if (list == null)
{
return;
}
- int index = av.getAlignment().findIndex((SequenceI) found.get(0));
+ int index = av.getAlignment().findIndex((SequenceI) list.get(0));
// do we need to scroll the panel?
if ((av.getStartSeq() > index) || (av.getEndSeq() < index))
if (jal.getGroups() != null)
{
JGroup[] groups = new JGroup[jal.getGroups().size()];
-
- for (int i = 0; i < groups.length; i++)
+ int i = -1;
+ for (jalview.datamodel.SequenceGroup sg:jal.getGroups())
{
- groups[i] = new JGroup();
+ groups[++i] = new JGroup();
- jalview.datamodel.SequenceGroup sg = (jalview.datamodel.SequenceGroup) jal
- .getGroups().elementAt(i);
groups[i].setStart(sg.getStartRes());
groups[i].setEnd(sg.getEndRes());
groups[i].setName(sg.getName());
{
SequenceGroup sg = getGroup();
sg.cs = new ClustalxColourScheme(
- sg.getSequences(ap.av.getHiddenRepSequences()),
- ap.av.getAlignment().getWidth());
+ sg,ap.av.getHiddenRepSequences());
refresh();
}
if ((group == null) && (av.getAlignment().getGroups().size() > 0))
{
- group = (SequenceGroup) av.getAlignment().getGroups().elementAt(0);
+ group = (SequenceGroup) av.getAlignment().getGroups().get(0);
groupIndex = 0;
}
break;
}
- group = (SequenceGroup) av.getAlignment().getGroups().elementAt(
+ group = (SequenceGroup) av.getAlignment().getGroups().get(
groupIndex);
} while (groupIndex < av.getAlignment().getGroups().size());
package jalview.gui;
import java.util.*;
+import java.util.List;
import java.awt.*;
import java.awt.event.*;
if (groupEditing)
{
- Vector vseqs = sg.getSequences(av.getHiddenRepSequences());
+ List<SequenceI> vseqs = sg.getSequences(av.getHiddenRepSequences());
int g, groupSize = vseqs.size();
SequenceI[] groupSeqs = new SequenceI[groupSize];
for (g = 0; g < groupSeqs.length; g++)
{
- groupSeqs[g] = (SequenceI) vseqs.elementAt(g);
+ groupSeqs[g] = (SequenceI) vseqs.get(g);
}
// drag to right
{
if (stretchGroup.cs instanceof ClustalxColourScheme)
{
- ((ClustalxColourScheme) stretchGroup.cs).resetClustalX(
- stretchGroup.getSequences(av.getHiddenRepSequences()),
- stretchGroup.getWidth());
+ ((ClustalxColourScheme) stretchGroup.cs).alignmentChanged(
+ stretchGroup,av.getHiddenRepSequences());
}
if (stretchGroup.cs.conservationApplied())
}
ColourSchemeI toChange = null;
- Vector allGroups = null;
+ List<SequenceGroup> allGroups = null;
int groupIndex = 0;
if (allGroupsCheck.isSelected())
return;
}
- Vector groups = ap.av.getAlignment().getGroups();
+
- for (int i = 0; i < groups.size(); i++)
+ for (SequenceGroup sg:ap.av.getAlignment().getGroups())
{
- SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
sg.textColour = ap.av.textColour;
sg.textColour2 = ap.av.textColour2;
sg.thresholdTextColour = ap.av.thresholdTextColour;
}
ColourSchemeI cs = null;
+ SequenceGroup sg = new SequenceGroup(sequences, null, cs, true, true,
+ false, 0, av.getAlignment().getWidth() - 1);
if (av.getGlobalColourScheme() != null)
{
}
else
{
- cs = ColourSchemeProperty.getColour(sequences, av.getAlignment()
- .getWidth(), ColourSchemeProperty.getColourName(av
+ cs = ColourSchemeProperty.getColour(sg, ColourSchemeProperty.getColourName(av
.getGlobalColourScheme()));
}
// cs is null if shading is an annotationColourGradient
av.getIgnoreGapsConsensus());
}
}
-
- SequenceGroup sg = new SequenceGroup(sequences, null, cs, true, true,
- false, 0, av.getAlignment().getWidth() - 1);
-
+ sg.cs=cs;
+// sg.recalcConservation();
sg.setName("JTreeGroup:" + sg.hashCode());
sg.setIdColour(col);
for (int a = 0; a < aps.length; a++)
{
String[] vobj = new String[seqsel.getSize()];
int o = 0;
- Enumeration sels = seqsel.getSequences(null).elements();
- while (sels.hasMoreElements())
+ for (SequenceI sel:seqsel.getSequences(null))
{
- SequenceI sel = (SequenceI) sels.nextElement();
VorbaId v = (VorbaId) jv2vobj.get(sel);
if (v != null)
{
* columns or hidden row keywords.\r
* \r
* @param annotations\r
- * @param groups\r
+ * @param list\r
* @param properties\r
* @return feature file as a string.\r
*/\r
public String printAnnotations(AlignmentAnnotation[] annotations,\r
- Vector groups, Hashtable properties)\r
+ List<SequenceGroup> list, Hashtable properties)\r
{\r
- return printAnnotations(annotations, groups, properties, null);\r
+ return printAnnotations(annotations, list, properties, null);\r
\r
}\r
\r
* properties and views.\r
* \r
* @param annotations\r
- * @param groups\r
+ * @param list\r
* @param properties\r
* @param views\r
* @return annotation file\r
*/\r
public String printAnnotations(AlignmentAnnotation[] annotations,\r
- Vector groups, Hashtable properties, ViewDef[] views)\r
+ List<SequenceGroup> list, Hashtable properties, ViewDef[] views)\r
{\r
// TODO: resolve views issue : annotationFile could contain visible region,\r
// or full data + hidden region specifications for a view.\r
text.append(rowprops.toString());\r
}\r
\r
- if (groups != null)\r
+ if (list != null)\r
{\r
- printGroups(groups);\r
+ printGroups(list);\r
}\r
\r
if (properties != null)\r
return text.toString();\r
}\r
\r
- public void printGroups(Vector sequenceGroups)\r
+ public void printGroups(List<SequenceGroup> list)\r
{\r
- SequenceGroup sg;\r
SequenceI seqrep = null;\r
- for (int i = 0; i < sequenceGroups.size(); i++)\r
+ for (SequenceGroup sg:list)\r
{\r
- sg = (SequenceGroup) sequenceGroups.elementAt(i);\r
if (!sg.hasSeqrep())\r
{\r
text.append("SEQUENCE_GROUP\t" + sg.getName() + "\t"\r
}\r
// Finally, resolve the groupRefs\r
Enumeration en = groupRefRows.keys();\r
- SequenceGroup theGroup = null;\r
-\r
+ \r
while (en.hasMoreElements())\r
{\r
groupRef = (String) en.nextElement();\r
boolean matched = false;\r
// Resolve group: TODO: add a getGroupByName method to alignments\r
- Vector grps = al.getGroups();\r
- for (int g = 0, gSize = grps.size(); g < gSize; g++)\r
+ for (SequenceGroup theGroup : al.getGroups())\r
{\r
- theGroup = (SequenceGroup) grps.elementAt(g);\r
if (theGroup.getName().equals(groupRef))\r
{\r
if (matched)\r
{\r
return;\r
}\r
- SequenceGroup sg = null;\r
-\r
+ \r
String name = st.nextToken();\r
-\r
- Vector groups = al.getGroups();\r
- for (int i = 0; i < groups.size(); i++)\r
+ SequenceGroup sg=null;\r
+ for (SequenceGroup _sg:al.getGroups())\r
{\r
- sg = (SequenceGroup) groups.elementAt(i);\r
- if (sg.getName().equals(name))\r
+ if ((sg=_sg).getName().equals(name))\r
{\r
break;\r
}\r
*/
package jalview.schemes;
+import jalview.datamodel.AnnotatedCollectionI;
+import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceI;
import java.awt.Color;
import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
import java.util.Vector;
public class ClustalxColourScheme extends ResidueColourScheme // implements
colhash.put("YELLOW", new Color((float) 0.8, (float) 0.8, (float) 0.0));
}
- public ClustalxColourScheme(Vector seqs, int maxWidth)
+ public ClustalxColourScheme(AnnotatedCollectionI alignment, Map<SequenceI, SequenceCollectionI> hiddenReps)
{
- resetClustalX(seqs, maxWidth);
+ alignmentChanged(alignment,hiddenReps);
}
-
- public void resetClustalX(Vector seqs, int maxWidth)
- {
+ public void alignmentChanged(AnnotatedCollectionI alignment, Map<SequenceI, SequenceCollectionI> hiddenReps) {
+ int maxWidth=alignment.getWidth();
+ List<SequenceI> seqs=alignment.getSequences(hiddenReps);
cons2 = new int[maxWidth][24];
includeGaps = isIncludeGaps(); // does nothing - TODO replace with call to
// get the current setting of the
int j = 0;
char[] seq;
- while (j < seqs.size())
+ for (SequenceI sq: seqs)
{
- seq = ((SequenceI) seqs.elementAt(j)).getSequence();
+ seq = sq.getSequence();
int end_j = seq.length - 1;
package jalview.schemes;
import java.awt.Color;
+import java.util.Map;
+import jalview.datamodel.AlignmentI;
import jalview.datamodel.AnnotatedCollectionI;
+import jalview.datamodel.SequenceCollectionI;
+import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
public interface ColourSchemeI
public void setThreshold(int ct, boolean ignoreGaps);
- public void alignmentChanged(AnnotatedCollectionI alignment);
+ public void alignmentChanged(AnnotatedCollectionI alignment, Map<SequenceI, SequenceCollectionI> hiddenReps);
}
*/
package jalview.schemes;
+import jalview.datamodel.AnnotatedCollectionI;
+
import java.awt.Color;
/**
return ret;
}
-
- /**
- * DOCUMENT ME!
- *
- * @param al
- * DOCUMENT ME!
- * @param name
- * DOCUMENT ME!
- *
- * @return DOCUMENT ME!
- */
- public static ColourSchemeI getColour(jalview.datamodel.AlignmentI al,
- String name)
- {
- return getColour(al.getSequences(), al.getWidth(), name);
- }
-
/**
* retrieve or create colourscheme associated with name
- *
+ *
* @param seqs
* sequences to colour
* @param width
* string to parse as colour for new coloursheme
* @return Valid Colourscheme
*/
- public static ColourSchemeI getColour(java.util.Vector seqs, int width,
+ public static ColourSchemeI getColour(AnnotatedCollectionI alignment,
String name)
{
int colindex = getColourIndexFromName(name);
}
}
}
- return getColour(seqs, width, getColourIndexFromName(name));
+ return getColour(alignment, getColourIndexFromName(name));
}
/**
*
* @return null or an instance of the colourscheme configured to colour given sequence set
*/
- public static ColourSchemeI getColour(java.util.Vector seqs, int width,
- int index)
+ public static ColourSchemeI getColour(jalview.datamodel.AnnotatedCollectionI coll, int index)
{
// TODO 3.0 2.8 refactor signature to take an alignmentI like container so colourschemes based on annotation can be initialised
ColourSchemeI cs = null;
switch (index)
{
case CLUSTAL:
- cs = new ClustalxColourScheme(seqs, width);
+ cs = new ClustalxColourScheme(coll, null);
break;
if (av.getAlignment().getGroups() != null)
{
oldgroupColours = new Hashtable();
- Vector allGroups = ap.getAlignment().getGroups();
- SequenceGroup sg;
- for (int g = 0; g < allGroups.size(); g++)
+ for (SequenceGroup sg:ap.getAlignment().getGroups())
{
- sg = (SequenceGroup) allGroups.get(g);
if (sg.cs != null)
{
oldgroupColours.put(sg, sg.cs);
if (av.getAlignment().getGroups() != null)
{
- Vector allGroups = ap.getAlignment().getGroups();
- SequenceGroup sg;
- for (int g = 0; g < allGroups.size(); g++)
+ for (SequenceGroup sg:ap.getAlignment().getGroups())
{
- sg = (SequenceGroup) allGroups.get(g);
-
if (sg.cs == null)
{
continue;
av.setGlobalColourScheme(oldcs);
if (av.getAlignment().getGroups() != null)
{
- Vector allGroups = ap.getAlignment().getGroups();
- SequenceGroup sg;
- for (int g = 0; g < allGroups.size(); g++)
+ for (SequenceGroup sg:ap.getAlignment().getGroups())
{
- sg = (SequenceGroup) allGroups.get(g);
sg.cs = (ColourSchemeI) oldgroupColours.get(sg);
}
}
import jalview.analysis.AAFrequency;
import jalview.analysis.Conservation;
import jalview.datamodel.AnnotatedCollectionI;
+import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceI;
import java.awt.Color;
import java.util.Hashtable;
+import java.util.Map;
/**
* DOCUMENT ME!
return currentColour;
}
- @Override public void alignmentChanged(AnnotatedCollectionI alignment) {};
-
/**
* Get the percentage threshold for this colour scheme
*
return currentColour;
}
+ @Override
+ public void alignmentChanged(AnnotatedCollectionI alignment,
+ Map<SequenceI, SequenceCollectionI> hiddenReps)
+ {
+ }
+
}
import jalview.datamodel.AlignmentI;
import jalview.datamodel.AnnotatedCollectionI;
import jalview.datamodel.Annotation;
+import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceI;
import jalview.io.TCoffeeScoreFile;
import java.awt.Color;
import java.util.ArrayList;
import java.util.IdentityHashMap;
+import java.util.Map;
import java.util.TreeMap;
/**
* @param alignment - annotated sequences to be searched
*/
public TCoffeeColourScheme(AnnotatedCollectionI alignment) {
- alignmentChanged(alignment);
+ alignmentChanged(alignment, null);
}
- @Override public void alignmentChanged(AnnotatedCollectionI alignment)
+ @Override
+ public void alignmentChanged(AnnotatedCollectionI alignment, Map<SequenceI, SequenceCollectionI> hiddenReps)
{
+ // TODO: if sequences have been represented and they have scores, could compute an average sequence score for the representative
+
// assume only one set of TCOFFEE scores - but could have more than one potentially.
ArrayList<AlignmentAnnotation> annots = new ArrayList<AlignmentAnnotation>();
// Search alignment to get all tcoffee annotation and pick one set of annotation to use to colour seqs.
*/
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.util.Hashtable;
+import java.util.List;
+import java.util.Map;
import java.util.Vector;
/**
*/
protected boolean isDataset = false;
- private Hashtable hiddenRepSequences;
+ private Map<SequenceI, SequenceCollectionI> hiddenRepSequences;
protected ColumnSelection colSel = new ColumnSelection();
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;
+ if (getColourAppliesToAllGroups())
+ {
+ for (SequenceGroup sg : getAlignment().getGroups())
+ {
+ if (cs == null)
+ {
+ sg.cs = null;
+ continue;
+ }
+ if (cs instanceof ClustalxColourScheme)
+ {
+ sg.cs = new ClustalxColourScheme(sg, getHiddenRepSequences());
+ }
+ else
+ {
+ try
+ {
+ sg.cs = cs.getClass().newInstance();
+ } catch (Exception ex)
+ {
+ ex.printStackTrace();
+ sg.cs = cs;
+ }
+ }
+
+ if (getAbovePIDThreshold() || cs instanceof PIDColourScheme
+ || cs instanceof Blosum62ColourScheme)
+ {
+ sg.cs.setThreshold(threshold, getIgnoreGapsConsensus());
+ sg.cs.setConsensus(AAFrequency.calculate(
+ sg.getSequences(getHiddenRepSequences()), 0,
+ sg.getWidth()));
+ }
+ else
+ {
+ sg.cs.setThreshold(0, getIgnoreGapsConsensus());
+ }
+
+ if (getConservationSelected())
+ {
+ 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);
+ }
+ else
+ {
+ sg.cs.setConservation(null);
+ sg.cs.setThreshold(0, getIgnoreGapsConsensus());
+ }
+
+ }
+ }
+
}
@Override
{
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()
// 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);
// alignment.adjustSequenceAnnotations();
}
-
/**
* reset scope and do calculations for all applied colourschemes on alignment
*/
ColourSchemeI cs = globalColourScheme;
if (cs != null)
{
- cs.alignmentChanged(alignment);
- // TODO: fold all recalc events for clustalX into alignmentChanged
- if (cs instanceof ClustalxColourScheme)
- {
- ((ClustalxColourScheme) cs).resetClustalX(alignment.getSequences(),
- alignment.getWidth());
- }
+ cs.alignmentChanged(alignment, null);
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();
}
- sg.recalcConservation();
}
}
// TODO: cope with recovering hidden sequences from
// resultContext
{
- Vector sqs = sg.getSequences(null);
- for (int sqsi = 0, iSize = sqs.size(); sqsi < iSize; sqsi++)
+ for (SequenceI oseq:sg.getSequences(null))
{
- SequenceI oseq = (SequenceI) sqs.get(sqsi);
SequenceI nseq = getNewSeq(oseq, rseqs[nrj],
ordermap[nrj], destAl);
if (nseq != null)
git://source.jalview.org / jalview.git / commitdiff