/*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
- * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.1)
+ * Copyright (C) 2014 The Jalview Authors
*
* This file is part of Jalview.
*
* 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.io;
StringBuffer colours = new StringBuffer();
StringBuffer graphLine = new StringBuffer();
StringBuffer rowprops = new StringBuffer();
- Hashtable graphGroup = new Hashtable();
+ Hashtable<Integer,String> graphGroup = new Hashtable<Integer,String>();
+ Hashtable<Integer, Object[]> graphGroup_refs = new Hashtable<Integer,Object[]>();
BitSet graphGroupSeen = new BitSet();
java.awt.Color color;
color = null;
oneColour = true;
-
- if (row.sequenceRef == null)
- {
- if (refSeq != null)
- {
- text.append(newline);
- text.append("SEQUENCE_REF\tALIGNMENT");
- text.append(newline);
- }
-
- refSeq = null;
- }
-
- else
- {
- if (refSeq == null || refSeq != row.sequenceRef)
- {
- refSeq = row.sequenceRef;
- text.append(newline);
- text.append("SEQUENCE_REF\t");
- text.append(refSeq.getName());
- text.append(newline);
- }
- }
+
+ // mark any sequence references for the row
+ writeSequence_Ref(refSeq ,row.sequenceRef);
+ refSeq = row.sequenceRef;
// mark any group references for the row
- if (row.groupRef == null)
- {
-
- if (refGroup != null)
- {
- text.append(newline);
- text.append("GROUP_REF\tALIGNMENT");
- text.append(newline);
- }
-
- refGroup = null;
- }
- else
- {
- if (refGroup == null || refGroup != row.groupRef)
- {
- refGroup = row.groupRef;
- text.append(newline);
- text.append("GROUP_REF\t");
- text.append(refGroup.getName());
- text.append(newline);
- }
- }
+ writeGroup_Ref(refGroup, row.groupRef);
+ refGroup = row.groupRef;
boolean hasGlyphs = row.hasIcons, hasLabels = row.hasText, hasValues = row.hasScore, hasText = false;
// lookahead to check what the annotation row object actually contains.
if (row.graphGroup > -1)
{
graphGroupSeen.set(row.graphGroup);
- String key = String.valueOf(row.graphGroup);
+ Integer key = new Integer(row.graphGroup);
if (graphGroup.containsKey(key))
{
graphGroup.put(key, graphGroup.get(key) + "\t" + row.label);
+
}
else
{
+ graphGroup_refs.put(key, new Object[] { refSeq, refGroup});
graphGroup.put(key, row.label);
}
}
rowprops.append(row.centreColLabels);
rowprops.append(newline);
}
+ if (graphLine.length()>0) {
+ text.append(graphLine.toString());
+ graphLine.setLength(0);
+ }
}
text.append(newline);
text.append(colours.toString());
- text.append(graphLine.toString());
if (graphGroup.size() > 0)
{
- Enumeration en = graphGroup.elements();
- while (en.hasMoreElements())
- {
+ SequenceI oldRefSeq = refSeq;
+ SequenceGroup oldRefGroup = refGroup;
+ for (Map.Entry<Integer, String> combine_statement:graphGroup.entrySet())
+ {
+ Object[] seqRefAndGroup=graphGroup_refs.get(combine_statement.getKey());
+
+ writeSequence_Ref(refSeq, (SequenceI)seqRefAndGroup[0]);
+ refSeq = (SequenceI)seqRefAndGroup[0];
+
+ writeGroup_Ref(refGroup, (SequenceGroup)seqRefAndGroup[1]);
+ refGroup = (SequenceGroup)seqRefAndGroup[1];
text.append("COMBINE\t");
- text.append(en.nextElement());
+ text.append(combine_statement.getValue());
text.append(newline);
}
+ writeSequence_Ref(refSeq, oldRefSeq);
+ refSeq = oldRefSeq;
+
+ writeGroup_Ref(refGroup, oldRefGroup);
+ refGroup = oldRefGroup;
}
text.append(rowprops.toString());
}
return text.toString();
}
+ private Object writeGroup_Ref(SequenceGroup refGroup, SequenceGroup next_refGroup)
+ {
+ if (next_refGroup == null)
+ {
+
+ if (refGroup != null)
+ {
+ text.append(newline);
+ text.append("GROUP_REF\t");
+ text.append("ALIGNMENT");
+ text.append(newline);
+ }
+ return true;
+ }
+ else
+ {
+ if (refGroup == null || refGroup != next_refGroup)
+ {
+ text.append(newline);
+ text.append("GROUP_REF\t");
+ text.append(next_refGroup.getName());
+ text.append(newline);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private boolean writeSequence_Ref(SequenceI refSeq, SequenceI next_refSeq)
+ {
+
+ if (next_refSeq==null)
+ {
+ if (refSeq != null)
+ {
+ text.append(newline);
+ text.append("SEQUENCE_REF\t");
+ text.append("ALIGNMENT");
+ text.append(newline);
+ return true;
+ }
+ }
+ else
+ {
+ if (refSeq == null || refSeq != next_refSeq)
+ {
+ text.append(newline);
+ text.append("SEQUENCE_REF\t");
+ text.append(next_refSeq.getName());
+ text.append(newline);
+ return true;
+ }
+ }
+ return false;
+ }
+
public void printGroups(List<SequenceGroup> list)
{
SequenceI seqrep = null;
}
long nlinesread=0;
String lastread="";
+ private static String GRAPHLINE="GRAPHLINE", COMBINE="COMBINE";
public boolean parseAnnotationFrom(AlignmentI al, BufferedReader in)
throws Exception
{
nlinesread = 0;
- /**
- * number of combine statements in this annotation file. Used to create new groups for combined annotation graphs without disturbing existing ones
- */
- int combinecount = 0;
+ ArrayList<Object[]> combineAnnotation_calls = new ArrayList<Object[]>();
+ ArrayList<Object[]> deferredAnnotation_calls = new ArrayList<Object[]>();
boolean modified = false;
String groupRef = null;
Hashtable groupRefRows = new Hashtable();
continue;
}
- else if (token.equalsIgnoreCase("COMBINE"))
+ else if (token.equalsIgnoreCase(COMBINE))
{
- combineAnnotations(al, combinecount++, st);
+ // keep a record of current state and resolve groupRef at end
+ combineAnnotation_calls.add(new Object[] { st, refSeq, groupRef});
modified = true;
continue;
}
modified = true;
continue;
}
- else if (token.equalsIgnoreCase("GRAPHLINE"))
+ else if (token.equalsIgnoreCase(GRAPHLINE))
{
- addLine(al, st);
+ // resolve at end
+ deferredAnnotation_calls.add(new Object[] { GRAPHLINE, st, refSeq, groupRef});
modified = true;
continue;
}
else if (token.equalsIgnoreCase("SEQUENCE_GROUP"))
{
addGroup(al, st);
+ modified=true;
continue;
}
// and set modification flag
modified = true;
}
- // Finally, resolve the groupRefs
+ // Resolve the groupRefs
+ Hashtable <String,SequenceGroup> groupRefLookup=new Hashtable<String,SequenceGroup>();
Enumeration en = groupRefRows.keys();
while (en.hasMoreElements())
{
matched = true;
Vector rowset = (Vector) groupRefRows.get(groupRef);
+ groupRefLookup.put(groupRef, theGroup);
if (rowset != null && rowset.size() > 0)
{
AlignmentAnnotation alan = null;
}
((Vector) groupRefRows.get(groupRef)).removeAllElements();
}
+ // process any deferred attribute settings for each context
+ for (Object[] _deferred_args : deferredAnnotation_calls)
+ {
+ if (_deferred_args[0] == GRAPHLINE)
+ {
+ addLine(al,
+ (StringTokenizer) _deferred_args[1], // st
+ (SequenceI) _deferred_args[2], // refSeq
+ (_deferred_args[3] == null) ? null : groupRefLookup
+ .get((String) _deferred_args[3]) // the reference
+ // group, or null
+ );
+ }
+ }
+
+ // finally, combine all the annotation rows within each context.
+ /**
+ * number of combine statements in this annotation file. Used to create new groups for combined annotation graphs without disturbing existing ones
+ */
+ int combinecount = 0;
+ for (Object[] _combine_args:combineAnnotation_calls) {
+ combineAnnotations(al,
+ ++combinecount,
+ (StringTokenizer) _combine_args[0], // st
+ (SequenceI) _combine_args[1], // refSeq
+ (_combine_args[2]==null) ? null : groupRefLookup.get((String)_combine_args[2]) // the reference group, or null
+ );
+ }
}
return modified;
}
}
}
- void combineAnnotations(AlignmentI al, int combineCount, StringTokenizer st)
+ void combineAnnotations(AlignmentI al, int combineCount, StringTokenizer st, SequenceI seqRef, SequenceGroup groupRef)
{
String group = st.nextToken();
// First make sure we are not overwriting the graphIndex
for (int i = 0; i < al.getAlignmentAnnotation().length; i++)
{
AlignmentAnnotation aa = al.getAlignmentAnnotation()[i];
+
if (aa.graphGroup>graphGroup)
{
// try to number graphGroups in order of occurence.
- graphGroup=aa.graphGroup;
+ graphGroup=aa.graphGroup+1;
}
- if (aa.label.equalsIgnoreCase(group))
+ if (aa.sequenceRef==seqRef && aa.groupRef==groupRef && aa.label.equalsIgnoreCase(group))
{
if (aa.graphGroup>-1)
{
graphGroup = aa.graphGroup;
} else {
- if (graphGroup >= combineCount)
+ if (graphGroup <= combineCount)
{
- graphGroup++;
+ graphGroup=combineCount+1;
}
aa.graphGroup = graphGroup;
}
group = st.nextToken();
for (int i = 0; i < al.getAlignmentAnnotation().length; i++)
{
- if (al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(group))
+ AlignmentAnnotation aa = al.getAlignmentAnnotation()[i];
+ if (aa.sequenceRef==seqRef && aa.groupRef==groupRef && aa.label.equalsIgnoreCase(group))
{
- al.getAlignmentAnnotation()[i].graphGroup = graphGroup;
+ aa.graphGroup = graphGroup;
break;
}
}
}
}
- void addLine(AlignmentI al, StringTokenizer st)
+ void addLine(AlignmentI al, StringTokenizer st, SequenceI seqRef, SequenceGroup groupRef)
{
String group = st.nextToken();
AlignmentAnnotation annotation = null, alannot[] = al
.getAlignmentAnnotation();
+ float value = new Float(st.nextToken()).floatValue();
+ String label = st.hasMoreTokens() ? st.nextToken() : null;
+ java.awt.Color colour = null;
+ if (st.hasMoreTokens())
+ {
+ UserColourScheme ucs = new UserColourScheme(st.nextToken());
+ colour = ucs.findColour('A');
+ }
if (alannot != null)
{
for (int i = 0; i < alannot.length; i++)
{
- if (alannot[i].label.equalsIgnoreCase(group))
+ if (alannot[i].label.equalsIgnoreCase(group) && (seqRef==null || alannot[i].sequenceRef==seqRef) && (groupRef==null || alannot[i].groupRef==groupRef))
{
- annotation = alannot[i];
- break;
+ alannot[i].setThreshold(new GraphLine(value, label, colour));
}
}
}
{
return;
}
- float value = new Float(st.nextToken()).floatValue();
- String label = st.hasMoreTokens() ? st.nextToken() : null;
- java.awt.Color colour = null;
- if (st.hasMoreTokens())
- {
- UserColourScheme ucs = new UserColourScheme(st.nextToken());
- colour = ucs.findColour('A');
- }
-
- annotation.setThreshold(new GraphLine(value, label, colour));
}
void addGroup(AlignmentI al, StringTokenizer st)