{\r
SequenceGroup sg2 = (SequenceGroup) groups.elementAt(j);\r
\r
- if (sg.getSize(false) > sg2.getSize(false))\r
+ if (sg.getSize() > sg2.getSize())\r
{\r
groups.insertElementAt(sg, j);\r
\r
this.alignment=alignment;
this.selection = selection;
}
-
+
public Finder(AlignmentI alignment, SequenceGroup selectionGroup, int seqIndex, int resIndex) {
this(alignment, selectionGroup);
this.seqIndex=seqIndex;
{
int res = Integer.parseInt(searchString);
found = true;
- if (selection == null || selection.getSize(false) < 1)
+ if (selection == null || selection.getSize() < 1)
{
seq = (Sequence) alignment.getSequenceAt(0);
}
int end = alignment.getHeight();
-
+
if (selection != null)
{
- if ((selection.getSize(false) < 1) ||
+ if ((selection.getSize() < 1) ||
((selection.getEndRes() - selection.getStartRes()) < 2))
{
selection = null;
{
seq = (Sequence) alignment.getSequenceAt(seqIndex);
- if ((selection != null) && !selection.getSequences(false).contains(seq))
+ if ((selection != null) && !selection.getSequences(null).contains(seq))
{
seqIndex++;
resIndex = 0;
{
item = item.substring(0, selection.getEndRes() + 1);
}
-
+
///Shall we ignore gaps???? - JBPNote: Add Flag for forcing this or not
StringBuffer noGapsSB = new StringBuffer();
int insertCount = 0;
\r
SequenceGroup sg = ap.av.getSelectionGroup();\r
\r
- if (sg != null && sg.getSize(false)>0)\r
+ if (sg != null && sg.getSize()>0)\r
{\r
showText.setState(sg.getDisplayText());\r
showColourText.setState(sg.getColourText());\r
}\r
\r
ChangeCaseCommand caseCommand = new ChangeCaseCommand(\r
- description, sg.getSequencesAsArray(true), startEnd, caseChange\r
+ description, sg.getSequencesAsArray(ap.av.hiddenRepSequences), startEnd, caseChange\r
);\r
\r
ap.alignFrame.addHistoryItem(caseCommand);\r
protected void clustalColour_actionPerformed()\r
{\r
SequenceGroup sg = getGroup();\r
- sg.cs = new ClustalxColourScheme(sg.getSequences(true), ap.av.alignment.getWidth());\r
+ sg.cs = new ClustalxColourScheme(sg.getSequences(ap.av.hiddenRepSequences),\r
+ ap.av.alignment.getWidth());\r
refresh();\r
}\r
\r
\r
if (abovePIDColour.getState())\r
{\r
- sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(true), 0,\r
+ sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(ap.av.hiddenRepSequences), 0,\r
ap.av.alignment.getWidth()));\r
int threshold = SliderPanel.setPIDSliderSource(ap, sg.cs,\r
getGroup().getName());\r
{\r
SequenceGroup sg = getGroup();\r
sg.cs = new PIDColourScheme();\r
- sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(true), 0,\r
+ sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(ap.av.hiddenRepSequences), 0,\r
ap.av.alignment.getWidth()));\r
refresh();\r
}\r
\r
sg.cs = new Blosum62ColourScheme();\r
\r
- sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(true), 0,\r
+ sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(ap.av.hiddenRepSequences), 0,\r
ap.av.alignment.getWidth()));\r
\r
refresh();\r
\r
Conservation c = new Conservation("Group",\r
ResidueProperties.propHash, 3,\r
- sg.getSequences(true), 0,\r
+ sg.getSequences(ap.av.hiddenRepSequences), 0,\r
ap.av.alignment.getWidth());\r
\r
c.calculate();\r
void hideSequences(boolean representGroup)\r
{\r
SequenceGroup sg = ap.av.getSelectionGroup();\r
- if(sg==null || sg.getSize(false)<1)\r
+ if(sg==null || sg.getSize()<1)\r
{\r
ap.av.hideSequence(new SequenceI[]{seq});\r
return;\r
}\r
\r
- int gsize = sg.getSize(false);\r
- SequenceI [] hseqs;\r
+ ap.av.setSelectionGroup(null);\r
\r
- hseqs = new SequenceI[ representGroup ? gsize-1 : gsize ];\r
+ if (representGroup)\r
+ {\r
+ ap.av.hideRepSequences(seq, sg);\r
\r
- int index = 0;\r
- for(int i=0; i<gsize; i++)\r
- {\r
- if(representGroup && sg.getSequenceAt(i)!=seq)\r
- {\r
- seq.addHiddenSequence(sg.getSequenceAt(i));\r
- hseqs[index++] = sg.getSequenceAt(i);\r
- }\r
- else if(!representGroup)\r
- {\r
- hseqs[index++] = sg.getSequenceAt(i);\r
- }\r
- }\r
+ return;\r
+ }\r
+\r
+ int gsize = sg.getSize();\r
+ SequenceI[] hseqs;\r
\r
- ap.av.hideSequence(hseqs);\r
+ hseqs = new SequenceI[gsize];\r
+\r
+ int index = 0;\r
+ for (int i = 0; i < gsize; i++)\r
+ {\r
+ hseqs[index++] = sg.getSequenceAt(i);\r
+ }\r
\r
- ap.av.setSelectionGroup(null);\r
+ ap.av.hideSequence(hseqs);\r
}\r
\r
}\r
\r
if(toggleSeqs)\r
{\r
- if (sg != null && sg.getSize(false) != viewport.alignment.getHeight())\r
+ if (sg != null && sg.getSize() != viewport.alignment.getHeight())\r
{\r
hide = true;\r
viewport.hideAllSelectedSeqs();\r
for (int i = 1; i < viewport.alignment.getHeight(); i++)\r
{\r
SequenceI seq = viewport.alignment.getSequenceAt(i);\r
- if (!sg.getSequences(false).contains(seq))\r
+ if (!sg.getSequences(null).contains(seq))\r
{\r
continue;\r
}\r
\r
SequenceI temp = viewport.alignment.getSequenceAt(i - 1);\r
- if (sg.getSequences(false).contains(temp))\r
+ if (sg.getSequences(null).contains(temp))\r
{\r
continue;\r
}\r
for (int i = viewport.alignment.getHeight() - 2; i > -1; i--)\r
{\r
SequenceI seq = viewport.alignment.getSequenceAt(i);\r
- if (!sg.getSequences(true).contains(seq))\r
+ if (!sg.getSequences(viewport.hiddenRepSequences).contains(seq))\r
{\r
continue;\r
}\r
\r
SequenceI temp = viewport.alignment.getSequenceAt(i + 1);\r
- if (sg.getSequences(true).contains(temp))\r
+ if (sg.getSequences(viewport.hiddenRepSequences).contains(temp))\r
{\r
continue;\r
}\r
SequenceGroup sg = viewport.getSelectionGroup();\r
copiedSequences = new StringBuffer();\r
Hashtable orderedSeqs = new Hashtable();\r
- for (int i = 0; i < sg.getSize(false); i++)\r
+ for (int i = 0; i < sg.getSize(); i++)\r
{\r
SequenceI seq = sg.getSequenceAt(i);\r
int index = viewport.alignment.findIndex(seq);\r
copiedHiddenColumns = null;\r
\r
\r
- for (int i = 0; i < sg.getSize(false); i++)\r
+ for (int i = 0; i < sg.getSize(); i++)\r
{\r
SequenceI seq = null;\r
\r
\r
Vector seqs = new Vector();\r
SequenceI seq;\r
- for (int i = 0; i < sg.getSize(false); i++)\r
+ for (int i = 0; i < sg.getSize(); i++)\r
{\r
seq = sg.getSequenceAt(i);\r
seqs.addElement(seq);\r
\r
\r
// If the cut affects all sequences, remove highlighted columns\r
- if (sg.getSize(false) == viewport.alignment.getHeight())\r
+ if (sg.getSize() == viewport.alignment.getHeight())\r
{\r
viewport.getColumnSelection().removeElements(sg.getStartRes(),\r
sg.getEndRes() + 1);\r
\r
SequenceI [] seqs;\r
if(viewport.getSelectionGroup()!=null)\r
- seqs = viewport.getSelectionGroup().getSequencesAsArray(true);\r
+ seqs = viewport.getSelectionGroup().getSequencesAsArray(viewport.hiddenRepSequences);\r
else\r
seqs = viewport.alignment.getSequencesArray();\r
\r
SequenceI[] seqs;\r
if (viewport.getSelectionGroup() != null)\r
{\r
- seqs = viewport.getSelectionGroup().getSequencesAsArray(true);\r
+ seqs = viewport.getSelectionGroup().getSequencesAsArray(viewport.hiddenRepSequences);\r
start = viewport.getSelectionGroup().getStartRes();\r
end = viewport.getSelectionGroup().getEndRes();\r
}\r
SequenceI[] seqs;\r
if (viewport.getSelectionGroup() != null)\r
{\r
- seqs = viewport.getSelectionGroup().getSequencesAsArray(true);\r
+ seqs = viewport.getSelectionGroup().getSequencesAsArray(viewport.hiddenRepSequences);\r
start = viewport.getSelectionGroup().getStartRes();\r
end = viewport.getSelectionGroup().getEndRes();\r
}\r
}\r
if (cs instanceof ClustalxColourScheme)\r
{\r
- sg.cs = new ClustalxColourScheme(sg.getSequences(true), sg.getWidth());\r
+ sg.cs = new ClustalxColourScheme(\r
+ sg.getSequences(viewport.hiddenRepSequences),\r
+ sg.getWidth());\r
}\r
else\r
{\r
|| cs instanceof Blosum62ColourScheme)\r
{\r
sg.cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());\r
- sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(true), 0, sg.getWidth()));\r
+ sg.cs.setConsensus(AAFrequency.calculate(\r
+ sg.getSequences(viewport.hiddenRepSequences), 0, sg.getWidth()));\r
}\r
else\r
sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());\r
{\r
Conservation c = new Conservation("Group",\r
ResidueProperties.propHash, 3,\r
- sg.getSequences(true), 0,\r
+ sg.getSequences(viewport.hiddenRepSequences), 0,\r
viewport.alignment.getWidth() - 1);\r
c.calculate();\r
c.verdict(false, viewport.ConsPercGaps);\r
public void pairwiseAlignmentMenuItem_actionPerformed()\r
{\r
if (viewport.getSelectionGroup()!=null\r
- && viewport.getSelectionGroup().getSize(false) > 1)\r
+ && viewport.getSelectionGroup().getSize() > 1)\r
{\r
Frame frame = new Frame();\r
frame.add(new PairwiseAlignPanel(alignPanel));\r
}\r
\r
if ( (viewport.getSelectionGroup() != null &&\r
- viewport.getSelectionGroup().getSize(false) < 4 &&\r
- viewport.getSelectionGroup().getSize(false) > 0)\r
+ viewport.getSelectionGroup().getSize() < 4 &&\r
+ viewport.getSelectionGroup().getSize() > 0)\r
|| viewport.getAlignment().getHeight() < 4)\r
{\r
return;\r
}\r
\r
if ( (viewport.getSelectionGroup() != null &&\r
- viewport.getSelectionGroup().getSize(false) > 1)\r
+ viewport.getSelectionGroup().getSize() > 1)\r
|| (viewport.getSelectionGroup() == null\r
&& viewport.alignment.getHeight() > 1))\r
{\r
\r
String sequenceSetID;\r
\r
+ Hashtable hiddenRepSequences;\r
+\r
public AlignViewport(AlignmentI al, JalviewLite applet)\r
{\r
this.applet = applet;\r
hasHiddenColumns = true;\r
}\r
\r
+ public void hideRepSequences(SequenceI repSequence, SequenceGroup sg)\r
+ {\r
+ int sSize = sg.getSize();\r
+ if(sSize < 2)\r
+ return;\r
+\r
+ if(hiddenRepSequences==null)\r
+ hiddenRepSequences = new Hashtable();\r
+\r
+ hiddenRepSequences.put(repSequence, sg);\r
+\r
+ //Hide all sequences except the repSequence\r
+ SequenceI [] seqs = new SequenceI[sSize-1];\r
+ int index = 0;\r
+ for(int i=0; i<sSize; i++)\r
+ if(sg.getSequenceAt(i)!=repSequence)\r
+ {\r
+ if(index==sSize-1)\r
+ return;\r
+\r
+ seqs[index++] = sg.getSequenceAt(i);\r
+ }\r
+\r
+ hideSequence(seqs);\r
+\r
+ }\r
+\r
public void hideAllSelectedSeqs()\r
{\r
if (selectionGroup == null)\r
selectionGroup = new SequenceGroup();\r
selectionGroup.setEndRes(alignment.getWidth()-1);\r
}\r
- Vector tmp = alignment.getHiddenSequences().showAll();\r
+ Vector tmp = alignment.getHiddenSequences().showAll(hiddenRepSequences);\r
for(int t=0; t<tmp.size(); t++)\r
{\r
selectionGroup.addSequence(\r
}\r
firePropertyChange("alignment", null, alignment.getSequences());\r
hasHiddenRows = false;\r
- }\r
+ hiddenRepSequences = null;\r
+ }\r
}\r
\r
public int adjustForHiddenSeqs(int alignmentIndex)\r
int start = 0, end = 0;\r
if(selectedRegionOnly && selectionGroup!=null)\r
{\r
- iSize = selectionGroup.getSize(false);\r
+ iSize = selectionGroup.getSize();\r
seqs = selectionGroup.getSequencesInOrder(alignment);\r
start = selectionGroup.getStartRes();\r
end = selectionGroup.getEndRes(); // inclusive for start and end in SeqCigar constructor\r
int start = 0, end = 0;\r
if(selectedRegionOnly && selectionGroup!=null)\r
{\r
- iSize = selectionGroup.getSize(false);\r
+ iSize = selectionGroup.getSize();\r
seqs = selectionGroup.getSequencesInOrder(alignment);\r
start = selectionGroup.getStartRes();\r
end = selectionGroup.getEndRes()+1;\r
if(sg.cs!=null && sg.cs instanceof ClustalxColourScheme)\r
{\r
((ClustalxColourScheme)sg.cs).resetClustalX(\r
- sg.getSequences(true), sg.getWidth());\r
+ sg.getSequences(hiddenRepSequences), sg.getWidth());\r
}\r
sg.recalcConservation();\r
}\r
int res = Integer.parseInt(searchString);\r
found = true;\r
\r
- if (av.getSelectionGroup() == null || av.getSelectionGroup().getSize(false) < 1)\r
+ if (av.getSelectionGroup() == null || av.getSelectionGroup().getSize() < 1)\r
{\r
seq = (Sequence) av.getAlignment().getSequenceAt(0);\r
}\r
SequenceGroup selection = av.getSelectionGroup();\r
if (selection != null)\r
{\r
- if (selection.getSize(false) < 1 ||\r
+ if (selection.getSize() < 1 ||\r
(selection.getEndRes() - selection.getStartRes() < 2))\r
{\r
selection = null;\r
\r
seq = (Sequence) av.alignment.getSequenceAt(seqIndex);\r
\r
- if (selection != null && !selection.getSequences(false).contains(seq))\r
+ if (selection != null && !selection.getSequences(null).contains(seq))\r
{\r
seqIndex++;\r
resIndex = 0;\r
gg.setColor(Color.white);\r
}\r
else if (av.getSelectionGroup() != null &&\r
- av.getSelectionGroup().getSequences(false).contains(s))\r
+ av.getSelectionGroup().getSequences(null).contains(s))\r
{\r
gg.setColor(Color.lightGray);\r
gg.fillRect(0, ((i - starty) * charHeight) + ypos,\r
currentTextColor = Color.white;\r
}\r
else if ( (av.getSelectionGroup() != null) &&\r
- av.getSelectionGroup().getSequences(false).contains(seq))\r
+ av.getSelectionGroup().getSequences(null).contains(seq))\r
{\r
currentColor = Color.lightGray;\r
currentTextColor = Color.black;\r
float scores[][] = new float[seqs.length][seqs.length];
double totscore = 0;
- int count = ap.av.getSelectionGroup().getSize(false);
+ int count = ap.av.getSelectionGroup().getSize();
String type=(ap.av.alignment.isNucleotide()) ? AlignSeq.DNA : AlignSeq.PEP;
Sequence seq;
\r
int start, end;\r
\r
- if ( (sg != null) && (sg.getSize(false) >= 1))\r
+ if ( (sg != null) && (sg.getSize() >= 1))\r
{\r
originalSequences = sg.getSequencesInOrder(ap.av.alignment);\r
start = sg.getStartRes();\r
\r
if (av.getSelectionGroup() != null)\r
{\r
- if (av.getSelectionGroup().getSequences(false).contains( ( (SequencePoint) points.\r
+ if (av.getSelectionGroup().getSequences(null).contains( ( (SequencePoint) points.\r
elementAt(i)).sequence))\r
{\r
g.setColor(Color.gray);\r
{\r
if (av != null)\r
{\r
- if (!av.getSelectionGroup().getSequences(false).contains(sp.sequence))\r
+ if (!av.getSelectionGroup().getSequences(null).contains(sp.sequence))\r
{\r
av.getSelectionGroup().addSequence(sp.sequence, true);\r
}\r
av.hideColumns(res, res);\r
if (av.getSelectionGroup() != null\r
&&\r
- av.getSelectionGroup().getSize(false) == av.alignment.getHeight())\r
+ av.getSelectionGroup().getSize() == av.alignment.getHeight())\r
av.setSelectionGroup(null);\r
\r
ap.repaint();\r
}\r
\r
if ( (sx <= (endRes - startRes) * av.charWidth) &&\r
- group.getSequences(false).\r
+ group.getSequences(null).\r
contains(av.alignment.getSequenceAt(i)))\r
{\r
if ( (bottom == -1) &&\r
(i >= alHeight ||\r
- !group.getSequences(false).contains(\r
+ !group.getSequences(null).contains(\r
av.alignment.getSequenceAt(i + 1))))\r
{\r
bottom = sy + av.charHeight;\r
if (!inGroup)\r
{\r
if ( ( (top == -1) && (i == 0)) ||\r
- !group.getSequences(false).contains(\r
+ !group.getSequences(null).contains(\r
av.alignment.getSequenceAt(i - 1)))\r
{\r
top = sy;\r
SequenceGroup sg = av.selectionGroup;\r
//Find the top and bottom of this group\r
int min = av.alignment.getHeight(), max = 0;\r
- for(int i=0; i<sg.getSize(false); i++)\r
+ for(int i=0; i<sg.getSize(); i++)\r
{\r
int index = av.alignment.findIndex( sg.getSequenceAt(i) );\r
if(index > max)\r
else\r
{\r
// Now add any sequences between min and max\r
- sg.getSequences(false).removeAllElements();\r
+ sg.getSequences(null).removeAllElements();\r
for (int i = min; i < max; i++)\r
{\r
sg.addSequence(av.alignment.getSequenceAt(i), false);\r
boolean fixedColumns = false;\r
SequenceGroup sg = av.getSelectionGroup();\r
\r
+ SequenceI seq = av.alignment.getSequenceAt(startseq);\r
\r
if (!groupEditing && av.hasHiddenRows)\r
{\r
- if (av.alignment.getSequenceAt(startseq).getHiddenSequences() != null)\r
+ if (av.hiddenRepSequences!=null\r
+ && av.hiddenRepSequences.containsKey(seq))\r
{\r
+ sg = (SequenceGroup)av.hiddenRepSequences.get(seq);\r
groupEditing = true;\r
- }\r
- }\r
-\r
- //No group, but the sequence may represent a group\r
- if (groupEditing\r
- && sg == null\r
- && av.alignment.getSequenceAt(startseq).getHiddenSequences() == null)\r
- {\r
- groupEditing = false;\r
+ }\r
}\r
\r
- SequenceI seq = av.alignment.getSequenceAt(startseq);\r
StringBuffer message = new StringBuffer();\r
if (groupEditing)\r
{\r
\r
//Are we editing within a selection group?\r
if (groupEditing\r
- || (sg != null && sg.getSequences(true).contains(seq)))\r
+ || (sg != null && sg.getSequences(av.hiddenRepSequences).contains(seq)))\r
{\r
fixedColumns = true;\r
\r
//but the sequence represents a group\r
if (sg == null)\r
{\r
- sg = new SequenceGroup(null, null, false, false, false, 0,\r
- av.alignment.getWidth()-1);\r
- sg.addSequence(av.alignment.getSequenceAt(startseq), false);\r
+ sg = (SequenceGroup) av.hiddenRepSequences.get(seq);\r
}\r
\r
fixedLeft = sg.getStartRes();\r
\r
if (groupEditing)\r
{\r
- Vector vseqs = sg.getSequences(true);\r
+ Vector vseqs = sg.getSequences(av.hiddenRepSequences);\r
int g, groupSize = vseqs.size();\r
SequenceI[] groupSeqs = new SequenceI[groupSize];\r
for (g = 0; g < groupSeqs.length; g++)\r
\r
if (!blank)\r
{\r
- if(sg.getSize(false) == av.alignment.getHeight() )\r
+ if(sg.getSize() == av.alignment.getHeight() )\r
{\r
if((av.hasHiddenColumns\r
&& startres<av.getColumnSelection().getHiddenBoundaryRight(startres)))\r
}\r
}\r
\r
- else if (!stretchGroup.getSequences(false).contains(sequence)\r
+ else if (!stretchGroup.getSequences(null).contains(sequence)\r
|| stretchGroup.getStartRes() > res\r
|| stretchGroup.getEndRes() < res)\r
{\r
if (stretchGroup.cs instanceof ClustalxColourScheme)\r
{\r
( (ClustalxColourScheme) stretchGroup.cs).resetClustalX(\r
- stretchGroup.getSequences(true),\r
+ stretchGroup.getSequences(av.hiddenRepSequences),\r
stretchGroup.getWidth());\r
}\r
\r
\r
Sequence nextSeq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);\r
\r
- if (stretchGroup.getSequences(false).contains(nextSeq))\r
+ if (stretchGroup.getSequences(null).contains(nextSeq))\r
{\r
stretchGroup.deleteSequence(seq, false);\r
}\r
// Colour selected leaves differently\r
SequenceGroup selected = av.getSelectionGroup();\r
if (selected != null &&\r
- selected.getSequences(false).contains( (SequenceI) node.element()))\r
+ selected.getSequences(null).contains( (SequenceI) node.element()))\r
{\r
g.setColor(Color.gray);\r
\r
{\r
Conservation c = new Conservation("Group",\r
ResidueProperties.propHash, 3,\r
- sg.getSequences(false),\r
+ sg.getSequences(null),\r
sg.getStartRes(),\r
sg.getEndRes());\r
\r
{
SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
- if (sg.getSequences(false).contains(s))
+ if (sg.getSequences(null).contains(s))
{
return sg;
}
for (int i = 0; i < gSize; i++)
{
SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
- if(sg==null || sg.getSequences(false)==null)
+ if(sg==null || sg.getSequences(null)==null)
{
this.deleteGroup(sg);
gSize--;
continue;
}
- if (sg.getSequences(false).contains(s))
+ if (sg.getSequences(null).contains(s))
{
temp.addElement(sg);
}
{
if(hiddenSequences.getSize()>0)
{
- //We're not going to make groups of
- //Hidden sequences
- int i, iSize = sg.getSize(false);
+ int i, iSize = sg.getSize();
for (i = 0; i < iSize; i++)
{
if (!sequences.contains(sg.getSequenceAt(i)))
}
}
- if (sg.getSize(true) < 1)
+ if (sg.getSize() < 1)
return;
}
{
return hiddenSequences;
}
- SequenceI [] getVisibleAndRepresentedSeqs()
- {
- if(hiddenSequences==null || hiddenSequences.getSize()<1)
- return getSequencesArray();
-
- Vector seqs = new Vector();
- SequenceI seq;
- SequenceGroup hidden;
- for (int i = 0; i < sequences.size(); i++)
- {
- seq = (SequenceI) sequences.elementAt(i);
- seqs.addElement(seq);
- hidden = seq.getHiddenSequences();
- if(hidden!=null)
- {
- for(int j=0; j<hidden.getSize(false); j++)
- {
- seqs.addElement(hidden.getSequenceAt(j));
- }
- }
- }
- SequenceI [] result = new SequenceI[seqs.size()];
- for(int i=0; i<seqs.size(); i++)
- result[i] = (SequenceI)seqs.elementAt(i);
-
- return result;
-
- }
public CigarArray getCompactAlignment()
{
alignment.deleteSequence(sequence);\r
}\r
\r
- public Vector showAll()\r
+ public Vector showAll(Hashtable hiddenReps)\r
{\r
Vector revealedSeqs = new Vector();\r
for(int i=0; i<hiddenSequences.length; i++)\r
{\r
if(hiddenSequences[i]!=null)\r
{\r
- Vector tmp = showSequence(i);\r
+ Vector tmp = showSequence(i, hiddenReps);\r
for (int t = 0; t < tmp.size(); t++)\r
revealedSeqs.addElement(tmp.elementAt(t));\r
}\r
return revealedSeqs;\r
}\r
\r
- public Vector showSequence(int alignmentIndex)\r
+ public Vector showSequence(int alignmentIndex, Hashtable hiddenReps)\r
{\r
Vector revealedSeqs = new Vector();\r
SequenceI repSequence = alignment.getSequenceAt(alignmentIndex);\r
- if(repSequence!=null\r
- && repSequence.getHiddenSequences()==null\r
- && alignmentIndex>0)\r
- repSequence = alignment.getSequenceAt(alignmentIndex-1);\r
-\r
- if(repSequence!=null\r
- && repSequence.getHiddenSequences()==null)\r
- repSequence = null;\r
+ if(repSequence !=null &&\r
+ hiddenReps!=null\r
+ && hiddenReps.containsKey(repSequence))\r
+ {\r
+ hiddenReps.remove(repSequence);\r
+ revealedSeqs.addElement(repSequence);\r
+ }\r
\r
int start = adjustForHiddenSeqs(alignmentIndex-1);\r
int end = adjustForHiddenSeqs(alignmentIndex);\r
}\r
else\r
System.out.println(seq.getName()+" has been deleted whilst hidden");\r
-\r
- if (repSequence != null)\r
- {\r
- repSequence.showHiddenSequence(seq);\r
- }\r
}\r
\r
}\r
*/
public class Sequence implements SequenceI
{
-
SequenceI datasetSequence;
String name;
private char [] sequence;
/** DOCUMENT ME!! */
public SequenceFeature[] sequenceFeatures;
- /** This array holds hidden sequences
- * of which this sequence is the representitive member of a group
- */
- SequenceGroup hiddenSequences;
/**
* Creates a new Sequence object.
this.annotation.addElement(annotation);
}
- public SequenceGroup getHiddenSequences()
- {
- return hiddenSequences;
- }
- public void addHiddenSequence(SequenceI seq)
- {
- if (hiddenSequences == null)
- {
- hiddenSequences = new SequenceGroup();
- }
- hiddenSequences.addSequence(seq, false);
- }
-
- public void showHiddenSequence(SequenceI seq)
- {
- hiddenSequences.deleteSequence(seq, false);
- if (hiddenSequences.getSize(false) < 1)
- {
- hiddenSequences = null;
- }
- }
/**
* test if this is a valid candidate for another
- * sequence's dataset sequence.
- *
+ * sequence's dataset sequence.
+ *
*/
private boolean isValidDatasetSequence() {
if (datasetSequence!=null)
return eres;\r
}\r
\r
- public Vector getSequences(boolean includeHidden)\r
+ public Vector getSequences(Hashtable hiddenReps)\r
{\r
- if(!includeHidden)\r
+ if(hiddenReps == null)\r
return sequences;\r
else\r
{\r
Vector allSequences = new Vector();\r
- SequenceI seq;\r
+ SequenceI seq, seq2;\r
for (int i = 0; i < sequences.size(); i++)\r
{\r
seq = (SequenceI) sequences.elementAt(i);\r
allSequences.addElement(seq);\r
- if (seq.getHiddenSequences() != null)\r
+ if (hiddenReps.containsKey(seq) )\r
{\r
- for (int h = 0; h < seq.getHiddenSequences().getSize(false); h++)\r
+ SequenceGroup hsg = (SequenceGroup)hiddenReps.get(seq);\r
+ for (int h = 0; h < hsg.getSize(); h++)\r
{\r
- allSequences.addElement(\r
- seq.getHiddenSequences().getSequenceAt(h)\r
- );\r
+ seq2 = hsg.getSequenceAt(h);\r
+ if (seq2 != seq\r
+ && !allSequences.contains(seq2))\r
+ allSequences.addElement(seq2);\r
}\r
}\r
}\r
}\r
}\r
\r
- public SequenceI[] getSequencesAsArray(boolean includeHidden)\r
+ public SequenceI[] getSequencesAsArray(Hashtable hiddenReps)\r
{\r
- Vector tmp = getSequences(includeHidden);\r
+ Vector tmp = getSequences(hiddenReps);\r
if(tmp==null)\r
return null;\r
SequenceI [] result = new SequenceI[tmp.size()];\r
*\r
* @return DOCUMENT ME!\r
*/\r
- public int getSize(boolean includeHidden)\r
+ public int getSize()\r
{\r
- if(!includeHidden)\r
return sequences.size();\r
- else\r
- {\r
- int total = sequences.size();\r
- SequenceI seq;\r
- for (int i = 0; i < sequences.size(); i++)\r
- {\r
- seq = (SequenceI) sequences.elementAt(i);\r
- if (seq.getHiddenSequences() != null)\r
- {\r
- total += seq.getHiddenSequences().getSize(false);\r
- }\r
- }\r
- return total;\r
- }\r
}\r
\r
/**\r
public void addAlignmentAnnotation(AlignmentAnnotation annotation);
- public SequenceGroup getHiddenSequences();
- public void addHiddenSequence(SequenceI seq);
-
- public void showHiddenSequence(SequenceI seq);
-
/**
* Derive a sequence (using this one's dataset or as the dataset)
* @return duplicate sequence with valid dataset sequence
SequenceGroup sg = viewport.getSelectionGroup();
if (toggleSeqs)
{
- if (sg != null && sg.getSize(false) != viewport.alignment.getHeight())
+ if (sg != null && sg.getSize() != viewport.alignment.getHeight())
{
hideSelSequences_actionPerformed(null);
hide = true;
{
SequenceI seq = viewport.alignment.getSequenceAt(i);
- if (!sg.getSequences(false).contains(seq))
+ if (!sg.getSequences(null).contains(seq))
{
continue;
}
SequenceI temp = viewport.alignment.getSequenceAt(i - 1);
- if (sg.getSequences(false).contains(temp))
+ if (sg.getSequences(null).contains(temp))
{
continue;
}
{
SequenceI seq = viewport.alignment.getSequenceAt(i);
- if (!sg.getSequences(false).contains(seq))
+ if (!sg.getSequences(null).contains(seq))
{
continue;
}
SequenceI temp = viewport.alignment.getSequenceAt(i + 1);
- if (sg.getSequences(false).contains(temp))
+ if (sg.getSequences(null).contains(temp))
{
continue;
}
Vector seqs = new Vector();
SequenceI seq;
- for (int i = 0; i < sg.getSize(false); i++)
+ for (int i = 0; i < sg.getSize(); i++)
{
seq = sg.getSequenceAt(i);
seqs.addElement(seq);
// If the cut affects all sequences, remove highlighted columns
- if (sg.getSize(false) == viewport.alignment.getHeight())
+ if (sg.getSize() == viewport.alignment.getHeight())
{
viewport.getColumnSelection().removeElements(sg.getStartRes(),
sg.getEndRes() + 1);
SequenceI [] seqs;
if(viewport.getSelectionGroup()!=null)
- seqs = viewport.getSelectionGroup().getSequencesAsArray(true);
+ seqs = viewport.getSelectionGroup().getSequencesAsArray(viewport.hiddenRepSequences);
else
seqs = viewport.alignment.getSequencesArray();
SequenceI[] seqs;
if (viewport.getSelectionGroup() != null)
{
- seqs = viewport.getSelectionGroup().getSequencesAsArray(true);
+ seqs = viewport.getSelectionGroup().getSequencesAsArray(viewport.hiddenRepSequences);
start = viewport.getSelectionGroup().getStartRes();
end = viewport.getSelectionGroup().getEndRes();
}
SequenceI[] seqs;
if (viewport.getSelectionGroup() != null)
{
- seqs = viewport.getSelectionGroup().getSequencesAsArray(true);
+ seqs = viewport.getSelectionGroup().getSequencesAsArray(viewport.hiddenRepSequences);
start = viewport.getSelectionGroup().getStartRes();
end = viewport.getSelectionGroup().getEndRes();
}
if (cs instanceof ClustalxColourScheme)
{
sg.cs = new ClustalxColourScheme(
- sg.getSequences(true), sg.getWidth());
+ sg.getSequences(viewport.hiddenRepSequences), sg.getWidth());
}
else if (cs instanceof UserColourScheme)
{
viewport.getIgnoreGapsConsensus());
sg.cs.setConsensus(AAFrequency.calculate(
- sg.getSequences(true), sg.getStartRes(),
+ sg.getSequences(viewport.hiddenRepSequences), sg.getStartRes(),
sg.getEndRes()+1));
}
else
{
Conservation c = new Conservation("Group",
ResidueProperties.propHash, 3,
- sg.getSequences(true),
+ sg.getSequences(viewport.hiddenRepSequences),
sg.getStartRes(),
sg.getEndRes()+1);
c.calculate();
public void pairwiseAlignmentMenuItem_actionPerformed(ActionEvent e)
{
if ( (viewport.getSelectionGroup() == null) ||
- (viewport.getSelectionGroup().getSize(false) < 2))
+ (viewport.getSelectionGroup().getSize() < 2))
{
JOptionPane.showInternalMessageDialog(this,
"You must select at least 2 sequences.",
public void PCAMenuItem_actionPerformed(ActionEvent e)
{
if ( ( (viewport.getSelectionGroup() != null) &&
- (viewport.getSelectionGroup().getSize(false) < 4) &&
- (viewport.getSelectionGroup().getSize(false) > 0)) ||
+ (viewport.getSelectionGroup().getSize() < 4) &&
+ (viewport.getSelectionGroup().getSize() > 0)) ||
(viewport.getAlignment().getHeight() < 4))
{
JOptionPane.showInternalMessageDialog(this,
TreePanel tp;
if (viewport.getSelectionGroup() != null) {
- if (viewport.getSelectionGroup().getSize(false) < 3) {
+ if (viewport.getSelectionGroup().getSize() < 3) {
JOptionPane.showMessageDialog(Desktop.desktop,
"You need to have more than two sequences selected to build a tree!",
"Not enough sequences",
SequenceGroup sg = viewport.getSelectionGroup();
/* Decide if the selection is a column region */
- while (s < sg.getSize(false))
+ while (s < sg.getSize())
{
- if ( ( (SequenceI) sg.getSequences(false).elementAt(s++)).getLength() <
+ if ( ( (SequenceI) sg.getSequences(null).elementAt(s++)).getLength() <
sg.getEndRes())
{
JOptionPane.showMessageDialog(Desktop.desktop,
AlignmentView msa = null;
if ( (viewport.getSelectionGroup() != null) &&
- (viewport.getSelectionGroup().getSize(false) > 1))
+ (viewport.getSelectionGroup().getSize() > 1))
{
// JBPNote UGLY! To prettify, make SequenceGroup and Alignment conform to some common interface!
/*SequenceGroup seqs = viewport.getSelectionGroup();
AlignmentView seqs = null;
if ( (viewport.getSelectionGroup() != null) &&
- (viewport.getSelectionGroup().getSize(false) > 0))
+ (viewport.getSelectionGroup().getSize() > 0))
{
seqs = viewport.getAlignmentView(true);
}
boolean rightAlignIds = false;
+ Hashtable hiddenRepSequences;
+
/**
* Creates a new AlignViewport object.
hasHiddenColumns = true;
}
+ public void hideRepSequences(SequenceI repSequence, SequenceGroup sg)
+ {
+ int sSize = sg.getSize();
+ if(sSize < 2)
+ return;
+
+ if(hiddenRepSequences==null)
+ hiddenRepSequences = new Hashtable();
+
+ hiddenRepSequences.put(repSequence, sg);
+
+ //Hide all sequences except the repSequence
+ SequenceI [] seqs = new SequenceI[sSize-1];
+ int index = 0;
+ for(int i=0; i<sSize; i++)
+ if(sg.getSequenceAt(i)!=repSequence)
+ {
+ if(index==sSize-1)
+ return;
+
+ seqs[index++] = sg.getSequenceAt(i);
+ }
+
+ hideSequence(seqs);
+
+ }
+
public void hideAllSelectedSeqs()
{
if (selectionGroup == null)
if(seq!=null)
{
for (int i = 0; i < seq.length; i++)
+ {
alignment.getHiddenSequences().hideSequence(seq[i]);
-
+ }
hasHiddenRows = true;
firePropertyChange("alignment", null, alignment.getSequences());
}
public void showSequence(int index)
{
- Vector tmp = alignment.getHiddenSequences().showSequence(index);
+ Vector tmp = alignment.getHiddenSequences().showSequence(index
+ , hiddenRepSequences);
if(tmp.size()>0)
{
if(selectionGroup==null)
selectionGroup = new SequenceGroup();
selectionGroup.setEndRes(alignment.getWidth()-1);
}
- Vector tmp = alignment.getHiddenSequences().showAll();
+ Vector tmp = alignment.getHiddenSequences().showAll(hiddenRepSequences);
for(int t=0; t<tmp.size(); t++)
{
selectionGroup.addSequence(
}
firePropertyChange("alignment", null, alignment.getSequences());
hasHiddenRows = false;
+ hiddenRepSequences = null;
}
}
+
+
public void invertColumnSelection()
{
for(int i=0; i<alignment.getWidth(); i++)
colSel.addElement(i);
}
}
-
}
-
}
public int adjustForHiddenSeqs(int alignmentIndex)
int start = 0, end = 0;
if(selectedRegionOnly && selectionGroup!=null)
{
- iSize = selectionGroup.getSize(false);
+ iSize = selectionGroup.getSize();
seqs = selectionGroup.getSequencesInOrder(alignment);
start = selectionGroup.getStartRes();
end = selectionGroup.getEndRes(); // inclusive for start and end in SeqCigar constructor
int start = 0, end = 0;
if(selectedRegionOnly && selectionGroup!=null)
{
- iSize = selectionGroup.getSize(false);
+ iSize = selectionGroup.getSize();
seqs = selectionGroup.getSequencesInOrder(alignment);
start = selectionGroup.getStartRes();
end = selectionGroup.getEndRes()+1;
if(sg.cs!=null && sg.cs instanceof ClustalxColourScheme)
{
((ClustalxColourScheme)sg.cs).resetClustalX(
- sg.getSequences(true), sg.getWidth());
+ sg.getSequences(hiddenRepSequences), sg.getWidth());
}
sg.recalcConservation();
}
{\r
seq = av.getAlignment().getSequenceAt(i);\r
if ( (av.getSelectionGroup() != null) &&\r
- av.getSelectionGroup().getSequences(false).contains(seq))\r
+ av.getSelectionGroup().getSequences(null).contains(seq))\r
{\r
currentColor = Color.gray;\r
currentTextColor = Color.black;\r
int iSize;\r
\r
if(af.getViewport().getSelectionGroup()!=null\r
- && af.getViewport().getSelectionGroup().getSize(false)>0)\r
+ && af.getViewport().getSelectionGroup().getSize()>0)\r
{\r
- iSize = af.getViewport().getSelectionGroup().getSize(false);\r
+ iSize = af.getViewport().getSelectionGroup().getSize();\r
dataset = new SequenceI[iSize];\r
seqs = af.getViewport().getSelectionGroup().\r
getSequencesInOrder(\r
{\r
int res = Integer.parseInt(searchString);\r
found = true;\r
- if (av.getSelectionGroup() == null || av.getSelectionGroup().getSize(false) < 1)\r
+ if (av.getSelectionGroup() == null || av.getSelectionGroup().getSize() < 1)\r
{\r
seq = (Sequence) av.getAlignment().getSequenceAt(0);\r
}\r
\r
if (selection != null)\r
{\r
- if ((selection.getSize(false) < 1) ||\r
+ if ((selection.getSize() < 1) ||\r
((selection.getEndRes() - selection.getStartRes()) < 2))\r
{\r
selection = null;\r
{\r
seq = (Sequence) av.alignment.getSequenceAt(seqIndex);\r
\r
- if ((selection != null) && !selection.getSequences(false).contains(seq))\r
+ if ((selection != null) && !selection.getSequences(null).contains(seq))\r
{\r
seqIndex++;\r
resIndex = 0;\r
gg.setColor(Color.white);\r
}\r
else if ((av.getSelectionGroup() != null) &&\r
- av.getSelectionGroup().getSequences(false).contains(s))\r
+ av.getSelectionGroup().getSequences(null).contains(s))\r
{\r
gg.setColor(Color.lightGray);\r
gg.fillRect(0, ((i - starty) * charHeight) + ypos, getWidth(),\r
{\r
for (int i = starty; i < alheight; i++)\r
{\r
+ SequenceI s = av.alignment.getSequenceAt(i);\r
if (av.hasHiddenRows)\r
{\r
- setHiddenFont(i);\r
+ setHiddenFont(s);\r
}\r
else\r
gg.setFont(italic);\r
\r
- SequenceI s = av.alignment.getSequenceAt(i);\r
drawIdString(gg, s, i, 0, ypos);\r
}\r
\r
\r
if (av.hasHiddenRows)\r
{\r
- setHiddenFont(i);\r
+ setHiddenFont(sequence);\r
}\r
\r
// Selected sequence colours\r
currentTextColor = Color.white;\r
}\r
else if ( (av.getSelectionGroup() != null) &&\r
- av.getSelectionGroup().getSequences(false).contains(\r
+ av.getSelectionGroup().getSequences(null).contains(\r
sequence))\r
{\r
currentColor = Color.lightGray;\r
}\r
}\r
\r
- void setHiddenFont(int i)\r
+ void setHiddenFont(SequenceI seq)\r
{\r
Font italic = new Font(av.getFont().getName(), Font.ITALIC,\r
av.getFont().getSize());\r
av.getFont().getSize());\r
\r
\r
- if (av.alignment.getSequenceAt(i)!=null\r
- && av.alignment.getSequenceAt(i).getHiddenSequences() != null)\r
+ if (av.hiddenRepSequences!=null &&\r
+ av.hiddenRepSequences.containsKey(seq))\r
gg.setFont(bold);\r
else\r
gg.setFont(italic);\r
{
jseq.setHidden(av.alignment.getHiddenSequences().isHidden(jds));
- if(jal.getSequenceAt(i).getHiddenSequences()!=null)
+ if(av.hiddenRepSequences!=null
+ && av.hiddenRepSequences.containsKey(jal.getSequenceAt(i)))
{
- jalview.datamodel.SequenceI [] reps =
- jal.getSequenceAt(i).getHiddenSequences().getSequencesInOrder(jal);
+ jalview.datamodel.SequenceI[] reps =
+ ( (jalview.datamodel.SequenceGroup)
+ av.hiddenRepSequences.get(
+ jal.getSequenceAt(i))).getSequencesInOrder(jal);
for(int h=0; h<reps.length; h++)
{
- jseq.addHiddenSequences(
- jal.findIndex(reps[h])
- );
+ if (reps[h] != jal.getSequenceAt(i))
+ jseq.addHiddenSequences(
+ jal.findIndex(reps[h])
+ );
}
}
}
groups[i].setTextCol2(sg.textColour2.getRGB());
groups[i].setTextColThreshold(sg.thresholdTextColour);
- for (int s = 0; s < sg.getSize(false); s++)
+ for (int s = 0; s < sg.getSize(); s++)
{
jalview.datamodel.Sequence seq =
(jalview.datamodel.Sequence) sg.getSequenceAt(s);
if (groups[i].getConsThreshold() != 0)
{
jalview.analysis.Conservation c = new jalview.analysis.Conservation("All",
- ResidueProperties.propHash, 3, sg.getSequences(false), 0,
+ ResidueProperties.propHash, 3, sg.getSequences(null), 0,
sg.getWidth() - 1);
c.calculate();
c.verdict(false, 25);
{
for(int s=0; s<JSEQ.length; s++)
{
+ jalview.datamodel.SequenceGroup hidden =
+ new jalview.datamodel.SequenceGroup();
+
for(int r=0; r<JSEQ[s].getHiddenSequencesCount(); r++)
{
- al.getSequenceAt(s).addHiddenSequence(
- al.getSequenceAt( JSEQ[s].getHiddenSequences(r) )
+ hidden.addSequence(
+ al.getSequenceAt(JSEQ[s].getHiddenSequences(r))
+ , false
);
}
+ af.viewport.hideRepSequences(al.getSequenceAt(s), hidden);
}
jalview.datamodel.SequenceI [] hseqs = new
if (groups[i].getConsThreshold() != 0)\r
{\r
jalview.analysis.Conservation c = new jalview.analysis.Conservation("All",\r
- ResidueProperties.propHash, 3, sg.getSequences(false), 0,\r
+ ResidueProperties.propHash, 3, sg.getSequences(null), 0,\r
sg.getWidth() - 1);\r
c.calculate();\r
c.verdict(false, 25);\r
add(menuItem);\r
\r
if(ap.av.getSelectionGroup() !=null\r
- && ap.av.getSelectionGroup().getSize(false)>1)\r
+ && ap.av.getSelectionGroup().getSize()>1)\r
{\r
menuItem = new JMenuItem("Represent Group with " + seq.getName());\r
menuItem.addActionListener(new java.awt.event.ActionListener()\r
protected void clustalColour_actionPerformed(ActionEvent e)\r
{\r
SequenceGroup sg = getGroup();\r
- sg.cs = new ClustalxColourScheme(sg.getSequences(true),\r
+ sg.cs = new ClustalxColourScheme(sg.getSequences(ap.av.hiddenRepSequences),\r
ap.av.alignment.getWidth());\r
refresh();\r
}\r
if (abovePIDColour.isSelected())\r
{\r
sg.cs.setConsensus(AAFrequency.calculate(\r
- sg.getSequences(true), sg.getStartRes(),\r
+ sg.getSequences(ap.av.hiddenRepSequences), sg.getStartRes(),\r
sg.getEndRes() + 1));\r
\r
int threshold = SliderPanel.setPIDSliderSource(ap, sg.cs,\r
{\r
SequenceGroup sg = getGroup();\r
sg.cs = new PIDColourScheme();\r
- sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(true),\r
+ sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(ap.av.hiddenRepSequences),\r
sg.getStartRes(),\r
sg.getEndRes() + 1));\r
refresh();\r
\r
sg.cs = new Blosum62ColourScheme();\r
\r
- sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(true),\r
+ sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(ap.av.hiddenRepSequences),\r
sg.getStartRes(),\r
sg.getEndRes() + 1));\r
\r
{\r
Conservation c = new Conservation("Group",\r
ResidueProperties.propHash, 3,\r
- sg.getSequences(true),\r
+ sg.getSequences(ap.av.hiddenRepSequences),\r
sg.getStartRes(),\r
sg.getEndRes() + 1);\r
\r
void hideSequences(boolean representGroup)\r
{\r
SequenceGroup sg = ap.av.getSelectionGroup();\r
- if(sg==null || sg.getSize(false)<1)\r
+ if(sg==null || sg.getSize()<1)\r
{\r
ap.av.hideSequence(new SequenceI[]{sequence});\r
return;\r
}\r
\r
- int gsize = sg.getSize(false);\r
- SequenceI [] hseqs;\r
+ ap.av.setSelectionGroup(null);\r
\r
- hseqs = new SequenceI[ representGroup ? gsize-1 : gsize ];\r
+ if (representGroup)\r
+ {\r
+ ap.av.hideRepSequences(sequence, sg);\r
\r
- int index = 0;\r
- for(int i=0; i<gsize; i++)\r
- {\r
- if(representGroup && sg.getSequenceAt(i)!=sequence)\r
- {\r
- sequence.addHiddenSequence(sg.getSequenceAt(i));\r
- hseqs[index++] = sg.getSequenceAt(i);\r
- }\r
- else if(!representGroup)\r
- {\r
- hseqs[index++] = sg.getSequenceAt(i);\r
- }\r
- }\r
+ return;\r
+ }\r
\r
- ap.av.hideSequence(hseqs);\r
+ int gsize = sg.getSize();\r
+ SequenceI[] hseqs;\r
\r
- ap.av.setSelectionGroup(null);\r
+ hseqs = new SequenceI[gsize];\r
+\r
+ int index = 0;\r
+ for (int i = 0; i < gsize; i++)\r
+ {\r
+ hseqs[index++] = sg.getSequenceAt(i);\r
+ }\r
+\r
+ ap.av.hideSequence(hseqs);\r
}\r
\r
public void copy_actionPerformed(ActionEvent e)\r
}\r
\r
ChangeCaseCommand caseCommand = new ChangeCaseCommand(\r
- description, sg.getSequencesAsArray(true), startEnd, caseChange\r
+ description, sg.getSequencesAsArray(ap.av.hiddenRepSequences),\r
+ startEnd, caseChange\r
);\r
\r
ap.alignFrame.addHistoryItem(caseCommand);\r
if(sg==null)\r
return;\r
\r
- int gSize= sg.getSize(false);\r
+ int gSize= sg.getSize();\r
SequenceI [] seqs = new SequenceI[gSize];\r
SequenceFeature [] features = new SequenceFeature[gSize];\r
\r
\r
int start, end;\r
\r
- if ( (sg != null) && (sg.getSize(false) >= 1))\r
+ if ( (sg != null) && (sg.getSize() >= 1))\r
{\r
originalSequences = sg.getSequencesInOrder(ap.av.alignment);\r
start = sg.getStartRes();\r
\r
if (av.getSelectionGroup() != null)\r
{\r
- if (av.getSelectionGroup().getSequences(false).contains(\r
+ if (av.getSelectionGroup().getSequences(null).contains(\r
((SequencePoint) points.elementAt(i)).sequence))\r
{\r
g.setColor(Color.gray);\r
{\r
if (av != null)\r
{\r
- if (!av.getSelectionGroup().getSequences(false).contains(sp.sequence))\r
+ if (!av.getSelectionGroup().getSequences(null).contains(sp.sequence))\r
{\r
av.getSelectionGroup().addSequence(sp.sequence, true);\r
}\r
{\r
av.hideColumns(res, res);\r
if(av.getSelectionGroup()!=null\r
- && av.getSelectionGroup().getSize(false)==av.alignment.getHeight())\r
+ && av.getSelectionGroup().getSize()==av.alignment.getHeight())\r
av.setSelectionGroup(null);\r
\r
ap.repaint();\r
}\r
\r
if ( (sx <= (endRes-startRes)*av.charWidth) &&\r
- group.getSequences(false).\r
+ group.getSequences(null).\r
contains(av.alignment.getSequenceAt(i)))\r
{\r
if ((bottom == -1) &&\r
- !group.getSequences(false).contains(\r
+ !group.getSequences(null).contains(\r
av.alignment.getSequenceAt(i + 1)))\r
{\r
bottom = sy + av.charHeight;\r
if (!inGroup)\r
{\r
if (((top == -1) && (i == 0)) ||\r
- !group.getSequences(false).contains(\r
+ !group.getSequences(null).contains(\r
av.alignment.getSequenceAt(i - 1)))\r
{\r
top = sy;\r
SequenceGroup sg = av.selectionGroup;\r
//Find the top and bottom of this group\r
int min = av.alignment.getHeight(), max = 0;\r
- for(int i=0; i<sg.getSize(false); i++)\r
+ for(int i=0; i<sg.getSize(); i++)\r
{\r
int index = av.alignment.findIndex( sg.getSequenceAt(i) );\r
if(index > max)\r
else\r
{\r
// Now add any sequences between min and max\r
- sg.getSequences(false).clear();\r
+ sg.getSequences(null).clear();\r
for (int i = min; i < max; i++)\r
{\r
sg.addSequence(av.alignment.getSequenceAt(i), false);\r
boolean fixedColumns = false;\r
SequenceGroup sg = av.getSelectionGroup();\r
\r
+ SequenceI seq = av.alignment.getSequenceAt(startseq);\r
\r
+ //No group, but the sequence may represent a group\r
if (!groupEditing && av.hasHiddenRows)\r
{\r
- if (av.alignment.getSequenceAt(startseq).getHiddenSequences() != null)\r
+ if (av.hiddenRepSequences!=null\r
+ && av.hiddenRepSequences.containsKey(seq))\r
{\r
+ sg = (SequenceGroup)av.hiddenRepSequences.get(seq);\r
groupEditing = true;\r
}\r
}\r
\r
- //No group, but the sequence may represent a group\r
- if (groupEditing\r
- && sg == null\r
- && av.alignment.getSequenceAt(startseq).getHiddenSequences() == null)\r
- {\r
- groupEditing = false;\r
- }\r
\r
- SequenceI seq = av.alignment.getSequenceAt(startseq);\r
StringBuffer message = new StringBuffer();\r
if (groupEditing)\r
{\r
\r
//Are we editing within a selection group?\r
if (groupEditing\r
- || (sg != null && sg.getSequences(true).contains(seq)))\r
+ || (sg != null && sg.getSequences(av.hiddenRepSequences).contains(seq)))\r
{\r
fixedColumns = true;\r
\r
//but the sequence represents a group\r
if (sg == null)\r
{\r
- sg = new SequenceGroup(null, null, false, false, false, 0,\r
- av.alignment.getWidth()-1);\r
- sg.addSequence(av.alignment.getSequenceAt(startseq), false);\r
+ sg = (SequenceGroup) av.hiddenRepSequences.get(seq);\r
}\r
\r
fixedLeft = sg.getStartRes();\r
\r
if (groupEditing)\r
{\r
- Vector vseqs = sg.getSequences(true);\r
+ Vector vseqs = sg.getSequences(av.hiddenRepSequences);\r
int g, groupSize = vseqs.size();\r
SequenceI[] groupSeqs = new SequenceI[groupSize];\r
for (g = 0; g < groupSeqs.length; g++)\r
\r
if (!blank)\r
{\r
- if(sg.getSize(false) == av.alignment.getHeight() )\r
+ if(sg.getSize() == av.alignment.getHeight() )\r
{\r
if((av.hasHiddenColumns\r
&& startres<av.getColumnSelection().getHiddenBoundaryRight(startres)))\r
SequenceI sequence = av.alignment.getSequenceAt( findSeq(evt) );\r
if(evt.getClickCount()>1)\r
{\r
- if (av.getSelectionGroup().getSize(false) == 1\r
+ if (av.getSelectionGroup().getSize() == 1\r
&& av.getSelectionGroup().getEndRes()\r
- av.getSelectionGroup().getStartRes() < 2)\r
av.setSelectionGroup(null);\r
stretchGroup = null;\r
}\r
}\r
- else if (!stretchGroup.getSequences(false).contains(sequence) ||\r
+ else if (!stretchGroup.getSequences(null).contains(sequence) ||\r
(stretchGroup.getStartRes() > res) ||\r
(stretchGroup.getEndRes() < res))\r
{\r
if (stretchGroup.cs instanceof ClustalxColourScheme)\r
{\r
( (ClustalxColourScheme) stretchGroup.cs).resetClustalX(\r
- stretchGroup.getSequences(true),\r
+ stretchGroup.getSequences(av.hiddenRepSequences),\r
stretchGroup.getWidth());\r
}\r
\r
\r
Sequence nextSeq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);\r
\r
- if (stretchGroup.getSequences(false).contains(nextSeq))\r
+ if (stretchGroup.getSequences(null).contains(nextSeq))\r
{\r
stretchGroup.deleteSequence(seq, false);\r
}\r
SequenceGroup selected = av.getSelectionGroup();
if ( (selected != null) &&
- selected.getSequences(false).contains( (SequenceI) node.element()))
+ selected.getSequences(null).contains( (SequenceI) node.element()))
{
g.setColor(Color.gray);
{
Conservation c = new Conservation("Group",
ResidueProperties.propHash, 3,
- sg.getSequences(false),
+ sg.getSequences(null),
sg.getStartRes(), sg.getEndRes());
c.calculate();