src/jalview/gui/Jalview2XML.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.gui;
  22
  23 import jalview.api.FeatureColourI;
  24 import jalview.api.ViewStyleI;
  25 import jalview.api.structures.JalviewStructureDisplayI;
  26 import jalview.bin.Cache;
  27 import jalview.datamodel.AlignedCodonFrame;
  28 import jalview.datamodel.Alignment;
  29 import jalview.datamodel.AlignmentAnnotation;
  30 import jalview.datamodel.AlignmentI;
  31 import jalview.datamodel.PDBEntry;
  32 import jalview.datamodel.RnaViewerModel;
  33 import jalview.datamodel.SequenceGroup;
  34 import jalview.datamodel.SequenceI;
  35 import jalview.datamodel.StructureViewerModel;
  36 import jalview.datamodel.StructureViewerModel.StructureData;
  37 import jalview.ext.varna.RnaModel;
  38 import jalview.gui.StructureViewer.ViewerType;
  39 import jalview.schemabinding.version2.AlcodMap;
  40 import jalview.schemabinding.version2.AlcodonFrame;
  41 import jalview.schemabinding.version2.Annotation;
  42 import jalview.schemabinding.version2.AnnotationColours;
  43 import jalview.schemabinding.version2.AnnotationElement;
  44 import jalview.schemabinding.version2.CalcIdParam;
  45 import jalview.schemabinding.version2.DBRef;
  46 import jalview.schemabinding.version2.Features;
  47 import jalview.schemabinding.version2.Group;
  48 import jalview.schemabinding.version2.HiddenColumns;
  49 import jalview.schemabinding.version2.JGroup;
  50 import jalview.schemabinding.version2.JSeq;
  51 import jalview.schemabinding.version2.JalviewModel;
  52 import jalview.schemabinding.version2.JalviewModelSequence;
  53 import jalview.schemabinding.version2.MapListFrom;
  54 import jalview.schemabinding.version2.MapListTo;
  55 import jalview.schemabinding.version2.Mapping;
  56 import jalview.schemabinding.version2.MappingChoice;
  57 import jalview.schemabinding.version2.OtherData;
  58 import jalview.schemabinding.version2.PdbentryItem;
  59 import jalview.schemabinding.version2.Pdbids;
  60 import jalview.schemabinding.version2.Property;
  61 import jalview.schemabinding.version2.RnaViewer;
  62 import jalview.schemabinding.version2.SecondaryStructure;
  63 import jalview.schemabinding.version2.Sequence;
  64 import jalview.schemabinding.version2.SequenceSet;
  65 import jalview.schemabinding.version2.SequenceSetProperties;
  66 import jalview.schemabinding.version2.Setting;
  67 import jalview.schemabinding.version2.StructureState;
  68 import jalview.schemabinding.version2.ThresholdLine;
  69 import jalview.schemabinding.version2.Tree;
  70 import jalview.schemabinding.version2.UserColours;
  71 import jalview.schemabinding.version2.Viewport;
  72 import jalview.schemes.AnnotationColourGradient;
  73 import jalview.schemes.ColourSchemeI;
  74 import jalview.schemes.ColourSchemeProperty;
  75 import jalview.schemes.FeatureColour;
  76 import jalview.schemes.ResidueColourScheme;
  77 import jalview.schemes.ResidueProperties;
  78 import jalview.schemes.UserColourScheme;
  79 import jalview.structure.StructureSelectionManager;
  80 import jalview.structures.models.AAStructureBindingModel;
  81 import jalview.util.MessageManager;
  82 import jalview.util.Platform;
  83 import jalview.util.StringUtils;
  84 import jalview.util.jarInputStreamProvider;
  85 import jalview.viewmodel.AlignmentViewport;
  86 import jalview.viewmodel.seqfeatures.FeatureRendererSettings;
  87 import jalview.viewmodel.seqfeatures.FeaturesDisplayed;
  88 import jalview.ws.jws2.Jws2Discoverer;
  89 import jalview.ws.jws2.dm.AAConSettings;
  90 import jalview.ws.jws2.jabaws2.Jws2Instance;
  91 import jalview.ws.params.ArgumentI;
  92 import jalview.ws.params.AutoCalcSetting;
  93 import jalview.ws.params.WsParamSetI;
  94
  95 import java.awt.Color;
  96 import java.awt.Rectangle;
  97 import java.io.BufferedReader;
  98 import java.io.DataInputStream;
  99 import java.io.DataOutputStream;
 100 import java.io.File;
 101 import java.io.FileInputStream;
 102 import java.io.FileOutputStream;
 103 import java.io.IOException;
 104 import java.io.InputStreamReader;
 105 import java.io.OutputStreamWriter;
 106 import java.io.PrintWriter;
 107 import java.lang.reflect.InvocationTargetException;
 108 import java.net.MalformedURLException;
 109 import java.net.URL;
 110 import java.util.ArrayList;
 111 import java.util.Enumeration;
 112 import java.util.HashMap;
 113 import java.util.HashSet;
 114 import java.util.Hashtable;
 115 import java.util.IdentityHashMap;
 116 import java.util.Iterator;
 117 import java.util.LinkedHashMap;
 118 import java.util.List;
 119 import java.util.Map;
 120 import java.util.Map.Entry;
 121 import java.util.Set;
 122 import java.util.Vector;
 123 import java.util.jar.JarEntry;
 124 import java.util.jar.JarInputStream;
 125 import java.util.jar.JarOutputStream;
 126
 127 import javax.swing.JInternalFrame;
 128 import javax.swing.JOptionPane;
 129 import javax.swing.SwingUtilities;
 130
 131 import org.exolab.castor.xml.Marshaller;
 132 import org.exolab.castor.xml.Unmarshaller;
 133
 134 /**
 135  * Write out the current jalview desktop state as a Jalview XML stream.
 136  *
 137  * Note: the vamsas objects referred to here are primitive versions of the
 138  * VAMSAS project schema elements - they are not the same and most likely never
 139  * will be :)
 140  *
 141  * @author $author$
 142  * @version $Revision: 1.134 $
 143  */
 144 public class Jalview2XML
 145 {
 146   private static final String VIEWER_PREFIX = "viewer_";
 147
 148   private static final String RNA_PREFIX = "rna_";
 149
 150   private static final String UTF_8 = "UTF-8";
 151
 152   // use this with nextCounter() to make unique names for entities
 153   private int counter = 0;
 154
 155   /*
 156    * SequenceI reference -> XML ID string in jalview XML. Populated as XML reps
 157    * of sequence objects are created.
 158    */
 159   IdentityHashMap<SequenceI, String> seqsToIds = null;
 160
 161   /**
 162    * jalview XML Sequence ID to jalview sequence object reference (both dataset
 163    * and alignment sequences. Populated as XML reps of sequence objects are
 164    * created.)
 165    */
 166   Map<String, SequenceI> seqRefIds = null;
 167
 168   Vector<Object[]> frefedSequence = null;
 169
 170   boolean raiseGUI = true; // whether errors are raised in dialog boxes or not
 171
 172   /*
 173    * Map of reconstructed AlignFrame objects that appear to have come from
 174    * SplitFrame objects (have a dna/protein complement view).
 175    */
 176   private Map<Viewport, AlignFrame> splitFrameCandidates = new HashMap<Viewport, AlignFrame>();
 177
 178   /*
 179    * Map from displayed rna structure models to their saved session state jar
 180    * entry names
 181    */
 182   private Map<RnaModel, String> rnaSessions = new HashMap<RnaModel, String>();
 183
 184   /**
 185    * create/return unique hash string for sq
 186    *
 187    * @param sq
 188    * @return new or existing unique string for sq
 189    */
 190   String seqHash(SequenceI sq)
 191   {
 192     if (seqsToIds == null)
 193     {
 194       initSeqRefs();
 195     }
 196     if (seqsToIds.containsKey(sq))
 197     {
 198       return seqsToIds.get(sq);
 199     }
 200     else
 201     {
 202       // create sequential key
 203       String key = "sq" + (seqsToIds.size() + 1);
 204       key = makeHashCode(sq, key); // check we don't have an external reference
 205       // for it already.
 206       seqsToIds.put(sq, key);
 207       return key;
 208     }
 209   }
 210
 211   void clearSeqRefs()
 212   {
 213     if (_cleartables)
 214     {
 215       if (seqRefIds != null)
 216       {
 217         seqRefIds.clear();
 218       }
 219       if (seqsToIds != null)
 220       {
 221         seqsToIds.clear();
 222       }
 223       // seqRefIds = null;
 224       // seqsToIds = null;
 225     }
 226     else
 227     {
 228       // do nothing
 229       warn("clearSeqRefs called when _cleartables was not set. Doing nothing.");
 230       // seqRefIds = new Hashtable();
 231       // seqsToIds = new IdentityHashMap();
 232     }
 233   }
 234
 235   void initSeqRefs()
 236   {
 237     if (seqsToIds == null)
 238     {
 239       seqsToIds = new IdentityHashMap<SequenceI, String>();
 240     }
 241     if (seqRefIds == null)
 242     {
 243       seqRefIds = new HashMap<String, SequenceI>();
 244     }
 245   }
 246
 247   public Jalview2XML()
 248   {
 249   }
 250
 251   public Jalview2XML(boolean raiseGUI)
 252   {
 253     this.raiseGUI = raiseGUI;
 254   }
 255
 256   public void resolveFrefedSequences()
 257   {
 258     if (frefedSequence.size() > 0)
 259     {
 260       int r = 0, rSize = frefedSequence.size();
 261       while (r < rSize)
 262       {
 263         Object[] ref = frefedSequence.elementAt(r);
 264         if (ref != null)
 265         {
 266           String sref = (String) ref[0];
 267           if (seqRefIds.containsKey(sref))
 268           {
 269             if (ref[1] instanceof jalview.datamodel.Mapping)
 270             {
 271               SequenceI seq = seqRefIds.get(sref);
 272               while (seq.getDatasetSequence() != null)
 273               {
 274                 seq = seq.getDatasetSequence();
 275               }
 276               ((jalview.datamodel.Mapping) ref[1]).setTo(seq);
 277             }
 278             else
 279             {
 280               if (ref[1] instanceof jalview.datamodel.AlignedCodonFrame)
 281               {
 282                 SequenceI seq = seqRefIds.get(sref);
 283                 while (seq.getDatasetSequence() != null)
 284                 {
 285                   seq = seq.getDatasetSequence();
 286                 }
 287                 if (ref[2] != null
 288                         && ref[2] instanceof jalview.datamodel.Mapping)
 289                 {
 290                   jalview.datamodel.Mapping mp = (jalview.datamodel.Mapping) ref[2];
 291                   ((jalview.datamodel.AlignedCodonFrame) ref[1]).addMap(
 292                           seq, mp.getTo(), mp.getMap());
 293                 }
 294                 else
 295                 {
 296                   System.err
 297                           .println("IMPLEMENTATION ERROR: Unimplemented forward sequence references for AlcodonFrames involving "
 298                                   + ref[2].getClass() + " type objects.");
 299                 }
 300               }
 301               else
 302               {
 303                 System.err
 304                         .println("IMPLEMENTATION ERROR: Unimplemented forward sequence references for "
 305                                 + ref[1].getClass() + " type objects.");
 306               }
 307             }
 308             frefedSequence.remove(r);
 309             rSize--;
 310           }
 311           else
 312           {
 313             System.err
 314                     .println("IMPLEMENTATION WARNING: Unresolved forward reference for hash string "
 315                             + ref[0]
 316                             + " with objecttype "
 317                             + ref[1].getClass());
 318             r++;
 319           }
 320         }
 321         else
 322         {
 323           // empty reference
 324           frefedSequence.remove(r);
 325           rSize--;
 326         }
 327       }
 328     }
 329   }
 330
 331   /**
 332    * This maintains a map of viewports, the key being the seqSetId. Important to
 333    * set historyItem and redoList for multiple views
 334    */
 335   Map<String, AlignViewport> viewportsAdded = new HashMap<String, AlignViewport>();
 336
 337   Map<String, AlignmentAnnotation> annotationIds = new HashMap<String, AlignmentAnnotation>();
 338
 339   String uniqueSetSuffix = "";
 340
 341   /**
 342    * List of pdbfiles added to Jar
 343    */
 344   List<String> pdbfiles = null;
 345
 346   // SAVES SEVERAL ALIGNMENT WINDOWS TO SAME JARFILE
 347   public void saveState(File statefile)
 348   {
 349     FileOutputStream fos = null;
 350     try
 351     {
 352       fos = new FileOutputStream(statefile);
 353       JarOutputStream jout = new JarOutputStream(fos);
 354       saveState(jout);
 355
 356     } catch (Exception e)
 357     {
 358       // TODO: inform user of the problem - they need to know if their data was
 359       // not saved !
 360       if (errorMessage == null)
 361       {
 362         errorMessage = "Couldn't write Jalview Archive to output file '"
 363                 + statefile + "' - See console error log for details";
 364       }
 365       else
 366       {
 367         errorMessage += "(output file was '" + statefile + "')";
 368       }
 369       e.printStackTrace();
 370     } finally
 371     {
 372       if (fos != null)
 373       {
 374         try
 375         {
 376           fos.close();
 377         } catch (IOException e)
 378         {
 379           // ignore
 380         }
 381       }
 382     }
 383     reportErrors();
 384   }
 385
 386   /**
 387    * Writes a jalview project archive to the given Jar output stream.
 388    *
 389    * @param jout
 390    */
 391   public void saveState(JarOutputStream jout)
 392   {
 393     AlignFrame[] frames = Desktop.getAlignFrames();
 394
 395     if (frames == null)
 396     {
 397       return;
 398     }
 399
 400     Hashtable<String, AlignFrame> dsses = new Hashtable<String, AlignFrame>();
 401
 402     /*
 403      * ensure cached data is clear before starting
 404      */
 405     // todo tidy up seqRefIds, seqsToIds initialisation / reset
 406     rnaSessions.clear();
 407     splitFrameCandidates.clear();
 408
 409     try
 410     {
 411
 412       // NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS
 413       // //////////////////////////////////////////////////
 414
 415       List<String> shortNames = new ArrayList<String>();
 416       List<String> viewIds = new ArrayList<String>();
 417
 418       // REVERSE ORDER
 419       for (int i = frames.length - 1; i > -1; i--)
 420       {
 421         AlignFrame af = frames[i];
 422         // skip ?
 423         if (skipList != null
 424                 && skipList
 425                         .containsKey(af.getViewport().getSequenceSetId()))
 426         {
 427           continue;
 428         }
 429
 430         String shortName = makeFilename(af, shortNames);
 431
 432         int ap, apSize = af.alignPanels.size();
 433
 434         for (ap = 0; ap < apSize; ap++)
 435         {
 436           AlignmentPanel apanel = af.alignPanels.get(ap);
 437           String fileName = apSize == 1 ? shortName : ap + shortName;
 438           if (!fileName.endsWith(".xml"))
 439           {
 440             fileName = fileName + ".xml";
 441           }
 442
 443           saveState(apanel, fileName, jout, viewIds);
 444
 445           String dssid = getDatasetIdRef(af.getViewport().getAlignment()
 446                   .getDataset());
 447           if (!dsses.containsKey(dssid))
 448           {
 449             dsses.put(dssid, af);
 450           }
 451         }
 452       }
 453
 454       writeDatasetFor(dsses, "" + jout.hashCode() + " " + uniqueSetSuffix,
 455               jout);
 456
 457       try
 458       {
 459         jout.flush();
 460       } catch (Exception foo)
 461       {
 462       }
 463       ;
 464       jout.close();
 465     } catch (Exception ex)
 466     {
 467       // TODO: inform user of the problem - they need to know if their data was
 468       // not saved !
 469       if (errorMessage == null)
 470       {
 471         errorMessage = "Couldn't write Jalview Archive - see error output for details";
 472       }
 473       ex.printStackTrace();
 474     }
 475   }
 476
 477   /**
 478    * Generates a distinct file name, based on the title of the AlignFrame, by
 479    * appending _n for increasing n until an unused name is generated. The new
 480    * name (without its extension) is added to the list.
 481    *
 482    * @param af
 483    * @param namesUsed
 484    * @return the generated name, with .xml extension
 485    */
 486   protected String makeFilename(AlignFrame af, List<String> namesUsed)
 487   {
 488     String shortName = af.getTitle();
 489
 490     if (shortName.indexOf(File.separatorChar) > -1)
 491     {
 492       shortName = shortName.substring(shortName
 493               .lastIndexOf(File.separatorChar) + 1);
 494     }
 495
 496     int count = 1;
 497
 498     while (namesUsed.contains(shortName))
 499     {
 500       if (shortName.endsWith("_" + (count - 1)))
 501       {
 502         shortName = shortName.substring(0, shortName.lastIndexOf("_"));
 503       }
 504
 505       shortName = shortName.concat("_" + count);
 506       count++;
 507     }
 508
 509     namesUsed.add(shortName);
 510
 511     if (!shortName.endsWith(".xml"))
 512     {
 513       shortName = shortName + ".xml";
 514     }
 515     return shortName;
 516   }
 517
 518   // USE THIS METHOD TO SAVE A SINGLE ALIGNMENT WINDOW
 519   public boolean saveAlignment(AlignFrame af, String jarFile,
 520           String fileName)
 521   {
 522     try
 523     {
 524       int ap = 0;
 525       int apSize = af.alignPanels.size();
 526       FileOutputStream fos = new FileOutputStream(jarFile);
 527       JarOutputStream jout = new JarOutputStream(fos);
 528       Hashtable<String, AlignFrame> dsses = new Hashtable<String, AlignFrame>();
 529       List<String> viewIds = new ArrayList<String>();
 530
 531       for (AlignmentPanel apanel : af.alignPanels)
 532       {
 533         String jfileName = apSize == 1 ? fileName : fileName + ap;
 534         ap++;
 535         if (!jfileName.endsWith(".xml"))
 536         {
 537           jfileName = jfileName + ".xml";
 538         }
 539         saveState(apanel, jfileName, jout, viewIds);
 540         String dssid = getDatasetIdRef(af.getViewport().getAlignment()
 541                 .getDataset());
 542         if (!dsses.containsKey(dssid))
 543         {
 544           dsses.put(dssid, af);
 545         }
 546       }
 547       writeDatasetFor(dsses, fileName, jout);
 548       try
 549       {
 550         jout.flush();
 551       } catch (Exception foo)
 552       {
 553       }
 554       ;
 555       jout.close();
 556       return true;
 557     } catch (Exception ex)
 558     {
 559       errorMessage = "Couldn't Write alignment view to Jalview Archive - see error output for details";
 560       ex.printStackTrace();
 561       return false;
 562     }
 563   }
 564
 565   private void writeDatasetFor(Hashtable<String, AlignFrame> dsses,
 566           String fileName, JarOutputStream jout)
 567   {
 568
 569     for (String dssids : dsses.keySet())
 570     {
 571       AlignFrame _af = dsses.get(dssids);
 572       String jfileName = fileName + " Dataset for " + _af.getTitle();
 573       if (!jfileName.endsWith(".xml"))
 574       {
 575         jfileName = jfileName + ".xml";
 576       }
 577       saveState(_af.alignPanel, jfileName, true, jout, null);
 578     }
 579   }
 580
 581   /**
 582    * create a JalviewModel from an alignment view and marshall it to a
 583    * JarOutputStream
 584    *
 585    * @param ap
 586    *          panel to create jalview model for
 587    * @param fileName
 588    *          name of alignment panel written to output stream
 589    * @param jout
 590    *          jar output stream
 591    * @param viewIds
 592    * @param out
 593    *          jar entry name
 594    */
 595   public JalviewModel saveState(AlignmentPanel ap, String fileName,
 596           JarOutputStream jout, List<String> viewIds)
 597   {
 598     return saveState(ap, fileName, false, jout, viewIds);
 599   }
 600
 601   /**
 602    * create a JalviewModel from an alignment view and marshall it to a
 603    * JarOutputStream
 604    *
 605    * @param ap
 606    *          panel to create jalview model for
 607    * @param fileName
 608    *          name of alignment panel written to output stream
 609    * @param storeDS
 610    *          when true, only write the dataset for the alignment, not the data
 611    *          associated with the view.
 612    * @param jout
 613    *          jar output stream
 614    * @param out
 615    *          jar entry name
 616    */
 617   public JalviewModel saveState(AlignmentPanel ap, String fileName,
 618           boolean storeDS, JarOutputStream jout, List<String> viewIds)
 619   {
 620     if (viewIds == null)
 621     {
 622       viewIds = new ArrayList<String>();
 623     }
 624
 625     initSeqRefs();
 626
 627     List<UserColourScheme> userColours = new ArrayList<UserColourScheme>();
 628
 629     AlignViewport av = ap.av;
 630
 631     JalviewModel object = new JalviewModel();
 632     object.setVamsasModel(new jalview.schemabinding.version2.VamsasModel());
 633
 634     object.setCreationDate(new java.util.Date(System.currentTimeMillis()));
 635     object.setVersion(jalview.bin.Cache.getDefault("VERSION",
 636             "Development Build"));
 637
 638     /**
 639      * rjal is full height alignment, jal is actual alignment with full metadata
 640      * but excludes hidden sequences.
 641      */
 642     jalview.datamodel.AlignmentI rjal = av.getAlignment(), jal = rjal;
 643
 644     if (av.hasHiddenRows())
 645     {
 646       rjal = jal.getHiddenSequences().getFullAlignment();
 647     }
 648
 649     SequenceSet vamsasSet = new SequenceSet();
 650     Sequence vamsasSeq;
 651     JalviewModelSequence jms = new JalviewModelSequence();
 652
 653     vamsasSet.setGapChar(jal.getGapCharacter() + "");
 654
 655     if (jal.getDataset() != null)
 656     {
 657       // dataset id is the dataset's hashcode
 658       vamsasSet.setDatasetId(getDatasetIdRef(jal.getDataset()));
 659       if (storeDS)
 660       {
 661         // switch jal and the dataset
 662         jal = jal.getDataset();
 663         rjal = jal;
 664       }
 665     }
 666     if (jal.getProperties() != null)
 667     {
 668       Enumeration en = jal.getProperties().keys();
 669       while (en.hasMoreElements())
 670       {
 671         String key = en.nextElement().toString();
 672         SequenceSetProperties ssp = new SequenceSetProperties();
 673         ssp.setKey(key);
 674         ssp.setValue(jal.getProperties().get(key).toString());
 675         vamsasSet.addSequenceSetProperties(ssp);
 676       }
 677     }
 678
 679     JSeq jseq;
 680     Set<String> calcIdSet = new HashSet<String>();
 681
 682     // SAVE SEQUENCES
 683     for (final SequenceI jds : rjal.getSequences())
 684     {
 685       final SequenceI jdatasq = jds.getDatasetSequence() == null ? jds
 686               : jds.getDatasetSequence();
 687       String id = seqHash(jds);
 688
 689       if (seqRefIds.get(id) != null)
 690       {
 691         // This happens for two reasons: 1. multiple views are being serialised.
 692         // 2. the hashCode has collided with another sequence's code. This DOES
 693         // HAPPEN! (PF00072.15.stk does this)
 694         // JBPNote: Uncomment to debug writing out of files that do not read
 695         // back in due to ArrayOutOfBoundExceptions.
 696         // System.err.println("vamsasSeq backref: "+id+"");
 697         // System.err.println(jds.getName()+"
 698         // "+jds.getStart()+"-"+jds.getEnd()+" "+jds.getSequenceAsString());
 699         // System.err.println("Hashcode: "+seqHash(jds));
 700         // SequenceI rsq = (SequenceI) seqRefIds.get(id + "");
 701         // System.err.println(rsq.getName()+"
 702         // "+rsq.getStart()+"-"+rsq.getEnd()+" "+rsq.getSequenceAsString());
 703         // System.err.println("Hashcode: "+seqHash(rsq));
 704       }
 705       else
 706       {
 707         vamsasSeq = createVamsasSequence(id, jds);
 708         vamsasSet.addSequence(vamsasSeq);
 709         seqRefIds.put(id, jds);
 710       }
 711
 712       jseq = new JSeq();
 713       jseq.setStart(jds.getStart());
 714       jseq.setEnd(jds.getEnd());
 715       jseq.setColour(av.getSequenceColour(jds).getRGB());
 716
 717       jseq.setId(id); // jseq id should be a string not a number
 718       if (!storeDS)
 719       {
 720         // Store any sequences this sequence represents
 721         if (av.hasHiddenRows())
 722         {
 723           // use rjal, contains the full height alignment
 724           jseq.setHidden(av.getAlignment().getHiddenSequences()
 725                   .isHidden(jds));
 726
 727           if (av.isHiddenRepSequence(jds))
 728           {
 729             jalview.datamodel.SequenceI[] reps = av
 730                     .getRepresentedSequences(jds)
 731                     .getSequencesInOrder(rjal);
 732
 733             for (int h = 0; h < reps.length; h++)
 734             {
 735               if (reps[h] != jds)
 736               {
 737                 jseq.addHiddenSequences(rjal.findIndex(reps[h]));
 738               }
 739             }
 740           }
 741         }
 742         // mark sequence as reference - if it is the reference for this view
 743         if (jal.hasSeqrep())
 744         {
 745           jseq.setViewreference(jds == jal.getSeqrep());
 746         }
 747       }
 748
 749       // TODO: omit sequence features from each alignment view's XML dump if we
 750       // are storing dataset
 751       if (jds.getSequenceFeatures() != null)
 752       {
 753         jalview.datamodel.SequenceFeature[] sf = jds.getSequenceFeatures();
 754         int index = 0;
 755         while (index < sf.length)
 756         {
 757           Features features = new Features();
 758
 759           features.setBegin(sf[index].getBegin());
 760           features.setEnd(sf[index].getEnd());
 761           features.setDescription(sf[index].getDescription());
 762           features.setType(sf[index].getType());
 763           features.setFeatureGroup(sf[index].getFeatureGroup());
 764           features.setScore(sf[index].getScore());
 765           if (sf[index].links != null)
 766           {
 767             for (int l = 0; l < sf[index].links.size(); l++)
 768             {
 769               OtherData keyValue = new OtherData();
 770               keyValue.setKey("LINK_" + l);
 771               keyValue.setValue(sf[index].links.elementAt(l).toString());
 772               features.addOtherData(keyValue);
 773             }
 774           }
 775           if (sf[index].otherDetails != null)
 776           {
 777             String key;
 778             Iterator<String> keys = sf[index].otherDetails.keySet()
 779                     .iterator();
 780             while (keys.hasNext())
 781             {
 782               key = keys.next();
 783               OtherData keyValue = new OtherData();
 784               keyValue.setKey(key);
 785               keyValue.setValue(sf[index].otherDetails.get(key).toString());
 786               features.addOtherData(keyValue);
 787             }
 788           }
 789
 790           jseq.addFeatures(features);
 791           index++;
 792         }
 793       }
 794
 795       if (jdatasq.getAllPDBEntries() != null)
 796       {
 797         Enumeration en = jdatasq.getAllPDBEntries().elements();
 798         while (en.hasMoreElements())
 799         {
 800           Pdbids pdb = new Pdbids();
 801           jalview.datamodel.PDBEntry entry = (jalview.datamodel.PDBEntry) en
 802                   .nextElement();
 803
 804           String pdbId = entry.getId();
 805           pdb.setId(pdbId);
 806           pdb.setType(entry.getType());
 807
 808           /*
 809            * Store any structure views associated with this sequence. This
 810            * section copes with duplicate entries in the project, so a dataset
 811            * only view *should* be coped with sensibly.
 812            */
 813           // This must have been loaded, is it still visible?
 814           JInternalFrame[] frames = Desktop.desktop.getAllFrames();
 815           String matchedFile = null;
 816           for (int f = frames.length - 1; f > -1; f--)
 817           {
 818             if (frames[f] instanceof StructureViewerBase)
 819             {
 820               StructureViewerBase viewFrame = (StructureViewerBase) frames[f];
 821               matchedFile = saveStructureState(ap, jds, pdb, entry,
 822                       viewIds, matchedFile, viewFrame);
 823               /*
 824                * Only store each structure viewer's state once in the project
 825                * jar. First time through only (storeDS==false)
 826                */
 827               String viewId = viewFrame.getViewId();
 828               if (!storeDS && !viewIds.contains(viewId))
 829               {
 830                 viewIds.add(viewId);
 831                 try
 832                 {
 833                   String viewerState = viewFrame.getStateInfo();
 834                   writeJarEntry(jout, getViewerJarEntryName(viewId),
 835                           viewerState.getBytes());
 836                 } catch (IOException e)
 837                 {
 838                   System.err.println("Error saving viewer state: "
 839                           + e.getMessage());
 840                 }
 841               }
 842             }
 843           }
 844
 845           if (matchedFile != null || entry.getFile() != null)
 846           {
 847             if (entry.getFile() != null)
 848             {
 849               // use entry's file
 850               matchedFile = entry.getFile();
 851             }
 852             pdb.setFile(matchedFile); // entry.getFile());
 853             if (pdbfiles == null)
 854             {
 855               pdbfiles = new ArrayList<String>();
 856             }
 857
 858             if (!pdbfiles.contains(pdbId))
 859             {
 860               pdbfiles.add(pdbId);
 861               copyFileToJar(jout, matchedFile, pdbId);
 862             }
 863           }
 864
 865           if (entry.getProperty() != null && !entry.getProperty().isEmpty())
 866           {
 867             PdbentryItem item = new PdbentryItem();
 868             Hashtable properties = entry.getProperty();
 869             Enumeration en2 = properties.keys();
 870             while (en2.hasMoreElements())
 871             {
 872               Property prop = new Property();
 873               String key = en2.nextElement().toString();
 874               prop.setName(key);
 875               prop.setValue(properties.get(key).toString());
 876               item.addProperty(prop);
 877             }
 878             pdb.addPdbentryItem(item);
 879           }
 880
 881           jseq.addPdbids(pdb);
 882         }
 883       }
 884
 885       saveRnaViewers(jout, jseq, jds, viewIds, ap, storeDS);
 886
 887       jms.addJSeq(jseq);
 888     }
 889
 890     if (!storeDS && av.hasHiddenRows())
 891     {
 892       jal = av.getAlignment();
 893     }
 894     // SAVE MAPPINGS
 895     if (jal.getCodonFrames() != null)
 896     {
 897       List<AlignedCodonFrame> jac = jal.getCodonFrames();
 898       for (AlignedCodonFrame acf : jac)
 899       {
 900         AlcodonFrame alc = new AlcodonFrame();
 901         if (acf.getProtMappings() != null
 902                 && acf.getProtMappings().length > 0)
 903         {
 904           boolean hasMap = false;
 905           SequenceI[] dnas = acf.getdnaSeqs();
 906           jalview.datamodel.Mapping[] pmaps = acf.getProtMappings();
 907           for (int m = 0; m < pmaps.length; m++)
 908           {
 909             AlcodMap alcmap = new AlcodMap();
 910             alcmap.setDnasq(seqHash(dnas[m]));
 911             alcmap.setMapping(createVamsasMapping(pmaps[m], dnas[m], null,
 912                     false));
 913             alc.addAlcodMap(alcmap);
 914             hasMap = true;
 915           }
 916           if (hasMap)
 917           {
 918             vamsasSet.addAlcodonFrame(alc);
 919           }
 920         }
 921         // TODO: delete this ? dead code from 2.8.3->2.9 ?
 922         // {
 923         // AlcodonFrame alc = new AlcodonFrame();
 924         // vamsasSet.addAlcodonFrame(alc);
 925         // for (int p = 0; p < acf.aaWidth; p++)
 926         // {
 927         // Alcodon cmap = new Alcodon();
 928         // if (acf.codons[p] != null)
 929         // {
 930         // // Null codons indicate a gapped column in the translated peptide
 931         // // alignment.
 932         // cmap.setPos1(acf.codons[p][0]);
 933         // cmap.setPos2(acf.codons[p][1]);
 934         // cmap.setPos3(acf.codons[p][2]);
 935         // }
 936         // alc.addAlcodon(cmap);
 937         // }
 938         // if (acf.getProtMappings() != null
 939         // && acf.getProtMappings().length > 0)
 940         // {
 941         // SequenceI[] dnas = acf.getdnaSeqs();
 942         // jalview.datamodel.Mapping[] pmaps = acf.getProtMappings();
 943         // for (int m = 0; m < pmaps.length; m++)
 944         // {
 945         // AlcodMap alcmap = new AlcodMap();
 946         // alcmap.setDnasq(seqHash(dnas[m]));
 947         // alcmap.setMapping(createVamsasMapping(pmaps[m], dnas[m], null,
 948         // false));
 949         // alc.addAlcodMap(alcmap);
 950         // }
 951         // }
 952       }
 953     }
 954
 955     // SAVE TREES
 956     // /////////////////////////////////
 957     if (!storeDS && av.currentTree != null)
 958     {
 959       // FIND ANY ASSOCIATED TREES
 960       // NOT IMPLEMENTED FOR HEADLESS STATE AT PRESENT
 961       if (Desktop.desktop != null)
 962       {
 963         JInternalFrame[] frames = Desktop.desktop.getAllFrames();
 964
 965         for (int t = 0; t < frames.length; t++)
 966         {
 967           if (frames[t] instanceof TreePanel)
 968           {
 969             TreePanel tp = (TreePanel) frames[t];
 970
 971             if (tp.treeCanvas.av.getAlignment() == jal)
 972             {
 973               Tree tree = new Tree();
 974               tree.setTitle(tp.getTitle());
 975               tree.setCurrentTree((av.currentTree == tp.getTree()));
 976               tree.setNewick(tp.getTree().toString());
 977               tree.setThreshold(tp.treeCanvas.threshold);
 978
 979               tree.setFitToWindow(tp.fitToWindow.getState());
 980               tree.setFontName(tp.getTreeFont().getName());
 981               tree.setFontSize(tp.getTreeFont().getSize());
 982               tree.setFontStyle(tp.getTreeFont().getStyle());
 983               tree.setMarkUnlinked(tp.placeholdersMenu.getState());
 984
 985               tree.setShowBootstrap(tp.bootstrapMenu.getState());
 986               tree.setShowDistances(tp.distanceMenu.getState());
 987
 988               tree.setHeight(tp.getHeight());
 989               tree.setWidth(tp.getWidth());
 990               tree.setXpos(tp.getX());
 991               tree.setYpos(tp.getY());
 992               tree.setId(makeHashCode(tp, null));
 993               jms.addTree(tree);
 994             }
 995           }
 996         }
 997       }
 998     }
 999
1000     // SAVE ANNOTATIONS
1001     /**
1002      * store forward refs from an annotationRow to any groups
1003      */
1004     IdentityHashMap<SequenceGroup, String> groupRefs = new IdentityHashMap<SequenceGroup, String>();
1005     if (storeDS)
1006     {
1007       for (SequenceI sq : jal.getSequences())
1008       {
1009         // Store annotation on dataset sequences only
1010         AlignmentAnnotation[] aa = sq.getAnnotation();
1011         if (aa != null && aa.length > 0)
1012         {
1013           storeAlignmentAnnotation(aa, groupRefs, av, calcIdSet, storeDS,
1014                   vamsasSet);
1015         }
1016       }
1017     }
1018     else
1019     {
1020       if (jal.getAlignmentAnnotation() != null)
1021       {
1022         // Store the annotation shown on the alignment.
1023         AlignmentAnnotation[] aa = jal.getAlignmentAnnotation();
1024         storeAlignmentAnnotation(aa, groupRefs, av, calcIdSet, storeDS,
1025                 vamsasSet);
1026       }
1027     }
1028     // SAVE GROUPS
1029     if (jal.getGroups() != null)
1030     {
1031       JGroup[] groups = new JGroup[jal.getGroups().size()];
1032       int i = -1;
1033       for (jalview.datamodel.SequenceGroup sg : jal.getGroups())
1034       {
1035         JGroup jGroup = new JGroup();
1036         groups[++i] = jGroup;
1037
1038         jGroup.setStart(sg.getStartRes());
1039         jGroup.setEnd(sg.getEndRes());
1040         jGroup.setName(sg.getName());
1041         if (groupRefs.containsKey(sg))
1042         {
1043           // group has references so set its ID field
1044           jGroup.setId(groupRefs.get(sg));
1045         }
1046         if (sg.cs != null)
1047         {
1048           if (sg.cs.conservationApplied())
1049           {
1050             jGroup.setConsThreshold(sg.cs.getConservationInc());
1051
1052             if (sg.cs instanceof jalview.schemes.UserColourScheme)
1053             {
1054               jGroup.setColour(setUserColourScheme(sg.cs, userColours, jms));
1055             }
1056             else
1057             {
1058               jGroup.setColour(ColourSchemeProperty.getColourName(sg.cs));
1059             }
1060           }
1061           else if (sg.cs instanceof jalview.schemes.AnnotationColourGradient)
1062           {
1063             jGroup.setColour("AnnotationColourGradient");
1064             jGroup.setAnnotationColours(constructAnnotationColours(
1065                     (jalview.schemes.AnnotationColourGradient) sg.cs,
1066                     userColours, jms));
1067           }
1068           else if (sg.cs instanceof jalview.schemes.UserColourScheme)
1069           {
1070             jGroup.setColour(setUserColourScheme(sg.cs, userColours, jms));
1071           }
1072           else
1073           {
1074             jGroup.setColour(ColourSchemeProperty.getColourName(sg.cs));
1075           }
1076
1077           jGroup.setPidThreshold(sg.cs.getThreshold());
1078         }
1079
1080         jGroup.setOutlineColour(sg.getOutlineColour().getRGB());
1081         jGroup.setDisplayBoxes(sg.getDisplayBoxes());
1082         jGroup.setDisplayText(sg.getDisplayText());
1083         jGroup.setColourText(sg.getColourText());
1084         jGroup.setTextCol1(sg.textColour.getRGB());
1085         jGroup.setTextCol2(sg.textColour2.getRGB());
1086         jGroup.setTextColThreshold(sg.thresholdTextColour);
1087         jGroup.setShowUnconserved(sg.getShowNonconserved());
1088         jGroup.setIgnoreGapsinConsensus(sg.getIgnoreGapsConsensus());
1089         jGroup.setShowConsensusHistogram(sg.isShowConsensusHistogram());
1090         jGroup.setShowSequenceLogo(sg.isShowSequenceLogo());
1091         jGroup.setNormaliseSequenceLogo(sg.isNormaliseSequenceLogo());
1092         for (SequenceI seq : sg.getSequences())
1093         {
1094           jGroup.addSeq(seqHash(seq));
1095         }
1096       }
1097
1098       jms.setJGroup(groups);
1099     }
1100     if (!storeDS)
1101     {
1102       // /////////SAVE VIEWPORT
1103       Viewport view = new Viewport();
1104       view.setTitle(ap.alignFrame.getTitle());
1105       view.setSequenceSetId(makeHashCode(av.getSequenceSetId(),
1106               av.getSequenceSetId()));
1107       view.setId(av.getViewId());
1108       if (av.getCodingComplement() != null)
1109       {
1110         view.setComplementId(av.getCodingComplement().getViewId());
1111       }
1112       view.setViewName(av.viewName);
1113       view.setGatheredViews(av.isGatherViewsHere());
1114
1115       Rectangle size = ap.av.getExplodedGeometry();
1116       Rectangle position = size;
1117       if (size == null)
1118       {
1119         size = ap.alignFrame.getBounds();
1120         if (av.getCodingComplement() != null)
1121         {
1122           position = ((SplitFrame) ap.alignFrame.getSplitViewContainer())
1123                   .getBounds();
1124         }
1125         else
1126         {
1127           position = size;
1128         }
1129       }
1130       view.setXpos(position.x);
1131       view.setYpos(position.y);
1132
1133       view.setWidth(size.width);
1134       view.setHeight(size.height);
1135
1136       view.setStartRes(av.startRes);
1137       view.setStartSeq(av.startSeq);
1138
1139       if (av.getGlobalColourScheme() instanceof jalview.schemes.UserColourScheme)
1140       {
1141         view.setBgColour(setUserColourScheme(av.getGlobalColourScheme(),
1142                 userColours, jms));
1143       }
1144       else if (av.getGlobalColourScheme() instanceof jalview.schemes.AnnotationColourGradient)
1145       {
1146         AnnotationColours ac = constructAnnotationColours(
1147                 (jalview.schemes.AnnotationColourGradient) av
1148                         .getGlobalColourScheme(),
1149                 userColours, jms);
1150
1151         view.setAnnotationColours(ac);
1152         view.setBgColour("AnnotationColourGradient");
1153       }
1154       else
1155       {
1156         view.setBgColour(ColourSchemeProperty.getColourName(av
1157                 .getGlobalColourScheme()));
1158       }
1159
1160       ColourSchemeI cs = av.getGlobalColourScheme();
1161
1162       if (cs != null)
1163       {
1164         if (cs.conservationApplied())
1165         {
1166           view.setConsThreshold(cs.getConservationInc());
1167           if (cs instanceof jalview.schemes.UserColourScheme)
1168           {
1169             view.setBgColour(setUserColourScheme(cs, userColours, jms));
1170           }
1171         }
1172
1173         if (cs instanceof ResidueColourScheme)
1174         {
1175           view.setPidThreshold(cs.getThreshold());
1176         }
1177       }
1178
1179       view.setConservationSelected(av.getConservationSelected());
1180       view.setPidSelected(av.getAbovePIDThreshold());
1181       view.setFontName(av.font.getName());
1182       view.setFontSize(av.font.getSize());
1183       view.setFontStyle(av.font.getStyle());
1184       view.setScaleProteinAsCdna(av.getViewStyle().isScaleProteinAsCdna());
1185       view.setRenderGaps(av.isRenderGaps());
1186       view.setShowAnnotation(av.isShowAnnotation());
1187       view.setShowBoxes(av.getShowBoxes());
1188       view.setShowColourText(av.getColourText());
1189       view.setShowFullId(av.getShowJVSuffix());
1190       view.setRightAlignIds(av.isRightAlignIds());
1191       view.setShowSequenceFeatures(av.isShowSequenceFeatures());
1192       view.setShowText(av.getShowText());
1193       view.setShowUnconserved(av.getShowUnconserved());
1194       view.setWrapAlignment(av.getWrapAlignment());
1195       view.setTextCol1(av.getTextColour().getRGB());
1196       view.setTextCol2(av.getTextColour2().getRGB());
1197       view.setTextColThreshold(av.getThresholdTextColour());
1198       view.setShowConsensusHistogram(av.isShowConsensusHistogram());
1199       view.setShowSequenceLogo(av.isShowSequenceLogo());
1200       view.setNormaliseSequenceLogo(av.isNormaliseSequenceLogo());
1201       view.setShowGroupConsensus(av.isShowGroupConsensus());
1202       view.setShowGroupConservation(av.isShowGroupConservation());
1203       view.setShowNPfeatureTooltip(av.isShowNPFeats());
1204       view.setShowDbRefTooltip(av.isShowDBRefs());
1205       view.setFollowHighlight(av.isFollowHighlight());
1206       view.setFollowSelection(av.followSelection);
1207       view.setIgnoreGapsinConsensus(av.isIgnoreGapsConsensus());
1208       if (av.getFeaturesDisplayed() != null)
1209       {
1210         jalview.schemabinding.version2.FeatureSettings fs = new jalview.schemabinding.version2.FeatureSettings();
1211
1212         String[] renderOrder = ap.getSeqPanel().seqCanvas
1213                 .getFeatureRenderer().getRenderOrder()
1214                 .toArray(new String[0]);
1215
1216         Vector<String> settingsAdded = new Vector<String>();
1217         if (renderOrder != null)
1218         {
1219           for (String featureType : renderOrder)
1220           {
1221             FeatureColourI fcol = ap.getSeqPanel().seqCanvas
1222                     .getFeatureRenderer()
1223                     .getFeatureStyle(featureType);
1224             Setting setting = new Setting();
1225             setting.setType(featureType);
1226             if (!fcol.isSimpleColour())
1227             {
1228               setting.setColour(fcol.getMaxColour().getRGB());
1229               setting.setMincolour(fcol.getMinColour().getRGB());
1230               setting.setMin(fcol.getMin());
1231               setting.setMax(fcol.getMax());
1232               setting.setColourByLabel(fcol.isColourByLabel());
1233               setting.setAutoScale(fcol.isAutoScaled());
1234               setting.setThreshold(fcol.getThreshold());
1235               // -1 = No threshold, 0 = Below, 1 = Above
1236               setting.setThreshstate(fcol.isAboveThreshold() ? 1
1237                       : (fcol.isBelowThreshold() ? 0 : -1));
1238             }
1239             else
1240             {
1241               setting.setColour(fcol.getColour().getRGB());
1242             }
1243
1244             setting.setDisplay(av.getFeaturesDisplayed().isVisible(
1245                     featureType));
1246             float rorder = ap.getSeqPanel().seqCanvas.getFeatureRenderer()
1247                     .getOrder(featureType);
1248             if (rorder > -1)
1249             {
1250               setting.setOrder(rorder);
1251             }
1252             fs.addSetting(setting);
1253             settingsAdded.addElement(featureType);
1254           }
1255         }
1256
1257         // is groups actually supposed to be a map here ?
1258         Iterator<String> en = ap.getSeqPanel().seqCanvas
1259                 .getFeatureRenderer()
1260                 .getFeatureGroups().iterator();
1261         Vector<String> groupsAdded = new Vector<String>();
1262         while (en.hasNext())
1263         {
1264           String grp = en.next();
1265           if (groupsAdded.contains(grp))
1266           {
1267             continue;
1268           }
1269           Group g = new Group();
1270           g.setName(grp);
1271           g.setDisplay(((Boolean) ap.getSeqPanel().seqCanvas
1272                   .getFeatureRenderer().checkGroupVisibility(grp, false))
1273                   .booleanValue());
1274           fs.addGroup(g);
1275           groupsAdded.addElement(grp);
1276         }
1277         jms.setFeatureSettings(fs);
1278       }
1279
1280       if (av.hasHiddenColumns())
1281       {
1282         if (av.getColumnSelection() == null
1283                 || av.getColumnSelection().getHiddenColumns() == null)
1284         {
1285           warn("REPORT BUG: avoided null columnselection bug (DMAM reported). Please contact Jim about this.");
1286         }
1287         else
1288         {
1289           for (int c = 0; c < av.getColumnSelection().getHiddenColumns()
1290                   .size(); c++)
1291           {
1292             int[] region = av.getColumnSelection().getHiddenColumns()
1293                     .get(c);
1294             HiddenColumns hc = new HiddenColumns();
1295             hc.setStart(region[0]);
1296             hc.setEnd(region[1]);
1297             view.addHiddenColumns(hc);
1298           }
1299         }
1300       }
1301       if (calcIdSet.size() > 0)
1302       {
1303         for (String calcId : calcIdSet)
1304         {
1305           if (calcId.trim().length() > 0)
1306           {
1307             CalcIdParam cidp = createCalcIdParam(calcId, av);
1308             // Some calcIds have no parameters.
1309             if (cidp != null)
1310             {
1311               view.addCalcIdParam(cidp);
1312             }
1313           }
1314         }
1315       }
1316
1317       jms.addViewport(view);
1318     }
1319     object.setJalviewModelSequence(jms);
1320     object.getVamsasModel().addSequenceSet(vamsasSet);
1321
1322     if (jout != null && fileName != null)
1323     {
1324       // We may not want to write the object to disk,
1325       // eg we can copy the alignViewport to a new view object
1326       // using save and then load
1327       try
1328       {
1329         System.out.println("Writing jar entry " + fileName);
1330         JarEntry entry = new JarEntry(fileName);
1331         jout.putNextEntry(entry);
1332         PrintWriter pout = new PrintWriter(new OutputStreamWriter(jout,
1333                 UTF_8));
1334         Marshaller marshaller = new Marshaller(pout);
1335         marshaller.marshal(object);
1336         pout.flush();
1337         jout.closeEntry();
1338       } catch (Exception ex)
1339       {
1340         // TODO: raise error in GUI if marshalling failed.
1341         ex.printStackTrace();
1342       }
1343     }
1344     return object;
1345   }
1346
1347   /**
1348    * Save any Varna viewers linked to this sequence. Writes an rnaViewer element
1349    * for each viewer, with
1350    * <ul>
1351    * <li>viewer geometry (position, size, split pane divider location)</li>
1352    * <li>index of the selected structure in the viewer (currently shows gapped
1353    * or ungapped)</li>
1354    * <li>the id of the annotation holding RNA secondary structure</li>
1355    * <li>(currently only one SS is shown per viewer, may be more in future)</li>
1356    * </ul>
1357    * Varna viewer state is also written out (in native Varna XML) to separate
1358    * project jar entries. A separate entry is written for each RNA structure
1359    * displayed, with the naming convention
1360    * <ul>
1361    * <li>rna_viewId_sequenceId_annotationId_[gapped|trimmed]</li>
1362    * </ul>
1363    *
1364    * @param jout
1365    * @param jseq
1366    * @param jds
1367    * @param viewIds
1368    * @param ap
1369    * @param storeDataset
1370    */
1371   protected void saveRnaViewers(JarOutputStream jout, JSeq jseq,
1372           final SequenceI jds, List<String> viewIds, AlignmentPanel ap,
1373           boolean storeDataset)
1374   {
1375     if (Desktop.desktop == null)
1376     {
1377       return;
1378     }
1379     JInternalFrame[] frames = Desktop.desktop.getAllFrames();
1380     for (int f = frames.length - 1; f > -1; f--)
1381     {
1382       if (frames[f] instanceof AppVarna)
1383       {
1384         AppVarna varna = (AppVarna) frames[f];
1385         /*
1386          * link the sequence to every viewer that is showing it and is linked to
1387          * its alignment panel
1388          */
1389         if (varna.isListeningFor(jds) && ap == varna.getAlignmentPanel())
1390         {
1391           String viewId = varna.getViewId();
1392           RnaViewer rna = new RnaViewer();
1393           rna.setViewId(viewId);
1394           rna.setTitle(varna.getTitle());
1395           rna.setXpos(varna.getX());
1396           rna.setYpos(varna.getY());
1397           rna.setWidth(varna.getWidth());
1398           rna.setHeight(varna.getHeight());
1399           rna.setDividerLocation(varna.getDividerLocation());
1400           rna.setSelectedRna(varna.getSelectedIndex());
1401           jseq.addRnaViewer(rna);
1402
1403           /*
1404            * Store each Varna panel's state once in the project per sequence.
1405            * First time through only (storeDataset==false)
1406            */
1407           // boolean storeSessions = false;
1408           // String sequenceViewId = viewId + seqsToIds.get(jds);
1409           // if (!storeDataset && !viewIds.contains(sequenceViewId))
1410           // {
1411           // viewIds.add(sequenceViewId);
1412           // storeSessions = true;
1413           // }
1414           for (RnaModel model : varna.getModels())
1415           {
1416             if (model.seq == jds)
1417             {
1418               /*
1419                * VARNA saves each view (sequence or alignment secondary
1420                * structure, gapped or trimmed) as a separate XML file
1421                */
1422               String jarEntryName = rnaSessions.get(model);
1423               if (jarEntryName == null)
1424               {
1425
1426                 String varnaStateFile = varna.getStateInfo(model.rna);
1427                 jarEntryName = RNA_PREFIX + viewId + "_" + nextCounter();
1428                 copyFileToJar(jout, varnaStateFile, jarEntryName);
1429                 rnaSessions.put(model, jarEntryName);
1430               }
1431               SecondaryStructure ss = new SecondaryStructure();
1432               String annotationId = varna.getAnnotation(jds).annotationId;
1433               ss.setAnnotationId(annotationId);
1434               ss.setViewerState(jarEntryName);
1435               ss.setGapped(model.gapped);
1436               ss.setTitle(model.title);
1437               rna.addSecondaryStructure(ss);
1438             }
1439           }
1440         }
1441       }
1442     }
1443   }
1444
1445   /**
1446    * Copy the contents of a file to a new entry added to the output jar
1447    *
1448    * @param jout
1449    * @param infilePath
1450    * @param jarEntryName
1451    */
1452   protected void copyFileToJar(JarOutputStream jout, String infilePath,
1453           String jarEntryName)
1454   {
1455     DataInputStream dis = null;
1456     try
1457     {
1458       File file = new File(infilePath);
1459       if (file.exists() && jout != null)
1460       {
1461         dis = new DataInputStream(new FileInputStream(file));
1462         byte[] data = new byte[(int) file.length()];
1463         dis.readFully(data);
1464         writeJarEntry(jout, jarEntryName, data);
1465       }
1466     } catch (Exception ex)
1467     {
1468       ex.printStackTrace();
1469     } finally
1470     {
1471       if (dis != null)
1472       {
1473         try
1474         {
1475           dis.close();
1476         } catch (IOException e)
1477         {
1478           // ignore
1479         }
1480       }
1481     }
1482   }
1483
1484   /**
1485    * Write the data to a new entry of given name in the output jar file
1486    *
1487    * @param jout
1488    * @param jarEntryName
1489    * @param data
1490    * @throws IOException
1491    */
1492   protected void writeJarEntry(JarOutputStream jout, String jarEntryName,
1493           byte[] data) throws IOException
1494   {
1495     if (jout != null)
1496     {
1497       System.out.println("Writing jar entry " + jarEntryName);
1498       jout.putNextEntry(new JarEntry(jarEntryName));
1499       DataOutputStream dout = new DataOutputStream(jout);
1500       dout.write(data, 0, data.length);
1501       dout.flush();
1502       jout.closeEntry();
1503     }
1504   }
1505
1506   /**
1507    * Save the state of a structure viewer
1508    *
1509    * @param ap
1510    * @param jds
1511    * @param pdb
1512    *          the archive XML element under which to save the state
1513    * @param entry
1514    * @param viewIds
1515    * @param matchedFile
1516    * @param viewFrame
1517    * @return
1518    */
1519   protected String saveStructureState(AlignmentPanel ap, SequenceI jds,
1520           Pdbids pdb, PDBEntry entry, List<String> viewIds,
1521           String matchedFile, StructureViewerBase viewFrame)
1522   {
1523     final AAStructureBindingModel bindingModel = viewFrame.getBinding();
1524
1525     /*
1526      * Look for any bindings for this viewer to the PDB file of interest
1527      * (including part matches excluding chain id)
1528      */
1529     for (int peid = 0; peid < bindingModel.getPdbCount(); peid++)
1530     {
1531       final PDBEntry pdbentry = bindingModel.getPdbEntry(peid);
1532       final String pdbId = pdbentry.getId();
1533       if (!pdbId.equals(entry.getId())
1534               && !(entry.getId().length() > 4 && entry.getId()
1535                       .toLowerCase().startsWith(pdbId.toLowerCase())))
1536       {
1537         /*
1538          * not interested in a binding to a different PDB entry here
1539          */
1540         continue;
1541       }
1542       if (matchedFile == null)
1543       {
1544         matchedFile = pdbentry.getFile();
1545       }
1546       else if (!matchedFile.equals(pdbentry.getFile()))
1547       {
1548         Cache.log
1549                 .warn("Probably lost some PDB-Sequence mappings for this structure file (which apparently has same PDB Entry code): "
1550                         + pdbentry.getFile());
1551       }
1552       // record the
1553       // file so we
1554       // can get at it if the ID
1555       // match is ambiguous (e.g.
1556       // 1QIP==1qipA)
1557
1558       for (int smap = 0; smap < viewFrame.getBinding().getSequence()[peid].length; smap++)
1559       {
1560         // if (jal.findIndex(jmol.jmb.sequence[peid][smap]) > -1)
1561         if (jds == viewFrame.getBinding().getSequence()[peid][smap])
1562         {
1563           StructureState state = new StructureState();
1564           state.setVisible(true);
1565           state.setXpos(viewFrame.getX());
1566           state.setYpos(viewFrame.getY());
1567           state.setWidth(viewFrame.getWidth());
1568           state.setHeight(viewFrame.getHeight());
1569           final String viewId = viewFrame.getViewId();
1570           state.setViewId(viewId);
1571           state.setAlignwithAlignPanel(viewFrame.isUsedforaligment(ap));
1572           state.setColourwithAlignPanel(viewFrame.isUsedforcolourby(ap));
1573           state.setColourByJmol(viewFrame.isColouredByViewer());
1574           state.setType(viewFrame.getViewerType().toString());
1575           pdb.addStructureState(state);
1576         }
1577       }
1578     }
1579     return matchedFile;
1580   }
1581
1582   private AnnotationColours constructAnnotationColours(
1583           AnnotationColourGradient acg, List<UserColourScheme> userColours,
1584           JalviewModelSequence jms)
1585   {
1586     AnnotationColours ac = new AnnotationColours();
1587     ac.setAboveThreshold(acg.getAboveThreshold());
1588     ac.setThreshold(acg.getAnnotationThreshold());
1589     ac.setAnnotation(acg.getAnnotation());
1590     if (acg.getBaseColour() instanceof jalview.schemes.UserColourScheme)
1591     {
1592       ac.setColourScheme(setUserColourScheme(acg.getBaseColour(),
1593               userColours, jms));
1594     }
1595     else
1596     {
1597       ac.setColourScheme(ColourSchemeProperty.getColourName(acg
1598               .getBaseColour()));
1599     }
1600
1601     ac.setMaxColour(acg.getMaxColour().getRGB());
1602     ac.setMinColour(acg.getMinColour().getRGB());
1603     ac.setPerSequence(acg.isSeqAssociated());
1604     ac.setPredefinedColours(acg.isPredefinedColours());
1605     return ac;
1606   }
1607
1608   private void storeAlignmentAnnotation(AlignmentAnnotation[] aa,
1609           IdentityHashMap<SequenceGroup, String> groupRefs,
1610           AlignmentViewport av, Set<String> calcIdSet, boolean storeDS,
1611           SequenceSet vamsasSet)
1612   {
1613
1614     for (int i = 0; i < aa.length; i++)
1615     {
1616       Annotation an = new Annotation();
1617
1618       AlignmentAnnotation annotation = aa[i];
1619       if (annotation.annotationId != null)
1620       {
1621         annotationIds.put(annotation.annotationId, annotation);
1622       }
1623
1624       an.setId(annotation.annotationId);
1625
1626       an.setVisible(annotation.visible);
1627
1628       an.setDescription(annotation.description);
1629
1630       if (annotation.sequenceRef != null)
1631       {
1632         // 2.9 JAL-1781 xref on sequence id rather than name
1633         an.setSequenceRef(seqsToIds.get(annotation.sequenceRef));
1634       }
1635       if (annotation.groupRef != null)
1636       {
1637         String groupIdr = groupRefs.get(annotation.groupRef);
1638         if (groupIdr == null)
1639         {
1640           // make a locally unique String
1641           groupRefs.put(
1642                   annotation.groupRef,
1643                   groupIdr = ("" + System.currentTimeMillis()
1644                           + annotation.groupRef.getName() + groupRefs
1645                           .size()));
1646         }
1647         an.setGroupRef(groupIdr.toString());
1648       }
1649
1650       // store all visualization attributes for annotation
1651       an.setGraphHeight(annotation.graphHeight);
1652       an.setCentreColLabels(annotation.centreColLabels);
1653       an.setScaleColLabels(annotation.scaleColLabel);
1654       an.setShowAllColLabels(annotation.showAllColLabels);
1655       an.setBelowAlignment(annotation.belowAlignment);
1656
1657       if (annotation.graph > 0)
1658       {
1659         an.setGraph(true);
1660         an.setGraphType(annotation.graph);
1661         an.setGraphGroup(annotation.graphGroup);
1662         if (annotation.getThreshold() != null)
1663         {
1664           ThresholdLine line = new ThresholdLine();
1665           line.setLabel(annotation.getThreshold().label);
1666           line.setValue(annotation.getThreshold().value);
1667           line.setColour(annotation.getThreshold().colour.getRGB());
1668           an.setThresholdLine(line);
1669         }
1670       }
1671       else
1672       {
1673         an.setGraph(false);
1674       }
1675
1676       an.setLabel(annotation.label);
1677
1678       if (annotation == av.getAlignmentQualityAnnot()
1679               || annotation == av.getAlignmentConservationAnnotation()
1680               || annotation == av.getAlignmentConsensusAnnotation()
1681               || annotation.autoCalculated)
1682       {
1683         // new way of indicating autocalculated annotation -
1684         an.setAutoCalculated(annotation.autoCalculated);
1685       }
1686       if (annotation.hasScore())
1687       {
1688         an.setScore(annotation.getScore());
1689       }
1690
1691       if (annotation.getCalcId() != null)
1692       {
1693         calcIdSet.add(annotation.getCalcId());
1694         an.setCalcId(annotation.getCalcId());
1695       }
1696       if (annotation.hasProperties())
1697       {
1698         for (String pr : annotation.getProperties())
1699         {
1700           Property prop = new Property();
1701           prop.setName(pr);
1702           prop.setValue(annotation.getProperty(pr));
1703           an.addProperty(prop);
1704         }
1705       }
1706
1707       AnnotationElement ae;
1708       if (annotation.annotations != null)
1709       {
1710         an.setScoreOnly(false);
1711         for (int a = 0; a < annotation.annotations.length; a++)
1712         {
1713           if ((annotation == null) || (annotation.annotations[a] == null))
1714           {
1715             continue;
1716           }
1717
1718           ae = new AnnotationElement();
1719           if (annotation.annotations[a].description != null)
1720           {
1721             ae.setDescription(annotation.annotations[a].description);
1722           }
1723           if (annotation.annotations[a].displayCharacter != null)
1724           {
1725             ae.setDisplayCharacter(annotation.annotations[a].displayCharacter);
1726           }
1727
1728           if (!Float.isNaN(annotation.annotations[a].value))
1729           {
1730             ae.setValue(annotation.annotations[a].value);
1731           }
1732
1733           ae.setPosition(a);
1734           if (annotation.annotations[a].secondaryStructure > ' ')
1735           {
1736             ae.setSecondaryStructure(annotation.annotations[a].secondaryStructure
1737                     + "");
1738           }
1739
1740           if (annotation.annotations[a].colour != null
1741                   && annotation.annotations[a].colour != java.awt.Color.black)
1742           {
1743             ae.setColour(annotation.annotations[a].colour.getRGB());
1744           }
1745
1746           an.addAnnotationElement(ae);
1747           if (annotation.autoCalculated)
1748           {
1749             // only write one non-null entry into the annotation row -
1750             // sufficient to get the visualization attributes necessary to
1751             // display data
1752             continue;
1753           }
1754         }
1755       }
1756       else
1757       {
1758         an.setScoreOnly(true);
1759       }
1760       if (!storeDS || (storeDS && !annotation.autoCalculated))
1761       {
1762         // skip autocalculated annotation - these are only provided for
1763         // alignments
1764         vamsasSet.addAnnotation(an);
1765       }
1766     }
1767
1768   }
1769
1770   private CalcIdParam createCalcIdParam(String calcId, AlignViewport av)
1771   {
1772     AutoCalcSetting settings = av.getCalcIdSettingsFor(calcId);
1773     if (settings != null)
1774     {
1775       CalcIdParam vCalcIdParam = new CalcIdParam();
1776       vCalcIdParam.setCalcId(calcId);
1777       vCalcIdParam.addServiceURL(settings.getServiceURI());
1778       // generic URI allowing a third party to resolve another instance of the
1779       // service used for this calculation
1780       for (String urls : settings.getServiceURLs())
1781       {
1782         vCalcIdParam.addServiceURL(urls);
1783       }
1784       vCalcIdParam.setVersion("1.0");
1785       if (settings.getPreset() != null)
1786       {
1787         WsParamSetI setting = settings.getPreset();
1788         vCalcIdParam.setName(setting.getName());
1789         vCalcIdParam.setDescription(setting.getDescription());
1790       }
1791       else
1792       {
1793         vCalcIdParam.setName("");
1794         vCalcIdParam.setDescription("Last used parameters");
1795       }
1796       // need to be able to recover 1) settings 2) user-defined presets or
1797       // recreate settings from preset 3) predefined settings provided by
1798       // service - or settings that can be transferred (or discarded)
1799       vCalcIdParam.setParameters(settings.getWsParamFile().replace("\n",
1800               "|\\n|"));
1801       vCalcIdParam.setAutoUpdate(settings.isAutoUpdate());
1802       // todo - decide if updateImmediately is needed for any projects.
1803
1804       return vCalcIdParam;
1805     }
1806     return null;
1807   }
1808
1809   private boolean recoverCalcIdParam(CalcIdParam calcIdParam,
1810           AlignViewport av)
1811   {
1812     if (calcIdParam.getVersion().equals("1.0"))
1813     {
1814       Jws2Instance service = Jws2Discoverer.getDiscoverer()
1815               .getPreferredServiceFor(calcIdParam.getServiceURL());
1816       if (service != null)
1817       {
1818         WsParamSetI parmSet = null;
1819         try
1820         {
1821           parmSet = service.getParamStore().parseServiceParameterFile(
1822                   calcIdParam.getName(), calcIdParam.getDescription(),
1823                   calcIdParam.getServiceURL(),
1824                   calcIdParam.getParameters().replace("|\\n|", "\n"));
1825         } catch (IOException x)
1826         {
1827           warn("Couldn't parse parameter data for "
1828                   + calcIdParam.getCalcId(), x);
1829           return false;
1830         }
1831         List<ArgumentI> argList = null;
1832         if (calcIdParam.getName().length() > 0)
1833         {
1834           parmSet = service.getParamStore()
1835                   .getPreset(calcIdParam.getName());
1836           if (parmSet != null)
1837           {
1838             // TODO : check we have a good match with settings in AACon -
1839             // otherwise we'll need to create a new preset
1840           }
1841         }
1842         else
1843         {
1844           argList = parmSet.getArguments();
1845           parmSet = null;
1846         }
1847         AAConSettings settings = new AAConSettings(
1848                 calcIdParam.isAutoUpdate(), service, parmSet, argList);
1849         av.setCalcIdSettingsFor(calcIdParam.getCalcId(), settings,
1850                 calcIdParam.isNeedsUpdate());
1851         return true;
1852       }
1853       else
1854       {
1855         warn("Cannot resolve a service for the parameters used in this project. Try configuring a JABAWS server.");
1856         return false;
1857       }
1858     }
1859     throw new Error(MessageManager.formatMessage(
1860             "error.unsupported_version_calcIdparam",
1861             new Object[] { calcIdParam.toString() }));
1862   }
1863
1864   /**
1865    * External mapping between jalview objects and objects yielding a valid and
1866    * unique object ID string. This is null for normal Jalview project IO, but
1867    * non-null when a jalview project is being read or written as part of a
1868    * vamsas session.
1869    */
1870   IdentityHashMap jv2vobj = null;
1871
1872   /**
1873    * Construct a unique ID for jvobj using either existing bindings or if none
1874    * exist, the result of the hashcode call for the object.
1875    *
1876    * @param jvobj
1877    *          jalview data object
1878    * @return unique ID for referring to jvobj
1879    */
1880   private String makeHashCode(Object jvobj, String altCode)
1881   {
1882     if (jv2vobj != null)
1883     {
1884       Object id = jv2vobj.get(jvobj);
1885       if (id != null)
1886       {
1887         return id.toString();
1888       }
1889       // check string ID mappings
1890       if (jvids2vobj != null && jvobj instanceof String)
1891       {
1892         id = jvids2vobj.get(jvobj);
1893       }
1894       if (id != null)
1895       {
1896         return id.toString();
1897       }
1898       // give up and warn that something has gone wrong
1899       warn("Cannot find ID for object in external mapping : " + jvobj);
1900     }
1901     return altCode;
1902   }
1903
1904   /**
1905    * return local jalview object mapped to ID, if it exists
1906    *
1907    * @param idcode
1908    *          (may be null)
1909    * @return null or object bound to idcode
1910    */
1911   private Object retrieveExistingObj(String idcode)
1912   {
1913     if (idcode != null && vobj2jv != null)
1914     {
1915       return vobj2jv.get(idcode);
1916     }
1917     return null;
1918   }
1919
1920   /**
1921    * binding from ID strings from external mapping table to jalview data model
1922    * objects.
1923    */
1924   private Hashtable vobj2jv;
1925
1926   private Sequence createVamsasSequence(String id, SequenceI jds)
1927   {
1928     return createVamsasSequence(true, id, jds, null);
1929   }
1930
1931   private Sequence createVamsasSequence(boolean recurse, String id,
1932           SequenceI jds, SequenceI parentseq)
1933   {
1934     Sequence vamsasSeq = new Sequence();
1935     vamsasSeq.setId(id);
1936     vamsasSeq.setName(jds.getName());
1937     vamsasSeq.setSequence(jds.getSequenceAsString());
1938     vamsasSeq.setDescription(jds.getDescription());
1939     jalview.datamodel.DBRefEntry[] dbrefs = null;
1940     if (jds.getDatasetSequence() != null)
1941     {
1942       vamsasSeq.setDsseqid(seqHash(jds.getDatasetSequence()));
1943       if (jds.getDatasetSequence().getDBRefs() != null)
1944       {
1945         dbrefs = jds.getDatasetSequence().getDBRefs();
1946       }
1947     }
1948     else
1949     {
1950       vamsasSeq.setDsseqid(id); // so we can tell which sequences really are
1951       // dataset sequences only
1952       dbrefs = jds.getDBRefs();
1953     }
1954     if (dbrefs != null)
1955     {
1956       for (int d = 0; d < dbrefs.length; d++)
1957       {
1958         DBRef dbref = new DBRef();
1959         dbref.setSource(dbrefs[d].getSource());
1960         dbref.setVersion(dbrefs[d].getVersion());
1961         dbref.setAccessionId(dbrefs[d].getAccessionId());
1962         if (dbrefs[d].hasMap())
1963         {
1964           Mapping mp = createVamsasMapping(dbrefs[d].getMap(), parentseq,
1965                   jds, recurse);
1966           dbref.setMapping(mp);
1967         }
1968         vamsasSeq.addDBRef(dbref);
1969       }
1970     }
1971     return vamsasSeq;
1972   }
1973
1974   private Mapping createVamsasMapping(jalview.datamodel.Mapping jmp,
1975           SequenceI parentseq, SequenceI jds, boolean recurse)
1976   {
1977     Mapping mp = null;
1978     if (jmp.getMap() != null)
1979     {
1980       mp = new Mapping();
1981
1982       jalview.util.MapList mlst = jmp.getMap();
1983       List<int[]> r = mlst.getFromRanges();
1984       for (int[] range : r)
1985       {
1986         MapListFrom mfrom = new MapListFrom();
1987         mfrom.setStart(range[0]);
1988         mfrom.setEnd(range[1]);
1989         mp.addMapListFrom(mfrom);
1990       }
1991       r = mlst.getToRanges();
1992       for (int[] range : r)
1993       {
1994         MapListTo mto = new MapListTo();
1995         mto.setStart(range[0]);
1996         mto.setEnd(range[1]);
1997         mp.addMapListTo(mto);
1998       }
1999       mp.setMapFromUnit(mlst.getFromRatio());
2000       mp.setMapToUnit(mlst.getToRatio());
2001       if (jmp.getTo() != null)
2002       {
2003         MappingChoice mpc = new MappingChoice();
2004         if (recurse
2005                 && (parentseq != jmp.getTo() || parentseq
2006                         .getDatasetSequence() != jmp.getTo()))
2007         {
2008           mpc.setSequence(createVamsasSequence(false, seqHash(jmp.getTo()),
2009                   jmp.getTo(), jds));
2010         }
2011         else
2012         {
2013           String jmpid = "";
2014           SequenceI ps = null;
2015           if (parentseq != jmp.getTo()
2016                   && parentseq.getDatasetSequence() != jmp.getTo())
2017           {
2018             // chaining dbref rather than a handshaking one
2019             jmpid = seqHash(ps = jmp.getTo());
2020           }
2021           else
2022           {
2023             jmpid = seqHash(ps = parentseq);
2024           }
2025           mpc.setDseqFor(jmpid);
2026           if (!seqRefIds.containsKey(mpc.getDseqFor()))
2027           {
2028             jalview.bin.Cache.log.debug("creatign new DseqFor ID");
2029             seqRefIds.put(mpc.getDseqFor(), ps);
2030           }
2031           else
2032           {
2033             jalview.bin.Cache.log.debug("reusing DseqFor ID");
2034           }
2035         }
2036         mp.setMappingChoice(mpc);
2037       }
2038     }
2039     return mp;
2040   }
2041
2042   String setUserColourScheme(jalview.schemes.ColourSchemeI cs,
2043           List<UserColourScheme> userColours, JalviewModelSequence jms)
2044   {
2045     String id = null;
2046     jalview.schemes.UserColourScheme ucs = (jalview.schemes.UserColourScheme) cs;
2047     boolean newucs = false;
2048     if (!userColours.contains(ucs))
2049     {
2050       userColours.add(ucs);
2051       newucs = true;
2052     }
2053     id = "ucs" + userColours.indexOf(ucs);
2054     if (newucs)
2055     {
2056       // actually create the scheme's entry in the XML model
2057       java.awt.Color[] colours = ucs.getColours();
2058       jalview.schemabinding.version2.UserColours uc = new jalview.schemabinding.version2.UserColours();
2059       jalview.schemabinding.version2.UserColourScheme jbucs = new jalview.schemabinding.version2.UserColourScheme();
2060
2061       for (int i = 0; i < colours.length; i++)
2062       {
2063         jalview.schemabinding.version2.Colour col = new jalview.schemabinding.version2.Colour();
2064         col.setName(ResidueProperties.aa[i]);
2065         col.setRGB(jalview.util.Format.getHexString(colours[i]));
2066         jbucs.addColour(col);
2067       }
2068       if (ucs.getLowerCaseColours() != null)
2069       {
2070         colours = ucs.getLowerCaseColours();
2071         for (int i = 0; i < colours.length; i++)
2072         {
2073           jalview.schemabinding.version2.Colour col = new jalview.schemabinding.version2.Colour();
2074           col.setName(ResidueProperties.aa[i].toLowerCase());
2075           col.setRGB(jalview.util.Format.getHexString(colours[i]));
2076           jbucs.addColour(col);
2077         }
2078       }
2079
2080       uc.setId(id);
2081       uc.setUserColourScheme(jbucs);
2082       jms.addUserColours(uc);
2083     }
2084
2085     return id;
2086   }
2087
2088   jalview.schemes.UserColourScheme getUserColourScheme(
2089           JalviewModelSequence jms, String id)
2090   {
2091     UserColours[] uc = jms.getUserColours();
2092     UserColours colours = null;
2093
2094     for (int i = 0; i < uc.length; i++)
2095     {
2096       if (uc[i].getId().equals(id))
2097       {
2098         colours = uc[i];
2099
2100         break;
2101       }
2102     }
2103
2104     java.awt.Color[] newColours = new java.awt.Color[24];
2105
2106     for (int i = 0; i < 24; i++)
2107     {
2108       newColours[i] = new java.awt.Color(Integer.parseInt(colours
2109               .getUserColourScheme().getColour(i).getRGB(), 16));
2110     }
2111
2112     jalview.schemes.UserColourScheme ucs = new jalview.schemes.UserColourScheme(
2113             newColours);
2114
2115     if (colours.getUserColourScheme().getColourCount() > 24)
2116     {
2117       newColours = new java.awt.Color[23];
2118       for (int i = 0; i < 23; i++)
2119       {
2120         newColours[i] = new java.awt.Color(Integer.parseInt(colours
2121                 .getUserColourScheme().getColour(i + 24).getRGB(), 16));
2122       }
2123       ucs.setLowerCaseColours(newColours);
2124     }
2125
2126     return ucs;
2127   }
2128
2129   /**
2130    * contains last error message (if any) encountered by XML loader.
2131    */
2132   String errorMessage = null;
2133
2134   /**
2135    * flag to control whether the Jalview2XML_V1 parser should be deferred to if
2136    * exceptions are raised during project XML parsing
2137    */
2138   public boolean attemptversion1parse = true;
2139
2140   /**
2141    * Load a jalview project archive from a jar file
2142    *
2143    * @param file
2144    *          - HTTP URL or filename
2145    */
2146   public AlignFrame loadJalviewAlign(final String file)
2147   {
2148
2149     jalview.gui.AlignFrame af = null;
2150
2151     try
2152     {
2153       // create list to store references for any new Jmol viewers created
2154       newStructureViewers = new Vector<JalviewStructureDisplayI>();
2155       // UNMARSHALLER SEEMS TO CLOSE JARINPUTSTREAM, MOST ANNOYING
2156       // Workaround is to make sure caller implements the JarInputStreamProvider
2157       // interface
2158       // so we can re-open the jar input stream for each entry.
2159
2160       jarInputStreamProvider jprovider = createjarInputStreamProvider(file);
2161       af = loadJalviewAlign(jprovider);
2162
2163     } catch (MalformedURLException e)
2164     {
2165       errorMessage = "Invalid URL format for '" + file + "'";
2166       reportErrors();
2167     } finally
2168     {
2169       try
2170       {
2171         SwingUtilities.invokeAndWait(new Runnable()
2172         {
2173           @Override
2174           public void run()
2175           {
2176             setLoadingFinishedForNewStructureViewers();
2177           };
2178         });
2179       } catch (Exception x)
2180       {
2181         System.err.println("Error loading alignment: " + x.getMessage());
2182       }
2183     }
2184     return af;
2185   }
2186
2187   private jarInputStreamProvider createjarInputStreamProvider(
2188           final String file) throws MalformedURLException
2189   {
2190     URL url = null;
2191     errorMessage = null;
2192     uniqueSetSuffix = null;
2193     seqRefIds = null;
2194     viewportsAdded.clear();
2195     frefedSequence = null;
2196
2197     if (file.startsWith("http://"))
2198     {
2199       url = new URL(file);
2200     }
2201     final URL _url = url;
2202     return new jarInputStreamProvider()
2203     {
2204
2205       @Override
2206       public JarInputStream getJarInputStream() throws IOException
2207       {
2208         if (_url != null)
2209         {
2210           return new JarInputStream(_url.openStream());
2211         }
2212         else
2213         {
2214           return new JarInputStream(new FileInputStream(file));
2215         }
2216       }
2217
2218       @Override
2219       public String getFilename()
2220       {
2221         return file;
2222       }
2223     };
2224   }
2225
2226   /**
2227    * Recover jalview session from a jalview project archive. Caller may
2228    * initialise uniqueSetSuffix, seqRefIds, viewportsAdded and frefedSequence
2229    * themselves. Any null fields will be initialised with default values,
2230    * non-null fields are left alone.
2231    *
2232    * @param jprovider
2233    * @return
2234    */
2235   public AlignFrame loadJalviewAlign(final jarInputStreamProvider jprovider)
2236   {
2237     errorMessage = null;
2238     if (uniqueSetSuffix == null)
2239     {
2240       uniqueSetSuffix = System.currentTimeMillis() % 100000 + "";
2241     }
2242     if (seqRefIds == null)
2243     {
2244       seqRefIds = new HashMap<String, SequenceI>();
2245     }
2246     if (frefedSequence == null)
2247     {
2248       frefedSequence = new Vector<Object[]>();
2249     }
2250
2251     AlignFrame af = null, _af = null;
2252     Map<String, AlignFrame> gatherToThisFrame = new HashMap<String, AlignFrame>();
2253     final String file = jprovider.getFilename();
2254     try
2255     {
2256       JarInputStream jin = null;
2257       JarEntry jarentry = null;
2258       int entryCount = 1;
2259
2260       do
2261       {
2262         jin = jprovider.getJarInputStream();
2263         for (int i = 0; i < entryCount; i++)
2264         {
2265           jarentry = jin.getNextJarEntry();
2266         }
2267
2268         if (jarentry != null && jarentry.getName().endsWith(".xml"))
2269         {
2270           InputStreamReader in = new InputStreamReader(jin, UTF_8);
2271           JalviewModel object = new JalviewModel();
2272
2273           Unmarshaller unmar = new Unmarshaller(object);
2274           unmar.setValidation(false);
2275           object = (JalviewModel) unmar.unmarshal(in);
2276           if (true) // !skipViewport(object))
2277           {
2278             _af = loadFromObject(object, file, true, jprovider);
2279             if (object.getJalviewModelSequence().getViewportCount() > 0)
2280             {
2281               af = _af;
2282               if (af.viewport.isGatherViewsHere())
2283               {
2284                 gatherToThisFrame.put(af.viewport.getSequenceSetId(), af);
2285               }
2286             }
2287           }
2288           entryCount++;
2289         }
2290         else if (jarentry != null)
2291         {
2292           // Some other file here.
2293           entryCount++;
2294         }
2295       } while (jarentry != null);
2296       resolveFrefedSequences();
2297     } catch (IOException ex)
2298     {
2299       ex.printStackTrace();
2300       errorMessage = "Couldn't locate Jalview XML file : " + file;
2301       System.err.println("Exception whilst loading jalview XML file : "
2302               + ex + "\n");
2303     } catch (Exception ex)
2304     {
2305       System.err.println("Parsing as Jalview Version 2 file failed.");
2306       ex.printStackTrace(System.err);
2307       if (attemptversion1parse)
2308       {
2309         // Is Version 1 Jar file?
2310         try
2311         {
2312           af = new Jalview2XML_V1(raiseGUI).LoadJalviewAlign(jprovider);
2313         } catch (Exception ex2)
2314         {
2315           System.err.println("Exception whilst loading as jalviewXMLV1:");
2316           ex2.printStackTrace();
2317           af = null;
2318         }
2319       }
2320       if (Desktop.instance != null)
2321       {
2322         Desktop.instance.stopLoading();
2323       }
2324       if (af != null)
2325       {
2326         System.out.println("Successfully loaded archive file");
2327         return af;
2328       }
2329       ex.printStackTrace();
2330
2331       System.err.println("Exception whilst loading jalview XML file : "
2332               + ex + "\n");
2333     } catch (OutOfMemoryError e)
2334     {
2335       // Don't use the OOM Window here
2336       errorMessage = "Out of memory loading jalview XML file";
2337       System.err.println("Out of memory whilst loading jalview XML file");
2338       e.printStackTrace();
2339     }
2340
2341     if (Desktop.instance != null)
2342     {
2343       Desktop.instance.stopLoading();
2344     }
2345
2346     /*
2347      * Regather multiple views (with the same sequence set id) to the frame (if
2348      * any) that is flagged as the one to gather to, i.e. convert them to tabbed
2349      * views instead of separate frames. Note this doesn't restore a state where
2350      * some expanded views in turn have tabbed views - the last "first tab" read
2351      * in will play the role of gatherer for all.
2352      */
2353     for (AlignFrame fr : gatherToThisFrame.values())
2354     {
2355       Desktop.instance.gatherViews(fr);
2356     }
2357
2358     restoreSplitFrames();
2359
2360     if (errorMessage != null)
2361     {
2362       reportErrors();
2363     }
2364     return af;
2365   }
2366
2367   /**
2368    * Try to reconstruct and display SplitFrame windows, where each contains
2369    * complementary dna and protein alignments. Done by pairing up AlignFrame
2370    * objects (created earlier) which have complementary viewport ids associated.
2371    */
2372   protected void restoreSplitFrames()
2373   {
2374     List<SplitFrame> gatherTo = new ArrayList<SplitFrame>();
2375     List<AlignFrame> addedToSplitFrames = new ArrayList<AlignFrame>();
2376     Map<String, AlignFrame> dna = new HashMap<String, AlignFrame>();
2377
2378     /*
2379      * Identify the DNA alignments
2380      */
2381     for (Entry<Viewport, AlignFrame> candidate : splitFrameCandidates
2382             .entrySet())
2383     {
2384       AlignFrame af = candidate.getValue();
2385       if (af.getViewport().getAlignment().isNucleotide())
2386       {
2387         dna.put(candidate.getKey().getId(), af);
2388       }
2389     }
2390
2391     /*
2392      * Try to match up the protein complements
2393      */
2394     for (Entry<Viewport, AlignFrame> candidate : splitFrameCandidates
2395             .entrySet())
2396     {
2397       AlignFrame af = candidate.getValue();
2398       if (!af.getViewport().getAlignment().isNucleotide())
2399       {
2400         String complementId = candidate.getKey().getComplementId();
2401         // only non-null complements should be in the Map
2402         if (complementId != null && dna.containsKey(complementId))
2403         {
2404           final AlignFrame dnaFrame = dna.get(complementId);
2405           SplitFrame sf = createSplitFrame(dnaFrame, af);
2406           addedToSplitFrames.add(dnaFrame);
2407           addedToSplitFrames.add(af);
2408           if (af.viewport.isGatherViewsHere())
2409           {
2410             gatherTo.add(sf);
2411           }
2412         }
2413       }
2414     }
2415
2416     /*
2417      * Open any that we failed to pair up (which shouldn't happen!) as
2418      * standalone AlignFrame's.
2419      */
2420     for (Entry<Viewport, AlignFrame> candidate : splitFrameCandidates
2421             .entrySet())
2422     {
2423       AlignFrame af = candidate.getValue();
2424       if (!addedToSplitFrames.contains(af))
2425       {
2426         Viewport view = candidate.getKey();
2427         Desktop.addInternalFrame(af, view.getTitle(), view.getWidth(),
2428                 view.getHeight());
2429         System.err.println("Failed to restore view " + view.getTitle()
2430                 + " to split frame");
2431       }
2432     }
2433
2434     /*
2435      * Gather back into tabbed views as flagged.
2436      */
2437     for (SplitFrame sf : gatherTo)
2438     {
2439       Desktop.instance.gatherViews(sf);
2440     }
2441
2442     splitFrameCandidates.clear();
2443   }
2444
2445   /**
2446    * Construct and display one SplitFrame holding DNA and protein alignments.
2447    *
2448    * @param dnaFrame
2449    * @param proteinFrame
2450    * @return
2451    */
2452   protected SplitFrame createSplitFrame(AlignFrame dnaFrame,
2453           AlignFrame proteinFrame)
2454   {
2455     SplitFrame splitFrame = new SplitFrame(dnaFrame, proteinFrame);
2456     String title = MessageManager.getString("label.linked_view_title");
2457     int width = (int) dnaFrame.getBounds().getWidth();
2458     int height = (int) (dnaFrame.getBounds().getHeight()
2459             + proteinFrame.getBounds().getHeight() + 50);
2460
2461     /*
2462      * SplitFrame location is saved to both enclosed frames
2463      */
2464     splitFrame.setLocation(dnaFrame.getX(), dnaFrame.getY());
2465     Desktop.addInternalFrame(splitFrame, title, width, height);
2466
2467     /*
2468      * And compute cDNA consensus (couldn't do earlier with consensus as
2469      * mappings were not yet present)
2470      */
2471     proteinFrame.viewport.alignmentChanged(proteinFrame.alignPanel);
2472
2473     return splitFrame;
2474   }
2475
2476   /**
2477    * check errorMessage for a valid error message and raise an error box in the
2478    * GUI or write the current errorMessage to stderr and then clear the error
2479    * state.
2480    */
2481   protected void reportErrors()
2482   {
2483     reportErrors(false);
2484   }
2485
2486   protected void reportErrors(final boolean saving)
2487   {
2488     if (errorMessage != null)
2489     {
2490       final String finalErrorMessage = errorMessage;
2491       if (raiseGUI)
2492       {
2493         javax.swing.SwingUtilities.invokeLater(new Runnable()
2494         {
2495           @Override
2496           public void run()
2497           {
2498             JOptionPane.showInternalMessageDialog(Desktop.desktop,
2499                     finalErrorMessage, "Error "
2500                             + (saving ? "saving" : "loading")
2501                             + " Jalview file", JOptionPane.WARNING_MESSAGE);
2502           }
2503         });
2504       }
2505       else
2506       {
2507         System.err.println("Problem loading Jalview file: " + errorMessage);
2508       }
2509     }
2510     errorMessage = null;
2511   }
2512
2513   Map<String, String> alreadyLoadedPDB = new HashMap<String, String>();
2514
2515   /**
2516    * when set, local views will be updated from view stored in JalviewXML
2517    * Currently (28th Sep 2008) things will go horribly wrong in vamsas document
2518    * sync if this is set to true.
2519    */
2520   private final boolean updateLocalViews = false;
2521
2522   /**
2523    * Returns the path to a temporary file holding the PDB file for the given PDB
2524    * id. The first time of asking, searches for a file of that name in the
2525    * Jalview project jar, and copies it to a new temporary file. Any repeat
2526    * requests just return the path to the file previously created.
2527    *
2528    * @param jprovider
2529    * @param pdbId
2530    * @return
2531    */
2532   String loadPDBFile(jarInputStreamProvider jprovider, String pdbId)
2533   {
2534     if (alreadyLoadedPDB.containsKey(pdbId))
2535     {
2536       return alreadyLoadedPDB.get(pdbId).toString();
2537     }
2538
2539     String tempFile = copyJarEntry(jprovider, pdbId, "jalview_pdb");
2540     if (tempFile != null)
2541     {
2542       alreadyLoadedPDB.put(pdbId, tempFile);
2543     }
2544     return tempFile;
2545   }
2546
2547   /**
2548    * Copies the jar entry of given name to a new temporary file and returns the
2549    * path to the file, or null if the entry is not found.
2550    *
2551    * @param jprovider
2552    * @param jarEntryName
2553    * @param prefix
2554    *          a prefix for the temporary file name, must be at least three
2555    *          characters long
2556    * @return
2557    */
2558   protected String copyJarEntry(jarInputStreamProvider jprovider,
2559           String jarEntryName, String prefix)
2560   {
2561     BufferedReader in = null;
2562     PrintWriter out = null;
2563
2564     try
2565     {
2566       JarInputStream jin = jprovider.getJarInputStream();
2567       /*
2568        * if (jprovider.startsWith("http://")) { jin = new JarInputStream(new
2569        * URL(jprovider).openStream()); } else { jin = new JarInputStream(new
2570        * FileInputStream(jprovider)); }
2571        */
2572
2573       JarEntry entry = null;
2574       do
2575       {
2576         entry = jin.getNextJarEntry();
2577       } while (entry != null && !entry.getName().equals(jarEntryName));
2578       if (entry != null)
2579       {
2580         in = new BufferedReader(new InputStreamReader(jin, UTF_8));
2581         File outFile = File.createTempFile(prefix, ".tmp");
2582         outFile.deleteOnExit();
2583         out = new PrintWriter(new FileOutputStream(outFile));
2584         String data;
2585
2586         while ((data = in.readLine()) != null)
2587         {
2588           out.println(data);
2589         }
2590         out.flush();
2591         String t = outFile.getAbsolutePath();
2592         return t;
2593       }
2594       else
2595       {
2596         warn("Couldn't find entry in Jalview Jar for " + jarEntryName);
2597       }
2598     } catch (Exception ex)
2599     {
2600       ex.printStackTrace();
2601     } finally
2602     {
2603       if (in != null)
2604       {
2605         try
2606         {
2607           in.close();
2608         } catch (IOException e)
2609         {
2610           // ignore
2611         }
2612       }
2613       if (out != null)
2614       {
2615         out.close();
2616       }
2617     }
2618
2619     return null;
2620   }
2621
2622   private class JvAnnotRow
2623   {
2624     public JvAnnotRow(int i, AlignmentAnnotation jaa)
2625     {
2626       order = i;
2627       template = jaa;
2628     }
2629
2630     /**
2631      * persisted version of annotation row from which to take vis properties
2632      */
2633     public jalview.datamodel.AlignmentAnnotation template;
2634
2635     /**
2636      * original position of the annotation row in the alignment
2637      */
2638     public int order;
2639   }
2640
2641   /**
2642    * Load alignment frame from jalview XML DOM object
2643    *
2644    * @param object
2645    *          DOM
2646    * @param file
2647    *          filename source string
2648    * @param loadTreesAndStructures
2649    *          when false only create Viewport
2650    * @param jprovider
2651    *          data source provider
2652    * @return alignment frame created from view stored in DOM
2653    */
2654   AlignFrame loadFromObject(JalviewModel object, String file,
2655           boolean loadTreesAndStructures, jarInputStreamProvider jprovider)
2656   {
2657     SequenceSet vamsasSet = object.getVamsasModel().getSequenceSet(0);
2658     Sequence[] vamsasSeq = vamsasSet.getSequence();
2659
2660     JalviewModelSequence jms = object.getJalviewModelSequence();
2661
2662     Viewport view = (jms.getViewportCount() > 0) ? jms.getViewport(0)
2663             : null;
2664
2665     // ////////////////////////////////
2666     // LOAD SEQUENCES
2667
2668     List<SequenceI> hiddenSeqs = null;
2669     jalview.datamodel.Sequence jseq;
2670
2671     List<SequenceI> tmpseqs = new ArrayList<SequenceI>();
2672
2673     boolean multipleView = false;
2674     SequenceI referenceseqForView = null;
2675     JSeq[] jseqs = object.getJalviewModelSequence().getJSeq();
2676     int vi = 0; // counter in vamsasSeq array
2677     for (int i = 0; i < jseqs.length; i++)
2678     {
2679       String seqId = jseqs[i].getId();
2680
2681       if (seqRefIds.get(seqId) != null)
2682       {
2683         tmpseqs.add(seqRefIds.get(seqId));
2684         multipleView = true;
2685       }
2686       else
2687       {
2688         jseq = new jalview.datamodel.Sequence(vamsasSeq[vi].getName(),
2689                 vamsasSeq[vi].getSequence());
2690         jseq.setDescription(vamsasSeq[vi].getDescription());
2691         jseq.setStart(jseqs[i].getStart());
2692         jseq.setEnd(jseqs[i].getEnd());
2693         jseq.setVamsasId(uniqueSetSuffix + seqId);
2694         seqRefIds.put(vamsasSeq[vi].getId(), jseq);
2695         tmpseqs.add(jseq);
2696         vi++;
2697       }
2698
2699       if (jseqs[i].hasViewreference() && jseqs[i].getViewreference())
2700       {
2701         referenceseqForView = tmpseqs.get(tmpseqs.size() - 1);
2702       }
2703
2704       if (jseqs[i].getHidden())
2705       {
2706         if (hiddenSeqs == null)
2707         {
2708           hiddenSeqs = new ArrayList<SequenceI>();
2709         }
2710
2711         hiddenSeqs.add(seqRefIds.get(seqId));
2712       }
2713     }
2714
2715     // /
2716     // Create the alignment object from the sequence set
2717     // ///////////////////////////////
2718     SequenceI[] orderedSeqs = tmpseqs
2719             .toArray(new SequenceI[tmpseqs.size()]);
2720
2721     AlignmentI al = new Alignment(orderedSeqs);
2722
2723     if (referenceseqForView != null)
2724     {
2725       al.setSeqrep(referenceseqForView);
2726     }
2727     // / Add the alignment properties
2728     for (int i = 0; i < vamsasSet.getSequenceSetPropertiesCount(); i++)
2729     {
2730       SequenceSetProperties ssp = vamsasSet.getSequenceSetProperties(i);
2731       al.setProperty(ssp.getKey(), ssp.getValue());
2732     }
2733
2734     // /
2735     // SequenceFeatures are added to the DatasetSequence,
2736     // so we must create or recover the dataset before loading features
2737     // ///////////////////////////////
2738     if (vamsasSet.getDatasetId() == null || vamsasSet.getDatasetId() == "")
2739     {
2740       // older jalview projects do not have a dataset id.
2741       al.setDataset(null);
2742     }
2743     else
2744     {
2745       // recover dataset - passing on flag indicating if this a 'viewless'
2746       // sequence set (a.k.a. a stored dataset for the project)
2747       recoverDatasetFor(vamsasSet, al, object.getJalviewModelSequence()
2748               .getViewportCount() == 0);
2749     }
2750     // ///////////////////////////////
2751
2752     Hashtable pdbloaded = new Hashtable(); // TODO nothing writes to this??
2753     if (!multipleView)
2754     {
2755       // load sequence features, database references and any associated PDB
2756       // structures for the alignment
2757       for (int i = 0; i < vamsasSeq.length; i++)
2758       {
2759         if (jseqs[i].getFeaturesCount() > 0)
2760         {
2761           Features[] features = jseqs[i].getFeatures();
2762           for (int f = 0; f < features.length; f++)
2763           {
2764             jalview.datamodel.SequenceFeature sf = new jalview.datamodel.SequenceFeature(
2765                     features[f].getType(), features[f].getDescription(),
2766                     features[f].getStatus(), features[f].getBegin(),
2767                     features[f].getEnd(), features[f].getFeatureGroup());
2768
2769             sf.setScore(features[f].getScore());
2770             for (int od = 0; od < features[f].getOtherDataCount(); od++)
2771             {
2772               OtherData keyValue = features[f].getOtherData(od);
2773               if (keyValue.getKey().startsWith("LINK"))
2774               {
2775                 sf.addLink(keyValue.getValue());
2776               }
2777               else
2778               {
2779                 sf.setValue(keyValue.getKey(), keyValue.getValue());
2780               }
2781
2782             }
2783
2784             al.getSequenceAt(i).getDatasetSequence().addSequenceFeature(sf);
2785           }
2786         }
2787         if (vamsasSeq[i].getDBRefCount() > 0)
2788         {
2789           addDBRefs(al.getSequenceAt(i).getDatasetSequence(), vamsasSeq[i]);
2790         }
2791         if (jseqs[i].getPdbidsCount() > 0)
2792         {
2793           Pdbids[] ids = jseqs[i].getPdbids();
2794           for (int p = 0; p < ids.length; p++)
2795           {
2796             jalview.datamodel.PDBEntry entry = new jalview.datamodel.PDBEntry();
2797             entry.setId(ids[p].getId());
2798             if (ids[p].getType() != null)
2799             {
2800               if (ids[p].getType().equalsIgnoreCase("PDB"))
2801               {
2802                 entry.setType(PDBEntry.Type.PDB);
2803               }
2804               else
2805               {
2806                 entry.setType(PDBEntry.Type.FILE);
2807               }
2808             }
2809             if (ids[p].getFile() != null)
2810             {
2811               if (!pdbloaded.containsKey(ids[p].getFile()))
2812               {
2813                 entry.setFile(loadPDBFile(jprovider, ids[p].getId()));
2814               }
2815               else
2816               {
2817                 entry.setFile(pdbloaded.get(ids[p].getId()).toString());
2818               }
2819             }
2820             StructureSelectionManager.getStructureSelectionManager(
2821                     Desktop.instance).registerPDBEntry(entry);
2822             al.getSequenceAt(i).getDatasetSequence().addPDBId(entry);
2823           }
2824         }
2825       }
2826     } // end !multipleview
2827
2828     // ///////////////////////////////
2829     // LOAD SEQUENCE MAPPINGS
2830
2831     if (vamsasSet.getAlcodonFrameCount() > 0)
2832     {
2833       // TODO Potentially this should only be done once for all views of an
2834       // alignment
2835       AlcodonFrame[] alc = vamsasSet.getAlcodonFrame();
2836       for (int i = 0; i < alc.length; i++)
2837       {
2838         AlignedCodonFrame cf = new AlignedCodonFrame();
2839         if (alc[i].getAlcodMapCount() > 0)
2840         {
2841           AlcodMap[] maps = alc[i].getAlcodMap();
2842           for (int m = 0; m < maps.length; m++)
2843           {
2844             SequenceI dnaseq = seqRefIds.get(maps[m].getDnasq());
2845             // Load Mapping
2846             jalview.datamodel.Mapping mapping = null;
2847             // attach to dna sequence reference.
2848             if (maps[m].getMapping() != null)
2849             {
2850               mapping = addMapping(maps[m].getMapping());
2851             }
2852             if (dnaseq != null && mapping.getTo() != null)
2853             {
2854               cf.addMap(dnaseq, mapping.getTo(), mapping.getMap());
2855             }
2856             else
2857             {
2858               // defer to later
2859               frefedSequence.add(new Object[] { maps[m].getDnasq(), cf,
2860                   mapping });
2861             }
2862           }
2863           al.addCodonFrame(cf);
2864         }
2865       }
2866     }
2867
2868     // ////////////////////////////////
2869     // LOAD ANNOTATIONS
2870     List<JvAnnotRow> autoAlan = new ArrayList<JvAnnotRow>();
2871
2872     /*
2873      * store any annotations which forward reference a group's ID
2874      */
2875     Map<String, List<AlignmentAnnotation>> groupAnnotRefs = new Hashtable<String, List<AlignmentAnnotation>>();
2876
2877     if (vamsasSet.getAnnotationCount() > 0)
2878     {
2879       Annotation[] an = vamsasSet.getAnnotation();
2880
2881       for (int i = 0; i < an.length; i++)
2882       {
2883         Annotation annotation = an[i];
2884
2885         /**
2886          * test if annotation is automatically calculated for this view only
2887          */
2888         boolean autoForView = false;
2889         if (annotation.getLabel().equals("Quality")
2890                 || annotation.getLabel().equals("Conservation")
2891                 || annotation.getLabel().equals("Consensus"))
2892         {
2893           // Kludge for pre 2.5 projects which lacked the autocalculated flag
2894           autoForView = true;
2895           if (!annotation.hasAutoCalculated())
2896           {
2897             annotation.setAutoCalculated(true);
2898           }
2899         }
2900         if (autoForView
2901                 || (annotation.hasAutoCalculated() && annotation
2902                         .isAutoCalculated()))
2903         {
2904           // remove ID - we don't recover annotation from other views for
2905           // view-specific annotation
2906           annotation.setId(null);
2907         }
2908
2909         // set visiblity for other annotation in this view
2910         String annotationId = annotation.getId();
2911         if (annotationId != null && annotationIds.containsKey(annotationId))
2912         {
2913           AlignmentAnnotation jda = annotationIds.get(annotationId);
2914           // in principle Visible should always be true for annotation displayed
2915           // in multiple views
2916           if (annotation.hasVisible())
2917           {
2918             jda.visible = annotation.getVisible();
2919           }
2920
2921           al.addAnnotation(jda);
2922
2923           continue;
2924         }
2925         // Construct new annotation from model.
2926         AnnotationElement[] ae = annotation.getAnnotationElement();
2927         jalview.datamodel.Annotation[] anot = null;
2928         java.awt.Color firstColour = null;
2929         int anpos;
2930         if (!annotation.getScoreOnly())
2931         {
2932           anot = new jalview.datamodel.Annotation[al.getWidth()];
2933           for (int aa = 0; aa < ae.length && aa < anot.length; aa++)
2934           {
2935             anpos = ae[aa].getPosition();
2936
2937             if (anpos >= anot.length)
2938             {
2939               continue;
2940             }
2941
2942             anot[anpos] = new jalview.datamodel.Annotation(
2943
2944             ae[aa].getDisplayCharacter(), ae[aa].getDescription(),
2945                     (ae[aa].getSecondaryStructure() == null || ae[aa]
2946                             .getSecondaryStructure().length() == 0) ? ' '
2947                             : ae[aa].getSecondaryStructure().charAt(0),
2948                     ae[aa].getValue()
2949
2950             );
2951             // JBPNote: Consider verifying dataflow for IO of secondary
2952             // structure annotation read from Stockholm files
2953             // this was added to try to ensure that
2954             // if (anot[ae[aa].getPosition()].secondaryStructure>' ')
2955             // {
2956             // anot[ae[aa].getPosition()].displayCharacter = "";
2957             // }
2958             anot[anpos].colour = new java.awt.Color(ae[aa].getColour());
2959             if (firstColour == null)
2960             {
2961               firstColour = anot[anpos].colour;
2962             }
2963           }
2964         }
2965         jalview.datamodel.AlignmentAnnotation jaa = null;
2966
2967         if (annotation.getGraph())
2968         {
2969           float llim = 0, hlim = 0;
2970           // if (autoForView || an[i].isAutoCalculated()) {
2971           // hlim=11f;
2972           // }
2973           jaa = new jalview.datamodel.AlignmentAnnotation(
2974                   annotation.getLabel(), annotation.getDescription(), anot,
2975                   llim, hlim, annotation.getGraphType());
2976
2977           jaa.graphGroup = annotation.getGraphGroup();
2978           jaa._linecolour = firstColour;
2979           if (annotation.getThresholdLine() != null)
2980           {
2981             jaa.setThreshold(new jalview.datamodel.GraphLine(annotation
2982                     .getThresholdLine().getValue(), annotation
2983                     .getThresholdLine().getLabel(), new java.awt.Color(
2984                     annotation.getThresholdLine().getColour())));
2985
2986           }
2987           if (autoForView || annotation.isAutoCalculated())
2988           {
2989             // Hardwire the symbol display line to ensure that labels for
2990             // histograms are displayed
2991             jaa.hasText = true;
2992           }
2993         }
2994         else
2995         {
2996           jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(),
2997                   an[i].getDescription(), anot);
2998           jaa._linecolour = firstColour;
2999         }
3000         // register new annotation
3001         if (an[i].getId() != null)
3002         {
3003           annotationIds.put(an[i].getId(), jaa);
3004           jaa.annotationId = an[i].getId();
3005         }
3006         // recover sequence association
3007         String sequenceRef = an[i].getSequenceRef();
3008         if (sequenceRef != null)
3009         {
3010           // from 2.9 sequenceRef is to sequence id (JAL-1781)
3011           SequenceI sequence = seqRefIds.get(sequenceRef);
3012           if (sequence == null)
3013           {
3014             // in pre-2.9 projects sequence ref is to sequence name
3015             sequence = al.findName(sequenceRef);
3016           }
3017           if (sequence != null)
3018           {
3019             jaa.createSequenceMapping(sequence, 1, true);
3020             sequence.addAlignmentAnnotation(jaa);
3021           }
3022         }
3023         // and make a note of any group association
3024         if (an[i].getGroupRef() != null && an[i].getGroupRef().length() > 0)
3025         {
3026           List<jalview.datamodel.AlignmentAnnotation> aal = groupAnnotRefs
3027                   .get(an[i].getGroupRef());
3028           if (aal == null)
3029           {
3030             aal = new ArrayList<jalview.datamodel.AlignmentAnnotation>();
3031             groupAnnotRefs.put(an[i].getGroupRef(), aal);
3032           }
3033           aal.add(jaa);
3034         }
3035
3036         if (an[i].hasScore())
3037         {
3038           jaa.setScore(an[i].getScore());
3039         }
3040         if (an[i].hasVisible())
3041         {
3042           jaa.visible = an[i].getVisible();
3043         }
3044
3045         if (an[i].hasCentreColLabels())
3046         {
3047           jaa.centreColLabels = an[i].getCentreColLabels();
3048         }
3049
3050         if (an[i].hasScaleColLabels())
3051         {
3052           jaa.scaleColLabel = an[i].getScaleColLabels();
3053         }
3054         if (an[i].hasAutoCalculated() && an[i].isAutoCalculated())
3055         {
3056           // newer files have an 'autoCalculated' flag and store calculation
3057           // state in viewport properties
3058           jaa.autoCalculated = true; // means annotation will be marked for
3059           // update at end of load.
3060         }
3061         if (an[i].hasGraphHeight())
3062         {
3063           jaa.graphHeight = an[i].getGraphHeight();
3064         }
3065         if (an[i].hasBelowAlignment())
3066         {
3067           jaa.belowAlignment = an[i].isBelowAlignment();
3068         }
3069         jaa.setCalcId(an[i].getCalcId());
3070         if (an[i].getPropertyCount() > 0)
3071         {
3072           for (jalview.schemabinding.version2.Property prop : an[i]
3073                   .getProperty())
3074           {
3075             jaa.setProperty(prop.getName(), prop.getValue());
3076           }
3077         }
3078         if (jaa.autoCalculated)
3079         {
3080           autoAlan.add(new JvAnnotRow(i, jaa));
3081         }
3082         else
3083         // if (!autoForView)
3084         {
3085           // add autocalculated group annotation and any user created annotation
3086           // for the view
3087           al.addAnnotation(jaa);
3088         }
3089       }
3090     }
3091     // ///////////////////////
3092     // LOAD GROUPS
3093     // Create alignment markup and styles for this view
3094     if (jms.getJGroupCount() > 0)
3095     {
3096       JGroup[] groups = jms.getJGroup();
3097       boolean addAnnotSchemeGroup = false;
3098       for (int i = 0; i < groups.length; i++)
3099       {
3100         JGroup jGroup = groups[i];
3101         ColourSchemeI cs = null;
3102         if (jGroup.getColour() != null)
3103         {
3104           if (jGroup.getColour().startsWith("ucs"))
3105           {
3106             cs = getUserColourScheme(jms, jGroup.getColour());
3107           }
3108           else if (jGroup.getColour().equals("AnnotationColourGradient")
3109                   && jGroup.getAnnotationColours() != null)
3110           {
3111             addAnnotSchemeGroup = true;
3112             cs = null;
3113           }
3114           else
3115           {
3116             cs = ColourSchemeProperty.getColour(al, jGroup.getColour());
3117           }
3118
3119           if (cs != null)
3120           {
3121             cs.setThreshold(jGroup.getPidThreshold(), true);
3122           }
3123         }
3124
3125         Vector<SequenceI> seqs = new Vector<SequenceI>();
3126
3127         for (int s = 0; s < jGroup.getSeqCount(); s++)
3128         {
3129           String seqId = jGroup.getSeq(s) + "";
3130           SequenceI ts = seqRefIds.get(seqId);
3131
3132           if (ts != null)
3133           {
3134             seqs.addElement(ts);
3135           }
3136         }
3137
3138         if (seqs.size() < 1)
3139         {
3140           continue;
3141         }
3142
3143         SequenceGroup sg = new SequenceGroup(seqs, jGroup.getName(), cs,
3144                 jGroup.getDisplayBoxes(), jGroup.getDisplayText(),
3145                 jGroup.getColourText(), jGroup.getStart(), jGroup.getEnd());
3146
3147         sg.setOutlineColour(new java.awt.Color(jGroup.getOutlineColour()));
3148
3149         sg.textColour = new java.awt.Color(jGroup.getTextCol1());
3150         sg.textColour2 = new java.awt.Color(jGroup.getTextCol2());
3151         sg.setShowNonconserved(jGroup.hasShowUnconserved() ? jGroup
3152                 .isShowUnconserved() : false);
3153         sg.thresholdTextColour = jGroup.getTextColThreshold();
3154         if (jGroup.hasShowConsensusHistogram())
3155         {
3156           sg.setShowConsensusHistogram(jGroup.isShowConsensusHistogram());
3157         }
3158         ;
3159         if (jGroup.hasShowSequenceLogo())
3160         {
3161           sg.setshowSequenceLogo(jGroup.isShowSequenceLogo());
3162         }
3163         if (jGroup.hasNormaliseSequenceLogo())
3164         {
3165           sg.setNormaliseSequenceLogo(jGroup.isNormaliseSequenceLogo());
3166         }
3167         if (jGroup.hasIgnoreGapsinConsensus())
3168         {
3169           sg.setIgnoreGapsConsensus(jGroup.getIgnoreGapsinConsensus());
3170         }
3171         if (jGroup.getConsThreshold() != 0)
3172         {
3173           jalview.analysis.Conservation c = new jalview.analysis.Conservation(
3174                   "All", ResidueProperties.propHash, 3,
3175                   sg.getSequences(null), 0, sg.getWidth() - 1);
3176           c.calculate();
3177           c.verdict(false, 25);
3178           sg.cs.setConservation(c);
3179         }
3180
3181         if (jGroup.getId() != null && groupAnnotRefs.size() > 0)
3182         {
3183           // re-instate unique group/annotation row reference
3184           List<AlignmentAnnotation> jaal = groupAnnotRefs.get(jGroup
3185                   .getId());
3186           if (jaal != null)
3187           {
3188             for (AlignmentAnnotation jaa : jaal)
3189             {
3190               jaa.groupRef = sg;
3191               if (jaa.autoCalculated)
3192               {
3193                 // match up and try to set group autocalc alignment row for this
3194                 // annotation
3195                 if (jaa.label.startsWith("Consensus for "))
3196                 {
3197                   sg.setConsensus(jaa);
3198                 }
3199                 // match up and try to set group autocalc alignment row for this
3200                 // annotation
3201                 if (jaa.label.startsWith("Conservation for "))
3202                 {
3203                   sg.setConservationRow(jaa);
3204                 }
3205               }
3206             }
3207           }
3208         }
3209         al.addGroup(sg);
3210         if (addAnnotSchemeGroup)
3211         {
3212           // reconstruct the annotation colourscheme
3213           sg.cs = constructAnnotationColour(jGroup.getAnnotationColours(),
3214                   null, al, jms, false);
3215         }
3216       }
3217     }
3218     if (view == null)
3219     {
3220       // only dataset in this model, so just return.
3221       return null;
3222     }
3223     // ///////////////////////////////
3224     // LOAD VIEWPORT
3225
3226     // If we just load in the same jar file again, the sequenceSetId
3227     // will be the same, and we end up with multiple references
3228     // to the same sequenceSet. We must modify this id on load
3229     // so that each load of the file gives a unique id
3230     String uniqueSeqSetId = view.getSequenceSetId() + uniqueSetSuffix;
3231     String viewId = (view.getId() == null ? null : view.getId()
3232             + uniqueSetSuffix);
3233     AlignFrame af = null;
3234     AlignViewport av = null;
3235     // now check to see if we really need to create a new viewport.
3236     if (multipleView && viewportsAdded.size() == 0)
3237     {
3238       // We recovered an alignment for which a viewport already exists.
3239       // TODO: fix up any settings necessary for overlaying stored state onto
3240       // state recovered from another document. (may not be necessary).
3241       // we may need a binding from a viewport in memory to one recovered from
3242       // XML.
3243       // and then recover its containing af to allow the settings to be applied.
3244       // TODO: fix for vamsas demo
3245       System.err
3246               .println("About to recover a viewport for existing alignment: Sequence set ID is "
3247                       + uniqueSeqSetId);
3248       Object seqsetobj = retrieveExistingObj(uniqueSeqSetId);
3249       if (seqsetobj != null)
3250       {
3251         if (seqsetobj instanceof String)
3252         {
3253           uniqueSeqSetId = (String) seqsetobj;
3254           System.err
3255                   .println("Recovered extant sequence set ID mapping for ID : New Sequence set ID is "
3256                           + uniqueSeqSetId);
3257         }
3258         else
3259         {
3260           System.err
3261                   .println("Warning : Collision between sequence set ID string and existing jalview object mapping.");
3262         }
3263
3264       }
3265     }
3266     /**
3267      * indicate that annotation colours are applied across all groups (pre
3268      * Jalview 2.8.1 behaviour)
3269      */
3270     boolean doGroupAnnColour = Jalview2XML.isVersionStringLaterThan(
3271             "2.8.1", object.getVersion());
3272
3273     AlignmentPanel ap = null;
3274     boolean isnewview = true;
3275     if (viewId != null)
3276     {
3277       // Check to see if this alignment already has a view id == viewId
3278       jalview.gui.AlignmentPanel views[] = Desktop
3279               .getAlignmentPanels(uniqueSeqSetId);
3280       if (views != null && views.length > 0)
3281       {
3282         for (int v = 0; v < views.length; v++)
3283         {
3284           if (views[v].av.getViewId().equalsIgnoreCase(viewId))
3285           {
3286             // recover the existing alignpanel, alignframe, viewport
3287             af = views[v].alignFrame;
3288             av = views[v].av;
3289             ap = views[v];
3290             // TODO: could even skip resetting view settings if we don't want to
3291             // change the local settings from other jalview processes
3292             isnewview = false;
3293           }
3294         }
3295       }
3296     }
3297
3298     if (isnewview)
3299     {
3300       af = loadViewport(file, jseqs, hiddenSeqs, al, jms, view,
3301               uniqueSeqSetId, viewId, autoAlan);
3302       av = af.viewport;
3303       ap = af.alignPanel;
3304     }
3305
3306     /*
3307      * Load any trees, PDB structures and viewers
3308      *
3309      * Not done if flag is false (when this method is used for New View)
3310      */
3311     if (loadTreesAndStructures)
3312     {
3313       loadTrees(jms, view, af, av, ap);
3314       loadPDBStructures(jprovider, jseqs, af, ap);
3315       loadRnaViewers(jprovider, jseqs, ap);
3316     }
3317     // and finally return.
3318     return af;
3319   }
3320
3321   /**
3322    * Instantiate and link any saved RNA (Varna) viewers. The state of the Varna
3323    * panel is restored from separate jar entries, two (gapped and trimmed) per
3324    * sequence and secondary structure.
3325    *
3326    * Currently each viewer shows just one sequence and structure (gapped and
3327    * trimmed), however this method is designed to support multiple sequences or
3328    * structures in viewers if wanted in future.
3329    *
3330    * @param jprovider
3331    * @param jseqs
3332    * @param ap
3333    */
3334   private void loadRnaViewers(jarInputStreamProvider jprovider,
3335           JSeq[] jseqs, AlignmentPanel ap)
3336   {
3337     /*
3338      * scan the sequences for references to viewers; create each one the first
3339      * time it is referenced, add Rna models to existing viewers
3340      */
3341     for (JSeq jseq : jseqs)
3342     {
3343       for (int i = 0; i < jseq.getRnaViewerCount(); i++)
3344       {
3345         RnaViewer viewer = jseq.getRnaViewer(i);
3346         AppVarna appVarna = findOrCreateVarnaViewer(viewer,
3347                 uniqueSetSuffix, ap);
3348
3349         for (int j = 0; j < viewer.getSecondaryStructureCount(); j++)
3350         {
3351           SecondaryStructure ss = viewer.getSecondaryStructure(j);
3352           SequenceI seq = seqRefIds.get(jseq.getId());
3353           AlignmentAnnotation ann = this.annotationIds.get(ss
3354                   .getAnnotationId());
3355
3356           /*
3357            * add the structure to the Varna display (with session state copied
3358            * from the jar to a temporary file)
3359            */
3360           boolean gapped = ss.isGapped();
3361           String rnaTitle = ss.getTitle();
3362           String sessionState = ss.getViewerState();
3363           String tempStateFile = copyJarEntry(jprovider, sessionState,
3364                   "varna");
3365           RnaModel rna = new RnaModel(rnaTitle, ann, seq, null, gapped);
3366           appVarna.addModelSession(rna, rnaTitle, tempStateFile);
3367         }
3368         appVarna.setInitialSelection(viewer.getSelectedRna());
3369       }
3370     }
3371   }
3372
3373   /**
3374    * Locate and return an already instantiated matching AppVarna, or create one
3375    * if not found
3376    *
3377    * @param viewer
3378    * @param viewIdSuffix
3379    * @param ap
3380    * @return
3381    */
3382   protected AppVarna findOrCreateVarnaViewer(RnaViewer viewer,
3383           String viewIdSuffix, AlignmentPanel ap)
3384   {
3385     /*
3386      * on each load a suffix is appended to the saved viewId, to avoid conflicts
3387      * if load is repeated
3388      */
3389     String postLoadId = viewer.getViewId() + viewIdSuffix;
3390     for (JInternalFrame frame : getAllFrames())
3391     {
3392       if (frame instanceof AppVarna)
3393       {
3394         AppVarna varna = (AppVarna) frame;
3395         if (postLoadId.equals(varna.getViewId()))
3396         {
3397           // this viewer is already instantiated
3398           // could in future here add ap as another 'parent' of the
3399           // AppVarna window; currently just 1-to-many
3400           return varna;
3401         }
3402       }
3403     }
3404
3405     /*
3406      * viewer not found - make it
3407      */
3408     RnaViewerModel model = new RnaViewerModel(postLoadId,
3409             viewer.getTitle(), viewer.getXpos(), viewer.getYpos(),
3410             viewer.getWidth(), viewer.getHeight(),
3411             viewer.getDividerLocation());
3412     AppVarna varna = new AppVarna(model, ap);
3413
3414     return varna;
3415   }
3416
3417   /**
3418    * Load any saved trees
3419    *
3420    * @param jms
3421    * @param view
3422    * @param af
3423    * @param av
3424    * @param ap
3425    */
3426   protected void loadTrees(JalviewModelSequence jms, Viewport view,
3427           AlignFrame af, AlignViewport av, AlignmentPanel ap)
3428   {
3429     // TODO result of automated refactoring - are all these parameters needed?
3430     try
3431     {
3432       for (int t = 0; t < jms.getTreeCount(); t++)
3433       {
3434
3435         Tree tree = jms.getTree(t);
3436
3437         TreePanel tp = (TreePanel) retrieveExistingObj(tree.getId());
3438         if (tp == null)
3439         {
3440           tp = af.ShowNewickTree(
3441                   new jalview.io.NewickFile(tree.getNewick()),
3442                   tree.getTitle(), tree.getWidth(), tree.getHeight(),
3443                   tree.getXpos(), tree.getYpos());
3444           if (tree.getId() != null)
3445           {
3446             // perhaps bind the tree id to something ?
3447           }
3448         }
3449         else
3450         {
3451           // update local tree attributes ?
3452           // TODO: should check if tp has been manipulated by user - if so its
3453           // settings shouldn't be modified
3454           tp.setTitle(tree.getTitle());
3455           tp.setBounds(new Rectangle(tree.getXpos(), tree.getYpos(), tree
3456                   .getWidth(), tree.getHeight()));
3457           tp.av = av; // af.viewport; // TODO: verify 'associate with all
3458           // views'
3459           // works still
3460           tp.treeCanvas.av = av; // af.viewport;
3461           tp.treeCanvas.ap = ap; // af.alignPanel;
3462
3463         }
3464         if (tp == null)
3465         {
3466           warn("There was a problem recovering stored Newick tree: \n"
3467                   + tree.getNewick());
3468           continue;
3469         }
3470
3471         tp.fitToWindow.setState(tree.getFitToWindow());
3472         tp.fitToWindow_actionPerformed(null);
3473
3474         if (tree.getFontName() != null)
3475         {
3476           tp.setTreeFont(new java.awt.Font(tree.getFontName(), tree
3477                   .getFontStyle(), tree.getFontSize()));
3478         }
3479         else
3480         {
3481           tp.setTreeFont(new java.awt.Font(view.getFontName(), view
3482                   .getFontStyle(), tree.getFontSize()));
3483         }
3484
3485         tp.showPlaceholders(tree.getMarkUnlinked());
3486         tp.showBootstrap(tree.getShowBootstrap());
3487         tp.showDistances(tree.getShowDistances());
3488
3489         tp.treeCanvas.threshold = tree.getThreshold();
3490
3491         if (tree.getCurrentTree())
3492         {
3493           af.viewport.setCurrentTree(tp.getTree());
3494         }
3495       }
3496
3497     } catch (Exception ex)
3498     {
3499       ex.printStackTrace();
3500     }
3501   }
3502
3503   /**
3504    * Load and link any saved structure viewers.
3505    *
3506    * @param jprovider
3507    * @param jseqs
3508    * @param af
3509    * @param ap
3510    */
3511   protected void loadPDBStructures(jarInputStreamProvider jprovider,
3512           JSeq[] jseqs, AlignFrame af, AlignmentPanel ap)
3513   {
3514     /*
3515      * Run through all PDB ids on the alignment, and collect mappings between
3516      * distinct view ids and all sequences referring to that view.
3517      */
3518     Map<String, StructureViewerModel> structureViewers = new LinkedHashMap<String, StructureViewerModel>();
3519
3520     for (int i = 0; i < jseqs.length; i++)
3521     {
3522       if (jseqs[i].getPdbidsCount() > 0)
3523       {
3524         Pdbids[] ids = jseqs[i].getPdbids();
3525         for (int p = 0; p < ids.length; p++)
3526         {
3527           final int structureStateCount = ids[p].getStructureStateCount();
3528           for (int s = 0; s < structureStateCount; s++)
3529           {
3530             // check to see if we haven't already created this structure view
3531             final StructureState structureState = ids[p]
3532                     .getStructureState(s);
3533             String sviewid = (structureState.getViewId() == null) ? null
3534                     : structureState.getViewId() + uniqueSetSuffix;
3535             jalview.datamodel.PDBEntry jpdb = new jalview.datamodel.PDBEntry();
3536             // Originally : ids[p].getFile()
3537             // : TODO: verify external PDB file recovery still works in normal
3538             // jalview project load
3539             jpdb.setFile(loadPDBFile(jprovider, ids[p].getId()));
3540             jpdb.setId(ids[p].getId());
3541
3542             int x = structureState.getXpos();
3543             int y = structureState.getYpos();
3544             int width = structureState.getWidth();
3545             int height = structureState.getHeight();
3546
3547             // Probably don't need to do this anymore...
3548             // Desktop.desktop.getComponentAt(x, y);
3549             // TODO: NOW: check that this recovers the PDB file correctly.
3550             String pdbFile = loadPDBFile(jprovider, ids[p].getId());
3551             jalview.datamodel.SequenceI seq = seqRefIds.get(jseqs[i]
3552                     .getId() + "");
3553             if (sviewid == null)
3554             {
3555               sviewid = "_jalview_pre2_4_" + x + "," + y + "," + width
3556                       + "," + height;
3557             }
3558             if (!structureViewers.containsKey(sviewid))
3559             {
3560               structureViewers.put(sviewid,
3561                       new StructureViewerModel(x, y, width, height, false,
3562                               false, true, structureState.getViewId(),
3563                               structureState.getType()));
3564               // Legacy pre-2.7 conversion JAL-823 :
3565               // do not assume any view has to be linked for colour by
3566               // sequence
3567             }
3568
3569             // assemble String[] { pdb files }, String[] { id for each
3570             // file }, orig_fileloc, SequenceI[][] {{ seqs_file 1 }, {
3571             // seqs_file 2}, boolean[] {
3572             // linkAlignPanel,superposeWithAlignpanel}} from hash
3573             StructureViewerModel jmoldat = structureViewers.get(sviewid);
3574             jmoldat.setAlignWithPanel(jmoldat.isAlignWithPanel()
3575                     | (structureState.hasAlignwithAlignPanel() ? structureState
3576                             .getAlignwithAlignPanel() : false));
3577
3578             /*
3579              * Default colour by linked panel to false if not specified (e.g.
3580              * for pre-2.7 projects)
3581              */
3582             boolean colourWithAlignPanel = jmoldat.isColourWithAlignPanel();
3583             colourWithAlignPanel |= (structureState
3584                     .hasColourwithAlignPanel() ? structureState
3585                     .getColourwithAlignPanel() : false);
3586             jmoldat.setColourWithAlignPanel(colourWithAlignPanel);
3587
3588             /*
3589              * Default colour by viewer to true if not specified (e.g. for
3590              * pre-2.7 projects)
3591              */
3592             boolean colourByViewer = jmoldat.isColourByViewer();
3593             colourByViewer &= structureState.hasColourByJmol() ? structureState
3594                     .getColourByJmol() : true;
3595             jmoldat.setColourByViewer(colourByViewer);
3596
3597             if (jmoldat.getStateData().length() < structureState
3598                     .getContent().length())
3599             {
3600               {
3601                 jmoldat.setStateData(structureState.getContent());
3602               }
3603             }
3604             if (ids[p].getFile() != null)
3605             {
3606               File mapkey = new File(ids[p].getFile());
3607               StructureData seqstrmaps = jmoldat.getFileData().get(mapkey);
3608               if (seqstrmaps == null)
3609               {
3610                 jmoldat.getFileData().put(
3611                         mapkey,
3612                         seqstrmaps = jmoldat.new StructureData(pdbFile,
3613                                 ids[p].getId()));
3614               }
3615               if (!seqstrmaps.getSeqList().contains(seq))
3616               {
3617                 seqstrmaps.getSeqList().add(seq);
3618                 // TODO and chains?
3619               }
3620             }
3621             else
3622             {
3623               errorMessage = ("The Jmol views in this project were imported\nfrom an older version of Jalview.\nPlease review the sequence colour associations\nin the Colour by section of the Jmol View menu.\n\nIn the case of problems, see note at\nhttp://issues.jalview.org/browse/JAL-747");
3624               warn(errorMessage);
3625             }
3626           }
3627         }
3628       }
3629     }
3630     // Instantiate the associated structure views
3631     for (Entry<String, StructureViewerModel> entry : structureViewers
3632             .entrySet())
3633     {
3634       try
3635       {
3636         createOrLinkStructureViewer(entry, af, ap, jprovider);
3637       } catch (Exception e)
3638       {
3639         System.err.println("Error loading structure viewer: "
3640                 + e.getMessage());
3641         // failed - try the next one
3642       }
3643     }
3644   }
3645
3646   /**
3647    *
3648    * @param viewerData
3649    * @param af
3650    * @param ap
3651    * @param jprovider
3652    */
3653   protected void createOrLinkStructureViewer(
3654           Entry<String, StructureViewerModel> viewerData, AlignFrame af,
3655           AlignmentPanel ap, jarInputStreamProvider jprovider)
3656   {
3657     final StructureViewerModel stateData = viewerData.getValue();
3658
3659     /*
3660      * Search for any viewer windows already open from other alignment views
3661      * that exactly match the stored structure state
3662      */
3663     StructureViewerBase comp = findMatchingViewer(viewerData);
3664
3665     if (comp != null)
3666     {
3667       linkStructureViewer(ap, comp, stateData);
3668       return;
3669     }
3670
3671     /*
3672      * From 2.9: stateData.type contains JMOL or CHIMERA, data is in jar entry
3673      * "viewer_"+stateData.viewId
3674      */
3675     if (ViewerType.CHIMERA.toString().equals(stateData.getType()))
3676     {
3677       createChimeraViewer(viewerData, af, jprovider);
3678     }
3679     else
3680     {
3681       /*
3682        * else Jmol (if pre-2.9, stateData contains JMOL state string)
3683        */
3684       createJmolViewer(viewerData, af, jprovider);
3685     }
3686   }
3687
3688   /**
3689    * Create a new Chimera viewer.
3690    *
3691    * @param data
3692    * @param af
3693    * @param jprovider
3694    */
3695   protected void createChimeraViewer(
3696           Entry<String, StructureViewerModel> viewerData, AlignFrame af,
3697           jarInputStreamProvider jprovider)
3698   {
3699     StructureViewerModel data = viewerData.getValue();
3700     String chimeraSessionFile = data.getStateData();
3701
3702     /*
3703      * Copy Chimera session from jar entry "viewer_"+viewId to a temporary file
3704      *
3705      * NB this is the 'saved' viewId as in the project file XML, _not_ the
3706      * 'uniquified' sviewid used to reconstruct the viewer here
3707      */
3708     String viewerJarEntryName = getViewerJarEntryName(data.getViewId());
3709     chimeraSessionFile = copyJarEntry(jprovider, viewerJarEntryName,
3710             "chimera");
3711
3712     Set<Entry<File, StructureData>> fileData = data.getFileData()
3713             .entrySet();
3714     List<PDBEntry> pdbs = new ArrayList<PDBEntry>();
3715     List<SequenceI[]> allseqs = new ArrayList<SequenceI[]>();
3716     for (Entry<File, StructureData> pdb : fileData)
3717     {
3718       String filePath = pdb.getValue().getFilePath();
3719       String pdbId = pdb.getValue().getPdbId();
3720       // pdbs.add(new PDBEntry(filePath, pdbId));
3721       pdbs.add(new PDBEntry(pdbId, null, PDBEntry.Type.PDB, filePath));
3722       final List<SequenceI> seqList = pdb.getValue().getSeqList();
3723       SequenceI[] seqs = seqList.toArray(new SequenceI[seqList.size()]);
3724       allseqs.add(seqs);
3725     }
3726
3727     boolean colourByChimera = data.isColourByViewer();
3728     boolean colourBySequence = data.isColourWithAlignPanel();
3729
3730     // TODO use StructureViewer as a factory here, see JAL-1761
3731     final PDBEntry[] pdbArray = pdbs.toArray(new PDBEntry[pdbs.size()]);
3732     final SequenceI[][] seqsArray = allseqs.toArray(new SequenceI[allseqs
3733             .size()][]);
3734     String newViewId = viewerData.getKey();
3735
3736     ChimeraViewFrame cvf = new ChimeraViewFrame(chimeraSessionFile,
3737             af.alignPanel, pdbArray, seqsArray, colourByChimera,
3738             colourBySequence, newViewId);
3739     cvf.setSize(data.getWidth(), data.getHeight());
3740     cvf.setLocation(data.getX(), data.getY());
3741   }
3742
3743   /**
3744    * Create a new Jmol window. First parse the Jmol state to translate filenames
3745    * loaded into the view, and record the order in which files are shown in the
3746    * Jmol view, so we can add the sequence mappings in same order.
3747    *
3748    * @param viewerData
3749    * @param af
3750    * @param jprovider
3751    */
3752   protected void createJmolViewer(
3753           final Entry<String, StructureViewerModel> viewerData,
3754           AlignFrame af, jarInputStreamProvider jprovider)
3755   {
3756     final StructureViewerModel svattrib = viewerData.getValue();
3757     String state = svattrib.getStateData();
3758
3759     /*
3760      * Pre-2.9: state element value is the Jmol state string
3761      *
3762      * 2.9+: @type is "JMOL", state data is in a Jar file member named "viewer_"
3763      * + viewId
3764      */
3765     if (ViewerType.JMOL.toString().equals(svattrib.getType()))
3766     {
3767       state = readJarEntry(jprovider,
3768               getViewerJarEntryName(svattrib.getViewId()));
3769     }
3770
3771     List<String> pdbfilenames = new ArrayList<String>();
3772     List<SequenceI[]> seqmaps = new ArrayList<SequenceI[]>();
3773     List<String> pdbids = new ArrayList<String>();
3774     StringBuilder newFileLoc = new StringBuilder(64);
3775     int cp = 0, ncp, ecp;
3776     Map<File, StructureData> oldFiles = svattrib.getFileData();
3777     while ((ncp = state.indexOf("load ", cp)) > -1)
3778     {
3779       do
3780       {
3781         // look for next filename in load statement
3782         newFileLoc.append(state.substring(cp,
3783                 ncp = (state.indexOf("\"", ncp + 1) + 1)));
3784         String oldfilenam = state.substring(ncp,
3785                 ecp = state.indexOf("\"", ncp));
3786         // recover the new mapping data for this old filename
3787         // have to normalize filename - since Jmol and jalview do
3788         // filename
3789         // translation differently.
3790         StructureData filedat = oldFiles.get(new File(oldfilenam));
3791         newFileLoc.append(Platform.escapeString(filedat.getFilePath()));
3792         pdbfilenames.add(filedat.getFilePath());
3793         pdbids.add(filedat.getPdbId());
3794         seqmaps.add(filedat.getSeqList().toArray(new SequenceI[0]));
3795         newFileLoc.append("\"");
3796         cp = ecp + 1; // advance beyond last \" and set cursor so we can
3797                       // look for next file statement.
3798       } while ((ncp = state.indexOf("/*file*/", cp)) > -1);
3799     }
3800     if (cp > 0)
3801     {
3802       // just append rest of state
3803       newFileLoc.append(state.substring(cp));
3804     }
3805     else
3806     {
3807       System.err.print("Ignoring incomplete Jmol state for PDB ids: ");
3808       newFileLoc = new StringBuilder(state);
3809       newFileLoc.append("; load append ");
3810       for (File id : oldFiles.keySet())
3811       {
3812         // add this and any other pdb files that should be present in
3813         // the viewer
3814         StructureData filedat = oldFiles.get(id);
3815         newFileLoc.append(filedat.getFilePath());
3816         pdbfilenames.add(filedat.getFilePath());
3817         pdbids.add(filedat.getPdbId());
3818         seqmaps.add(filedat.getSeqList().toArray(new SequenceI[0]));
3819         newFileLoc.append(" \"");
3820         newFileLoc.append(filedat.getFilePath());
3821         newFileLoc.append("\"");
3822
3823       }
3824       newFileLoc.append(";");
3825     }
3826
3827     if (newFileLoc.length() == 0)
3828     {
3829       return;
3830     }
3831     int histbug = newFileLoc.indexOf("history = ");
3832     if (histbug > -1)
3833     {
3834       /*
3835        * change "history = [true|false];" to "history = [1|0];"
3836        */
3837       histbug += 10;
3838       int diff = histbug == -1 ? -1 : newFileLoc.indexOf(";", histbug);
3839       String val = (diff == -1) ? null : newFileLoc
3840               .substring(histbug, diff);
3841       if (val != null && val.length() >= 4)
3842       {
3843         if (val.contains("e")) // eh? what can it be?
3844         {
3845           if (val.trim().equals("true"))
3846           {
3847             val = "1";
3848           }
3849           else
3850           {
3851             val = "0";
3852           }
3853           newFileLoc.replace(histbug, diff, val);
3854         }
3855       }
3856     }
3857
3858     final String[] pdbf = pdbfilenames.toArray(new String[pdbfilenames
3859             .size()]);
3860     final String[] id = pdbids.toArray(new String[pdbids.size()]);
3861     final SequenceI[][] sq = seqmaps
3862             .toArray(new SequenceI[seqmaps.size()][]);
3863     final String fileloc = newFileLoc.toString();
3864     final String sviewid = viewerData.getKey();
3865     final AlignFrame alf = af;
3866     final Rectangle rect = new Rectangle(svattrib.getX(), svattrib.getY(),
3867             svattrib.getWidth(), svattrib.getHeight());
3868     try
3869     {
3870       javax.swing.SwingUtilities.invokeAndWait(new Runnable()
3871       {
3872         @Override
3873         public void run()
3874         {
3875           JalviewStructureDisplayI sview = null;
3876           try
3877           {
3878             sview = new StructureViewer(alf.alignPanel
3879                     .getStructureSelectionManager()).createView(
3880                     StructureViewer.ViewerType.JMOL, pdbf, id, sq,
3881                     alf.alignPanel, svattrib, fileloc, rect, sviewid);
3882             addNewStructureViewer(sview);
3883           } catch (OutOfMemoryError ex)
3884           {
3885             new OOMWarning("restoring structure view for PDB id " + id,
3886                     (OutOfMemoryError) ex.getCause());
3887             if (sview != null && sview.isVisible())
3888             {
3889               sview.closeViewer(false);
3890               sview.setVisible(false);
3891               sview.dispose();
3892             }
3893           }
3894         }
3895       });
3896     } catch (InvocationTargetException ex)
3897     {
3898       warn("Unexpected error when opening Jmol view.", ex);
3899
3900     } catch (InterruptedException e)
3901     {
3902       // e.printStackTrace();
3903     }
3904
3905   }
3906
3907   /**
3908    * Generates a name for the entry in the project jar file to hold state
3909    * information for a structure viewer
3910    *
3911    * @param viewId
3912    * @return
3913    */
3914   protected String getViewerJarEntryName(String viewId)
3915   {
3916     return VIEWER_PREFIX + viewId;
3917   }
3918
3919   /**
3920    * Returns any open frame that matches given structure viewer data. The match
3921    * is based on the unique viewId, or (for older project versions) the frame's
3922    * geometry.
3923    *
3924    * @param viewerData
3925    * @return
3926    */
3927   protected StructureViewerBase findMatchingViewer(
3928           Entry<String, StructureViewerModel> viewerData)
3929   {
3930     final String sviewid = viewerData.getKey();
3931     final StructureViewerModel svattrib = viewerData.getValue();
3932     StructureViewerBase comp = null;
3933     JInternalFrame[] frames = getAllFrames();
3934     for (JInternalFrame frame : frames)
3935     {
3936       if (frame instanceof StructureViewerBase)
3937       {
3938         /*
3939          * Post jalview 2.4 schema includes structure view id
3940          */
3941         if (sviewid != null
3942                 && ((StructureViewerBase) frame).getViewId()
3943                         .equals(sviewid))
3944         {
3945           comp = (StructureViewerBase) frame;
3946           break; // break added in 2.9
3947         }
3948         /*
3949          * Otherwise test for matching position and size of viewer frame
3950          */
3951         else if (frame.getX() == svattrib.getX()
3952                 && frame.getY() == svattrib.getY()
3953                 && frame.getHeight() == svattrib.getHeight()
3954                 && frame.getWidth() == svattrib.getWidth())
3955         {
3956           comp = (StructureViewerBase) frame;
3957           // no break in faint hope of an exact match on viewId
3958         }
3959       }
3960     }
3961     return comp;
3962   }
3963
3964   /**
3965    * Link an AlignmentPanel to an existing structure viewer.
3966    *
3967    * @param ap
3968    * @param viewer
3969    * @param oldFiles
3970    * @param useinViewerSuperpos
3971    * @param usetoColourbyseq
3972    * @param viewerColouring
3973    */
3974   protected void linkStructureViewer(AlignmentPanel ap,
3975           StructureViewerBase viewer, StructureViewerModel stateData)
3976   {
3977     // NOTE: if the jalview project is part of a shared session then
3978     // view synchronization should/could be done here.
3979
3980     final boolean useinViewerSuperpos = stateData.isAlignWithPanel();
3981     final boolean usetoColourbyseq = stateData.isColourWithAlignPanel();
3982     final boolean viewerColouring = stateData.isColourByViewer();
3983     Map<File, StructureData> oldFiles = stateData.getFileData();
3984
3985     /*
3986      * Add mapping for sequences in this view to an already open viewer
3987      */
3988     final AAStructureBindingModel binding = viewer.getBinding();
3989     for (File id : oldFiles.keySet())
3990     {
3991       // add this and any other pdb files that should be present in the
3992       // viewer
3993       StructureData filedat = oldFiles.get(id);
3994       String pdbFile = filedat.getFilePath();
3995       SequenceI[] seq = filedat.getSeqList().toArray(new SequenceI[0]);
3996       binding.getSsm().setMapping(seq, null, pdbFile,
3997               jalview.io.AppletFormatAdapter.FILE);
3998       binding.addSequenceForStructFile(pdbFile, seq);
3999     }
4000     // and add the AlignmentPanel's reference to the view panel
4001     viewer.addAlignmentPanel(ap);
4002     if (useinViewerSuperpos)
4003     {
4004       viewer.useAlignmentPanelForSuperposition(ap);
4005     }
4006     else
4007     {
4008       viewer.excludeAlignmentPanelForSuperposition(ap);
4009     }
4010     if (usetoColourbyseq)
4011     {
4012       viewer.useAlignmentPanelForColourbyseq(ap, !viewerColouring);
4013     }
4014     else
4015     {
4016       viewer.excludeAlignmentPanelForColourbyseq(ap);
4017     }
4018   }
4019
4020   /**
4021    * Get all frames within the Desktop.
4022    *
4023    * @return
4024    */
4025   protected JInternalFrame[] getAllFrames()
4026   {
4027     JInternalFrame[] frames = null;
4028     // TODO is this necessary - is it safe - risk of hanging?
4029     do
4030     {
4031       try
4032       {
4033         frames = Desktop.desktop.getAllFrames();
4034       } catch (ArrayIndexOutOfBoundsException e)
4035       {
4036         // occasional No such child exceptions are thrown here...
4037         try
4038         {
4039           Thread.sleep(10);
4040         } catch (InterruptedException f)
4041         {
4042         }
4043       }
4044     } while (frames == null);
4045     return frames;
4046   }
4047
4048   /**
4049    * Answers true if 'version' is equal to or later than 'supported', where each
4050    * is formatted as major/minor versions like "2.8.3" or "2.3.4b1" for bugfix
4051    * changes. Development and test values for 'version' are leniently treated
4052    * i.e. answer true.
4053    *
4054    * @param supported
4055    *          - minimum version we are comparing against
4056    * @param version
4057    *          - version of data being processsed
4058    * @return
4059    */
4060   public static boolean isVersionStringLaterThan(String supported,
4061           String version)
4062   {
4063     if (supported == null || version == null
4064             || version.equalsIgnoreCase("DEVELOPMENT BUILD")
4065             || version.equalsIgnoreCase("Test")
4066             || version.equalsIgnoreCase("AUTOMATED BUILD"))
4067     {
4068       System.err.println("Assuming project file with "
4069               + (version == null ? "null" : version)
4070               + " is compatible with Jalview version " + supported);
4071       return true;
4072     }
4073     else
4074     {
4075       return StringUtils.compareVersions(version, supported, "b") >= 0;
4076     }
4077   }
4078
4079   Vector<JalviewStructureDisplayI> newStructureViewers = null;
4080
4081   protected void addNewStructureViewer(JalviewStructureDisplayI sview)
4082   {
4083     if (newStructureViewers != null)
4084     {
4085       sview.getBinding().setFinishedLoadingFromArchive(false);
4086       newStructureViewers.add(sview);
4087     }
4088   }
4089
4090   protected void setLoadingFinishedForNewStructureViewers()
4091   {
4092     if (newStructureViewers != null)
4093     {
4094       for (JalviewStructureDisplayI sview : newStructureViewers)
4095       {
4096         sview.getBinding().setFinishedLoadingFromArchive(true);
4097       }
4098       newStructureViewers.clear();
4099       newStructureViewers = null;
4100     }
4101   }
4102
4103   AlignFrame loadViewport(String file, JSeq[] JSEQ,
4104           List<SequenceI> hiddenSeqs, AlignmentI al,
4105           JalviewModelSequence jms, Viewport view, String uniqueSeqSetId,
4106           String viewId, List<JvAnnotRow> autoAlan)
4107   {
4108     AlignFrame af = null;
4109     af = new AlignFrame(al, view.getWidth(), view.getHeight(),
4110             uniqueSeqSetId, viewId);
4111
4112     af.setFileName(file, "Jalview");
4113
4114     for (int i = 0; i < JSEQ.length; i++)
4115     {
4116       af.viewport.setSequenceColour(af.viewport.getAlignment()
4117               .getSequenceAt(i), new java.awt.Color(JSEQ[i].getColour()));
4118     }
4119
4120     if (al.hasSeqrep())
4121     {
4122       af.getViewport().setColourByReferenceSeq(true);
4123       af.getViewport().setDisplayReferenceSeq(true);
4124     }
4125
4126     af.viewport.setGatherViewsHere(view.getGatheredViews());
4127
4128     if (view.getSequenceSetId() != null)
4129     {
4130       AlignmentViewport av = viewportsAdded.get(uniqueSeqSetId);
4131
4132       af.viewport.setSequenceSetId(uniqueSeqSetId);
4133       if (av != null)
4134       {
4135         // propagate shared settings to this new view
4136         af.viewport.setHistoryList(av.getHistoryList());
4137         af.viewport.setRedoList(av.getRedoList());
4138       }
4139       else
4140       {
4141         viewportsAdded.put(uniqueSeqSetId, af.viewport);
4142       }
4143       // TODO: check if this method can be called repeatedly without
4144       // side-effects if alignpanel already registered.
4145       PaintRefresher.Register(af.alignPanel, uniqueSeqSetId);
4146     }
4147     // apply Hidden regions to view.
4148     if (hiddenSeqs != null)
4149     {
4150       for (int s = 0; s < JSEQ.length; s++)
4151       {
4152         SequenceGroup hidden = new SequenceGroup();
4153         boolean isRepresentative = false;
4154         for (int r = 0; r < JSEQ[s].getHiddenSequencesCount(); r++)
4155         {
4156           isRepresentative = true;
4157           SequenceI sequenceToHide = al.getSequenceAt(JSEQ[s]
4158                   .getHiddenSequences(r));
4159           hidden.addSequence(sequenceToHide, false);
4160           // remove from hiddenSeqs list so we don't try to hide it twice
4161           hiddenSeqs.remove(sequenceToHide);
4162         }
4163         if (isRepresentative)
4164         {
4165           SequenceI representativeSequence = al.getSequenceAt(s);
4166           hidden.addSequence(representativeSequence, false);
4167           af.viewport.hideRepSequences(representativeSequence, hidden);
4168         }
4169       }
4170
4171       SequenceI[] hseqs = hiddenSeqs.toArray(new SequenceI[hiddenSeqs
4172               .size()]);
4173       af.viewport.hideSequence(hseqs);
4174
4175     }
4176     // recover view properties and display parameters
4177     if (view.getViewName() != null)
4178     {
4179       af.viewport.viewName = view.getViewName();
4180       af.setInitialTabVisible();
4181     }
4182     af.setBounds(view.getXpos(), view.getYpos(), view.getWidth(),
4183             view.getHeight());
4184
4185     af.viewport.setShowAnnotation(view.getShowAnnotation());
4186     af.viewport.setAbovePIDThreshold(view.getPidSelected());
4187
4188     af.viewport.setColourText(view.getShowColourText());
4189
4190     af.viewport.setConservationSelected(view.getConservationSelected());
4191     af.viewport.setShowJVSuffix(view.getShowFullId());
4192     af.viewport.setRightAlignIds(view.getRightAlignIds());
4193     af.viewport.setFont(
4194             new java.awt.Font(view.getFontName(), view.getFontStyle(), view
4195                     .getFontSize()), true);
4196     ViewStyleI vs = af.viewport.getViewStyle();
4197     vs.setScaleProteinAsCdna(view.isScaleProteinAsCdna());
4198     af.viewport.setViewStyle(vs);
4199     // TODO: allow custom charWidth/Heights to be restored by updating them
4200     // after setting font - which means set above to false
4201     af.viewport.setRenderGaps(view.getRenderGaps());
4202     af.viewport.setWrapAlignment(view.getWrapAlignment());
4203     af.viewport.setShowAnnotation(view.getShowAnnotation());
4204
4205     af.viewport.setShowBoxes(view.getShowBoxes());
4206
4207     af.viewport.setShowText(view.getShowText());
4208
4209     af.viewport.setTextColour(new java.awt.Color(view.getTextCol1()));
4210     af.viewport.setTextColour2(new java.awt.Color(view.getTextCol2()));
4211     af.viewport.setThresholdTextColour(view.getTextColThreshold());
4212     af.viewport.setShowUnconserved(view.hasShowUnconserved() ? view
4213             .isShowUnconserved() : false);
4214     af.viewport.setStartRes(view.getStartRes());
4215     af.viewport.setStartSeq(view.getStartSeq());
4216     af.alignPanel.updateLayout();
4217     ColourSchemeI cs = null;
4218     // apply colourschemes
4219     if (view.getBgColour() != null)
4220     {
4221       if (view.getBgColour().startsWith("ucs"))
4222       {
4223         cs = getUserColourScheme(jms, view.getBgColour());
4224       }
4225       else if (view.getBgColour().startsWith("Annotation"))
4226       {
4227         AnnotationColours viewAnnColour = view.getAnnotationColours();
4228         cs = constructAnnotationColour(viewAnnColour, af, al, jms, true);
4229
4230         // annpos
4231
4232       }
4233       else
4234       {
4235         cs = ColourSchemeProperty.getColour(al, view.getBgColour());
4236       }
4237
4238       if (cs != null)
4239       {
4240         cs.setThreshold(view.getPidThreshold(), true);
4241         cs.setConsensus(af.viewport.getSequenceConsensusHash());
4242       }
4243     }
4244
4245     af.viewport.setGlobalColourScheme(cs);
4246     af.viewport.setColourAppliesToAllGroups(false);
4247
4248     if (view.getConservationSelected() && cs != null)
4249     {
4250       cs.setConservationInc(view.getConsThreshold());
4251     }
4252
4253     af.changeColour(cs);
4254
4255     af.viewport.setColourAppliesToAllGroups(true);
4256
4257     af.viewport.setShowSequenceFeatures(view.getShowSequenceFeatures());
4258
4259     if (view.hasCentreColumnLabels())
4260     {
4261       af.viewport.setCentreColumnLabels(view.getCentreColumnLabels());
4262     }
4263     if (view.hasIgnoreGapsinConsensus())
4264     {
4265       af.viewport.setIgnoreGapsConsensus(view.getIgnoreGapsinConsensus(),
4266               null);
4267     }
4268     if (view.hasFollowHighlight())
4269     {
4270       af.viewport.setFollowHighlight(view.getFollowHighlight());
4271     }
4272     if (view.hasFollowSelection())
4273     {
4274       af.viewport.followSelection = view.getFollowSelection();
4275     }
4276     if (view.hasShowConsensusHistogram())
4277     {
4278       af.viewport.setShowConsensusHistogram(view
4279               .getShowConsensusHistogram());
4280     }
4281     else
4282     {
4283       af.viewport.setShowConsensusHistogram(true);
4284     }
4285     if (view.hasShowSequenceLogo())
4286     {
4287       af.viewport.setShowSequenceLogo(view.getShowSequenceLogo());
4288     }
4289     else
4290     {
4291       af.viewport.setShowSequenceLogo(false);
4292     }
4293     if (view.hasNormaliseSequenceLogo())
4294     {
4295       af.viewport.setNormaliseSequenceLogo(view.getNormaliseSequenceLogo());
4296     }
4297     if (view.hasShowDbRefTooltip())
4298     {
4299       af.viewport.setShowDBRefs(view.getShowDbRefTooltip());
4300     }
4301     if (view.hasShowNPfeatureTooltip())
4302     {
4303       af.viewport.setShowNPFeats(view.hasShowNPfeatureTooltip());
4304     }
4305     if (view.hasShowGroupConsensus())
4306     {
4307       af.viewport.setShowGroupConsensus(view.getShowGroupConsensus());
4308     }
4309     else
4310     {
4311       af.viewport.setShowGroupConsensus(false);
4312     }
4313     if (view.hasShowGroupConservation())
4314     {
4315       af.viewport.setShowGroupConservation(view.getShowGroupConservation());
4316     }
4317     else
4318     {
4319       af.viewport.setShowGroupConservation(false);
4320     }
4321
4322     // recover featre settings
4323     if (jms.getFeatureSettings() != null)
4324     {
4325       FeaturesDisplayed fdi;
4326       af.viewport.setFeaturesDisplayed(fdi = new FeaturesDisplayed());
4327       String[] renderOrder = new String[jms.getFeatureSettings()
4328               .getSettingCount()];
4329       Map<String, FeatureColourI> featureColours = new Hashtable<String, FeatureColourI>();
4330       Map<String, Float> featureOrder = new Hashtable<String, Float>();
4331
4332       for (int fs = 0; fs < jms.getFeatureSettings().getSettingCount(); fs++)
4333       {
4334         Setting setting = jms.getFeatureSettings().getSetting(fs);
4335         if (setting.hasMincolour())
4336         {
4337           FeatureColourI gc = setting.hasMin() ? new FeatureColour(
4338                   new Color(setting.getMincolour()), new Color(
4339                           setting.getColour()), setting.getMin(),
4340                   setting.getMax()) : new FeatureColour(new Color(
4341                   setting.getMincolour()), new Color(setting.getColour()),
4342                   0, 1);
4343           if (setting.hasThreshold())
4344           {
4345             gc.setThreshold(setting.getThreshold());
4346             int threshstate = setting.getThreshstate();
4347             // -1 = None, 0 = Below, 1 = Above threshold
4348             if (threshstate == 0)
4349             {
4350               gc.setBelowThreshold(true);
4351             }
4352             else if (threshstate == 1)
4353             {
4354               gc.setAboveThreshold(true);
4355             }
4356           }
4357           gc.setAutoScaled(true); // default
4358           if (setting.hasAutoScale())
4359           {
4360             gc.setAutoScaled(setting.getAutoScale());
4361           }
4362           if (setting.hasColourByLabel())
4363           {
4364             gc.setColourByLabel(setting.getColourByLabel());
4365           }
4366           // and put in the feature colour table.
4367           featureColours.put(setting.getType(), gc);
4368         }
4369         else
4370         {
4371           featureColours.put(setting.getType(), new FeatureColour(
4372                   new Color(setting.getColour())));
4373         }
4374         renderOrder[fs] = setting.getType();
4375         if (setting.hasOrder())
4376         {
4377           featureOrder.put(setting.getType(), setting.getOrder());
4378         }
4379         else
4380         {
4381           featureOrder.put(setting.getType(), new Float(fs
4382                   / jms.getFeatureSettings().getSettingCount()));
4383         }
4384         if (setting.getDisplay())
4385         {
4386           fdi.setVisible(setting.getType());
4387         }
4388       }
4389       Map<String, Boolean> fgtable = new Hashtable<String, Boolean>();
4390       for (int gs = 0; gs < jms.getFeatureSettings().getGroupCount(); gs++)
4391       {
4392         Group grp = jms.getFeatureSettings().getGroup(gs);
4393         fgtable.put(grp.getName(), new Boolean(grp.getDisplay()));
4394       }
4395       // FeatureRendererSettings frs = new FeatureRendererSettings(renderOrder,
4396       // fgtable, featureColours, jms.getFeatureSettings().hasTransparency() ?
4397       // jms.getFeatureSettings().getTransparency() : 0.0, featureOrder);
4398       FeatureRendererSettings frs = new FeatureRendererSettings(
4399               renderOrder, fgtable, featureColours, 1.0f, featureOrder);
4400       af.alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer()
4401               .transferSettings(frs);
4402
4403     }
4404
4405     if (view.getHiddenColumnsCount() > 0)
4406     {
4407       for (int c = 0; c < view.getHiddenColumnsCount(); c++)
4408       {
4409         af.viewport.hideColumns(view.getHiddenColumns(c).getStart(), view
4410                 .getHiddenColumns(c).getEnd() // +1
4411                 );
4412       }
4413     }
4414     if (view.getCalcIdParam() != null)
4415     {
4416       for (CalcIdParam calcIdParam : view.getCalcIdParam())
4417       {
4418         if (calcIdParam != null)
4419         {
4420           if (recoverCalcIdParam(calcIdParam, af.viewport))
4421           {
4422           }
4423           else
4424           {
4425             warn("Couldn't recover parameters for "
4426                     + calcIdParam.getCalcId());
4427           }
4428         }
4429       }
4430     }
4431     af.setMenusFromViewport(af.viewport);
4432
4433     // TODO: we don't need to do this if the viewport is aready visible.
4434     /*
4435      * Add the AlignFrame to the desktop (it may be 'gathered' later), unless it
4436      * has a 'cdna/protein complement' view, in which case save it in order to
4437      * populate a SplitFrame once all views have been read in.
4438      */
4439     String complementaryViewId = view.getComplementId();
4440     if (complementaryViewId == null)
4441     {
4442       Desktop.addInternalFrame(af, view.getTitle(), view.getWidth(),
4443               view.getHeight());
4444       // recompute any autoannotation
4445       af.alignPanel.updateAnnotation(false, true);
4446       reorderAutoannotation(af, al, autoAlan);
4447       af.alignPanel.alignmentChanged();
4448     }
4449     else
4450     {
4451       splitFrameCandidates.put(view, af);
4452     }
4453     return af;
4454   }
4455
4456   private ColourSchemeI constructAnnotationColour(
4457           AnnotationColours viewAnnColour, AlignFrame af, AlignmentI al,
4458           JalviewModelSequence jms, boolean checkGroupAnnColour)
4459   {
4460     boolean propagateAnnColour = false;
4461     ColourSchemeI cs = null;
4462     AlignmentI annAlignment = af != null ? af.viewport.getAlignment() : al;
4463     if (checkGroupAnnColour && al.getGroups() != null
4464             && al.getGroups().size() > 0)
4465     {
4466       // pre 2.8.1 behaviour
4467       // check to see if we should transfer annotation colours
4468       propagateAnnColour = true;
4469       for (jalview.datamodel.SequenceGroup sg : al.getGroups())
4470       {
4471         if (sg.cs instanceof AnnotationColourGradient)
4472         {
4473           propagateAnnColour = false;
4474         }
4475       }
4476     }
4477     // int find annotation
4478     if (annAlignment.getAlignmentAnnotation() != null)
4479     {
4480       for (int i = 0; i < annAlignment.getAlignmentAnnotation().length; i++)
4481       {
4482         if (annAlignment.getAlignmentAnnotation()[i].label
4483                 .equals(viewAnnColour.getAnnotation()))
4484         {
4485           if (annAlignment.getAlignmentAnnotation()[i].getThreshold() == null)
4486           {
4487             annAlignment.getAlignmentAnnotation()[i]
4488                     .setThreshold(new jalview.datamodel.GraphLine(
4489                             viewAnnColour.getThreshold(), "Threshold",
4490                             java.awt.Color.black)
4491
4492                     );
4493           }
4494
4495           if (viewAnnColour.getColourScheme().equals("None"))
4496           {
4497             cs = new AnnotationColourGradient(
4498                     annAlignment.getAlignmentAnnotation()[i],
4499                     new java.awt.Color(viewAnnColour.getMinColour()),
4500                     new java.awt.Color(viewAnnColour.getMaxColour()),
4501                     viewAnnColour.getAboveThreshold());
4502           }
4503           else if (viewAnnColour.getColourScheme().startsWith("ucs"))
4504           {
4505             cs = new AnnotationColourGradient(
4506                     annAlignment.getAlignmentAnnotation()[i],
4507                     getUserColourScheme(jms,
4508                             viewAnnColour.getColourScheme()),
4509                     viewAnnColour.getAboveThreshold());
4510           }
4511           else
4512           {
4513             cs = new AnnotationColourGradient(
4514                     annAlignment.getAlignmentAnnotation()[i],
4515                     ColourSchemeProperty.getColour(al,
4516                             viewAnnColour.getColourScheme()),
4517                     viewAnnColour.getAboveThreshold());
4518           }
4519           if (viewAnnColour.hasPerSequence())
4520           {
4521             ((AnnotationColourGradient) cs).setSeqAssociated(viewAnnColour
4522                     .isPerSequence());
4523           }
4524           if (viewAnnColour.hasPredefinedColours())
4525           {
4526             ((AnnotationColourGradient) cs)
4527                     .setPredefinedColours(viewAnnColour
4528                             .isPredefinedColours());
4529           }
4530           if (propagateAnnColour && al.getGroups() != null)
4531           {
4532             // Also use these settings for all the groups
4533             for (int g = 0; g < al.getGroups().size(); g++)
4534             {
4535               jalview.datamodel.SequenceGroup sg = al.getGroups().get(g);
4536
4537               if (sg.cs == null)
4538               {
4539                 continue;
4540               }
4541
4542               /*
4543                * if (viewAnnColour.getColourScheme().equals("None" )) { sg.cs =
4544                * new AnnotationColourGradient(
4545                * annAlignment.getAlignmentAnnotation()[i], new
4546                * java.awt.Color(viewAnnColour. getMinColour()), new
4547                * java.awt.Color(viewAnnColour. getMaxColour()),
4548                * viewAnnColour.getAboveThreshold()); } else
4549                */
4550               {
4551                 sg.cs = new AnnotationColourGradient(
4552                         annAlignment.getAlignmentAnnotation()[i], sg.cs,
4553                         viewAnnColour.getAboveThreshold());
4554                 if (cs instanceof AnnotationColourGradient)
4555                 {
4556                   if (viewAnnColour.hasPerSequence())
4557                   {
4558                     ((AnnotationColourGradient) cs)
4559                             .setSeqAssociated(viewAnnColour.isPerSequence());
4560                   }
4561                   if (viewAnnColour.hasPredefinedColours())
4562                   {
4563                     ((AnnotationColourGradient) cs)
4564                             .setPredefinedColours(viewAnnColour
4565                                     .isPredefinedColours());
4566                   }
4567                 }
4568               }
4569
4570             }
4571           }
4572
4573           break;
4574         }
4575
4576       }
4577     }
4578     return cs;
4579   }
4580
4581   private void reorderAutoannotation(AlignFrame af, AlignmentI al,
4582           List<JvAnnotRow> autoAlan)
4583   {
4584     // copy over visualization settings for autocalculated annotation in the
4585     // view
4586     if (al.getAlignmentAnnotation() != null)
4587     {
4588       /**
4589        * Kludge for magic autoannotation names (see JAL-811)
4590        */
4591       String[] magicNames = new String[] { "Consensus", "Quality",
4592           "Conservation" };
4593       JvAnnotRow nullAnnot = new JvAnnotRow(-1, null);
4594       Hashtable<String, JvAnnotRow> visan = new Hashtable<String, JvAnnotRow>();
4595       for (String nm : magicNames)
4596       {
4597         visan.put(nm, nullAnnot);
4598       }
4599       for (JvAnnotRow auan : autoAlan)
4600       {
4601         visan.put(auan.template.label
4602                 + (auan.template.getCalcId() == null ? "" : "\t"
4603                         + auan.template.getCalcId()), auan);
4604       }
4605       int hSize = al.getAlignmentAnnotation().length;
4606       List<JvAnnotRow> reorder = new ArrayList<JvAnnotRow>();
4607       // work through any autoCalculated annotation already on the view
4608       // removing it if it should be placed in a different location on the
4609       // annotation panel.
4610       List<String> remains = new ArrayList<String>(visan.keySet());
4611       for (int h = 0; h < hSize; h++)
4612       {
4613         jalview.datamodel.AlignmentAnnotation jalan = al
4614                 .getAlignmentAnnotation()[h];
4615         if (jalan.autoCalculated)
4616         {
4617           String k;
4618           JvAnnotRow valan = visan.get(k = jalan.label);
4619           if (jalan.getCalcId() != null)
4620           {
4621             valan = visan.get(k = jalan.label + "\t" + jalan.getCalcId());
4622           }
4623
4624           if (valan != null)
4625           {
4626             // delete the auto calculated row from the alignment
4627             al.deleteAnnotation(jalan, false);
4628             remains.remove(k);
4629             hSize--;
4630             h--;
4631             if (valan != nullAnnot)
4632             {
4633               if (jalan != valan.template)
4634               {
4635                 // newly created autoannotation row instance
4636                 // so keep a reference to the visible annotation row
4637                 // and copy over all relevant attributes
4638                 if (valan.template.graphHeight >= 0)
4639
4640                 {
4641                   jalan.graphHeight = valan.template.graphHeight;
4642                 }
4643                 jalan.visible = valan.template.visible;
4644               }
4645               reorder.add(new JvAnnotRow(valan.order, jalan));
4646             }
4647           }
4648         }
4649       }
4650       // Add any (possibly stale) autocalculated rows that were not appended to
4651       // the view during construction
4652       for (String other : remains)
4653       {
4654         JvAnnotRow othera = visan.get(other);
4655         if (othera != nullAnnot && othera.template.getCalcId() != null
4656                 && othera.template.getCalcId().length() > 0)
4657         {
4658           reorder.add(othera);
4659         }
4660       }
4661       // now put the automatic annotation in its correct place
4662       int s = 0, srt[] = new int[reorder.size()];
4663       JvAnnotRow[] rws = new JvAnnotRow[reorder.size()];
4664       for (JvAnnotRow jvar : reorder)
4665       {
4666         rws[s] = jvar;
4667         srt[s++] = jvar.order;
4668       }
4669       reorder.clear();
4670       jalview.util.QuickSort.sort(srt, rws);
4671       // and re-insert the annotation at its correct position
4672       for (JvAnnotRow jvar : rws)
4673       {
4674         al.addAnnotation(jvar.template, jvar.order);
4675       }
4676       af.alignPanel.adjustAnnotationHeight();
4677     }
4678   }
4679
4680   Hashtable skipList = null;
4681
4682   /**
4683    * TODO remove this method
4684    *
4685    * @param view
4686    * @return AlignFrame bound to sequenceSetId from view, if one exists. private
4687    *         AlignFrame getSkippedFrame(Viewport view) { if (skipList==null) {
4688    *         throw new Error("Implementation Error. No skipList defined for this
4689    *         Jalview2XML instance."); } return (AlignFrame)
4690    *         skipList.get(view.getSequenceSetId()); }
4691    */
4692
4693   /**
4694    * Check if the Jalview view contained in object should be skipped or not.
4695    *
4696    * @param object
4697    * @return true if view's sequenceSetId is a key in skipList
4698    */
4699   private boolean skipViewport(JalviewModel object)
4700   {
4701     if (skipList == null)
4702     {
4703       return false;
4704     }
4705     String id;
4706     if (skipList.containsKey(id = object.getJalviewModelSequence()
4707             .getViewport()[0].getSequenceSetId()))
4708     {
4709       if (Cache.log != null && Cache.log.isDebugEnabled())
4710       {
4711         Cache.log.debug("Skipping seuqence set id " + id);
4712       }
4713       return true;
4714     }
4715     return false;
4716   }
4717
4718   public void addToSkipList(AlignFrame af)
4719   {
4720     if (skipList == null)
4721     {
4722       skipList = new Hashtable();
4723     }
4724     skipList.put(af.getViewport().getSequenceSetId(), af);
4725   }
4726
4727   public void clearSkipList()
4728   {
4729     if (skipList != null)
4730     {
4731       skipList.clear();
4732       skipList = null;
4733     }
4734   }
4735
4736   private void recoverDatasetFor(SequenceSet vamsasSet, AlignmentI al,
4737           boolean ignoreUnrefed)
4738   {
4739     jalview.datamodel.AlignmentI ds = getDatasetFor(vamsasSet
4740             .getDatasetId());
4741     Vector dseqs = null;
4742     if (ds == null)
4743     {
4744       // create a list of new dataset sequences
4745       dseqs = new Vector();
4746     }
4747     for (int i = 0, iSize = vamsasSet.getSequenceCount(); i < iSize; i++)
4748     {
4749       Sequence vamsasSeq = vamsasSet.getSequence(i);
4750       ensureJalviewDatasetSequence(vamsasSeq, ds, dseqs, ignoreUnrefed);
4751     }
4752     // create a new dataset
4753     if (ds == null)
4754     {
4755       SequenceI[] dsseqs = new SequenceI[dseqs.size()];
4756       dseqs.copyInto(dsseqs);
4757       ds = new jalview.datamodel.Alignment(dsseqs);
4758       debug("Created new dataset " + vamsasSet.getDatasetId()
4759               + " for alignment " + System.identityHashCode(al));
4760       addDatasetRef(vamsasSet.getDatasetId(), ds);
4761     }
4762     // set the dataset for the newly imported alignment.
4763     if (al.getDataset() == null && !ignoreUnrefed)
4764     {
4765       al.setDataset(ds);
4766     }
4767   }
4768
4769   /**
4770    *
4771    * @param vamsasSeq
4772    *          sequence definition to create/merge dataset sequence for
4773    * @param ds
4774    *          dataset alignment
4775    * @param dseqs
4776    *          vector to add new dataset sequence to
4777    */
4778   private void ensureJalviewDatasetSequence(Sequence vamsasSeq,
4779           AlignmentI ds, Vector dseqs, boolean ignoreUnrefed)
4780   {
4781     // JBP TODO: Check this is called for AlCodonFrames to support recovery of
4782     // xRef Codon Maps
4783     SequenceI sq = seqRefIds.get(vamsasSeq.getId());
4784     SequenceI dsq = null;
4785     if (sq != null && sq.getDatasetSequence() != null)
4786     {
4787       dsq = sq.getDatasetSequence();
4788     }
4789     if (sq == null && ignoreUnrefed)
4790     {
4791       return;
4792     }
4793     String sqid = vamsasSeq.getDsseqid();
4794     if (dsq == null)
4795     {
4796       // need to create or add a new dataset sequence reference to this sequence
4797       if (sqid != null)
4798       {
4799         dsq = seqRefIds.get(sqid);
4800       }
4801       // check again
4802       if (dsq == null)
4803       {
4804         // make a new dataset sequence
4805         dsq = sq.createDatasetSequence();
4806         if (sqid == null)
4807         {
4808           // make up a new dataset reference for this sequence
4809           sqid = seqHash(dsq);
4810         }
4811         dsq.setVamsasId(uniqueSetSuffix + sqid);
4812         seqRefIds.put(sqid, dsq);
4813         if (ds == null)
4814         {
4815           if (dseqs != null)
4816           {
4817             dseqs.addElement(dsq);
4818           }
4819         }
4820         else
4821         {
4822           ds.addSequence(dsq);
4823         }
4824       }
4825       else
4826       {
4827         if (sq != dsq)
4828         { // make this dataset sequence sq's dataset sequence
4829           sq.setDatasetSequence(dsq);
4830           // and update the current dataset alignment
4831           if (ds == null)
4832           {
4833             if (dseqs != null)
4834             {
4835               if (!dseqs.contains(dsq))
4836               {
4837                 dseqs.add(dsq);
4838               }
4839             }
4840             else
4841             {
4842               if (ds.findIndex(dsq) < 0)
4843               {
4844                 ds.addSequence(dsq);
4845               }
4846             }
4847           }
4848         }
4849       }
4850     }
4851     // TODO: refactor this as a merge dataset sequence function
4852     // now check that sq (the dataset sequence) sequence really is the union of
4853     // all references to it
4854     // boolean pre = sq.getStart() < dsq.getStart();
4855     // boolean post = sq.getEnd() > dsq.getEnd();
4856     // if (pre || post)
4857     if (sq != dsq)
4858     {
4859       // StringBuffer sb = new StringBuffer();
4860       String newres = jalview.analysis.AlignSeq.extractGaps(
4861               jalview.util.Comparison.GapChars, sq.getSequenceAsString());
4862       if (!newres.equalsIgnoreCase(dsq.getSequenceAsString())
4863               && newres.length() > dsq.getLength())
4864       {
4865         // Update with the longer sequence.
4866         synchronized (dsq)
4867         {
4868           /*
4869            * if (pre) { sb.insert(0, newres .substring(0, dsq.getStart() -
4870            * sq.getStart())); dsq.setStart(sq.getStart()); } if (post) {
4871            * sb.append(newres.substring(newres.length() - sq.getEnd() -
4872            * dsq.getEnd())); dsq.setEnd(sq.getEnd()); }
4873            */
4874           dsq.setSequence(newres);
4875         }
4876         // TODO: merges will never happen if we 'know' we have the real dataset
4877         // sequence - this should be detected when id==dssid
4878         System.err
4879                 .println("DEBUG Notice:  Merged dataset sequence (if you see this often, post at http://issues.jalview.org/browse/JAL-1474)"); // ("
4880         // + (pre ? "prepended" : "") + " "
4881         // + (post ? "appended" : ""));
4882       }
4883     }
4884   }
4885
4886   /*
4887    * TODO use AlignmentI here and in related methods - needs
4888    * AlignmentI.getDataset() changed to return AlignmentI instead of Alignment
4889    */
4890   Hashtable<String, AlignmentI> datasetIds = null;
4891
4892   IdentityHashMap<AlignmentI, String> dataset2Ids = null;
4893
4894   private AlignmentI getDatasetFor(String datasetId)
4895   {
4896     if (datasetIds == null)
4897     {
4898       datasetIds = new Hashtable<String, AlignmentI>();
4899       return null;
4900     }
4901     if (datasetIds.containsKey(datasetId))
4902     {
4903       return datasetIds.get(datasetId);
4904     }
4905     return null;
4906   }
4907
4908   private void addDatasetRef(String datasetId, AlignmentI dataset)
4909   {
4910     if (datasetIds == null)
4911     {
4912       datasetIds = new Hashtable<String, AlignmentI>();
4913     }
4914     datasetIds.put(datasetId, dataset);
4915   }
4916
4917   /**
4918    * make a new dataset ID for this jalview dataset alignment
4919    *
4920    * @param dataset
4921    * @return
4922    */
4923   private String getDatasetIdRef(AlignmentI dataset)
4924   {
4925     if (dataset.getDataset() != null)
4926     {
4927       warn("Serious issue!  Dataset Object passed to getDatasetIdRef is not a Jalview DATASET alignment...");
4928     }
4929     String datasetId = makeHashCode(dataset, null);
4930     if (datasetId == null)
4931     {
4932       // make a new datasetId and record it
4933       if (dataset2Ids == null)
4934       {
4935         dataset2Ids = new IdentityHashMap<AlignmentI, String>();
4936       }
4937       else
4938       {
4939         datasetId = dataset2Ids.get(dataset);
4940       }
4941       if (datasetId == null)
4942       {
4943         datasetId = "ds" + dataset2Ids.size() + 1;
4944         dataset2Ids.put(dataset, datasetId);
4945       }
4946     }
4947     return datasetId;
4948   }
4949
4950   private void addDBRefs(SequenceI datasetSequence, Sequence sequence)
4951   {
4952     for (int d = 0; d < sequence.getDBRefCount(); d++)
4953     {
4954       DBRef dr = sequence.getDBRef(d);
4955       jalview.datamodel.DBRefEntry entry = new jalview.datamodel.DBRefEntry(
4956               sequence.getDBRef(d).getSource(), sequence.getDBRef(d)
4957                       .getVersion(), sequence.getDBRef(d).getAccessionId());
4958       if (dr.getMapping() != null)
4959       {
4960         entry.setMap(addMapping(dr.getMapping()));
4961       }
4962       datasetSequence.addDBRef(entry);
4963     }
4964   }
4965
4966   private jalview.datamodel.Mapping addMapping(Mapping m)
4967   {
4968     SequenceI dsto = null;
4969     // Mapping m = dr.getMapping();
4970     int fr[] = new int[m.getMapListFromCount() * 2];
4971     Enumeration f = m.enumerateMapListFrom();
4972     for (int _i = 0; f.hasMoreElements(); _i += 2)
4973     {
4974       MapListFrom mf = (MapListFrom) f.nextElement();
4975       fr[_i] = mf.getStart();
4976       fr[_i + 1] = mf.getEnd();
4977     }
4978     int fto[] = new int[m.getMapListToCount() * 2];
4979     f = m.enumerateMapListTo();
4980     for (int _i = 0; f.hasMoreElements(); _i += 2)
4981     {
4982       MapListTo mf = (MapListTo) f.nextElement();
4983       fto[_i] = mf.getStart();
4984       fto[_i + 1] = mf.getEnd();
4985     }
4986     jalview.datamodel.Mapping jmap = new jalview.datamodel.Mapping(dsto,
4987             fr, fto, (int) m.getMapFromUnit(), (int) m.getMapToUnit());
4988     if (m.getMappingChoice() != null)
4989     {
4990       MappingChoice mc = m.getMappingChoice();
4991       if (mc.getDseqFor() != null)
4992       {
4993         String dsfor = "" + mc.getDseqFor();
4994         if (seqRefIds.containsKey(dsfor))
4995         {
4996           /**
4997            * recover from hash
4998            */
4999           jmap.setTo(seqRefIds.get(dsfor));
5000         }
5001         else
5002         {
5003           frefedSequence.add(new Object[] { dsfor, jmap });
5004         }
5005       }
5006       else
5007       {
5008         /**
5009          * local sequence definition
5010          */
5011         Sequence ms = mc.getSequence();
5012         SequenceI djs = null;
5013         String sqid = ms.getDsseqid();
5014         if (sqid != null && sqid.length() > 0)
5015         {
5016           /*
5017            * recover dataset sequence
5018            */
5019           djs = seqRefIds.get(sqid);
5020         }
5021         else
5022         {
5023           System.err
5024                   .println("Warning - making up dataset sequence id for DbRef sequence map reference");
5025           sqid = ((Object) ms).toString(); // make up a new hascode for
5026           // undefined dataset sequence hash
5027           // (unlikely to happen)
5028         }
5029
5030         if (djs == null)
5031         {
5032           /**
5033            * make a new dataset sequence and add it to refIds hash
5034            */
5035           djs = new jalview.datamodel.Sequence(ms.getName(),
5036                   ms.getSequence());
5037           djs.setStart(jmap.getMap().getToLowest());
5038           djs.setEnd(jmap.getMap().getToHighest());
5039           djs.setVamsasId(uniqueSetSuffix + sqid);
5040           jmap.setTo(djs);
5041           seqRefIds.put(sqid, djs);
5042
5043         }
5044         jalview.bin.Cache.log.debug("about to recurse on addDBRefs.");
5045         addDBRefs(djs, ms);
5046
5047       }
5048     }
5049     return (jmap);
5050
5051   }
5052
5053   public jalview.gui.AlignmentPanel copyAlignPanel(AlignmentPanel ap,
5054           boolean keepSeqRefs)
5055   {
5056     initSeqRefs();
5057     JalviewModel jm = saveState(ap, null, null, null);
5058
5059     if (!keepSeqRefs)
5060     {
5061       clearSeqRefs();
5062       jm.getJalviewModelSequence().getViewport(0).setSequenceSetId(null);
5063     }
5064     else
5065     {
5066       uniqueSetSuffix = "";
5067       jm.getJalviewModelSequence().getViewport(0).setId(null); // we don't
5068       // overwrite the
5069       // view we just
5070       // copied
5071     }
5072     if (this.frefedSequence == null)
5073     {
5074       frefedSequence = new Vector();
5075     }
5076
5077     viewportsAdded.clear();
5078
5079     AlignFrame af = loadFromObject(jm, null, false, null);
5080     af.alignPanels.clear();
5081     af.closeMenuItem_actionPerformed(true);
5082
5083     /*
5084      * if(ap.av.getAlignment().getAlignmentAnnotation()!=null) { for(int i=0;
5085      * i<ap.av.getAlignment().getAlignmentAnnotation().length; i++) {
5086      * if(!ap.av.getAlignment().getAlignmentAnnotation()[i].autoCalculated) {
5087      * af.alignPanel.av.getAlignment().getAlignmentAnnotation()[i] =
5088      * ap.av.getAlignment().getAlignmentAnnotation()[i]; } } }
5089      */
5090
5091     return af.alignPanel;
5092   }
5093
5094   /**
5095    * flag indicating if hashtables should be cleared on finalization TODO this
5096    * flag may not be necessary
5097    */
5098   private final boolean _cleartables = true;
5099
5100   private Hashtable jvids2vobj;
5101
5102   /*
5103    * (non-Javadoc)
5104    *
5105    * @see java.lang.Object#finalize()
5106    */
5107   @Override
5108   protected void finalize() throws Throwable
5109   {
5110     // really make sure we have no buried refs left.
5111     if (_cleartables)
5112     {
5113       clearSeqRefs();
5114     }
5115     this.seqRefIds = null;
5116     this.seqsToIds = null;
5117     super.finalize();
5118   }
5119
5120   private void warn(String msg)
5121   {
5122     warn(msg, null);
5123   }
5124
5125   private void warn(String msg, Exception e)
5126   {
5127     if (Cache.log != null)
5128     {
5129       if (e != null)
5130       {
5131         Cache.log.warn(msg, e);
5132       }
5133       else
5134       {
5135         Cache.log.warn(msg);
5136       }
5137     }
5138     else
5139     {
5140       System.err.println("Warning: " + msg);
5141       if (e != null)
5142       {
5143         e.printStackTrace();
5144       }
5145     }
5146   }
5147
5148   private void debug(String string)
5149   {
5150     debug(string, null);
5151   }
5152
5153   private void debug(String msg, Exception e)
5154   {
5155     if (Cache.log != null)
5156     {
5157       if (e != null)
5158       {
5159         Cache.log.debug(msg, e);
5160       }
5161       else
5162       {
5163         Cache.log.debug(msg);
5164       }
5165     }
5166     else
5167     {
5168       System.err.println("Warning: " + msg);
5169       if (e != null)
5170       {
5171         e.printStackTrace();
5172       }
5173     }
5174   }
5175
5176   /**
5177    * set the object to ID mapping tables used to write/recover objects and XML
5178    * ID strings for the jalview project. If external tables are provided then
5179    * finalize and clearSeqRefs will not clear the tables when the Jalview2XML
5180    * object goes out of scope. - also populates the datasetIds hashtable with
5181    * alignment objects containing dataset sequences
5182    *
5183    * @param vobj2jv
5184    *          Map from ID strings to jalview datamodel
5185    * @param jv2vobj
5186    *          Map from jalview datamodel to ID strings
5187    *
5188    *
5189    */
5190   public void setObjectMappingTables(Hashtable vobj2jv,
5191           IdentityHashMap jv2vobj)
5192   {
5193     this.jv2vobj = jv2vobj;
5194     this.vobj2jv = vobj2jv;
5195     Iterator ds = jv2vobj.keySet().iterator();
5196     String id;
5197     while (ds.hasNext())
5198     {
5199       Object jvobj = ds.next();
5200       id = jv2vobj.get(jvobj).toString();
5201       if (jvobj instanceof jalview.datamodel.Alignment)
5202       {
5203         if (((jalview.datamodel.Alignment) jvobj).getDataset() == null)
5204         {
5205           addDatasetRef(id, (jalview.datamodel.Alignment) jvobj);
5206         }
5207       }
5208       else if (jvobj instanceof jalview.datamodel.Sequence)
5209       {
5210         // register sequence object so the XML parser can recover it.
5211         if (seqRefIds == null)
5212         {
5213           seqRefIds = new HashMap<String, SequenceI>();
5214         }
5215         if (seqsToIds == null)
5216         {
5217           seqsToIds = new IdentityHashMap<SequenceI, String>();
5218         }
5219         seqRefIds.put(jv2vobj.get(jvobj).toString(), (SequenceI) jvobj);
5220         seqsToIds.put((SequenceI) jvobj, id);
5221       }
5222       else if (jvobj instanceof jalview.datamodel.AlignmentAnnotation)
5223       {
5224         String anid;
5225         AlignmentAnnotation jvann = (AlignmentAnnotation) jvobj;
5226         annotationIds.put(anid = jv2vobj.get(jvobj).toString(), jvann);
5227         if (jvann.annotationId == null)
5228         {
5229           jvann.annotationId = anid;
5230         }
5231         if (!jvann.annotationId.equals(anid))
5232         {
5233           // TODO verify that this is the correct behaviour
5234           this.warn("Overriding Annotation ID for " + anid
5235                   + " from different id : " + jvann.annotationId);
5236           jvann.annotationId = anid;
5237         }
5238       }
5239       else if (jvobj instanceof String)
5240       {
5241         if (jvids2vobj == null)
5242         {
5243           jvids2vobj = new Hashtable();
5244           jvids2vobj.put(jvobj, jv2vobj.get(jvobj).toString());
5245         }
5246       }
5247       else
5248       {
5249         Cache.log.debug("Ignoring " + jvobj.getClass() + " (ID = " + id);
5250       }
5251     }
5252   }
5253
5254   /**
5255    * set the uniqueSetSuffix used to prefix/suffix object IDs for jalview
5256    * objects created from the project archive. If string is null (default for
5257    * construction) then suffix will be set automatically.
5258    *
5259    * @param string
5260    */
5261   public void setUniqueSetSuffix(String string)
5262   {
5263     uniqueSetSuffix = string;
5264
5265   }
5266
5267   /**
5268    * uses skipList2 as the skipList for skipping views on sequence sets
5269    * associated with keys in the skipList
5270    *
5271    * @param skipList2
5272    */
5273   public void setSkipList(Hashtable skipList2)
5274   {
5275     skipList = skipList2;
5276   }
5277
5278   /**
5279    * Reads the jar entry of given name and returns its contents, or null if the
5280    * entry is not found.
5281    *
5282    * @param jprovider
5283    * @param jarEntryName
5284    * @return
5285    */
5286   protected String readJarEntry(jarInputStreamProvider jprovider,
5287           String jarEntryName)
5288   {
5289     String result = null;
5290     BufferedReader in = null;
5291
5292     try
5293     {
5294       /*
5295        * Reopen the jar input stream and traverse its entries to find a matching
5296        * name
5297        */
5298       JarInputStream jin = jprovider.getJarInputStream();
5299       JarEntry entry = null;
5300       do
5301       {
5302         entry = jin.getNextJarEntry();
5303       } while (entry != null && !entry.getName().equals(jarEntryName));
5304
5305       if (entry != null)
5306       {
5307         StringBuilder out = new StringBuilder(256);
5308         in = new BufferedReader(new InputStreamReader(jin, UTF_8));
5309         String data;
5310
5311         while ((data = in.readLine()) != null)
5312         {
5313           out.append(data);
5314         }
5315         result = out.toString();
5316       }
5317       else
5318       {
5319         warn("Couldn't find entry in Jalview Jar for " + jarEntryName);
5320       }
5321     } catch (Exception ex)
5322     {
5323       ex.printStackTrace();
5324     } finally
5325     {
5326       if (in != null)
5327       {
5328         try
5329         {
5330           in.close();
5331         } catch (IOException e)
5332         {
5333           // ignore
5334         }
5335       }
5336     }
5337
5338     return result;
5339   }
5340
5341   /**
5342    * Returns an incrementing counter (0, 1, 2...)
5343    *
5344    * @return
5345    */
5346   private synchronized int nextCounter()
5347   {
5348     return counter++;
5349   }
5350 }