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