JAL-2137 create 1:1 mapping between model and query sequence
[jalview.git] / src / jalview / io / AnnotationFile.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.io;
22
23 import jalview.analysis.Conservation;
24 import jalview.api.AlignViewportI;
25 import jalview.datamodel.AlignmentAnnotation;
26 import jalview.datamodel.AlignmentI;
27 import jalview.datamodel.Annotation;
28 import jalview.datamodel.ColumnSelection;
29 import jalview.datamodel.GraphLine;
30 import jalview.datamodel.HiddenSequences;
31 import jalview.datamodel.PDBEntry;
32 import jalview.datamodel.PDBEntry.Type;
33 import jalview.datamodel.SequenceGroup;
34 import jalview.datamodel.SequenceI;
35 import jalview.schemes.ColourSchemeI;
36 import jalview.schemes.ColourSchemeProperty;
37 import jalview.schemes.ResidueProperties;
38 import jalview.schemes.UserColourScheme;
39 import jalview.structure.StructureSelectionManager;
40
41 import java.io.BufferedReader;
42 import java.io.File;
43 import java.io.FileReader;
44 import java.io.IOException;
45 import java.io.InputStreamReader;
46 import java.io.StringReader;
47 import java.net.URL;
48 import java.util.ArrayList;
49 import java.util.BitSet;
50 import java.util.Enumeration;
51 import java.util.Hashtable;
52 import java.util.List;
53 import java.util.Map;
54 import java.util.StringTokenizer;
55 import java.util.Vector;
56
57 public class AnnotationFile
58 {
59   public AnnotationFile()
60   {
61     init();
62   }
63
64   /**
65    * character used to write newlines
66    */
67   protected String newline = System.getProperty("line.separator");
68
69   /**
70    * set new line string and reset the output buffer
71    * 
72    * @param nl
73    */
74   public void setNewlineString(String nl)
75   {
76     newline = nl;
77     init();
78   }
79
80   public String getNewlineString()
81   {
82     return newline;
83   }
84
85   StringBuffer text;
86
87   private void init()
88   {
89     text = new StringBuffer("JALVIEW_ANNOTATION" + newline + "# Created: "
90             + new java.util.Date() + newline + newline);
91     refSeq = null;
92     refSeqId = null;
93   }
94
95   /**
96    * convenience method for pre-2.9 annotation files which have no view, hidden
97    * columns or hidden row keywords.
98    * 
99    * @param annotations
100    * @param list
101    * @param properties
102    * @return annotation file as a string.
103    */
104   public String printAnnotations(AlignmentAnnotation[] annotations,
105           List<SequenceGroup> list, Hashtable properties)
106   {
107     return printAnnotations(annotations, list, properties, null, null, null);
108
109   }
110
111   /**
112    * hold all the information about a particular view definition read from or
113    * written out in an annotations file.
114    */
115   public class ViewDef
116   {
117     public String viewname;
118
119     public HiddenSequences hidseqs;
120
121     public ColumnSelection hiddencols;
122
123     public Vector visibleGroups;
124
125     public Hashtable hiddenRepSeqs;
126
127     public ViewDef(String viewname, HiddenSequences hidseqs,
128             ColumnSelection hiddencols, Hashtable hiddenRepSeqs)
129     {
130       this.viewname = viewname;
131       this.hidseqs = hidseqs;
132       this.hiddencols = hiddencols;
133       this.hiddenRepSeqs = hiddenRepSeqs;
134     }
135   }
136
137   /**
138    * Prepare an annotation file given a set of annotations, groups, alignment
139    * properties and views.
140    * 
141    * @param annotations
142    * @param list
143    * @param properties
144    * @param views
145    * @return annotation file
146    */
147   public String printAnnotations(AlignmentAnnotation[] annotations,
148           List<SequenceGroup> list, Hashtable properties,
149           ColumnSelection cs, AlignmentI al, ViewDef view)
150   {
151     if (view != null)
152     {
153       if (view.viewname != null)
154       {
155         text.append("VIEW_DEF\t" + view.viewname + "\n");
156       }
157       if (list == null)
158       {
159         list = view.visibleGroups;
160       }
161       if (cs == null)
162       {
163         cs = view.hiddencols;
164       }
165       if (al == null)
166       {
167         // add hidden rep sequences.
168       }
169     }
170     // first target - store and restore all settings for a view.
171     if (al != null && al.hasSeqrep())
172     {
173       text.append("VIEW_SETREF\t" + al.getSeqrep().getName() + "\n");
174     }
175     if (cs != null && cs.hasHiddenColumns())
176     {
177       text.append("VIEW_HIDECOLS\t");
178       List<int[]> hc = cs.getHiddenColumns();
179       boolean comma = false;
180       for (int[] r : hc)
181       {
182         if (!comma)
183         {
184           comma = true;
185         }
186         else
187         {
188           text.append(",");
189         }
190         text.append(r[0]);
191         text.append("-");
192         text.append(r[1]);
193       }
194       text.append("\n");
195     }
196     // TODO: allow efficient recovery of annotation data shown in several
197     // different views
198     if (annotations != null)
199     {
200       boolean oneColour = true;
201       AlignmentAnnotation row;
202       String comma;
203       SequenceI refSeq = null;
204       SequenceGroup refGroup = null;
205
206       StringBuffer colours = new StringBuffer();
207       StringBuffer graphLine = new StringBuffer();
208       StringBuffer rowprops = new StringBuffer();
209       Hashtable<Integer, String> graphGroup = new Hashtable<Integer, String>();
210       Hashtable<Integer, Object[]> graphGroup_refs = new Hashtable<Integer, Object[]>();
211       BitSet graphGroupSeen = new BitSet();
212
213       java.awt.Color color;
214
215       for (int i = 0; i < annotations.length; i++)
216       {
217         row = annotations[i];
218
219         if (!row.visible
220                 && !row.hasScore()
221                 && !(row.graphGroup > -1 && graphGroupSeen
222                         .get(row.graphGroup)))
223         {
224           continue;
225         }
226
227         color = null;
228         oneColour = true;
229
230         // mark any sequence references for the row
231         writeSequence_Ref(refSeq, row.sequenceRef);
232         refSeq = row.sequenceRef;
233         // mark any group references for the row
234         writeGroup_Ref(refGroup, row.groupRef);
235         refGroup = row.groupRef;
236
237         boolean hasGlyphs = row.hasIcons, hasLabels = row.hasText, hasValues = row.hasScore, hasText = false;
238         // lookahead to check what the annotation row object actually contains.
239         for (int j = 0; row.annotations != null
240                 && j < row.annotations.length
241                 && (!hasGlyphs || !hasLabels || !hasValues); j++)
242         {
243           if (row.annotations[j] != null)
244           {
245             hasLabels |= (row.annotations[j].displayCharacter != null
246                     && row.annotations[j].displayCharacter.length() > 0 && !row.annotations[j].displayCharacter
247                     .equals(" "));
248             hasGlyphs |= (row.annotations[j].secondaryStructure != 0 && row.annotations[j].secondaryStructure != ' ');
249             hasValues |= (!Float.isNaN(row.annotations[j].value)); // NaNs can't
250             // be
251             // rendered..
252             hasText |= (row.annotations[j].description != null && row.annotations[j].description
253                     .length() > 0);
254           }
255         }
256
257         if (row.graph == AlignmentAnnotation.NO_GRAPH)
258         {
259           text.append("NO_GRAPH\t");
260           hasValues = false; // only secondary structure
261           // hasLabels = false; // and annotation description string.
262         }
263         else
264         {
265           if (row.graph == AlignmentAnnotation.BAR_GRAPH)
266           {
267             text.append("BAR_GRAPH\t");
268             hasGlyphs = false; // no secondary structure
269
270           }
271           else if (row.graph == AlignmentAnnotation.LINE_GRAPH)
272           {
273             hasGlyphs = false; // no secondary structure
274             text.append("LINE_GRAPH\t");
275           }
276
277           if (row.getThreshold() != null)
278           {
279             graphLine.append("GRAPHLINE\t");
280             graphLine.append(row.label);
281             graphLine.append("\t");
282             graphLine.append(row.getThreshold().value);
283             graphLine.append("\t");
284             graphLine.append(row.getThreshold().label);
285             graphLine.append("\t");
286             graphLine.append(jalview.util.Format.getHexString(row
287                     .getThreshold().colour));
288             graphLine.append(newline);
289           }
290
291           if (row.graphGroup > -1)
292           {
293             graphGroupSeen.set(row.graphGroup);
294             Integer key = new Integer(row.graphGroup);
295             if (graphGroup.containsKey(key))
296             {
297               graphGroup.put(key, graphGroup.get(key) + "\t" + row.label);
298
299             }
300             else
301             {
302               graphGroup_refs.put(key, new Object[] { refSeq, refGroup });
303               graphGroup.put(key, row.label);
304             }
305           }
306         }
307
308         text.append(row.label + "\t");
309         if (row.description != null)
310         {
311           text.append(row.description + "\t");
312         }
313         for (int j = 0; row.annotations != null
314                 && j < row.annotations.length; j++)
315         {
316           if (refSeq != null
317                   && jalview.util.Comparison.isGap(refSeq.getCharAt(j)))
318           {
319             continue;
320           }
321
322           if (row.annotations[j] != null)
323           {
324             comma = "";
325             if (hasGlyphs) // could be also hasGlyphs || ...
326             {
327
328               text.append(comma);
329               if (row.annotations[j].secondaryStructure != ' ')
330               {
331                 // only write out the field if its not whitespace.
332                 text.append(row.annotations[j].secondaryStructure);
333               }
334               comma = ",";
335             }
336             if (hasValues)
337             {
338               if (!Float.isNaN(row.annotations[j].value))
339               {
340                 text.append(comma + row.annotations[j].value);
341               }
342               else
343               {
344                 // System.err.println("Skipping NaN - not valid value.");
345                 text.append(comma + 0f);// row.annotations[j].value);
346               }
347               comma = ",";
348             }
349             if (hasLabels)
350             {
351               // TODO: labels are emitted after values for bar graphs.
352               if // empty labels are allowed, so
353               (row.annotations[j].displayCharacter != null
354                       && row.annotations[j].displayCharacter.length() > 0
355                       && !row.annotations[j].displayCharacter.equals(" "))
356               {
357                 text.append(comma + row.annotations[j].displayCharacter);
358                 comma = ",";
359               }
360             }
361             if (hasText)
362             {
363               if (row.annotations[j].description != null
364                       && row.annotations[j].description.length() > 0
365                       && !row.annotations[j].description
366                               .equals(row.annotations[j].displayCharacter))
367               {
368                 text.append(comma + row.annotations[j].description);
369                 comma = ",";
370               }
371             }
372             if (color != null && !color.equals(row.annotations[j].colour))
373             {
374               oneColour = false;
375             }
376
377             color = row.annotations[j].colour;
378
379             if (row.annotations[j].colour != null
380                     && row.annotations[j].colour != java.awt.Color.black)
381             {
382               text.append(comma
383                       + "["
384                       + jalview.util.Format
385                               .getHexString(row.annotations[j].colour)
386                       + "]");
387               comma = ",";
388             }
389           }
390           text.append("|");
391         }
392
393         if (row.hasScore())
394         {
395           text.append("\t" + row.score);
396         }
397
398         text.append(newline);
399
400         if (color != null && color != java.awt.Color.black && oneColour)
401         {
402           colours.append("COLOUR\t");
403           colours.append(row.label);
404           colours.append("\t");
405           colours.append(jalview.util.Format.getHexString(color));
406           colours.append(newline);
407         }
408         if (row.scaleColLabel || row.showAllColLabels
409                 || row.centreColLabels)
410         {
411           rowprops.append("ROWPROPERTIES\t");
412           rowprops.append(row.label);
413           rowprops.append("\tscaletofit=");
414           rowprops.append(row.scaleColLabel);
415           rowprops.append("\tshowalllabs=");
416           rowprops.append(row.showAllColLabels);
417           rowprops.append("\tcentrelabs=");
418           rowprops.append(row.centreColLabels);
419           rowprops.append(newline);
420         }
421         if (graphLine.length() > 0)
422         {
423           text.append(graphLine.toString());
424           graphLine.setLength(0);
425         }
426       }
427
428       text.append(newline);
429
430       text.append(colours.toString());
431       if (graphGroup.size() > 0)
432       {
433         SequenceI oldRefSeq = refSeq;
434         SequenceGroup oldRefGroup = refGroup;
435         for (Map.Entry<Integer, String> combine_statement : graphGroup
436                 .entrySet())
437         {
438           Object[] seqRefAndGroup = graphGroup_refs.get(combine_statement
439                   .getKey());
440
441           writeSequence_Ref(refSeq, (SequenceI) seqRefAndGroup[0]);
442           refSeq = (SequenceI) seqRefAndGroup[0];
443
444           writeGroup_Ref(refGroup, (SequenceGroup) seqRefAndGroup[1]);
445           refGroup = (SequenceGroup) seqRefAndGroup[1];
446           text.append("COMBINE\t");
447           text.append(combine_statement.getValue());
448           text.append(newline);
449         }
450         writeSequence_Ref(refSeq, oldRefSeq);
451         refSeq = oldRefSeq;
452
453         writeGroup_Ref(refGroup, oldRefGroup);
454         refGroup = oldRefGroup;
455       }
456       text.append(rowprops.toString());
457     }
458
459     if (list != null)
460     {
461       printGroups(list);
462     }
463
464     if (properties != null)
465     {
466       text.append(newline);
467       text.append(newline);
468       text.append("ALIGNMENT");
469       Enumeration en = properties.keys();
470       while (en.hasMoreElements())
471       {
472         String key = en.nextElement().toString();
473         text.append("\t");
474         text.append(key);
475         text.append("=");
476         text.append(properties.get(key));
477       }
478       // TODO: output alignment visualization settings here if required
479       // iterate through one or more views, defining, marking columns and rows
480       // as visible/hidden, and emmitting view properties.
481       // View specific annotation is
482     }
483
484     return text.toString();
485   }
486
487   private Object writeGroup_Ref(SequenceGroup refGroup,
488           SequenceGroup next_refGroup)
489   {
490     if (next_refGroup == null)
491     {
492
493       if (refGroup != null)
494       {
495         text.append(newline);
496         text.append("GROUP_REF\t");
497         text.append("ALIGNMENT");
498         text.append(newline);
499       }
500       return true;
501     }
502     else
503     {
504       if (refGroup == null || refGroup != next_refGroup)
505       {
506         text.append(newline);
507         text.append("GROUP_REF\t");
508         text.append(next_refGroup.getName());
509         text.append(newline);
510         return true;
511       }
512     }
513     return false;
514   }
515
516   private boolean writeSequence_Ref(SequenceI refSeq, SequenceI next_refSeq)
517   {
518
519     if (next_refSeq == null)
520     {
521       if (refSeq != null)
522       {
523         text.append(newline);
524         text.append("SEQUENCE_REF\t");
525         text.append("ALIGNMENT");
526         text.append(newline);
527         return true;
528       }
529     }
530     else
531     {
532       if (refSeq == null || refSeq != next_refSeq)
533       {
534         text.append(newline);
535         text.append("SEQUENCE_REF\t");
536         text.append(next_refSeq.getName());
537         text.append(newline);
538         return true;
539       }
540     }
541     return false;
542   }
543
544   public void printGroups(List<SequenceGroup> list)
545   {
546     SequenceI seqrep = null;
547     for (SequenceGroup sg : list)
548     {
549       if (!sg.hasSeqrep())
550       {
551         text.append("SEQUENCE_GROUP\t" + sg.getName() + "\t"
552                 + (sg.getStartRes() + 1) + "\t" + (sg.getEndRes() + 1)
553                 + "\t" + "-1\t");
554         seqrep = null;
555       }
556       else
557       {
558         seqrep = sg.getSeqrep();
559         text.append("SEQUENCE_REF\t");
560         text.append(seqrep.getName());
561         text.append(newline);
562         text.append("SEQUENCE_GROUP\t");
563         text.append(sg.getName());
564         text.append("\t");
565         text.append((seqrep.findPosition(sg.getStartRes())));
566         text.append("\t");
567         text.append((seqrep.findPosition(sg.getEndRes())));
568         text.append("\t");
569         text.append("-1\t");
570       }
571       for (int s = 0; s < sg.getSize(); s++)
572       {
573         text.append(sg.getSequenceAt(s).getName());
574         text.append("\t");
575       }
576       text.append(newline);
577       text.append("PROPERTIES\t");
578       text.append(sg.getName());
579       text.append("\t");
580
581       if (sg.getDescription() != null)
582       {
583         text.append("description=");
584         text.append(sg.getDescription());
585         text.append("\t");
586       }
587       if (sg.cs != null)
588       {
589         text.append("colour=");
590         text.append(ColourSchemeProperty.getColourName(sg.cs));
591         text.append("\t");
592         if (sg.cs.getThreshold() != 0)
593         {
594           text.append("pidThreshold=");
595           text.append(sg.cs.getThreshold());
596         }
597         if (sg.cs.conservationApplied())
598         {
599           text.append("consThreshold=");
600           text.append(sg.cs.getConservationInc());
601           text.append("\t");
602         }
603       }
604       text.append("outlineColour=");
605       text.append(jalview.util.Format.getHexString(sg.getOutlineColour()));
606       text.append("\t");
607
608       text.append("displayBoxes=");
609       text.append(sg.getDisplayBoxes());
610       text.append("\t");
611       text.append("displayText=");
612       text.append(sg.getDisplayText());
613       text.append("\t");
614       text.append("colourText=");
615       text.append(sg.getColourText());
616       text.append("\t");
617       text.append("showUnconserved=");
618       text.append(sg.getShowNonconserved());
619       text.append("\t");
620       if (sg.textColour != java.awt.Color.black)
621       {
622         text.append("textCol1=");
623         text.append(jalview.util.Format.getHexString(sg.textColour));
624         text.append("\t");
625       }
626       if (sg.textColour2 != java.awt.Color.white)
627       {
628         text.append("textCol2=");
629         text.append(jalview.util.Format.getHexString(sg.textColour2));
630         text.append("\t");
631       }
632       if (sg.thresholdTextColour != 0)
633       {
634         text.append("textColThreshold=");
635         text.append(sg.thresholdTextColour);
636         text.append("\t");
637       }
638       if (sg.idColour != null)
639       {
640         text.append("idColour=");
641         text.append(jalview.util.Format.getHexString(sg.idColour));
642         text.append("\t");
643       }
644       if (sg.isHidereps())
645       {
646         text.append("hide=true\t");
647       }
648       if (sg.isHideCols())
649       {
650         text.append("hidecols=true\t");
651       }
652       if (seqrep != null)
653       {
654         // terminate the last line and clear the sequence ref for the group
655         text.append(newline);
656         text.append("SEQUENCE_REF");
657       }
658       text.append(newline);
659       text.append(newline);
660
661     }
662   }
663
664   SequenceI refSeq = null;
665
666   String refSeqId = null;
667
668   public boolean annotateAlignmentView(AlignViewportI viewport,
669           String file, String protocol)
670   {
671     ColumnSelection colSel = viewport.getColumnSelection();
672     if (colSel == null)
673     {
674       colSel = new ColumnSelection();
675     }
676     boolean rslt = readAnnotationFile(viewport.getAlignment(), colSel,
677             file, protocol);
678     if (rslt && (colSel.hasSelectedColumns() || colSel.hasHiddenColumns()))
679     {
680       viewport.setColumnSelection(colSel);
681     }
682
683     return rslt;
684   }
685
686   public boolean readAnnotationFile(AlignmentI al, String file,
687           String protocol)
688   {
689     return readAnnotationFile(al, null, file, protocol);
690   }
691
692   public boolean readAnnotationFile(AlignmentI al, ColumnSelection colSel,
693           String file, String protocol)
694   {
695     baseUri = "";
696     BufferedReader in = null;
697     try
698     {
699       if (protocol.equals(AppletFormatAdapter.FILE))
700       {
701         in = new BufferedReader(new FileReader(file));
702         baseUri = new File(file).getParent();
703         if (baseUri == null)
704         {
705           baseUri = "";
706         }
707         else
708         {
709           baseUri += "/";
710         }
711       }
712       else if (protocol.equals(AppletFormatAdapter.URL))
713       {
714         URL url = new URL(file);
715         in = new BufferedReader(new InputStreamReader(url.openStream()));
716         String bs = url.toExternalForm();
717         baseUri = bs.substring(0, bs.indexOf(url.getHost())
718                 + url.getHost().length());
719         baseUri += url.toURI().getPath();
720         if (baseUri.lastIndexOf("/") > -1)
721         {
722           baseUri = baseUri.substring(0, baseUri.lastIndexOf("/")) + "/";
723         }
724       }
725       else if (protocol.equals(AppletFormatAdapter.PASTE))
726       {
727         in = new BufferedReader(new StringReader(file));
728         // TODO - support mimencoded PDBs for a paste.. ?
729         baseUri = "";
730       }
731       else if (protocol.equals(AppletFormatAdapter.CLASSLOADER))
732       {
733         java.io.InputStream is = getClass().getResourceAsStream("/" + file);
734         if (is != null)
735         {
736           in = new BufferedReader(new java.io.InputStreamReader(is));
737           // TODO: this probably doesn't work for classloader - needs a test
738           baseUri = new File("/" + file).getParent() + "/";
739         }
740       }
741       if (in != null)
742       {
743         return parseAnnotationFrom(al, colSel, in);
744       }
745
746     } catch (Exception ex)
747     {
748       ex.printStackTrace();
749       System.out.println("Problem reading annotation file: " + ex);
750       if (nlinesread > 0)
751       {
752         System.out.println("Last read line " + nlinesread + ": '"
753                 + lastread + "' (first 80 chars) ...");
754       }
755       return false;
756     }
757     return false;
758   }
759
760   long nlinesread = 0;
761
762   String lastread = "";
763
764   /**
765    * used for resolving absolute references to resources relative to
766    * annotationFile location
767    */
768   String baseUri = "";
769
770   private static String GRAPHLINE = "GRAPHLINE", COMBINE = "COMBINE",
771           STRUCTMODEL = "STRUCTMODEL";
772
773   public boolean parseAnnotationFrom(AlignmentI al, ColumnSelection colSel,
774           BufferedReader in) throws Exception
775   {
776     nlinesread = 0;
777     ArrayList<Object[]> combineAnnotation_calls = new ArrayList<Object[]>();
778     ArrayList<Object[]> deferredAnnotation_calls = new ArrayList<Object[]>();
779     boolean modified = false;
780     String groupRef = null;
781     Hashtable groupRefRows = new Hashtable();
782
783     Hashtable autoAnnots = new Hashtable();
784     {
785       String line, label, description, token;
786       int graphStyle, index;
787       int refSeqIndex = 1;
788       int existingAnnotations = 0;
789       // when true - will add new rows regardless of whether they are duplicate
790       // auto-annotation like consensus or conservation graphs
791       boolean overrideAutoAnnot = false;
792       if (al.getAlignmentAnnotation() != null)
793       {
794         existingAnnotations = al.getAlignmentAnnotation().length;
795         if (existingAnnotations > 0)
796         {
797           AlignmentAnnotation[] aa = al.getAlignmentAnnotation();
798           for (int aai = 0; aai < aa.length; aai++)
799           {
800             if (aa[aai].autoCalculated)
801             {
802               // make a note of the name and description
803               autoAnnots.put(
804                       autoAnnotsKey(aa[aai], aa[aai].sequenceRef,
805                               (aa[aai].groupRef == null ? null
806                                       : aa[aai].groupRef.getName())),
807                       new Integer(1));
808             }
809           }
810         }
811       }
812
813       int alWidth = al.getWidth();
814
815       StringTokenizer st;
816       Annotation[] annotations;
817       AlignmentAnnotation annotation = null;
818
819       // First confirm this is an Annotation file
820       boolean jvAnnotationFile = false;
821       while ((line = in.readLine()) != null)
822       {
823         nlinesread++;
824         lastread = new String(line);
825         if (line.indexOf("#") == 0)
826         {
827           continue;
828         }
829
830         if (line.indexOf("JALVIEW_ANNOTATION") > -1)
831         {
832           jvAnnotationFile = true;
833           break;
834         }
835       }
836
837       if (!jvAnnotationFile)
838       {
839         in.close();
840         return false;
841       }
842
843       while ((line = in.readLine()) != null)
844       {
845         nlinesread++;
846         lastread = new String(line);
847         if (line.indexOf("#") == 0
848                 || line.indexOf("JALVIEW_ANNOTATION") > -1
849                 || line.length() == 0)
850         {
851           continue;
852         }
853
854         st = new StringTokenizer(line, "\t");
855         token = st.nextToken();
856         if (token.equalsIgnoreCase("COLOUR"))
857         {
858           // TODO: use graduated colour def'n here too
859           colourAnnotations(al, st.nextToken(), st.nextToken());
860           modified = true;
861           continue;
862         }
863
864         else if (token.equalsIgnoreCase(COMBINE))
865         {
866           // keep a record of current state and resolve groupRef at end
867           combineAnnotation_calls
868                   .add(new Object[] { st, refSeq, groupRef });
869           modified = true;
870           continue;
871         }
872         else if (token.equalsIgnoreCase("ROWPROPERTIES"))
873         {
874           addRowProperties(al, st);
875           modified = true;
876           continue;
877         }
878         else if (token.equalsIgnoreCase(GRAPHLINE))
879         {
880           // resolve at end
881           deferredAnnotation_calls.add(new Object[] { GRAPHLINE, st,
882               refSeq, groupRef });
883           modified = true;
884           continue;
885         }
886
887         else if (token.equalsIgnoreCase("SEQUENCE_REF"))
888         {
889           if (st.hasMoreTokens())
890           {
891             refSeq = al.findName(refSeqId = st.nextToken());
892             if (refSeq == null)
893             {
894               refSeqId = null;
895             }
896             try
897             {
898               refSeqIndex = Integer.parseInt(st.nextToken());
899               if (refSeqIndex < 1)
900               {
901                 refSeqIndex = 1;
902                 System.out
903                         .println("WARNING: SEQUENCE_REF index must be > 0 in AnnotationFile");
904               }
905             } catch (Exception ex)
906             {
907               refSeqIndex = 1;
908             }
909           }
910           else
911           {
912             refSeq = null;
913             refSeqId = null;
914           }
915           continue;
916         }
917         else if (token.equalsIgnoreCase("GROUP_REF"))
918         {
919           // Group references could be forward or backwards, so they are
920           // resolved after the whole file is read in
921           groupRef = null;
922           if (st.hasMoreTokens())
923           {
924             groupRef = st.nextToken();
925             if (groupRef.length() < 1)
926             {
927               groupRef = null; // empty string
928             }
929             else
930             {
931               if (groupRefRows.get(groupRef) == null)
932               {
933                 groupRefRows.put(groupRef, new Vector());
934               }
935             }
936           }
937           continue;
938         }
939         else if (token.equalsIgnoreCase("SEQUENCE_GROUP"))
940         {
941           addGroup(al, st);
942           modified = true;
943           continue;
944         }
945
946         else if (token.equalsIgnoreCase("PROPERTIES"))
947         {
948           addProperties(al, st);
949           modified = true;
950           continue;
951         }
952
953         else if (token.equalsIgnoreCase("BELOW_ALIGNMENT"))
954         {
955           setBelowAlignment(al, st);
956           modified = true;
957           continue;
958         }
959         else if (token.equalsIgnoreCase("ALIGNMENT"))
960         {
961           addAlignmentDetails(al, st);
962           modified = true;
963           continue;
964         }
965         // else if (token.equalsIgnoreCase("VIEW_DEF"))
966         // {
967         // addOrSetView(al,st);
968         // modified = true;
969         // continue;
970         // }
971         else if (token.equalsIgnoreCase("VIEW_SETREF"))
972         {
973           if (refSeq != null)
974           {
975             al.setSeqrep(refSeq);
976           }
977           modified = true;
978           continue;
979         }
980         else if (token.equalsIgnoreCase("VIEW_HIDECOLS"))
981         {
982           if (st.hasMoreTokens())
983           {
984             if (colSel == null)
985             {
986               colSel = new ColumnSelection();
987             }
988             parseHideCols(colSel, st.nextToken());
989           }
990           modified = true;
991           continue;
992         }
993         else if (token.equalsIgnoreCase("HIDE_INSERTIONS"))
994         {
995           SequenceI sr = refSeq == null ? al.getSeqrep() : refSeq;
996           if (sr == null)
997           {
998             sr = al.getSequenceAt(0);
999           }
1000           if (sr != null)
1001           {
1002             if (colSel == null)
1003             {
1004               System.err
1005                       .println("Cannot process HIDE_INSERTIONS without an alignment view: Ignoring line: "
1006                               + line);
1007             }
1008             else
1009             {
1010               // consider deferring this till after the file has been parsed ?
1011               colSel.hideInsertionsFor(sr);
1012             }
1013           }
1014           modified = true;
1015           continue;
1016         }
1017         else if (token.equalsIgnoreCase(STRUCTMODEL))
1018         {
1019           boolean failedtoadd = true;
1020           // expect
1021           // STRUCTMODEL <QUERYID> <TemplateID> <URL to model> <URL to
1022           // alignment>
1023           if (st.hasMoreTokens()) {
1024             refSeq = al.findName(refSeqId = st.nextToken());
1025             if (refSeq == null)
1026             {
1027               System.err.println("Couldn't locate " + refSeqId
1028                       + " in the alignment for STRUCTMODEL");
1029               refSeqId = null;
1030             }
1031             else
1032             {
1033               String tempId = st.nextToken();
1034               String urlToModel = st.nextToken();
1035               String urlToPairwise = st.hasMoreTokens() ? st.nextToken()
1036                       : "";
1037               if (add_structmodel(al, refSeq, tempId, urlToModel,
1038                       urlToPairwise))
1039               {
1040                 failedtoadd = false;
1041               }
1042             }
1043           }
1044           if (failedtoadd)
1045           {
1046             System.err
1047                     .println("Need <QueryId> <TemplateId> <URL to Model> [<URL to pairwise alignment>] as tab separated fields after "
1048                             + STRUCTMODEL);
1049           } else {
1050             modified = true;
1051           }
1052           continue;
1053         }
1054         // Parse out the annotation row
1055         graphStyle = AlignmentAnnotation.getGraphValueFromString(token);
1056         label = st.nextToken();
1057
1058         index = 0;
1059         annotations = new Annotation[alWidth];
1060         description = null;
1061         float score = Float.NaN;
1062
1063         if (st.hasMoreTokens())
1064         {
1065           line = st.nextToken();
1066
1067           if (line.indexOf("|") == -1)
1068           {
1069             description = line;
1070             if (st.hasMoreTokens())
1071             {
1072               line = st.nextToken();
1073             }
1074           }
1075
1076           if (st.hasMoreTokens())
1077           {
1078             // This must be the score
1079             score = Float.valueOf(st.nextToken()).floatValue();
1080           }
1081
1082           st = new StringTokenizer(line, "|", true);
1083
1084           boolean emptyColumn = true;
1085           boolean onlyOneElement = (st.countTokens() == 1);
1086
1087           while (st.hasMoreElements() && index < alWidth)
1088           {
1089             token = st.nextToken().trim();
1090
1091             if (onlyOneElement)
1092             {
1093               try
1094               {
1095                 score = Float.valueOf(token).floatValue();
1096                 break;
1097               } catch (NumberFormatException ex)
1098               {
1099               }
1100             }
1101
1102             if (token.equals("|"))
1103             {
1104               if (emptyColumn)
1105               {
1106                 index++;
1107               }
1108
1109               emptyColumn = true;
1110             }
1111             else
1112             {
1113               annotations[index++] = parseAnnotation(token, graphStyle);
1114               emptyColumn = false;
1115             }
1116           }
1117
1118         }
1119
1120         annotation = new AlignmentAnnotation(label, description,
1121                 (index == 0) ? null : annotations, 0, 0, graphStyle);
1122
1123         annotation.score = score;
1124         if (!overrideAutoAnnot
1125                 && autoAnnots.containsKey(autoAnnotsKey(annotation, refSeq,
1126                         groupRef)))
1127         {
1128           // skip - we've already got an automatic annotation of this type.
1129           continue;
1130         }
1131         // otherwise add it!
1132         if (refSeq != null)
1133         {
1134
1135           annotation.belowAlignment = false;
1136           // make a copy of refSeq so we can find other matches in the alignment
1137           SequenceI referedSeq = refSeq;
1138           do
1139           {
1140             // copy before we do any mapping business.
1141             // TODO: verify that undo/redo with 1:many sequence associated
1142             // annotations can be undone correctly
1143             AlignmentAnnotation ann = new AlignmentAnnotation(annotation);
1144             annotation
1145                     .createSequenceMapping(referedSeq, refSeqIndex, false);
1146             annotation.adjustForAlignment();
1147             referedSeq.addAlignmentAnnotation(annotation);
1148             al.addAnnotation(annotation);
1149             al.setAnnotationIndex(annotation,
1150                     al.getAlignmentAnnotation().length
1151                             - existingAnnotations - 1);
1152             if (groupRef != null)
1153             {
1154               ((Vector) groupRefRows.get(groupRef)).addElement(annotation);
1155             }
1156             // and recover our virgin copy to use again if necessary.
1157             annotation = ann;
1158
1159           } while (refSeqId != null
1160                   && (referedSeq = al.findName(referedSeq, refSeqId, true)) != null);
1161         }
1162         else
1163         {
1164           al.addAnnotation(annotation);
1165           al.setAnnotationIndex(annotation,
1166                   al.getAlignmentAnnotation().length - existingAnnotations
1167                           - 1);
1168           if (groupRef != null)
1169           {
1170             ((Vector) groupRefRows.get(groupRef)).addElement(annotation);
1171           }
1172         }
1173         // and set modification flag
1174         modified = true;
1175       }
1176       // Resolve the groupRefs
1177       Hashtable<String, SequenceGroup> groupRefLookup = new Hashtable<String, SequenceGroup>();
1178       Enumeration en = groupRefRows.keys();
1179
1180       while (en.hasMoreElements())
1181       {
1182         groupRef = (String) en.nextElement();
1183         boolean matched = false;
1184         // Resolve group: TODO: add a getGroupByName method to alignments
1185         for (SequenceGroup theGroup : al.getGroups())
1186         {
1187           if (theGroup.getName().equals(groupRef))
1188           {
1189             if (matched)
1190             {
1191               // TODO: specify and implement duplication of alignment annotation
1192               // for multiple group references.
1193               System.err
1194                       .println("Ignoring 1:many group reference mappings for group name '"
1195                               + groupRef + "'");
1196             }
1197             else
1198             {
1199               matched = true;
1200               Vector rowset = (Vector) groupRefRows.get(groupRef);
1201               groupRefLookup.put(groupRef, theGroup);
1202               if (rowset != null && rowset.size() > 0)
1203               {
1204                 AlignmentAnnotation alan = null;
1205                 for (int elm = 0, elmSize = rowset.size(); elm < elmSize; elm++)
1206                 {
1207                   alan = (AlignmentAnnotation) rowset.elementAt(elm);
1208                   alan.groupRef = theGroup;
1209                 }
1210               }
1211             }
1212           }
1213         }
1214         ((Vector) groupRefRows.get(groupRef)).removeAllElements();
1215       }
1216       // process any deferred attribute settings for each context
1217       for (Object[] _deferred_args : deferredAnnotation_calls)
1218       {
1219         if (_deferred_args[0] == GRAPHLINE)
1220         {
1221           addLine(al,
1222                   (StringTokenizer) _deferred_args[1], // st
1223                   (SequenceI) _deferred_args[2], // refSeq
1224                   (_deferred_args[3] == null) ? null : groupRefLookup
1225                           .get(_deferred_args[3]) // the reference
1226                                                   // group, or null
1227           );
1228         }
1229       }
1230
1231       // finally, combine all the annotation rows within each context.
1232       /**
1233        * number of combine statements in this annotation file. Used to create
1234        * new groups for combined annotation graphs without disturbing existing
1235        * ones
1236        */
1237       int combinecount = 0;
1238       for (Object[] _combine_args : combineAnnotation_calls)
1239       {
1240         combineAnnotations(al,
1241                 ++combinecount,
1242                 (StringTokenizer) _combine_args[0], // st
1243                 (SequenceI) _combine_args[1], // refSeq
1244                 (_combine_args[2] == null) ? null : groupRefLookup
1245                         .get(_combine_args[2]) // the reference group,
1246                                                // or null
1247         );
1248       }
1249     }
1250     return modified;
1251   }
1252
1253   /**
1254    * resolve a structural model and generate and add an alignment sequence for
1255    * it
1256    * 
1257    * @param refSeq2
1258    * @param tempId
1259    * @param urlToModel
1260    * @param urlToPairwise
1261    * @return true if model and sequence was added
1262    */
1263   private boolean add_structmodel(AlignmentI al, SequenceI refSeq2, String tempId,
1264           String urlToModel, String urlToPairwise)
1265   {
1266     String warningMessage = null, modelPath = null, modelProt = null, aliPath = null, aliProt = null;
1267     boolean added = false;
1268     try {
1269       // locate tempId. if it exists, will need to merge, otherwise:
1270       SequenceI templateSeq = al.findName(tempId);
1271       // 1. load urlToModel
1272       modelPath = resolveAbsolute(urlToModel);
1273       modelProt = AppletFormatAdapter.checkProtocol(modelPath);
1274       // need to transfer to local temp file ?
1275       PDBEntry modelpe = new PDBEntry(tempId, null, Type.FILE, modelPath);
1276       PDBEntry templpe = new PDBEntry(tempId, null, Type.FILE, modelPath);
1277       refSeq2.addPDBId(modelpe);
1278       aliPath = resolveAbsolute(urlToPairwise);
1279       aliProt = AppletFormatAdapter.checkProtocol(aliPath);
1280       // 2. load urlToPairwise
1281       AlignmentI pwa = new AppletFormatAdapter().readFile(aliPath, aliProt,
1282               "FASTA");
1283       SequenceI qPw = null, tPw = null;
1284       if (pwa != null)
1285       {
1286         // resolve query/template sequences in provided alignment
1287         qPw = pwa.findName(refSeqId);
1288         tPw = pwa.findName(tempId);
1289       }
1290       if (false)
1291       // (qPw != null && tPw != null)
1292       {
1293         // not yet complete
1294         // refalQ vvva--addrvvvtttddd
1295         // refalT ---aaaa---sss---ddd
1296         // profalQ ---v-v-v-a.-.-a---dd--r--vvvtt--td--dd
1297         // profalT ---.-.-.-aa-a-a---..--.--sss..--.d--dd
1298         // Pragmatic solution here:
1299         // Map templpe onto refalT only where refalT and refalQ are both
1300         // non-gaps
1301
1302         // columns for start..end in refSeq2
1303         int[] gapMap = refSeq2.gapMap();
1304         // insert gaps in tPw
1305         int curi = 0, width = refSeq2.getLength();
1306         // TBC
1307       }
1308       else
1309       {
1310         // assume 1:1 - so synthesise sequences to use to construct mapping
1311         StructureFile pdbf = StructureSelectionManager
1312                 .getStructureSelectionManager().setMapping(false,
1313                         new SequenceI[] { refSeq2.getDatasetSequence() },
1314                         null, modelPath, modelProt);
1315         refSeq2.getDatasetSequence().addPDBId(modelpe);
1316         if (templateSeq == null && tPw != null)
1317         {
1318           tPw.createDatasetSequence();
1319           tPw.getDatasetSequence().addPDBId(templpe); // needs to set mapping based on model yet...
1320           al.addSequence(tPw);
1321           added = true;
1322         }
1323       }
1324     // 3. pad/insert gaps in urlToPairwise according to gaps already present in
1325     // refSeq2
1326     // 4. add padded tempId sequence to alignment
1327     // 4. associate urlToModel with refSeq2 based on position map provided by
1328     // urlToPairwise
1329     // 5. associate urlToModel with tempId based on position map provided by
1330     // urlToPairwise
1331     // start a thread to load urlToModel and process/annotate sequences.
1332     } catch (IOException x)
1333     {
1334       warningMessage = x.toString();
1335     } finally {
1336       if (warningMessage !=null)
1337       {
1338         System.err.println("Warnings whilst processing STRUCTMODEL: "+warningMessage);
1339       }
1340       return added;
1341     }
1342   }
1343
1344   private String resolveAbsolute(String relURI)
1345   {
1346     if (relURI.indexOf(":/") > -1 || relURI.startsWith("/")
1347             || "".equals(baseUri) || relURI.startsWith(baseUri))
1348     {
1349       return relURI;
1350     }
1351     return baseUri + relURI;
1352   }
1353
1354   private void parseHideCols(ColumnSelection colSel, String nextToken)
1355   {
1356     StringTokenizer inval = new StringTokenizer(nextToken, ",");
1357     while (inval.hasMoreTokens())
1358     {
1359       String range = inval.nextToken().trim();
1360       int from, to = range.indexOf("-");
1361       if (to == -1)
1362       {
1363         from = to = Integer.parseInt(range);
1364         if (from >= 0)
1365         {
1366           colSel.hideColumns(from, to);
1367         }
1368       }
1369       else
1370       {
1371         from = Integer.parseInt(range.substring(0, to));
1372         if (to < range.length() - 1)
1373         {
1374           to = Integer.parseInt(range.substring(to + 1));
1375         }
1376         else
1377         {
1378           to = from;
1379         }
1380         if (from > 0 && to >= from)
1381         {
1382           colSel.hideColumns(from, to);
1383         }
1384       }
1385     }
1386   }
1387
1388   private Object autoAnnotsKey(AlignmentAnnotation annotation,
1389           SequenceI refSeq, String groupRef)
1390   {
1391     return annotation.graph + "\t" + annotation.label + "\t"
1392             + annotation.description + "\t"
1393             + (refSeq != null ? refSeq.getDisplayId(true) : "");
1394   }
1395
1396   Annotation parseAnnotation(String string, int graphStyle)
1397   {
1398     boolean hasSymbols = (graphStyle == AlignmentAnnotation.NO_GRAPH); // don't
1399     // do the
1400     // glyph
1401     // test
1402     // if we
1403     // don't
1404     // want
1405     // secondary
1406     // structure
1407     String desc = null, displayChar = null;
1408     char ss = ' '; // secondaryStructure
1409     float value = 0;
1410     boolean parsedValue = false, dcset = false;
1411
1412     // find colour here
1413     java.awt.Color colour = null;
1414     int i = string.indexOf("[");
1415     int j = string.indexOf("]");
1416     if (i > -1 && j > -1)
1417     {
1418       UserColourScheme ucs = new UserColourScheme();
1419
1420       colour = ucs.getColourFromString(string.substring(i + 1, j));
1421       if (i > 0 && string.charAt(i - 1) == ',')
1422       {
1423         // clip the preceding comma as well
1424         i--;
1425       }
1426       string = string.substring(0, i) + string.substring(j + 1);
1427     }
1428
1429     StringTokenizer st = new StringTokenizer(string, ",", true);
1430     String token;
1431     boolean seenContent = false;
1432     int pass = 0;
1433     while (st.hasMoreTokens())
1434     {
1435       pass++;
1436       token = st.nextToken().trim();
1437       if (token.equals(","))
1438       {
1439         if (!seenContent && parsedValue && !dcset)
1440         {
1441           // allow the value below the bar/line to be empty
1442           dcset = true;
1443           displayChar = " ";
1444         }
1445         seenContent = false;
1446         continue;
1447       }
1448       else
1449       {
1450         seenContent = true;
1451       }
1452
1453       if (!parsedValue)
1454       {
1455         try
1456         {
1457           displayChar = token;
1458           // foo
1459           value = new Float(token).floatValue();
1460           parsedValue = true;
1461           continue;
1462         } catch (NumberFormatException ex)
1463         {
1464         }
1465       }
1466       else
1467       {
1468         if (token.length() == 1)
1469         {
1470           displayChar = token;
1471         }
1472       }
1473       if (hasSymbols
1474               && (token.length() == 1 && "()<>[]{}AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz"
1475                       .contains(token)))
1476       {
1477         // Either this character represents a helix or sheet
1478         // or an integer which can be displayed
1479         ss = token.charAt(0);
1480         if (displayChar.equals(token.substring(0, 1)))
1481         {
1482           displayChar = "";
1483         }
1484       }
1485       else if (desc == null || (parsedValue && pass > 2))
1486       {
1487         desc = token;
1488       }
1489
1490     }
1491     // if (!dcset && string.charAt(string.length() - 1) == ',')
1492     // {
1493     // displayChar = " "; // empty display char symbol.
1494     // }
1495     if (displayChar != null && desc != null && desc.length() == 1)
1496     {
1497       if (displayChar.length() > 1)
1498       {
1499         // switch desc and displayChar - legacy support
1500         String tmp = displayChar;
1501         displayChar = desc;
1502         desc = tmp;
1503       }
1504       else
1505       {
1506         if (displayChar.equals(desc))
1507         {
1508           // duplicate label - hangover from the 'robust parser' above
1509           desc = null;
1510         }
1511       }
1512     }
1513     Annotation anot = new Annotation(displayChar, desc, ss, value);
1514
1515     anot.colour = colour;
1516
1517     return anot;
1518   }
1519
1520   void colourAnnotations(AlignmentI al, String label, String colour)
1521   {
1522     UserColourScheme ucs = new UserColourScheme(colour);
1523     Annotation[] annotations;
1524     for (int i = 0; i < al.getAlignmentAnnotation().length; i++)
1525     {
1526       if (al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(label))
1527       {
1528         annotations = al.getAlignmentAnnotation()[i].annotations;
1529         for (int j = 0; j < annotations.length; j++)
1530         {
1531           if (annotations[j] != null)
1532           {
1533             annotations[j].colour = ucs.findColour('A');
1534           }
1535         }
1536       }
1537     }
1538   }
1539
1540   void combineAnnotations(AlignmentI al, int combineCount,
1541           StringTokenizer st, SequenceI seqRef, SequenceGroup groupRef)
1542   {
1543     String group = st.nextToken();
1544     // First make sure we are not overwriting the graphIndex
1545     int graphGroup = 0;
1546     if (al.getAlignmentAnnotation() != null)
1547     {
1548       for (int i = 0; i < al.getAlignmentAnnotation().length; i++)
1549       {
1550         AlignmentAnnotation aa = al.getAlignmentAnnotation()[i];
1551
1552         if (aa.graphGroup > graphGroup)
1553         {
1554           // try to number graphGroups in order of occurence.
1555           graphGroup = aa.graphGroup + 1;
1556         }
1557         if (aa.sequenceRef == seqRef && aa.groupRef == groupRef
1558                 && aa.label.equalsIgnoreCase(group))
1559         {
1560           if (aa.graphGroup > -1)
1561           {
1562             graphGroup = aa.graphGroup;
1563           }
1564           else
1565           {
1566             if (graphGroup <= combineCount)
1567             {
1568               graphGroup = combineCount + 1;
1569             }
1570             aa.graphGroup = graphGroup;
1571           }
1572           break;
1573         }
1574       }
1575
1576       // Now update groups
1577       while (st.hasMoreTokens())
1578       {
1579         group = st.nextToken();
1580         for (int i = 0; i < al.getAlignmentAnnotation().length; i++)
1581         {
1582           AlignmentAnnotation aa = al.getAlignmentAnnotation()[i];
1583           if (aa.sequenceRef == seqRef && aa.groupRef == groupRef
1584                   && aa.label.equalsIgnoreCase(group))
1585           {
1586             aa.graphGroup = graphGroup;
1587             break;
1588           }
1589         }
1590       }
1591     }
1592     else
1593     {
1594       System.err
1595               .println("Couldn't combine annotations. None are added to alignment yet!");
1596     }
1597   }
1598
1599   void addLine(AlignmentI al, StringTokenizer st, SequenceI seqRef,
1600           SequenceGroup groupRef)
1601   {
1602     String group = st.nextToken();
1603     AlignmentAnnotation annotation = null, alannot[] = al
1604             .getAlignmentAnnotation();
1605     float value = new Float(st.nextToken()).floatValue();
1606     String label = st.hasMoreTokens() ? st.nextToken() : null;
1607     java.awt.Color colour = null;
1608     if (st.hasMoreTokens())
1609     {
1610       UserColourScheme ucs = new UserColourScheme(st.nextToken());
1611       colour = ucs.findColour('A');
1612     }
1613     if (alannot != null)
1614     {
1615       for (int i = 0; i < alannot.length; i++)
1616       {
1617         if (alannot[i].label.equalsIgnoreCase(group)
1618                 && (seqRef == null || alannot[i].sequenceRef == seqRef)
1619                 && (groupRef == null || alannot[i].groupRef == groupRef))
1620         {
1621           alannot[i].setThreshold(new GraphLine(value, label, colour));
1622         }
1623       }
1624     }
1625     if (annotation == null)
1626     {
1627       return;
1628     }
1629   }
1630
1631   void addGroup(AlignmentI al, StringTokenizer st)
1632   {
1633     SequenceGroup sg = new SequenceGroup();
1634     sg.setName(st.nextToken());
1635     String rng = "";
1636     try
1637     {
1638       rng = st.nextToken();
1639       if (rng.length() > 0 && !rng.startsWith("*"))
1640       {
1641         sg.setStartRes(Integer.parseInt(rng) - 1);
1642       }
1643       else
1644       {
1645         sg.setStartRes(0);
1646       }
1647       rng = st.nextToken();
1648       if (rng.length() > 0 && !rng.startsWith("*"))
1649       {
1650         sg.setEndRes(Integer.parseInt(rng) - 1);
1651       }
1652       else
1653       {
1654         sg.setEndRes(al.getWidth() - 1);
1655       }
1656     } catch (Exception e)
1657     {
1658       System.err
1659               .println("Couldn't parse Group Start or End Field as '*' or a valid column or sequence index: '"
1660                       + rng + "' - assuming alignment width for group.");
1661       // assume group is full width
1662       sg.setStartRes(0);
1663       sg.setEndRes(al.getWidth() - 1);
1664     }
1665
1666     String index = st.nextToken();
1667     if (index.equals("-1"))
1668     {
1669       while (st.hasMoreElements())
1670       {
1671         sg.addSequence(al.findName(st.nextToken()), false);
1672       }
1673     }
1674     else
1675     {
1676       StringTokenizer st2 = new StringTokenizer(index, ",");
1677
1678       while (st2.hasMoreTokens())
1679       {
1680         String tmp = st2.nextToken();
1681         if (tmp.equals("*"))
1682         {
1683           for (int i = 0; i < al.getHeight(); i++)
1684           {
1685             sg.addSequence(al.getSequenceAt(i), false);
1686           }
1687         }
1688         else if (tmp.indexOf("-") >= 0)
1689         {
1690           StringTokenizer st3 = new StringTokenizer(tmp, "-");
1691
1692           int start = (Integer.parseInt(st3.nextToken()));
1693           int end = (Integer.parseInt(st3.nextToken()));
1694
1695           if (end > start)
1696           {
1697             for (int i = start; i <= end; i++)
1698             {
1699               sg.addSequence(al.getSequenceAt(i - 1), false);
1700             }
1701           }
1702         }
1703         else
1704         {
1705           sg.addSequence(al.getSequenceAt(Integer.parseInt(tmp) - 1), false);
1706         }
1707       }
1708     }
1709
1710     if (refSeq != null)
1711     {
1712       sg.setStartRes(refSeq.findIndex(sg.getStartRes() + 1) - 1);
1713       sg.setEndRes(refSeq.findIndex(sg.getEndRes() + 1) - 1);
1714       sg.setSeqrep(refSeq);
1715     }
1716
1717     if (sg.getSize() > 0)
1718     {
1719       al.addGroup(sg);
1720     }
1721   }
1722
1723   void addRowProperties(AlignmentI al, StringTokenizer st)
1724   {
1725     String label = st.nextToken(), keyValue, key, value;
1726     boolean scaletofit = false, centerlab = false, showalllabs = false;
1727     while (st.hasMoreTokens())
1728     {
1729       keyValue = st.nextToken();
1730       key = keyValue.substring(0, keyValue.indexOf("="));
1731       value = keyValue.substring(keyValue.indexOf("=") + 1);
1732       if (key.equalsIgnoreCase("scaletofit"))
1733       {
1734         scaletofit = Boolean.valueOf(value).booleanValue();
1735       }
1736       if (key.equalsIgnoreCase("showalllabs"))
1737       {
1738         showalllabs = Boolean.valueOf(value).booleanValue();
1739       }
1740       if (key.equalsIgnoreCase("centrelabs"))
1741       {
1742         centerlab = Boolean.valueOf(value).booleanValue();
1743       }
1744       AlignmentAnnotation[] alr = al.getAlignmentAnnotation();
1745       if (alr != null)
1746       {
1747         for (int i = 0; i < alr.length; i++)
1748         {
1749           if (alr[i].label.equalsIgnoreCase(label))
1750           {
1751             alr[i].centreColLabels = centerlab;
1752             alr[i].scaleColLabel = scaletofit;
1753             alr[i].showAllColLabels = showalllabs;
1754           }
1755         }
1756       }
1757     }
1758   }
1759
1760   void addProperties(AlignmentI al, StringTokenizer st)
1761   {
1762
1763     // So far we have only added groups to the annotationHash,
1764     // the idea is in the future properties can be added to
1765     // alignments, other annotations etc
1766     if (al.getGroups() == null)
1767     {
1768       return;
1769     }
1770
1771     String name = st.nextToken();
1772     SequenceGroup sg = null;
1773     for (SequenceGroup _sg : al.getGroups())
1774     {
1775       if ((sg = _sg).getName().equals(name))
1776       {
1777         break;
1778       }
1779       else
1780       {
1781         sg = null;
1782       }
1783     }
1784
1785     if (sg != null)
1786     {
1787       String keyValue, key, value;
1788       ColourSchemeI def = sg.cs;
1789       sg.cs = null;
1790       while (st.hasMoreTokens())
1791       {
1792         keyValue = st.nextToken();
1793         key = keyValue.substring(0, keyValue.indexOf("="));
1794         value = keyValue.substring(keyValue.indexOf("=") + 1);
1795
1796         if (key.equalsIgnoreCase("description"))
1797         {
1798           sg.setDescription(value);
1799         }
1800         else if (key.equalsIgnoreCase("colour"))
1801         {
1802           sg.cs = ColourSchemeProperty.getColour(al, value);
1803         }
1804         else if (key.equalsIgnoreCase("pidThreshold"))
1805         {
1806           sg.cs.setThreshold(Integer.parseInt(value), true);
1807
1808         }
1809         else if (key.equalsIgnoreCase("consThreshold"))
1810         {
1811           sg.cs.setConservationInc(Integer.parseInt(value));
1812           Conservation c = new Conservation("Group",
1813                   ResidueProperties.propHash, 3, sg.getSequences(null),
1814                   sg.getStartRes(), sg.getEndRes() + 1);
1815
1816           c.calculate();
1817           c.verdict(false, 25); // TODO: refer to conservation percent threshold
1818
1819           sg.cs.setConservation(c);
1820
1821         }
1822         else if (key.equalsIgnoreCase("outlineColour"))
1823         {
1824           sg.setOutlineColour(new UserColourScheme(value).findColour('A'));
1825         }
1826         else if (key.equalsIgnoreCase("displayBoxes"))
1827         {
1828           sg.setDisplayBoxes(Boolean.valueOf(value).booleanValue());
1829         }
1830         else if (key.equalsIgnoreCase("showUnconserved"))
1831         {
1832           sg.setShowNonconserved(Boolean.valueOf(value).booleanValue());
1833         }
1834         else if (key.equalsIgnoreCase("displayText"))
1835         {
1836           sg.setDisplayText(Boolean.valueOf(value).booleanValue());
1837         }
1838         else if (key.equalsIgnoreCase("colourText"))
1839         {
1840           sg.setColourText(Boolean.valueOf(value).booleanValue());
1841         }
1842         else if (key.equalsIgnoreCase("textCol1"))
1843         {
1844           sg.textColour = new UserColourScheme(value).findColour('A');
1845         }
1846         else if (key.equalsIgnoreCase("textCol2"))
1847         {
1848           sg.textColour2 = new UserColourScheme(value).findColour('A');
1849         }
1850         else if (key.equalsIgnoreCase("textColThreshold"))
1851         {
1852           sg.thresholdTextColour = Integer.parseInt(value);
1853         }
1854         else if (key.equalsIgnoreCase("idColour"))
1855         {
1856           // consider warning if colour doesn't resolve to a real colour
1857           sg.setIdColour((def = new UserColourScheme(value))
1858                   .findColour('A'));
1859         }
1860         else if (key.equalsIgnoreCase("hide"))
1861         {
1862           // see bug https://mantis.lifesci.dundee.ac.uk/view.php?id=25847
1863           sg.setHidereps(true);
1864         }
1865         else if (key.equalsIgnoreCase("hidecols"))
1866         {
1867           // see bug https://mantis.lifesci.dundee.ac.uk/view.php?id=25847
1868           sg.setHideCols(true);
1869         }
1870         sg.recalcConservation();
1871       }
1872       if (sg.cs == null)
1873       {
1874         sg.cs = def;
1875       }
1876     }
1877   }
1878
1879   void setBelowAlignment(AlignmentI al, StringTokenizer st)
1880   {
1881     String token;
1882     AlignmentAnnotation aa, ala[] = al.getAlignmentAnnotation();
1883     if (ala == null)
1884     {
1885       System.err
1886               .print("Warning - no annotation to set below for sequence associated annotation:");
1887     }
1888     while (st.hasMoreTokens())
1889     {
1890       token = st.nextToken();
1891       if (ala == null)
1892       {
1893         System.err.print(" " + token);
1894       }
1895       else
1896       {
1897         for (int i = 0; i < al.getAlignmentAnnotation().length; i++)
1898         {
1899           aa = al.getAlignmentAnnotation()[i];
1900           if (aa.sequenceRef == refSeq && aa.label.equals(token))
1901           {
1902             aa.belowAlignment = true;
1903           }
1904         }
1905       }
1906     }
1907     if (ala == null)
1908     {
1909       System.err.print("\n");
1910     }
1911   }
1912
1913   void addAlignmentDetails(AlignmentI al, StringTokenizer st)
1914   {
1915     String keyValue, key, value;
1916     while (st.hasMoreTokens())
1917     {
1918       keyValue = st.nextToken();
1919       key = keyValue.substring(0, keyValue.indexOf("="));
1920       value = keyValue.substring(keyValue.indexOf("=") + 1);
1921       al.setProperty(key, value);
1922     }
1923   }
1924
1925   /**
1926    * Write annotations as a CSV file of the form 'label, value, value, ...' for
1927    * each row.
1928    * 
1929    * @param annotations
1930    * @return CSV file as a string.
1931    */
1932   public String printCSVAnnotations(AlignmentAnnotation[] annotations)
1933   {
1934     if (annotations == null)
1935     {
1936       return "";
1937     }
1938     StringBuffer sp = new StringBuffer();
1939     for (int i = 0; i < annotations.length; i++)
1940     {
1941       String atos = annotations[i].toString();
1942       int p = 0;
1943       do
1944       {
1945         int cp = atos.indexOf("\n", p);
1946         sp.append(annotations[i].label);
1947         sp.append(",");
1948         if (cp > p)
1949         {
1950           sp.append(atos.substring(p, cp + 1));
1951         }
1952         else
1953         {
1954           sp.append(atos.substring(p));
1955           sp.append(newline);
1956         }
1957         p = cp + 1;
1958       } while (p > 0);
1959     }
1960     return sp.toString();
1961   }
1962
1963   public String printAnnotationsForView(AlignViewportI viewport)
1964   {
1965     return printAnnotations(viewport.isShowAnnotation() ? viewport
1966             .getAlignment().getAlignmentAnnotation() : null, viewport
1967             .getAlignment().getGroups(), viewport.getAlignment()
1968             .getProperties(), viewport.getColumnSelection(),
1969             viewport.getAlignment(), null);
1970   }
1971
1972   public String printAnnotationsForAlignment(AlignmentI al)
1973   {
1974     return printAnnotations(al.getAlignmentAnnotation(), al.getGroups(),
1975             al.getProperties(), null, al, null);
1976   }
1977 }