src/jalview/project/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.project;
  22
  23 import static jalview.math.RotatableMatrix.Axis.X;
  24 import static jalview.math.RotatableMatrix.Axis.Y;
  25 import static jalview.math.RotatableMatrix.Axis.Z;
  26
  27 import jalview.analysis.Conservation;
  28 import jalview.analysis.PCA;
  29 import jalview.analysis.scoremodels.ScoreModels;
  30 import jalview.analysis.scoremodels.SimilarityParams;
  31 import jalview.api.FeatureColourI;
  32 import jalview.api.ViewStyleI;
  33 import jalview.api.analysis.ScoreModelI;
  34 import jalview.api.analysis.SimilarityParamsI;
  35 import jalview.api.structures.JalviewStructureDisplayI;
  36 import jalview.bin.Cache;
  37 import jalview.datamodel.AlignedCodonFrame;
  38 import jalview.datamodel.Alignment;
  39 import jalview.datamodel.AlignmentAnnotation;
  40 import jalview.datamodel.AlignmentI;
  41 import jalview.datamodel.GraphLine;
  42 import jalview.datamodel.HiddenMarkovModel;
  43 import jalview.datamodel.PDBEntry;
  44 import jalview.datamodel.Point;
  45 import jalview.datamodel.RnaViewerModel;
  46 import jalview.datamodel.SequenceFeature;
  47 import jalview.datamodel.SequenceGroup;
  48 import jalview.datamodel.SequenceI;
  49 import jalview.datamodel.StructureViewerModel;
  50 import jalview.datamodel.StructureViewerModel.StructureData;
  51 import jalview.datamodel.features.FeatureMatcher;
  52 import jalview.datamodel.features.FeatureMatcherI;
  53 import jalview.datamodel.features.FeatureMatcherSet;
  54 import jalview.datamodel.features.FeatureMatcherSetI;
  55 import jalview.ext.varna.RnaModel;
  56 import jalview.gui.AlignFrame;
  57 import jalview.gui.AlignViewport;
  58 import jalview.gui.AlignmentPanel;
  59 import jalview.gui.AppVarna;
  60 import jalview.gui.ChimeraViewFrame;
  61 import jalview.gui.Desktop;
  62 import jalview.gui.FeatureRenderer;
  63 import jalview.gui.JvOptionPane;
  64 import jalview.gui.OOMWarning;
  65 import jalview.gui.PCAPanel;
  66 import jalview.gui.PaintRefresher;
  67 import jalview.gui.SplitFrame;
  68 import jalview.gui.StructureViewer;
  69 import jalview.gui.StructureViewer.ViewerType;
  70 import jalview.gui.StructureViewerBase;
  71 import jalview.gui.TreePanel;
  72 import jalview.io.BackupFiles;
  73 import jalview.io.DataSourceType;
  74 import jalview.io.FileFormat;
  75 import jalview.io.HMMFile;
  76 import jalview.io.NewickFile;
  77 import jalview.math.Matrix;
  78 import jalview.math.MatrixI;
  79 import jalview.renderer.ResidueShaderI;
  80 import jalview.schemes.AnnotationColourGradient;
  81 import jalview.schemes.ColourSchemeI;
  82 import jalview.schemes.ColourSchemeProperty;
  83 import jalview.schemes.FeatureColour;
  84 import jalview.schemes.ResidueProperties;
  85 import jalview.schemes.UserColourScheme;
  86 import jalview.structure.StructureSelectionManager;
  87 import jalview.structures.models.AAStructureBindingModel;
  88 import jalview.util.Format;
  89 import jalview.util.MessageManager;
  90 import jalview.util.Platform;
  91 import jalview.util.StringUtils;
  92 import jalview.util.jarInputStreamProvider;
  93 import jalview.util.matcher.Condition;
  94 import jalview.viewmodel.AlignmentViewport;
  95 import jalview.viewmodel.PCAModel;
  96 import jalview.viewmodel.ViewportRanges;
  97 import jalview.viewmodel.seqfeatures.FeatureRendererSettings;
  98 import jalview.viewmodel.seqfeatures.FeaturesDisplayed;
  99 import jalview.ws.jws2.Jws2Discoverer;
 100 import jalview.ws.jws2.dm.AAConSettings;
 101 import jalview.ws.jws2.jabaws2.Jws2Instance;
 102 import jalview.ws.params.ArgumentI;
 103 import jalview.ws.params.AutoCalcSetting;
 104 import jalview.ws.params.WsParamSetI;
 105 import jalview.xml.binding.jalview.AlcodonFrame;
 106 import jalview.xml.binding.jalview.AlcodonFrame.AlcodMap;
 107 import jalview.xml.binding.jalview.Annotation;
 108 import jalview.xml.binding.jalview.Annotation.ThresholdLine;
 109 import jalview.xml.binding.jalview.AnnotationColourScheme;
 110 import jalview.xml.binding.jalview.AnnotationElement;
 111 import jalview.xml.binding.jalview.DoubleMatrix;
 112 import jalview.xml.binding.jalview.DoubleVector;
 113 import jalview.xml.binding.jalview.Feature;
 114 import jalview.xml.binding.jalview.Feature.OtherData;
 115 import jalview.xml.binding.jalview.FeatureMatcherSet.CompoundMatcher;
 116 import jalview.xml.binding.jalview.FilterBy;
 117 import jalview.xml.binding.jalview.JalviewModel;
 118 import jalview.xml.binding.jalview.JalviewModel.FeatureSettings;
 119 import jalview.xml.binding.jalview.JalviewModel.FeatureSettings.Group;
 120 import jalview.xml.binding.jalview.JalviewModel.FeatureSettings.Setting;
 121 import jalview.xml.binding.jalview.JalviewModel.JGroup;
 122 import jalview.xml.binding.jalview.JalviewModel.JSeq;
 123 import jalview.xml.binding.jalview.JalviewModel.JSeq.Pdbids;
 124 import jalview.xml.binding.jalview.JalviewModel.JSeq.Pdbids.StructureState;
 125 import jalview.xml.binding.jalview.JalviewModel.JSeq.RnaViewer;
 126 import jalview.xml.binding.jalview.JalviewModel.JSeq.RnaViewer.SecondaryStructure;
 127 import jalview.xml.binding.jalview.JalviewModel.PcaViewer;
 128 import jalview.xml.binding.jalview.JalviewModel.PcaViewer.Axis;
 129 import jalview.xml.binding.jalview.JalviewModel.PcaViewer.SeqPointMax;
 130 import jalview.xml.binding.jalview.JalviewModel.PcaViewer.SeqPointMin;
 131 import jalview.xml.binding.jalview.JalviewModel.PcaViewer.SequencePoint;
 132 import jalview.xml.binding.jalview.JalviewModel.Tree;
 133 import jalview.xml.binding.jalview.JalviewModel.UserColours;
 134 import jalview.xml.binding.jalview.JalviewModel.Viewport;
 135 import jalview.xml.binding.jalview.JalviewModel.Viewport.CalcIdParam;
 136 import jalview.xml.binding.jalview.JalviewModel.Viewport.HiddenColumns;
 137 import jalview.xml.binding.jalview.JalviewUserColours;
 138 import jalview.xml.binding.jalview.JalviewUserColours.Colour;
 139 import jalview.xml.binding.jalview.MapListType.MapListFrom;
 140 import jalview.xml.binding.jalview.MapListType.MapListTo;
 141 import jalview.xml.binding.jalview.Mapping;
 142 import jalview.xml.binding.jalview.NoValueColour;
 143 import jalview.xml.binding.jalview.ObjectFactory;
 144 import jalview.xml.binding.jalview.PcaDataType;
 145 import jalview.xml.binding.jalview.Pdbentry.Property;
 146 import jalview.xml.binding.jalview.Sequence;
 147 import jalview.xml.binding.jalview.Sequence.DBRef;
 148 import jalview.xml.binding.jalview.SequenceSet;
 149 import jalview.xml.binding.jalview.SequenceSet.SequenceSetProperties;
 150 import jalview.xml.binding.jalview.ThresholdType;
 151 import jalview.xml.binding.jalview.VAMSAS;
 152
 153 import java.awt.Color;
 154 import java.awt.Font;
 155 import java.awt.Rectangle;
 156 import java.io.BufferedReader;
 157 import java.io.DataInputStream;
 158 import java.io.DataOutputStream;
 159 import java.io.File;
 160 import java.io.FileInputStream;
 161 import java.io.FileOutputStream;
 162 import java.io.IOException;
 163 import java.io.InputStreamReader;
 164 import java.io.OutputStreamWriter;
 165 import java.io.PrintWriter;
 166 import java.lang.reflect.InvocationTargetException;
 167 import java.math.BigInteger;
 168 import java.net.MalformedURLException;
 169 import java.net.URL;
 170 import java.util.ArrayList;
 171 import java.util.Arrays;
 172 import java.util.Collections;
 173 import java.util.Enumeration;
 174 import java.util.GregorianCalendar;
 175 import java.util.HashMap;
 176 import java.util.HashSet;
 177 import java.util.Hashtable;
 178 import java.util.IdentityHashMap;
 179 import java.util.Iterator;
 180 import java.util.LinkedHashMap;
 181 import java.util.List;
 182 import java.util.Map;
 183 import java.util.Map.Entry;
 184 import java.util.Set;
 185 import java.util.Vector;
 186 import java.util.jar.JarEntry;
 187 import java.util.jar.JarInputStream;
 188 import java.util.jar.JarOutputStream;
 189
 190 import javax.swing.JInternalFrame;
 191 import javax.swing.SwingUtilities;
 192 import javax.xml.bind.JAXBContext;
 193 import javax.xml.bind.JAXBElement;
 194 import javax.xml.bind.Marshaller;
 195 import javax.xml.datatype.DatatypeConfigurationException;
 196 import javax.xml.datatype.DatatypeFactory;
 197 import javax.xml.datatype.XMLGregorianCalendar;
 198 import javax.xml.stream.XMLInputFactory;
 199 import javax.xml.stream.XMLStreamReader;
 200
 201 /**
 202  * Write out the current jalview desktop state as a Jalview XML stream.
 203  *
 204  * Note: the vamsas objects referred to here are primitive versions of the
 205  * VAMSAS project schema elements - they are not the same and most likely never
 206  * will be :)
 207  *
 208  * @author $author$
 209  * @version $Revision: 1.134 $
 210  */
 211 public class Jalview2XML
 212 {
 213   private static final String VIEWER_PREFIX = "viewer_";
 214
 215   private static final String RNA_PREFIX = "rna_";
 216
 217   private static final String HMMER_PREFIX = "hmmer_";
 218
 219   private static final String UTF_8 = "UTF-8";
 220
 221   /**
 222    * prefix for recovering datasets for alignments with multiple views where
 223    * non-existent dataset IDs were written for some views
 224    */
 225   private static final String UNIQSEQSETID = "uniqueSeqSetId.";
 226
 227   // use this with nextCounter() to make unique names for entities
 228   private int counter = 0;
 229
 230   /*
 231    * SequenceI reference -> XML ID string in jalview XML. Populated as XML reps
 232    * of sequence objects are created.
 233    */
 234   IdentityHashMap<SequenceI, String> seqsToIds = null;
 235
 236   /**
 237    * jalview XML Sequence ID to jalview sequence object reference (both dataset
 238    * and alignment sequences. Populated as XML reps of sequence objects are
 239    * created.)
 240    */
 241   Map<String, SequenceI> seqRefIds = null;
 242
 243   Map<String, SequenceI> incompleteSeqs = null;
 244
 245   List<SeqFref> frefedSequence = null;
 246
 247   boolean raiseGUI = true; // whether errors are raised in dialog boxes or not
 248
 249   /*
 250    * Map of reconstructed AlignFrame objects that appear to have come from
 251    * SplitFrame objects (have a dna/protein complement view).
 252    */
 253   private Map<Viewport, AlignFrame> splitFrameCandidates = new HashMap<>();
 254
 255   /*
 256    * Map from displayed rna structure models to their saved session state jar
 257    * entry names
 258    */
 259   private Map<RnaModel, String> rnaSessions = new HashMap<>();
 260
 261   /**
 262    * A helper method for safely using the value of an optional attribute that
 263    * may be null if not present in the XML. Answers the boolean value, or false
 264    * if null.
 265    *
 266    * @param b
 267    * @return
 268    */
 269   public static boolean safeBoolean(Boolean b)
 270   {
 271     return b == null ? false : b.booleanValue();
 272   }
 273
 274   /**
 275    * A helper method for safely using the value of an optional attribute that
 276    * may be null if not present in the XML. Answers the integer value, or zero
 277    * if null.
 278    *
 279    * @param i
 280    * @return
 281    */
 282   public static int safeInt(Integer i)
 283   {
 284     return i == null ? 0 : i.intValue();
 285   }
 286
 287   /**
 288    * A helper method for safely using the value of an optional attribute that
 289    * may be null if not present in the XML. Answers the float value, or zero if
 290    * null.
 291    *
 292    * @param f
 293    * @return
 294    */
 295   public static float safeFloat(Float f)
 296   {
 297     return f == null ? 0f : f.floatValue();
 298   }
 299
 300   /**
 301    * create/return unique hash string for sq
 302    *
 303    * @param sq
 304    * @return new or existing unique string for sq
 305    */
 306   String seqHash(SequenceI sq)
 307   {
 308     if (seqsToIds == null)
 309     {
 310       initSeqRefs();
 311     }
 312     if (seqsToIds.containsKey(sq))
 313     {
 314       return seqsToIds.get(sq);
 315     }
 316     else
 317     {
 318       // create sequential key
 319       String key = "sq" + (seqsToIds.size() + 1);
 320       key = makeHashCode(sq, key); // check we don't have an external reference
 321       // for it already.
 322       seqsToIds.put(sq, key);
 323       return key;
 324     }
 325   }
 326
 327   void initSeqRefs()
 328   {
 329     if (seqsToIds == null)
 330     {
 331       seqsToIds = new IdentityHashMap<>();
 332     }
 333     if (seqRefIds == null)
 334     {
 335       seqRefIds = new HashMap<>();
 336     }
 337     if (incompleteSeqs == null)
 338     {
 339       incompleteSeqs = new HashMap<>();
 340     }
 341     if (frefedSequence == null)
 342     {
 343       frefedSequence = new ArrayList<>();
 344     }
 345   }
 346
 347   public Jalview2XML()
 348   {
 349   }
 350
 351   public Jalview2XML(boolean raiseGUI)
 352   {
 353     this.raiseGUI = raiseGUI;
 354   }
 355
 356   /**
 357    * base class for resolving forward references to sequences by their ID
 358    *
 359    * @author jprocter
 360    *
 361    */
 362   abstract class SeqFref
 363   {
 364     String sref;
 365
 366     String type;
 367
 368     public SeqFref(String _sref, String type)
 369     {
 370       sref = _sref;
 371       this.type = type;
 372     }
 373
 374     public String getSref()
 375     {
 376       return sref;
 377     }
 378
 379     public SequenceI getSrefSeq()
 380     {
 381       return seqRefIds.get(sref);
 382     }
 383
 384     public boolean isResolvable()
 385     {
 386       return seqRefIds.get(sref) != null;
 387     }
 388
 389     public SequenceI getSrefDatasetSeq()
 390     {
 391       SequenceI sq = seqRefIds.get(sref);
 392       if (sq != null)
 393       {
 394         while (sq.getDatasetSequence() != null)
 395         {
 396           sq = sq.getDatasetSequence();
 397         }
 398       }
 399       return sq;
 400     }
 401
 402     /**
 403      * @return true if the forward reference was fully resolved
 404      */
 405     abstract boolean resolve();
 406
 407     @Override
 408     public String toString()
 409     {
 410       return type + " reference to " + sref;
 411     }
 412   }
 413
 414   /**
 415    * create forward reference for a mapping
 416    *
 417    * @param sref
 418    * @param _jmap
 419    * @return
 420    */
 421   public SeqFref newMappingRef(final String sref,
 422           final jalview.datamodel.Mapping _jmap)
 423   {
 424     SeqFref fref = new SeqFref(sref, "Mapping")
 425     {
 426       public jalview.datamodel.Mapping jmap = _jmap;
 427
 428       @Override
 429       boolean resolve()
 430       {
 431         SequenceI seq = getSrefDatasetSeq();
 432         if (seq == null)
 433         {
 434           return false;
 435         }
 436         jmap.setTo(seq);
 437         return true;
 438       }
 439     };
 440     return fref;
 441   }
 442
 443   public SeqFref newAlcodMapRef(final String sref,
 444           final AlignedCodonFrame _cf,
 445           final jalview.datamodel.Mapping _jmap)
 446   {
 447
 448     SeqFref fref = new SeqFref(sref, "Codon Frame")
 449     {
 450       AlignedCodonFrame cf = _cf;
 451
 452       public jalview.datamodel.Mapping mp = _jmap;
 453
 454       @Override
 455       public boolean isResolvable()
 456       {
 457         return super.isResolvable() && mp.getTo() != null;
 458       };
 459
 460       @Override
 461       boolean resolve()
 462       {
 463         SequenceI seq = getSrefDatasetSeq();
 464         if (seq == null)
 465         {
 466           return false;
 467         }
 468         cf.addMap(seq, mp.getTo(), mp.getMap());
 469         return true;
 470       }
 471     };
 472     return fref;
 473   }
 474
 475   public void resolveFrefedSequences()
 476   {
 477     Iterator<SeqFref> nextFref = frefedSequence.iterator();
 478     int toresolve = frefedSequence.size();
 479     int unresolved = 0, failedtoresolve = 0;
 480     while (nextFref.hasNext())
 481     {
 482       SeqFref ref = nextFref.next();
 483       if (ref.isResolvable())
 484       {
 485         try
 486         {
 487           if (ref.resolve())
 488           {
 489             nextFref.remove();
 490           }
 491           else
 492           {
 493             failedtoresolve++;
 494           }
 495         } catch (Exception x)
 496         {
 497           System.err.println(
 498                   "IMPLEMENTATION ERROR: Failed to resolve forward reference for sequence "
 499                           + ref.getSref());
 500           x.printStackTrace();
 501           failedtoresolve++;
 502         }
 503       }
 504       else
 505       {
 506         unresolved++;
 507       }
 508     }
 509     if (unresolved > 0)
 510     {
 511       System.err.println("Jalview Project Import: There were " + unresolved
 512               + " forward references left unresolved on the stack.");
 513     }
 514     if (failedtoresolve > 0)
 515     {
 516       System.err.println("SERIOUS! " + failedtoresolve
 517               + " resolvable forward references failed to resolve.");
 518     }
 519     if (incompleteSeqs != null && incompleteSeqs.size() > 0)
 520     {
 521       System.err.println(
 522               "Jalview Project Import: There are " + incompleteSeqs.size()
 523                       + " sequences which may have incomplete metadata.");
 524       if (incompleteSeqs.size() < 10)
 525       {
 526         for (SequenceI s : incompleteSeqs.values())
 527         {
 528           System.err.println(s.toString());
 529         }
 530       }
 531       else
 532       {
 533         System.err.println(
 534                 "Too many to report. Skipping output of incomplete sequences.");
 535       }
 536     }
 537   }
 538
 539   /**
 540    * This maintains a map of viewports, the key being the seqSetId. Important to
 541    * set historyItem and redoList for multiple views
 542    */
 543   Map<String, AlignViewport> viewportsAdded = new HashMap<>();
 544
 545   Map<String, AlignmentAnnotation> annotationIds = new HashMap<>();
 546
 547   String uniqueSetSuffix = "";
 548
 549   /**
 550    * List of pdbfiles added to Jar
 551    */
 552   List<String> pdbfiles = null;
 553
 554   // SAVES SEVERAL ALIGNMENT WINDOWS TO SAME JARFILE
 555   public void saveState(File statefile)
 556   {
 557     FileOutputStream fos = null;
 558
 559     try
 560     {
 561
 562       fos = new FileOutputStream(statefile);
 563
 564       JarOutputStream jout = new JarOutputStream(fos);
 565       saveState(jout);
 566       fos.close();
 567
 568     } catch (Exception e)
 569     {
 570       Cache.log.error("Couln't write Jalview state to " + statefile, e);
 571       // TODO: inform user of the problem - they need to know if their data was
 572       // not saved !
 573       if (errorMessage == null)
 574       {
 575         errorMessage = "Did't write Jalview Archive to output file '"
 576                 + statefile + "' - See console error log for details";
 577       }
 578       else
 579       {
 580         errorMessage += "(Didn't write Jalview Archive to output file '"
 581                 + statefile + ")";
 582       }
 583       e.printStackTrace();
 584     } finally
 585     {
 586       if (fos != null)
 587       {
 588         try
 589         {
 590           fos.close();
 591         } catch (IOException e)
 592         {
 593           // ignore
 594         }
 595       }
 596     }
 597     reportErrors();
 598   }
 599
 600   /**
 601    * Writes a jalview project archive to the given Jar output stream.
 602    *
 603    * @param jout
 604    */
 605   public void saveState(JarOutputStream jout)
 606   {
 607     AlignFrame[] frames = Desktop.getAlignFrames();
 608
 609     if (frames == null)
 610     {
 611       return;
 612     }
 613     saveAllFrames(Arrays.asList(frames), jout);
 614   }
 615
 616   /**
 617    * core method for storing state for a set of AlignFrames.
 618    *
 619    * @param frames
 620    *          - frames involving all data to be exported (including containing
 621    *          splitframes)
 622    * @param jout
 623    *          - project output stream
 624    */
 625   private void saveAllFrames(List<AlignFrame> frames, JarOutputStream jout)
 626   {
 627     Hashtable<String, AlignFrame> dsses = new Hashtable<>();
 628
 629     /*
 630      * ensure cached data is clear before starting
 631      */
 632     // todo tidy up seqRefIds, seqsToIds initialisation / reset
 633     rnaSessions.clear();
 634     splitFrameCandidates.clear();
 635
 636     try
 637     {
 638
 639       // NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS
 640       // //////////////////////////////////////////////////
 641
 642       List<String> shortNames = new ArrayList<>();
 643       List<String> viewIds = new ArrayList<>();
 644
 645       // REVERSE ORDER
 646       for (int i = frames.size() - 1; i > -1; i--)
 647       {
 648         AlignFrame af = frames.get(i);
 649         // skip ?
 650         if (skipList != null && skipList
 651                 .containsKey(af.getViewport().getSequenceSetId()))
 652         {
 653           continue;
 654         }
 655
 656         String shortName = makeFilename(af, shortNames);
 657
 658         int apSize = af.getAlignPanels().size();
 659
 660         for (int ap = 0; ap < apSize; ap++)
 661         {
 662           AlignmentPanel apanel = (AlignmentPanel) af.getAlignPanels()
 663                   .get(ap);
 664           String fileName = apSize == 1 ? shortName : ap + shortName;
 665           if (!fileName.endsWith(".xml"))
 666           {
 667             fileName = fileName + ".xml";
 668           }
 669
 670           saveState(apanel, fileName, jout, viewIds);
 671
 672           String dssid = getDatasetIdRef(
 673                   af.getViewport().getAlignment().getDataset());
 674           if (!dsses.containsKey(dssid))
 675           {
 676             dsses.put(dssid, af);
 677           }
 678         }
 679       }
 680
 681       writeDatasetFor(dsses, "" + jout.hashCode() + " " + uniqueSetSuffix,
 682               jout);
 683
 684       try
 685       {
 686         jout.flush();
 687       } catch (Exception foo)
 688       {
 689       }
 690       ;
 691       jout.close();
 692     } catch (Exception ex)
 693     {
 694       // TODO: inform user of the problem - they need to know if their data was
 695       // not saved !
 696       if (errorMessage == null)
 697       {
 698         errorMessage = "Couldn't write Jalview Archive - see error output for details";
 699       }
 700       ex.printStackTrace();
 701     }
 702   }
 703
 704   /**
 705    * Generates a distinct file name, based on the title of the AlignFrame, by
 706    * appending _n for increasing n until an unused name is generated. The new
 707    * name (without its extension) is added to the list.
 708    *
 709    * @param af
 710    * @param namesUsed
 711    * @return the generated name, with .xml extension
 712    */
 713   protected String makeFilename(AlignFrame af, List<String> namesUsed)
 714   {
 715     String shortName = af.getTitle();
 716
 717     if (shortName.indexOf(File.separatorChar) > -1)
 718     {
 719       shortName = shortName
 720               .substring(shortName.lastIndexOf(File.separatorChar) + 1);
 721     }
 722
 723     int count = 1;
 724
 725     while (namesUsed.contains(shortName))
 726     {
 727       if (shortName.endsWith("_" + (count - 1)))
 728       {
 729         shortName = shortName.substring(0, shortName.lastIndexOf("_"));
 730       }
 731
 732       shortName = shortName.concat("_" + count);
 733       count++;
 734     }
 735
 736     namesUsed.add(shortName);
 737
 738     if (!shortName.endsWith(".xml"))
 739     {
 740       shortName = shortName + ".xml";
 741     }
 742     return shortName;
 743   }
 744
 745   // USE THIS METHOD TO SAVE A SINGLE ALIGNMENT WINDOW
 746   public boolean saveAlignment(AlignFrame af, String jarFile,
 747           String fileName)
 748   {
 749     try
 750     {
 751       // create backupfiles object and get new temp filename destination
 752       BackupFiles backupfiles = new BackupFiles(jarFile);
 753       FileOutputStream fos = new FileOutputStream(
 754               backupfiles.getTempFilePath());
 755
 756       JarOutputStream jout = new JarOutputStream(fos);
 757       List<AlignFrame> frames = new ArrayList<>();
 758
 759       // resolve splitframes
 760       if (af.getViewport().getCodingComplement() != null)
 761       {
 762         frames = ((SplitFrame) af.getSplitViewContainer()).getAlignFrames();
 763       }
 764       else
 765       {
 766         frames.add(af);
 767       }
 768       saveAllFrames(frames, jout);
 769       try
 770       {
 771         jout.flush();
 772       } catch (Exception foo)
 773       {
 774       }
 775       ;
 776       jout.close();
 777       boolean success = true;
 778
 779       backupfiles.setWriteSuccess(success);
 780       success = backupfiles.rollBackupsAndRenameTempFile();
 781
 782       return success;
 783     } catch (Exception ex)
 784     {
 785       errorMessage = "Couldn't Write alignment view to Jalview Archive - see error output for details";
 786       ex.printStackTrace();
 787       return false;
 788     }
 789   }
 790
 791   private void writeDatasetFor(Hashtable<String, AlignFrame> dsses,
 792           String fileName, JarOutputStream jout)
 793   {
 794
 795     for (String dssids : dsses.keySet())
 796     {
 797       AlignFrame _af = dsses.get(dssids);
 798       String jfileName = fileName + " Dataset for " + _af.getTitle();
 799       if (!jfileName.endsWith(".xml"))
 800       {
 801         jfileName = jfileName + ".xml";
 802       }
 803       saveState(_af.alignPanel, jfileName, true, jout, null);
 804     }
 805   }
 806
 807   /**
 808    * create a JalviewModel from an alignment view and marshall it to a
 809    * JarOutputStream
 810    *
 811    * @param ap
 812    *          panel to create jalview model for
 813    * @param fileName
 814    *          name of alignment panel written to output stream
 815    * @param jout
 816    *          jar output stream
 817    * @param viewIds
 818    * @param out
 819    *          jar entry name
 820    */
 821   public JalviewModel saveState(AlignmentPanel ap, String fileName,
 822           JarOutputStream jout, List<String> viewIds)
 823   {
 824     return saveState(ap, fileName, false, jout, viewIds);
 825   }
 826
 827   /**
 828    * create a JalviewModel from an alignment view and marshall it to a
 829    * JarOutputStream
 830    *
 831    * @param ap
 832    *          panel to create jalview model for
 833    * @param fileName
 834    *          name of alignment panel written to output stream
 835    * @param storeDS
 836    *          when true, only write the dataset for the alignment, not the data
 837    *          associated with the view.
 838    * @param jout
 839    *          jar output stream
 840    * @param out
 841    *          jar entry name
 842    */
 843   public JalviewModel saveState(AlignmentPanel ap, String fileName,
 844           boolean storeDS, JarOutputStream jout, List<String> viewIds)
 845   {
 846     if (viewIds == null)
 847     {
 848       viewIds = new ArrayList<>();
 849     }
 850
 851     initSeqRefs();
 852
 853     List<UserColourScheme> userColours = new ArrayList<>();
 854
 855     AlignViewport av = ap.av;
 856     ViewportRanges vpRanges = av.getRanges();
 857
 858     final ObjectFactory objectFactory = new ObjectFactory();
 859     JalviewModel object = objectFactory.createJalviewModel();
 860     object.setVamsasModel(new VAMSAS());
 861
 862     // object.setCreationDate(new java.util.Date(System.currentTimeMillis()));
 863     try
 864     {
 865       GregorianCalendar c = new GregorianCalendar();
 866       DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
 867       XMLGregorianCalendar now = datatypeFactory.newXMLGregorianCalendar(c);// gregorianCalendar);
 868       object.setCreationDate(now);
 869     } catch (DatatypeConfigurationException e)
 870     {
 871       System.err.println("error writing date: " + e.toString());
 872     }
 873     object.setVersion(
 874             jalview.bin.Cache.getDefault("VERSION", "Development Build"));
 875
 876     /**
 877      * rjal is full height alignment, jal is actual alignment with full metadata
 878      * but excludes hidden sequences.
 879      */
 880     jalview.datamodel.AlignmentI rjal = av.getAlignment(), jal = rjal;
 881
 882     if (av.hasHiddenRows())
 883     {
 884       rjal = jal.getHiddenSequences().getFullAlignment();
 885     }
 886
 887     SequenceSet vamsasSet = new SequenceSet();
 888     Sequence vamsasSeq;
 889     // JalviewModelSequence jms = new JalviewModelSequence();
 890
 891     vamsasSet.setGapChar(jal.getGapCharacter() + "");
 892
 893     if (jal.getDataset() != null)
 894     {
 895       // dataset id is the dataset's hashcode
 896       vamsasSet.setDatasetId(getDatasetIdRef(jal.getDataset()));
 897       if (storeDS)
 898       {
 899         // switch jal and the dataset
 900         jal = jal.getDataset();
 901         rjal = jal;
 902       }
 903     }
 904     if (jal.getProperties() != null)
 905     {
 906       Enumeration en = jal.getProperties().keys();
 907       while (en.hasMoreElements())
 908       {
 909         String key = en.nextElement().toString();
 910         SequenceSetProperties ssp = new SequenceSetProperties();
 911         ssp.setKey(key);
 912         ssp.setValue(jal.getProperties().get(key).toString());
 913         // vamsasSet.addSequenceSetProperties(ssp);
 914         vamsasSet.getSequenceSetProperties().add(ssp);
 915       }
 916     }
 917
 918     JSeq jseq;
 919     Set<String> calcIdSet = new HashSet<>();
 920     // record the set of vamsas sequence XML POJO we create.
 921     HashMap<String, Sequence> vamsasSetIds = new HashMap<>();
 922     // SAVE SEQUENCES
 923     for (final SequenceI jds : rjal.getSequences())
 924     {
 925       final SequenceI jdatasq = jds.getDatasetSequence() == null ? jds
 926               : jds.getDatasetSequence();
 927       String id = seqHash(jds);
 928       if (vamsasSetIds.get(id) == null)
 929       {
 930         if (seqRefIds.get(id) != null && !storeDS)
 931         {
 932           // This happens for two reasons: 1. multiple views are being
 933           // serialised.
 934           // 2. the hashCode has collided with another sequence's code. This
 935           // DOES
 936           // HAPPEN! (PF00072.15.stk does this)
 937           // JBPNote: Uncomment to debug writing out of files that do not read
 938           // back in due to ArrayOutOfBoundExceptions.
 939           // System.err.println("vamsasSeq backref: "+id+"");
 940           // System.err.println(jds.getName()+"
 941           // "+jds.getStart()+"-"+jds.getEnd()+" "+jds.getSequenceAsString());
 942           // System.err.println("Hashcode: "+seqHash(jds));
 943           // SequenceI rsq = (SequenceI) seqRefIds.get(id + "");
 944           // System.err.println(rsq.getName()+"
 945           // "+rsq.getStart()+"-"+rsq.getEnd()+" "+rsq.getSequenceAsString());
 946           // System.err.println("Hashcode: "+seqHash(rsq));
 947         }
 948         else
 949         {
 950           vamsasSeq = createVamsasSequence(id, jds);
 951 //          vamsasSet.addSequence(vamsasSeq);
 952           vamsasSet.getSequence().add(vamsasSeq);
 953           vamsasSetIds.put(id, vamsasSeq);
 954           seqRefIds.put(id, jds);
 955         }
 956       }
 957       jseq = new JSeq();
 958       jseq.setStart(jds.getStart());
 959       jseq.setEnd(jds.getEnd());
 960       jseq.setColour(av.getSequenceColour(jds).getRGB());
 961
 962       jseq.setId(id); // jseq id should be a string not a number
 963       if (!storeDS)
 964       {
 965         // Store any sequences this sequence represents
 966         if (av.hasHiddenRows())
 967         {
 968           // use rjal, contains the full height alignment
 969           jseq.setHidden(
 970                   av.getAlignment().getHiddenSequences().isHidden(jds));
 971
 972           if (av.isHiddenRepSequence(jds))
 973           {
 974             jalview.datamodel.SequenceI[] reps = av
 975                     .getRepresentedSequences(jds).getSequencesInOrder(rjal);
 976
 977             for (int h = 0; h < reps.length; h++)
 978             {
 979               if (reps[h] != jds)
 980               {
 981                 // jseq.addHiddenSequences(rjal.findIndex(reps[h]));
 982                 jseq.getHiddenSequences().add(rjal.findIndex(reps[h]));
 983               }
 984             }
 985           }
 986         }
 987         // mark sequence as reference - if it is the reference for this view
 988         if (jal.hasSeqrep())
 989         {
 990           jseq.setViewreference(jds == jal.getSeqrep());
 991         }
 992       }
 993
 994       // TODO: omit sequence features from each alignment view's XML dump if we
 995       // are storing dataset
 996       List<SequenceFeature> sfs = jds.getSequenceFeatures();
 997       for (SequenceFeature sf : sfs)
 998       {
 999         // Features features = new Features();
1000         Feature features = new Feature();
1001
1002         features.setBegin(sf.getBegin());
1003         features.setEnd(sf.getEnd());
1004         features.setDescription(sf.getDescription());
1005         features.setType(sf.getType());
1006         features.setFeatureGroup(sf.getFeatureGroup());
1007         features.setScore(sf.getScore());
1008         if (sf.links != null)
1009         {
1010           for (int l = 0; l < sf.links.size(); l++)
1011           {
1012             OtherData keyValue = new OtherData();
1013             keyValue.setKey("LINK_" + l);
1014             keyValue.setValue(sf.links.elementAt(l).toString());
1015             // features.addOtherData(keyValue);
1016             features.getOtherData().add(keyValue);
1017           }
1018         }
1019         if (sf.otherDetails != null)
1020         {
1021           /*
1022            * save feature attributes, which may be simple strings or
1023            * map valued (have sub-attributes)
1024            */
1025           for (Entry<String, Object> entry : sf.otherDetails.entrySet())
1026           {
1027             String key = entry.getKey();
1028             Object value = entry.getValue();
1029             if (value instanceof Map<?, ?>)
1030             {
1031               for (Entry<String, Object> subAttribute : ((Map<String, Object>) value)
1032                       .entrySet())
1033               {
1034                 OtherData otherData = new OtherData();
1035                 otherData.setKey(key);
1036                 otherData.setKey2(subAttribute.getKey());
1037                 otherData.setValue(subAttribute.getValue().toString());
1038                 // features.addOtherData(otherData);
1039                 features.getOtherData().add(otherData);
1040               }
1041             }
1042             else
1043             {
1044               OtherData otherData = new OtherData();
1045               otherData.setKey(key);
1046               otherData.setValue(value.toString());
1047               // features.addOtherData(otherData);
1048               features.getOtherData().add(otherData);
1049             }
1050           }
1051         }
1052
1053         // jseq.addFeatures(features);
1054         jseq.getFeatures().add(features);
1055       }
1056
1057       /*
1058        * save PDB entries for sequence
1059        */
1060       if (jdatasq.getAllPDBEntries() != null)
1061       {
1062         Enumeration<PDBEntry> en = jdatasq.getAllPDBEntries().elements();
1063         while (en.hasMoreElements())
1064         {
1065           Pdbids pdb = new Pdbids();
1066           jalview.datamodel.PDBEntry entry = en.nextElement();
1067
1068           String pdbId = entry.getId();
1069           pdb.setId(pdbId);
1070           pdb.setType(entry.getType());
1071
1072           /*
1073            * Store any structure views associated with this sequence. This
1074            * section copes with duplicate entries in the project, so a dataset
1075            * only view *should* be coped with sensibly.
1076            */
1077           // This must have been loaded, is it still visible?
1078           JInternalFrame[] frames = Desktop.desktop.getAllFrames();
1079           String matchedFile = null;
1080           for (int f = frames.length - 1; f > -1; f--)
1081           {
1082             if (frames[f] instanceof StructureViewerBase)
1083             {
1084               StructureViewerBase viewFrame = (StructureViewerBase) frames[f];
1085               matchedFile = saveStructureState(ap, jds, pdb, entry, viewIds,
1086                       matchedFile, viewFrame);
1087               /*
1088                * Only store each structure viewer's state once in the project
1089                * jar. First time through only (storeDS==false)
1090                */
1091               String viewId = viewFrame.getViewId();
1092               if (!storeDS && !viewIds.contains(viewId))
1093               {
1094                 viewIds.add(viewId);
1095                 try
1096                 {
1097                   String viewerState = viewFrame.getStateInfo();
1098                   writeJarEntry(jout, getViewerJarEntryName(viewId),
1099                           viewerState.getBytes());
1100                 } catch (IOException e)
1101                 {
1102                   System.err.println(
1103                           "Error saving viewer state: " + e.getMessage());
1104                 }
1105               }
1106             }
1107           }
1108
1109           if (matchedFile != null || entry.getFile() != null)
1110           {
1111             if (entry.getFile() != null)
1112             {
1113               // use entry's file
1114               matchedFile = entry.getFile();
1115             }
1116             pdb.setFile(matchedFile); // entry.getFile());
1117             if (pdbfiles == null)
1118             {
1119               pdbfiles = new ArrayList<>();
1120             }
1121
1122             if (!pdbfiles.contains(pdbId))
1123             {
1124               pdbfiles.add(pdbId);
1125               copyFileToJar(jout, matchedFile, pdbId);
1126             }
1127           }
1128
1129           Enumeration<String> props = entry.getProperties();
1130           if (props.hasMoreElements())
1131           {
1132             // PdbentryItem item = new PdbentryItem();
1133             while (props.hasMoreElements())
1134             {
1135               Property prop = new Property();
1136               String key = props.nextElement();
1137               prop.setName(key);
1138               prop.setValue(entry.getProperty(key).toString());
1139               // item.addProperty(prop);
1140               pdb.getProperty().add(prop);
1141             }
1142             // pdb.addPdbentryItem(item);
1143           }
1144
1145           // jseq.addPdbids(pdb);
1146           jseq.getPdbids().add(pdb);
1147         }
1148       }
1149
1150       saveRnaViewers(jout, jseq, jds, viewIds, ap, storeDS);
1151
1152       if (jds.hasHMMProfile())
1153       {
1154         saveHmmerProfile(jout, jseq, jds);
1155       }
1156
1157       // jms.addJSeq(jseq);
1158       object.getJSeq().add(jseq);
1159     }
1160
1161     if (!storeDS && av.hasHiddenRows())
1162     {
1163       jal = av.getAlignment();
1164     }
1165     // SAVE MAPPINGS
1166     // FOR DATASET
1167     if (storeDS && jal.getCodonFrames() != null)
1168     {
1169       List<AlignedCodonFrame> jac = jal.getCodonFrames();
1170       for (AlignedCodonFrame acf : jac)
1171       {
1172         AlcodonFrame alc = new AlcodonFrame();
1173         if (acf.getProtMappings() != null
1174                 && acf.getProtMappings().length > 0)
1175         {
1176           boolean hasMap = false;
1177           SequenceI[] dnas = acf.getdnaSeqs();
1178           jalview.datamodel.Mapping[] pmaps = acf.getProtMappings();
1179           for (int m = 0; m < pmaps.length; m++)
1180           {
1181             AlcodMap alcmap = new AlcodMap();
1182             alcmap.setDnasq(seqHash(dnas[m]));
1183             alcmap.setMapping(
1184                     createVamsasMapping(pmaps[m], dnas[m], null, false));
1185             // alc.addAlcodMap(alcmap);
1186             alc.getAlcodMap().add(alcmap);
1187             hasMap = true;
1188           }
1189           if (hasMap)
1190           {
1191             // vamsasSet.addAlcodonFrame(alc);
1192             vamsasSet.getAlcodonFrame().add(alc);
1193           }
1194         }
1195         // TODO: delete this ? dead code from 2.8.3->2.9 ?
1196         // {
1197         // AlcodonFrame alc = new AlcodonFrame();
1198         // vamsasSet.addAlcodonFrame(alc);
1199         // for (int p = 0; p < acf.aaWidth; p++)
1200         // {
1201         // Alcodon cmap = new Alcodon();
1202         // if (acf.codons[p] != null)
1203         // {
1204         // // Null codons indicate a gapped column in the translated peptide
1205         // // alignment.
1206         // cmap.setPos1(acf.codons[p][0]);
1207         // cmap.setPos2(acf.codons[p][1]);
1208         // cmap.setPos3(acf.codons[p][2]);
1209         // }
1210         // alc.addAlcodon(cmap);
1211         // }
1212         // if (acf.getProtMappings() != null
1213         // && acf.getProtMappings().length > 0)
1214         // {
1215         // SequenceI[] dnas = acf.getdnaSeqs();
1216         // jalview.datamodel.Mapping[] pmaps = acf.getProtMappings();
1217         // for (int m = 0; m < pmaps.length; m++)
1218         // {
1219         // AlcodMap alcmap = new AlcodMap();
1220         // alcmap.setDnasq(seqHash(dnas[m]));
1221         // alcmap.setMapping(createVamsasMapping(pmaps[m], dnas[m], null,
1222         // false));
1223         // alc.addAlcodMap(alcmap);
1224         // }
1225         // }
1226       }
1227     }
1228
1229     // SAVE TREES
1230     // /////////////////////////////////
1231     if (!storeDS && av.getCurrentTree() != null)
1232     {
1233       // FIND ANY ASSOCIATED TREES
1234       // NOT IMPLEMENTED FOR HEADLESS STATE AT PRESENT
1235       if (Desktop.desktop != null)
1236       {
1237         JInternalFrame[] frames = Desktop.desktop.getAllFrames();
1238
1239         for (int t = 0; t < frames.length; t++)
1240         {
1241           if (frames[t] instanceof TreePanel)
1242           {
1243             TreePanel tp = (TreePanel) frames[t];
1244
1245             if (tp.getTreeCanvas().getViewport().getAlignment() == jal)
1246             {
1247               JalviewModel.Tree tree = new JalviewModel.Tree();
1248               tree.setTitle(tp.getTitle());
1249               tree.setCurrentTree((av.getCurrentTree() == tp.getTree()));
1250               tree.setNewick(tp.getTree().print());
1251               tree.setThreshold(tp.getTreeCanvas().getThreshold());
1252
1253               tree.setFitToWindow(tp.fitToWindow.getState());
1254               tree.setFontName(tp.getTreeFont().getName());
1255               tree.setFontSize(tp.getTreeFont().getSize());
1256               tree.setFontStyle(tp.getTreeFont().getStyle());
1257               tree.setMarkUnlinked(tp.placeholdersMenu.getState());
1258
1259               tree.setShowBootstrap(tp.bootstrapMenu.getState());
1260               tree.setShowDistances(tp.distanceMenu.getState());
1261
1262               tree.setHeight(tp.getHeight());
1263               tree.setWidth(tp.getWidth());
1264               tree.setXpos(tp.getX());
1265               tree.setYpos(tp.getY());
1266               tree.setId(makeHashCode(tp, null));
1267               tree.setLinkToAllViews(
1268                       tp.getTreeCanvas().isApplyToAllViews());
1269
1270               // jms.addTree(tree);
1271               object.getTree().add(tree);
1272             }
1273           }
1274         }
1275       }
1276     }
1277
1278     /*
1279      * save PCA viewers
1280      */
1281     if (!storeDS && Desktop.desktop != null)
1282     {
1283       for (JInternalFrame frame : Desktop.desktop.getAllFrames())
1284       {
1285         if (frame instanceof PCAPanel)
1286         {
1287           PCAPanel panel = (PCAPanel) frame;
1288           if (panel.getAlignViewport().getAlignment() == jal)
1289           {
1290             savePCA(panel, object);
1291           }
1292         }
1293       }
1294     }
1295
1296     // SAVE ANNOTATIONS
1297     /**
1298      * store forward refs from an annotationRow to any groups
1299      */
1300     IdentityHashMap<SequenceGroup, String> groupRefs = new IdentityHashMap<>();
1301     if (storeDS)
1302     {
1303       for (SequenceI sq : jal.getSequences())
1304       {
1305         // Store annotation on dataset sequences only
1306         AlignmentAnnotation[] aa = sq.getAnnotation();
1307         if (aa != null && aa.length > 0)
1308         {
1309           storeAlignmentAnnotation(aa, groupRefs, av, calcIdSet, storeDS,
1310                   vamsasSet);
1311         }
1312       }
1313     }
1314     else
1315     {
1316       if (jal.getAlignmentAnnotation() != null)
1317       {
1318         // Store the annotation shown on the alignment.
1319         AlignmentAnnotation[] aa = jal.getAlignmentAnnotation();
1320         storeAlignmentAnnotation(aa, groupRefs, av, calcIdSet, storeDS,
1321                 vamsasSet);
1322       }
1323     }
1324     // SAVE GROUPS
1325     if (jal.getGroups() != null)
1326     {
1327       JGroup[] groups = new JGroup[jal.getGroups().size()];
1328       int i = -1;
1329       for (jalview.datamodel.SequenceGroup sg : jal.getGroups())
1330       {
1331         JGroup jGroup = new JGroup();
1332         groups[++i] = jGroup;
1333
1334         jGroup.setStart(sg.getStartRes());
1335         jGroup.setEnd(sg.getEndRes());
1336         jGroup.setName(sg.getName());
1337         if (groupRefs.containsKey(sg))
1338         {
1339           // group has references so set its ID field
1340           jGroup.setId(groupRefs.get(sg));
1341         }
1342         ColourSchemeI colourScheme = sg.getColourScheme();
1343         if (colourScheme != null)
1344         {
1345           ResidueShaderI groupColourScheme = sg.getGroupColourScheme();
1346           if (groupColourScheme.conservationApplied())
1347           {
1348             jGroup.setConsThreshold(groupColourScheme.getConservationInc());
1349
1350             if (colourScheme instanceof jalview.schemes.UserColourScheme)
1351             {
1352               jGroup.setColour(
1353                       setUserColourScheme(colourScheme, userColours,
1354                               object));
1355             }
1356             else
1357             {
1358               jGroup.setColour(colourScheme.getSchemeName());
1359             }
1360           }
1361           else if (colourScheme instanceof jalview.schemes.AnnotationColourGradient)
1362           {
1363             jGroup.setColour("AnnotationColourGradient");
1364             jGroup.setAnnotationColours(constructAnnotationColours(
1365                     (jalview.schemes.AnnotationColourGradient) colourScheme,
1366                     userColours, object));
1367           }
1368           else if (colourScheme instanceof jalview.schemes.UserColourScheme)
1369           {
1370             jGroup.setColour(
1371                     setUserColourScheme(colourScheme, userColours, object));
1372           }
1373           else
1374           {
1375             jGroup.setColour(colourScheme.getSchemeName());
1376           }
1377
1378           jGroup.setPidThreshold(groupColourScheme.getThreshold());
1379         }
1380
1381         jGroup.setOutlineColour(sg.getOutlineColour().getRGB());
1382         jGroup.setDisplayBoxes(sg.getDisplayBoxes());
1383         jGroup.setDisplayText(sg.getDisplayText());
1384         jGroup.setColourText(sg.getColourText());
1385         jGroup.setTextCol1(sg.textColour.getRGB());
1386         jGroup.setTextCol2(sg.textColour2.getRGB());
1387         jGroup.setTextColThreshold(sg.thresholdTextColour);
1388         jGroup.setShowUnconserved(sg.getShowNonconserved());
1389         jGroup.setIgnoreGapsinConsensus(sg.getIgnoreGapsConsensus());
1390         jGroup.setShowConsensusHistogram(sg.isShowConsensusHistogram());
1391         jGroup.setShowSequenceLogo(sg.isShowSequenceLogo());
1392         jGroup.setNormaliseSequenceLogo(sg.isNormaliseSequenceLogo());
1393         for (SequenceI seq : sg.getSequences())
1394         {
1395           // jGroup.addSeq(seqHash(seq));
1396           jGroup.getSeq().add(seqHash(seq));
1397         }
1398       }
1399
1400       //jms.setJGroup(groups);
1401       Object group;
1402       for (JGroup grp : groups)
1403       {
1404         object.getJGroup().add(grp);
1405       }
1406     }
1407     if (!storeDS)
1408     {
1409       // /////////SAVE VIEWPORT
1410       Viewport view = new Viewport();
1411       view.setTitle(ap.alignFrame.getTitle());
1412       view.setSequenceSetId(
1413               makeHashCode(av.getSequenceSetId(), av.getSequenceSetId()));
1414       view.setId(av.getViewId());
1415       if (av.getCodingComplement() != null)
1416       {
1417         view.setComplementId(av.getCodingComplement().getViewId());
1418       }
1419       view.setViewName(av.getViewName());
1420       view.setGatheredViews(av.isGatherViewsHere());
1421
1422       Rectangle size = ap.av.getExplodedGeometry();
1423       Rectangle position = size;
1424       if (size == null)
1425       {
1426         size = ap.alignFrame.getBounds();
1427         if (av.getCodingComplement() != null)
1428         {
1429           position = ((SplitFrame) ap.alignFrame.getSplitViewContainer())
1430                   .getBounds();
1431         }
1432         else
1433         {
1434           position = size;
1435         }
1436       }
1437       view.setXpos(position.x);
1438       view.setYpos(position.y);
1439
1440       view.setWidth(size.width);
1441       view.setHeight(size.height);
1442
1443       view.setStartRes(vpRanges.getStartRes());
1444       view.setStartSeq(vpRanges.getStartSeq());
1445
1446       if (av.getGlobalColourScheme() instanceof jalview.schemes.UserColourScheme)
1447       {
1448         view.setBgColour(setUserColourScheme(av.getGlobalColourScheme(),
1449                 userColours, object));
1450       }
1451       else if (av
1452               .getGlobalColourScheme() instanceof jalview.schemes.AnnotationColourGradient)
1453       {
1454         AnnotationColourScheme ac = constructAnnotationColours(
1455                 (jalview.schemes.AnnotationColourGradient) av
1456                         .getGlobalColourScheme(),
1457                 userColours, object);
1458
1459         view.setAnnotationColours(ac);
1460         view.setBgColour("AnnotationColourGradient");
1461       }
1462       else
1463       {
1464         view.setBgColour(ColourSchemeProperty
1465                 .getColourName(av.getGlobalColourScheme()));
1466       }
1467
1468       ResidueShaderI vcs = av.getResidueShading();
1469       ColourSchemeI cs = av.getGlobalColourScheme();
1470
1471       if (cs != null)
1472       {
1473         if (vcs.conservationApplied())
1474         {
1475           view.setConsThreshold(vcs.getConservationInc());
1476           if (cs instanceof jalview.schemes.UserColourScheme)
1477           {
1478             view.setBgColour(setUserColourScheme(cs, userColours, object));
1479           }
1480         }
1481         view.setPidThreshold(vcs.getThreshold());
1482       }
1483
1484       view.setConservationSelected(av.getConservationSelected());
1485       view.setPidSelected(av.getAbovePIDThreshold());
1486       final Font font = av.getFont();
1487       view.setFontName(font.getName());
1488       view.setFontSize(font.getSize());
1489       view.setFontStyle(font.getStyle());
1490       view.setScaleProteinAsCdna(av.getViewStyle().isScaleProteinAsCdna());
1491       view.setRenderGaps(av.isRenderGaps());
1492       view.setShowAnnotation(av.isShowAnnotation());
1493       view.setShowBoxes(av.getShowBoxes());
1494       view.setShowColourText(av.getColourText());
1495       view.setShowFullId(av.getShowJVSuffix());
1496       view.setRightAlignIds(av.isRightAlignIds());
1497       view.setShowSequenceFeatures(av.isShowSequenceFeatures());
1498       view.setShowText(av.getShowText());
1499       view.setShowUnconserved(av.getShowUnconserved());
1500       view.setWrapAlignment(av.getWrapAlignment());
1501       view.setTextCol1(av.getTextColour().getRGB());
1502       view.setTextCol2(av.getTextColour2().getRGB());
1503       view.setTextColThreshold(av.getThresholdTextColour());
1504       view.setShowConsensusHistogram(av.isShowConsensusHistogram());
1505       view.setShowSequenceLogo(av.isShowSequenceLogo());
1506       view.setNormaliseSequenceLogo(av.isNormaliseSequenceLogo());
1507       view.setShowGroupConsensus(av.isShowGroupConsensus());
1508       view.setShowGroupConservation(av.isShowGroupConservation());
1509       view.setShowNPfeatureTooltip(av.isShowNPFeats());
1510       view.setShowDbRefTooltip(av.isShowDBRefs());
1511       view.setFollowHighlight(av.isFollowHighlight());
1512       view.setFollowSelection(av.followSelection);
1513       view.setIgnoreGapsinConsensus(av.isIgnoreGapsConsensus());
1514       if (av.getFeaturesDisplayed() != null)
1515       {
1516         FeatureSettings fs = new FeatureSettings();
1517
1518         FeatureRenderer fr = ap.getSeqPanel().seqCanvas
1519                 .getFeatureRenderer();
1520         String[] renderOrder = fr.getRenderOrder().toArray(new String[0]);
1521
1522         Vector<String> settingsAdded = new Vector<>();
1523         if (renderOrder != null)
1524         {
1525           for (String featureType : renderOrder)
1526           {
1527             FeatureSettings.Setting setting = new FeatureSettings.Setting();
1528             setting.setType(featureType);
1529
1530             /*
1531              * save any filter for the feature type
1532              */
1533             FeatureMatcherSetI filter = fr.getFeatureFilter(featureType);
1534             if (filter != null)  {
1535               Iterator<FeatureMatcherI> filters = filter.getMatchers().iterator();
1536               FeatureMatcherI firstFilter = filters.next();
1537               setting.setMatcherSet(Jalview2XML.marshalFilter(
1538                       firstFilter, filters, filter.isAnded()));
1539             }
1540
1541             /*
1542              * save colour scheme for the feature type
1543              */
1544             FeatureColourI fcol = fr.getFeatureStyle(featureType);
1545             if (!fcol.isSimpleColour())
1546             {
1547               setting.setColour(fcol.getMaxColour().getRGB());
1548               setting.setMincolour(fcol.getMinColour().getRGB());
1549               setting.setMin(fcol.getMin());
1550               setting.setMax(fcol.getMax());
1551               setting.setColourByLabel(fcol.isColourByLabel());
1552               if (fcol.isColourByAttribute())
1553               {
1554                 String[] attName = fcol.getAttributeName();
1555                 setting.getAttributeName().add(attName[0]);
1556                 if (attName.length > 1)
1557                 {
1558                   setting.getAttributeName().add(attName[1]);
1559                 }
1560               }
1561               setting.setAutoScale(fcol.isAutoScaled());
1562               setting.setThreshold(fcol.getThreshold());
1563               Color noColour = fcol.getNoColour();
1564               if (noColour == null)
1565               {
1566                 setting.setNoValueColour(NoValueColour.NONE);
1567               }
1568               else if (noColour.equals(fcol.getMaxColour()))
1569               {
1570                 setting.setNoValueColour(NoValueColour.MAX);
1571               }
1572               else
1573               {
1574                 setting.setNoValueColour(NoValueColour.MIN);
1575               }
1576               // -1 = No threshold, 0 = Below, 1 = Above
1577               setting.setThreshstate(fcol.isAboveThreshold() ? 1
1578                       : (fcol.isBelowThreshold() ? 0 : -1));
1579             }
1580             else
1581             {
1582               setting.setColour(fcol.getColour().getRGB());
1583             }
1584
1585             setting.setDisplay(
1586                     av.getFeaturesDisplayed().isVisible(featureType));
1587             float rorder = fr
1588                     .getOrder(featureType);
1589             if (rorder > -1)
1590             {
1591               setting.setOrder(rorder);
1592             }
1593             /// fs.addSetting(setting);
1594             fs.getSetting().add(setting);
1595             settingsAdded.addElement(featureType);
1596           }
1597         }
1598
1599         // is groups actually supposed to be a map here ?
1600         Iterator<String> en = fr.getFeatureGroups().iterator();
1601         Vector<String> groupsAdded = new Vector<>();
1602         while (en.hasNext())
1603         {
1604           String grp = en.next();
1605           if (groupsAdded.contains(grp))
1606           {
1607             continue;
1608           }
1609           Group g = new Group();
1610           g.setName(grp);
1611           g.setDisplay(((Boolean) fr.checkGroupVisibility(grp, false))
1612                           .booleanValue());
1613           // fs.addGroup(g);
1614           fs.getGroup().add(g);
1615           groupsAdded.addElement(grp);
1616         }
1617         // jms.setFeatureSettings(fs);
1618         object.setFeatureSettings(fs);
1619       }
1620
1621       if (av.hasHiddenColumns())
1622       {
1623         jalview.datamodel.HiddenColumns hidden = av.getAlignment()
1624                 .getHiddenColumns();
1625         if (hidden == null)
1626         {
1627           warn("REPORT BUG: avoided null columnselection bug (DMAM reported). Please contact Jim about this.");
1628         }
1629         else
1630         {
1631           Iterator<int[]> hiddenRegions = hidden.iterator();
1632           while (hiddenRegions.hasNext())
1633           {
1634             int[] region = hiddenRegions.next();
1635             HiddenColumns hc = new HiddenColumns();
1636             hc.setStart(region[0]);
1637             hc.setEnd(region[1]);
1638             // view.addHiddenColumns(hc);
1639             view.getHiddenColumns().add(hc);
1640           }
1641         }
1642       }
1643       if (calcIdSet.size() > 0)
1644       {
1645         for (String calcId : calcIdSet)
1646         {
1647           if (calcId.trim().length() > 0)
1648           {
1649             CalcIdParam cidp = createCalcIdParam(calcId, av);
1650             // Some calcIds have no parameters.
1651             if (cidp != null)
1652             {
1653               // view.addCalcIdParam(cidp);
1654               view.getCalcIdParam().add(cidp);
1655             }
1656           }
1657         }
1658       }
1659
1660       // jms.addViewport(view);
1661       object.getViewport().add(view);
1662     }
1663     // object.setJalviewModelSequence(jms);
1664     // object.getVamsasModel().addSequenceSet(vamsasSet);
1665     object.getVamsasModel().getSequenceSet().add(vamsasSet);
1666
1667     if (jout != null && fileName != null)
1668     {
1669       // We may not want to write the object to disk,
1670       // eg we can copy the alignViewport to a new view object
1671       // using save and then load
1672       try
1673       {
1674         System.out.println("Writing jar entry " + fileName);
1675         JarEntry entry = new JarEntry(fileName);
1676         jout.putNextEntry(entry);
1677         PrintWriter pout = new PrintWriter(
1678                 new OutputStreamWriter(jout, UTF_8));
1679         JAXBContext jaxbContext = JAXBContext
1680                 .newInstance(JalviewModel.class);
1681         Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
1682
1683         // output pretty printed
1684         // jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
1685         jaxbMarshaller.marshal(
1686                 new ObjectFactory().createJalviewModel(object), pout);
1687
1688         // jaxbMarshaller.marshal(object, pout);
1689         // marshaller.marshal(object);
1690         pout.flush();
1691         jout.closeEntry();
1692       } catch (Exception ex)
1693       {
1694         // TODO: raise error in GUI if marshalling failed.
1695         System.err.println("Error writing Jalview project");
1696         ex.printStackTrace();
1697       }
1698     }
1699     return object;
1700   }
1701   /**
1702    * Saves the HMMER profile associated with the sequence as a file in the jar,
1703    * in HMMER format, and saves the name of the file as a child element of the
1704    * XML sequence element
1705    *
1706    * @param jout
1707    * @param xmlSeq
1708    * @param seq
1709    */
1710   protected void saveHmmerProfile(JarOutputStream jout, JSeq xmlSeq,
1711           SequenceI seq)
1712   {
1713     HiddenMarkovModel profile = seq.getHMM();
1714     if (profile == null)
1715     {
1716       warn("Want to save HMM profile for " + seq.getName()
1717               + " but none found");
1718       return;
1719     }
1720     HMMFile hmmFile = new HMMFile(profile);
1721     String hmmAsString = hmmFile.print();
1722     String jarEntryName = HMMER_PREFIX + nextCounter();
1723     try
1724     {
1725       writeJarEntry(jout, jarEntryName, hmmAsString.getBytes());
1726       xmlSeq.setHmmerProfile(jarEntryName);
1727     } catch (IOException e)
1728     {
1729       warn("Error saving HMM profile: " + e.getMessage());
1730     }
1731   }
1732
1733
1734   /**
1735    * Writes PCA viewer attributes and computed values to an XML model object and
1736    * adds it to the JalviewModel. Any exceptions are reported by logging.
1737    */
1738   protected void savePCA(PCAPanel panel, JalviewModel object)
1739   {
1740     try
1741     {
1742       PcaViewer viewer = new PcaViewer();
1743       viewer.setHeight(panel.getHeight());
1744       viewer.setWidth(panel.getWidth());
1745       viewer.setXpos(panel.getX());
1746       viewer.setYpos(panel.getY());
1747       viewer.setTitle(panel.getTitle());
1748       PCAModel pcaModel = panel.getPcaModel();
1749       viewer.setScoreModelName(pcaModel.getScoreModelName());
1750       viewer.setXDim(panel.getSelectedDimensionIndex(X));
1751       viewer.setYDim(panel.getSelectedDimensionIndex(Y));
1752       viewer.setZDim(panel.getSelectedDimensionIndex(Z));
1753       viewer.setBgColour(
1754               panel.getRotatableCanvas().getBackgroundColour().getRGB());
1755       viewer.setScaleFactor(panel.getRotatableCanvas().getScaleFactor());
1756       float[] spMin = panel.getRotatableCanvas().getSeqMin();
1757       SeqPointMin spmin = new SeqPointMin();
1758       spmin.setXPos(spMin[0]);
1759       spmin.setYPos(spMin[1]);
1760       spmin.setZPos(spMin[2]);
1761       viewer.setSeqPointMin(spmin);
1762       float[] spMax = panel.getRotatableCanvas().getSeqMax();
1763       SeqPointMax spmax = new SeqPointMax();
1764       spmax.setXPos(spMax[0]);
1765       spmax.setYPos(spMax[1]);
1766       spmax.setZPos(spMax[2]);
1767       viewer.setSeqPointMax(spmax);
1768       viewer.setShowLabels(panel.getRotatableCanvas().isShowLabels());
1769       viewer.setLinkToAllViews(
1770               panel.getRotatableCanvas().isApplyToAllViews());
1771       SimilarityParamsI sp = pcaModel.getSimilarityParameters();
1772       viewer.setIncludeGaps(sp.includeGaps());
1773       viewer.setMatchGaps(sp.matchGaps());
1774       viewer.setIncludeGappedColumns(sp.includeGappedColumns());
1775       viewer.setDenominateByShortestLength(sp.denominateByShortestLength());
1776
1777       /*
1778        * sequence points on display
1779        */
1780       for (jalview.datamodel.SequencePoint spt : pcaModel
1781               .getSequencePoints())
1782       {
1783         SequencePoint point = new SequencePoint();
1784         point.setSequenceRef(seqHash(spt.getSequence()));
1785         point.setXPos(spt.coord.x);
1786         point.setYPos(spt.coord.y);
1787         point.setZPos(spt.coord.z);
1788         viewer.getSequencePoint().add(point);
1789       }
1790
1791       /*
1792        * (end points of) axes on display
1793        */
1794       for (Point p : panel.getRotatableCanvas().getAxisEndPoints())
1795       {
1796
1797         Axis axis = new Axis();
1798         axis.setXPos(p.x);
1799         axis.setYPos(p.y);
1800         axis.setZPos(p.z);
1801         viewer.getAxis().add(axis);
1802       }
1803
1804       /*
1805        * raw PCA data (note we are not restoring PCA inputs here -
1806        * alignment view, score model, similarity parameters)
1807        */
1808       PcaDataType data = new PcaDataType();
1809       viewer.setPcaData(data);
1810       PCA pca = pcaModel.getPcaData();
1811
1812       DoubleMatrix pm = new DoubleMatrix();
1813       saveDoubleMatrix(pca.getPairwiseScores(), pm);
1814       data.setPairwiseMatrix(pm);
1815
1816       DoubleMatrix tm = new DoubleMatrix();
1817       saveDoubleMatrix(pca.getTridiagonal(), tm);
1818       data.setTridiagonalMatrix(tm);
1819
1820       DoubleMatrix eigenMatrix = new DoubleMatrix();
1821       data.setEigenMatrix(eigenMatrix);
1822       saveDoubleMatrix(pca.getEigenmatrix(), eigenMatrix);
1823
1824       object.getPcaViewer().add(viewer);
1825     } catch (Throwable t)
1826     {
1827       Cache.log.error("Error saving PCA: " + t.getMessage());
1828     }
1829   }
1830
1831   /**
1832    * Stores values from a matrix into an XML element, including (if present) the
1833    * D or E vectors
1834    *
1835    * @param m
1836    * @param xmlMatrix
1837    * @see #loadDoubleMatrix(DoubleMatrix)
1838    */
1839   protected void saveDoubleMatrix(MatrixI m, DoubleMatrix xmlMatrix)
1840   {
1841     xmlMatrix.setRows(m.height());
1842     xmlMatrix.setColumns(m.width());
1843     for (int i = 0; i < m.height(); i++)
1844     {
1845       DoubleVector row = new DoubleVector();
1846       for (int j = 0; j < m.width(); j++)
1847       {
1848         row.getV().add(m.getValue(i, j));
1849       }
1850       xmlMatrix.getRow().add(row);
1851     }
1852     if (m.getD() != null)
1853     {
1854       DoubleVector dVector = new DoubleVector();
1855       for (double d : m.getD())
1856       {
1857         dVector.getV().add(d);
1858       }
1859       xmlMatrix.setD(dVector);
1860     }
1861     if (m.getE() != null)
1862     {
1863       DoubleVector eVector = new DoubleVector();
1864       for (double e : m.getE())
1865       {
1866         eVector.getV().add(e);
1867       }
1868       xmlMatrix.setE(eVector);
1869     }
1870   }
1871
1872   /**
1873    * Loads XML matrix data into a new Matrix object, including the D and/or E
1874    * vectors (if present)
1875    *
1876    * @param mData
1877    * @return
1878    * @see Jalview2XML#saveDoubleMatrix(MatrixI, DoubleMatrix)
1879    */
1880   protected MatrixI loadDoubleMatrix(DoubleMatrix mData)
1881   {
1882     int rows = mData.getRows();
1883     double[][] vals = new double[rows][];
1884
1885     for (int i = 0; i < rows; i++)
1886     {
1887       List<Double> dVector = mData.getRow().get(i).getV();
1888       vals[i] = new double[dVector.size()];
1889       int dvi = 0;
1890       for (Double d : dVector)
1891       {
1892         vals[i][dvi++] = d;
1893       }
1894     }
1895
1896     MatrixI m = new Matrix(vals);
1897
1898     if (mData.getD() != null)
1899     {
1900       List<Double> dVector = mData.getD().getV();
1901       double[] vec = new double[dVector.size()];
1902       int dvi = 0;
1903       for (Double d : dVector)
1904       {
1905         vec[dvi++] = d;
1906       }
1907       m.setD(vec);
1908     }
1909     if (mData.getE() != null)
1910     {
1911       List<Double> dVector = mData.getE().getV();
1912       double[] vec = new double[dVector.size()];
1913       int dvi = 0;
1914       for (Double d : dVector)
1915       {
1916         vec[dvi++] = d;
1917       }
1918       m.setE(vec);
1919     }
1920
1921     return m;
1922   }
1923
1924   /**
1925    * Save any Varna viewers linked to this sequence. Writes an rnaViewer element
1926    * for each viewer, with
1927    * <ul>
1928    * <li>viewer geometry (position, size, split pane divider location)</li>
1929    * <li>index of the selected structure in the viewer (currently shows gapped
1930    * or ungapped)</li>
1931    * <li>the id of the annotation holding RNA secondary structure</li>
1932    * <li>(currently only one SS is shown per viewer, may be more in future)</li>
1933    * </ul>
1934    * Varna viewer state is also written out (in native Varna XML) to separate
1935    * project jar entries. A separate entry is written for each RNA structure
1936    * displayed, with the naming convention
1937    * <ul>
1938    * <li>rna_viewId_sequenceId_annotationId_[gapped|trimmed]</li>
1939    * </ul>
1940    *
1941    * @param jout
1942    * @param jseq
1943    * @param jds
1944    * @param viewIds
1945    * @param ap
1946    * @param storeDataset
1947    */
1948   protected void saveRnaViewers(JarOutputStream jout, JSeq jseq,
1949           final SequenceI jds, List<String> viewIds, AlignmentPanel ap,
1950           boolean storeDataset)
1951   {
1952     if (Desktop.desktop == null)
1953     {
1954       return;
1955     }
1956     JInternalFrame[] frames = Desktop.desktop.getAllFrames();
1957     for (int f = frames.length - 1; f > -1; f--)
1958     {
1959       if (frames[f] instanceof AppVarna)
1960       {
1961         AppVarna varna = (AppVarna) frames[f];
1962         /*
1963          * link the sequence to every viewer that is showing it and is linked to
1964          * its alignment panel
1965          */
1966         if (varna.isListeningFor(jds) && ap == varna.getAlignmentPanel())
1967         {
1968           String viewId = varna.getViewId();
1969           RnaViewer rna = new RnaViewer();
1970           rna.setViewId(viewId);
1971           rna.setTitle(varna.getTitle());
1972           rna.setXpos(varna.getX());
1973           rna.setYpos(varna.getY());
1974           rna.setWidth(varna.getWidth());
1975           rna.setHeight(varna.getHeight());
1976           rna.setDividerLocation(varna.getDividerLocation());
1977           rna.setSelectedRna(varna.getSelectedIndex());
1978           // jseq.addRnaViewer(rna);
1979           jseq.getRnaViewer().add(rna);
1980
1981           /*
1982            * Store each Varna panel's state once in the project per sequence.
1983            * First time through only (storeDataset==false)
1984            */
1985           // boolean storeSessions = false;
1986           // String sequenceViewId = viewId + seqsToIds.get(jds);
1987           // if (!storeDataset && !viewIds.contains(sequenceViewId))
1988           // {
1989           // viewIds.add(sequenceViewId);
1990           // storeSessions = true;
1991           // }
1992           for (RnaModel model : varna.getModels())
1993           {
1994             if (model.seq == jds)
1995             {
1996               /*
1997                * VARNA saves each view (sequence or alignment secondary
1998                * structure, gapped or trimmed) as a separate XML file
1999                */
2000               String jarEntryName = rnaSessions.get(model);
2001               if (jarEntryName == null)
2002               {
2003
2004                 String varnaStateFile = varna.getStateInfo(model.rna);
2005                 jarEntryName = RNA_PREFIX + viewId + "_" + nextCounter();
2006                 copyFileToJar(jout, varnaStateFile, jarEntryName);
2007                 rnaSessions.put(model, jarEntryName);
2008               }
2009               SecondaryStructure ss = new SecondaryStructure();
2010               String annotationId = varna.getAnnotation(jds).annotationId;
2011               ss.setAnnotationId(annotationId);
2012               ss.setViewerState(jarEntryName);
2013               ss.setGapped(model.gapped);
2014               ss.setTitle(model.title);
2015               // rna.addSecondaryStructure(ss);
2016               rna.getSecondaryStructure().add(ss);
2017             }
2018           }
2019         }
2020       }
2021     }
2022   }
2023
2024   /**
2025    * Copy the contents of a file to a new entry added to the output jar
2026    *
2027    * @param jout
2028    * @param infilePath
2029    * @param jarEntryName
2030    */
2031   protected void copyFileToJar(JarOutputStream jout, String infilePath,
2032           String jarEntryName)
2033   {
2034     DataInputStream dis = null;
2035     try
2036     {
2037       File file = new File(infilePath);
2038       if (file.exists() && jout != null)
2039       {
2040         dis = new DataInputStream(new FileInputStream(file));
2041         byte[] data = new byte[(int) file.length()];
2042         dis.readFully(data);
2043         writeJarEntry(jout, jarEntryName, data);
2044       }
2045     } catch (Exception ex)
2046     {
2047       ex.printStackTrace();
2048     } finally
2049     {
2050       if (dis != null)
2051       {
2052         try
2053         {
2054           dis.close();
2055         } catch (IOException e)
2056         {
2057           // ignore
2058         }
2059       }
2060     }
2061   }
2062
2063   /**
2064    * Write the data to a new entry of given name in the output jar file
2065    *
2066    * @param jout
2067    * @param jarEntryName
2068    * @param data
2069    * @throws IOException
2070    */
2071   protected void writeJarEntry(JarOutputStream jout, String jarEntryName,
2072           byte[] data) throws IOException
2073   {
2074     if (jout != null)
2075     {
2076       System.out.println("Writing jar entry " + jarEntryName);
2077       jout.putNextEntry(new JarEntry(jarEntryName));
2078       DataOutputStream dout = new DataOutputStream(jout);
2079       dout.write(data, 0, data.length);
2080       dout.flush();
2081       jout.closeEntry();
2082     }
2083   }
2084
2085   /**
2086    * Save the state of a structure viewer
2087    *
2088    * @param ap
2089    * @param jds
2090    * @param pdb
2091    *          the archive XML element under which to save the state
2092    * @param entry
2093    * @param viewIds
2094    * @param matchedFile
2095    * @param viewFrame
2096    * @return
2097    */
2098   protected String saveStructureState(AlignmentPanel ap, SequenceI jds,
2099           Pdbids pdb, PDBEntry entry, List<String> viewIds,
2100           String matchedFile, StructureViewerBase viewFrame)
2101   {
2102     final AAStructureBindingModel bindingModel = viewFrame.getBinding();
2103
2104     /*
2105      * Look for any bindings for this viewer to the PDB file of interest
2106      * (including part matches excluding chain id)
2107      */
2108     for (int peid = 0; peid < bindingModel.getPdbCount(); peid++)
2109     {
2110       final PDBEntry pdbentry = bindingModel.getPdbEntry(peid);
2111       final String pdbId = pdbentry.getId();
2112       if (!pdbId.equals(entry.getId())
2113               && !(entry.getId().length() > 4 && entry.getId().toLowerCase()
2114                       .startsWith(pdbId.toLowerCase())))
2115       {
2116         /*
2117          * not interested in a binding to a different PDB entry here
2118          */
2119         continue;
2120       }
2121       if (matchedFile == null)
2122       {
2123         matchedFile = pdbentry.getFile();
2124       }
2125       else if (!matchedFile.equals(pdbentry.getFile()))
2126       {
2127           Cache.log.warn(
2128                   "Probably lost some PDB-Sequence mappings for this structure file (which apparently has same PDB Entry code): "
2129                           + pdbentry.getFile());
2130       }
2131       // record the
2132       // file so we
2133       // can get at it if the ID
2134       // match is ambiguous (e.g.
2135       // 1QIP==1qipA)
2136
2137       for (int smap = 0; smap < viewFrame.getBinding()
2138               .getSequence()[peid].length; smap++)
2139       {
2140         // if (jal.findIndex(jmol.jmb.sequence[peid][smap]) > -1)
2141         if (jds == viewFrame.getBinding().getSequence()[peid][smap])
2142         {
2143           StructureState state = new StructureState();
2144           state.setVisible(true);
2145           state.setXpos(viewFrame.getX());
2146           state.setYpos(viewFrame.getY());
2147           state.setWidth(viewFrame.getWidth());
2148           state.setHeight(viewFrame.getHeight());
2149           final String viewId = viewFrame.getViewId();
2150           state.setViewId(viewId);
2151           state.setAlignwithAlignPanel(viewFrame.isUsedforaligment(ap));
2152           state.setColourwithAlignPanel(viewFrame.isUsedforcolourby(ap));
2153           state.setColourByJmol(viewFrame.isColouredByViewer());
2154           state.setType(viewFrame.getViewerType().toString());
2155           // pdb.addStructureState(state);
2156           pdb.getStructureState().add(state);
2157         }
2158       }
2159     }
2160     return matchedFile;
2161   }
2162
2163   /**
2164    * Populates the AnnotationColourScheme xml for save. This captures the
2165    * settings of the options in the 'Colour by Annotation' dialog.
2166    *
2167    * @param acg
2168    * @param userColours
2169    * @param jm
2170    * @return
2171    */
2172   private AnnotationColourScheme constructAnnotationColours(
2173           AnnotationColourGradient acg, List<UserColourScheme> userColours,
2174           JalviewModel jm)
2175   {
2176     AnnotationColourScheme ac = new AnnotationColourScheme();
2177     ac.setAboveThreshold(acg.getAboveThreshold());
2178     ac.setThreshold(acg.getAnnotationThreshold());
2179     // 2.10.2 save annotationId (unique) not annotation label
2180     ac.setAnnotation(acg.getAnnotation().annotationId);
2181     if (acg.getBaseColour() instanceof UserColourScheme)
2182     {
2183       ac.setColourScheme(
2184               setUserColourScheme(acg.getBaseColour(), userColours, jm));
2185     }
2186     else
2187     {
2188       ac.setColourScheme(
2189               ColourSchemeProperty.getColourName(acg.getBaseColour()));
2190     }
2191
2192     ac.setMaxColour(acg.getMaxColour().getRGB());
2193     ac.setMinColour(acg.getMinColour().getRGB());
2194     ac.setPerSequence(acg.isSeqAssociated());
2195     ac.setPredefinedColours(acg.isPredefinedColours());
2196     return ac;
2197   }
2198
2199   private void storeAlignmentAnnotation(AlignmentAnnotation[] aa,
2200           IdentityHashMap<SequenceGroup, String> groupRefs,
2201           AlignmentViewport av, Set<String> calcIdSet, boolean storeDS,
2202           SequenceSet vamsasSet)
2203   {
2204
2205     for (int i = 0; i < aa.length; i++)
2206     {
2207       Annotation an = new Annotation();
2208
2209       AlignmentAnnotation annotation = aa[i];
2210       if (annotation.annotationId != null)
2211       {
2212         annotationIds.put(annotation.annotationId, annotation);
2213       }
2214
2215       an.setId(annotation.annotationId);
2216
2217       an.setVisible(annotation.visible);
2218
2219       an.setDescription(annotation.description);
2220
2221       if (annotation.sequenceRef != null)
2222       {
2223         // 2.9 JAL-1781 xref on sequence id rather than name
2224         an.setSequenceRef(seqsToIds.get(annotation.sequenceRef));
2225       }
2226       if (annotation.groupRef != null)
2227       {
2228         String groupIdr = groupRefs.get(annotation.groupRef);
2229         if (groupIdr == null)
2230         {
2231           // make a locally unique String
2232           groupRefs.put(annotation.groupRef,
2233                   groupIdr = ("" + System.currentTimeMillis()
2234                           + annotation.groupRef.getName()
2235                           + groupRefs.size()));
2236         }
2237         an.setGroupRef(groupIdr.toString());
2238       }
2239
2240       // store all visualization attributes for annotation
2241       an.setGraphHeight(annotation.graphHeight);
2242       an.setCentreColLabels(annotation.centreColLabels);
2243       an.setScaleColLabels(annotation.scaleColLabel);
2244       an.setShowAllColLabels(annotation.showAllColLabels);
2245       an.setBelowAlignment(annotation.belowAlignment);
2246
2247       if (annotation.graph > 0)
2248       {
2249         an.setGraph(true);
2250         an.setGraphType(annotation.graph);
2251         an.setGraphGroup(annotation.graphGroup);
2252         if (annotation.getThreshold() != null)
2253         {
2254           ThresholdLine line = new ThresholdLine();
2255           line.setLabel(annotation.getThreshold().label);
2256           line.setValue(annotation.getThreshold().value);
2257           line.setColour(annotation.getThreshold().colour.getRGB());
2258           an.setThresholdLine(line);
2259         }
2260       }
2261       else
2262       {
2263         an.setGraph(false);
2264       }
2265
2266       an.setLabel(annotation.label);
2267
2268       if (annotation == av.getAlignmentQualityAnnot()
2269               || annotation == av.getAlignmentConservationAnnotation()
2270               || annotation == av.getAlignmentConsensusAnnotation()
2271               || annotation.autoCalculated)
2272       {
2273         // new way of indicating autocalculated annotation -
2274         an.setAutoCalculated(annotation.autoCalculated);
2275       }
2276       if (annotation.hasScore())
2277       {
2278         an.setScore(annotation.getScore());
2279       }
2280
2281       if (annotation.getCalcId() != null)
2282       {
2283         calcIdSet.add(annotation.getCalcId());
2284         an.setCalcId(annotation.getCalcId());
2285       }
2286       if (annotation.hasProperties())
2287       {
2288         for (String pr : annotation.getProperties())
2289         {
2290           jalview.xml.binding.jalview.Annotation.Property prop = new jalview.xml.binding.jalview.Annotation.Property();
2291           prop.setName(pr);
2292           prop.setValue(annotation.getProperty(pr));
2293           // an.addProperty(prop);
2294           an.getProperty().add(prop);
2295         }
2296       }
2297
2298       AnnotationElement ae;
2299       if (annotation.annotations != null)
2300       {
2301         an.setScoreOnly(false);
2302         for (int a = 0; a < annotation.annotations.length; a++)
2303         {
2304           if ((annotation == null) || (annotation.annotations[a] == null))
2305           {
2306             continue;
2307           }
2308
2309           ae = new AnnotationElement();
2310           if (annotation.annotations[a].description != null)
2311           {
2312             ae.setDescription(annotation.annotations[a].description);
2313           }
2314           if (annotation.annotations[a].displayCharacter != null)
2315           {
2316             ae.setDisplayCharacter(
2317                     annotation.annotations[a].displayCharacter);
2318           }
2319
2320           if (!Float.isNaN(annotation.annotations[a].value))
2321           {
2322             ae.setValue(annotation.annotations[a].value);
2323           }
2324
2325           ae.setPosition(a);
2326           if (annotation.annotations[a].secondaryStructure > ' ')
2327           {
2328             ae.setSecondaryStructure(
2329                     annotation.annotations[a].secondaryStructure + "");
2330           }
2331
2332           if (annotation.annotations[a].colour != null
2333                   && annotation.annotations[a].colour != java.awt.Color.black)
2334           {
2335             ae.setColour(annotation.annotations[a].colour.getRGB());
2336           }
2337
2338           // an.addAnnotationElement(ae);
2339           an.getAnnotationElement().add(ae);
2340           if (annotation.autoCalculated)
2341           {
2342             // only write one non-null entry into the annotation row -
2343             // sufficient to get the visualization attributes necessary to
2344             // display data
2345             continue;
2346           }
2347         }
2348       }
2349       else
2350       {
2351         an.setScoreOnly(true);
2352       }
2353       if (!storeDS || (storeDS && !annotation.autoCalculated))
2354       {
2355         // skip autocalculated annotation - these are only provided for
2356         // alignments
2357         // vamsasSet.addAnnotation(an);
2358         vamsasSet.getAnnotation().add(an);
2359       }
2360     }
2361
2362   }
2363
2364   private CalcIdParam createCalcIdParam(String calcId, AlignViewport av)
2365   {
2366     AutoCalcSetting settings = av.getCalcIdSettingsFor(calcId);
2367     if (settings != null)
2368     {
2369       CalcIdParam vCalcIdParam = new CalcIdParam();
2370       vCalcIdParam.setCalcId(calcId);
2371       // vCalcIdParam.addServiceURL(settings.getServiceURI());
2372       vCalcIdParam.getServiceURL().add(settings.getServiceURI());
2373       // generic URI allowing a third party to resolve another instance of the
2374       // service used for this calculation
2375       for (String url : settings.getServiceURLs())
2376       {
2377         // vCalcIdParam.addServiceURL(urls);
2378         vCalcIdParam.getServiceURL().add(url);
2379       }
2380       vCalcIdParam.setVersion("1.0");
2381       if (settings.getPreset() != null)
2382       {
2383         WsParamSetI setting = settings.getPreset();
2384         vCalcIdParam.setName(setting.getName());
2385         vCalcIdParam.setDescription(setting.getDescription());
2386       }
2387       else
2388       {
2389         vCalcIdParam.setName("");
2390         vCalcIdParam.setDescription("Last used parameters");
2391       }
2392       // need to be able to recover 1) settings 2) user-defined presets or
2393       // recreate settings from preset 3) predefined settings provided by
2394       // service - or settings that can be transferred (or discarded)
2395       vCalcIdParam.setParameters(
2396               settings.getWsParamFile().replace("\n", "|\\n|"));
2397       vCalcIdParam.setAutoUpdate(settings.isAutoUpdate());
2398       // todo - decide if updateImmediately is needed for any projects.
2399
2400       return vCalcIdParam;
2401     }
2402     return null;
2403   }
2404
2405   private boolean recoverCalcIdParam(CalcIdParam calcIdParam,
2406           AlignViewport av)
2407   {
2408     if (calcIdParam.getVersion().equals("1.0"))
2409     {
2410       final String[] calcIds = calcIdParam.getServiceURL().toArray(new String[0]);
2411       Jws2Instance service = Jws2Discoverer.getDiscoverer()
2412               .getPreferredServiceFor(calcIds);
2413       if (service != null)
2414       {
2415         WsParamSetI parmSet = null;
2416         try
2417         {
2418           parmSet = service.getParamStore().parseServiceParameterFile(
2419                   calcIdParam.getName(), calcIdParam.getDescription(),
2420                   calcIds,
2421                   calcIdParam.getParameters().replace("|\\n|", "\n"));
2422         } catch (IOException x)
2423         {
2424           warn("Couldn't parse parameter data for "
2425                   + calcIdParam.getCalcId(), x);
2426           return false;
2427         }
2428         List<ArgumentI> argList = null;
2429         if (calcIdParam.getName().length() > 0)
2430         {
2431           parmSet = service.getParamStore()
2432                   .getPreset(calcIdParam.getName());
2433           if (parmSet != null)
2434           {
2435             // TODO : check we have a good match with settings in AACon -
2436             // otherwise we'll need to create a new preset
2437           }
2438         }
2439         else
2440         {
2441           argList = parmSet.getArguments();
2442           parmSet = null;
2443         }
2444         AAConSettings settings = new AAConSettings(
2445                 calcIdParam.isAutoUpdate(), service, parmSet, argList);
2446         av.setCalcIdSettingsFor(calcIdParam.getCalcId(), settings,
2447                 calcIdParam.isNeedsUpdate());
2448         return true;
2449       }
2450       else
2451       {
2452         warn("Cannot resolve a service for the parameters used in this project. Try configuring a JABAWS server.");
2453         return false;
2454       }
2455     }
2456     throw new Error(MessageManager.formatMessage(
2457             "error.unsupported_version_calcIdparam", new Object[]
2458             { calcIdParam.toString() }));
2459   }
2460
2461   /**
2462    * External mapping between jalview objects and objects yielding a valid and
2463    * unique object ID string. This is null for normal Jalview project IO, but
2464    * non-null when a jalview project is being read or written as part of a
2465    * vamsas session.
2466    */
2467   IdentityHashMap jv2vobj = null;
2468
2469   /**
2470    * Construct a unique ID for jvobj using either existing bindings or if none
2471    * exist, the result of the hashcode call for the object.
2472    *
2473    * @param jvobj
2474    *          jalview data object
2475    * @return unique ID for referring to jvobj
2476    */
2477   private String makeHashCode(Object jvobj, String altCode)
2478   {
2479     if (jv2vobj != null)
2480     {
2481       Object id = jv2vobj.get(jvobj);
2482       if (id != null)
2483       {
2484         return id.toString();
2485       }
2486       // check string ID mappings
2487       if (jvids2vobj != null && jvobj instanceof String)
2488       {
2489         id = jvids2vobj.get(jvobj);
2490       }
2491       if (id != null)
2492       {
2493         return id.toString();
2494       }
2495       // give up and warn that something has gone wrong
2496       warn("Cannot find ID for object in external mapping : " + jvobj);
2497     }
2498     return altCode;
2499   }
2500
2501   /**
2502    * return local jalview object mapped to ID, if it exists
2503    *
2504    * @param idcode
2505    *          (may be null)
2506    * @return null or object bound to idcode
2507    */
2508   private Object retrieveExistingObj(String idcode)
2509   {
2510     if (idcode != null && vobj2jv != null)
2511     {
2512       return vobj2jv.get(idcode);
2513     }
2514     return null;
2515   }
2516
2517   /**
2518    * binding from ID strings from external mapping table to jalview data model
2519    * objects.
2520    */
2521   private Hashtable vobj2jv;
2522
2523   private Sequence createVamsasSequence(String id, SequenceI jds)
2524   {
2525     return createVamsasSequence(true, id, jds, null);
2526   }
2527
2528   private Sequence createVamsasSequence(boolean recurse, String id,
2529           SequenceI jds, SequenceI parentseq)
2530   {
2531     Sequence vamsasSeq = new Sequence();
2532     vamsasSeq.setId(id);
2533     vamsasSeq.setName(jds.getName());
2534     vamsasSeq.setSequence(jds.getSequenceAsString());
2535     vamsasSeq.setDescription(jds.getDescription());
2536     jalview.datamodel.DBRefEntry[] dbrefs = null;
2537     if (jds.getDatasetSequence() != null)
2538     {
2539       vamsasSeq.setDsseqid(seqHash(jds.getDatasetSequence()));
2540     }
2541     else
2542     {
2543       // seqId==dsseqid so we can tell which sequences really are
2544       // dataset sequences only
2545       vamsasSeq.setDsseqid(id);
2546       dbrefs = jds.getDBRefs();
2547       if (parentseq == null)
2548       {
2549         parentseq = jds;
2550       }
2551     }
2552     if (dbrefs != null)
2553     {
2554       for (int d = 0; d < dbrefs.length; d++)
2555       {
2556         DBRef dbref = new DBRef();
2557         dbref.setSource(dbrefs[d].getSource());
2558         dbref.setVersion(dbrefs[d].getVersion());
2559         dbref.setAccessionId(dbrefs[d].getAccessionId());
2560         if (dbrefs[d].hasMap())
2561         {
2562           Mapping mp = createVamsasMapping(dbrefs[d].getMap(), parentseq,
2563                   jds, recurse);
2564           dbref.setMapping(mp);
2565         }
2566         // vamsasSeq.addDBRef(dbref);
2567         vamsasSeq.getDBRef().add(dbref);
2568       }
2569     }
2570     return vamsasSeq;
2571   }
2572
2573   private Mapping createVamsasMapping(jalview.datamodel.Mapping jmp,
2574           SequenceI parentseq, SequenceI jds, boolean recurse)
2575   {
2576     Mapping mp = null;
2577     if (jmp.getMap() != null)
2578     {
2579       mp = new Mapping();
2580
2581       jalview.util.MapList mlst = jmp.getMap();
2582       List<int[]> r = mlst.getFromRanges();
2583       for (int[] range : r)
2584       {
2585         MapListFrom mfrom = new MapListFrom();
2586         mfrom.setStart(range[0]);
2587         mfrom.setEnd(range[1]);
2588         // mp.addMapListFrom(mfrom);
2589         mp.getMapListFrom().add(mfrom);
2590       }
2591       r = mlst.getToRanges();
2592       for (int[] range : r)
2593       {
2594         MapListTo mto = new MapListTo();
2595         mto.setStart(range[0]);
2596         mto.setEnd(range[1]);
2597         // mp.addMapListTo(mto);
2598         mp.getMapListTo().add(mto);
2599       }
2600       mp.setMapFromUnit(BigInteger.valueOf(mlst.getFromRatio()));
2601       mp.setMapToUnit(BigInteger.valueOf(mlst.getToRatio()));
2602       if (jmp.getTo() != null)
2603       {
2604         // MappingChoice mpc = new MappingChoice();
2605
2606         // check/create ID for the sequence referenced by getTo()
2607
2608         String jmpid = "";
2609         SequenceI ps = null;
2610         if (parentseq != jmp.getTo()
2611                 && parentseq.getDatasetSequence() != jmp.getTo())
2612         {
2613           // chaining dbref rather than a handshaking one
2614           jmpid = seqHash(ps = jmp.getTo());
2615         }
2616         else
2617         {
2618           jmpid = seqHash(ps = parentseq);
2619         }
2620         // mpc.setDseqFor(jmpid);
2621         mp.setDseqFor(jmpid);
2622         if (!seqRefIds.containsKey(jmpid))
2623         {
2624           jalview.bin.Cache.log.debug("creatign new DseqFor ID");
2625           seqRefIds.put(jmpid, ps);
2626         }
2627         else
2628         {
2629           jalview.bin.Cache.log.debug("reusing DseqFor ID");
2630         }
2631
2632         // mp.setMappingChoice(mpc);
2633       }
2634     }
2635     return mp;
2636   }
2637
2638   String setUserColourScheme(jalview.schemes.ColourSchemeI cs,
2639           List<UserColourScheme> userColours, JalviewModel jm)
2640   {
2641     String id = null;
2642     jalview.schemes.UserColourScheme ucs = (jalview.schemes.UserColourScheme) cs;
2643     boolean newucs = false;
2644     if (!userColours.contains(ucs))
2645     {
2646       userColours.add(ucs);
2647       newucs = true;
2648     }
2649     id = "ucs" + userColours.indexOf(ucs);
2650     if (newucs)
2651     {
2652       // actually create the scheme's entry in the XML model
2653       java.awt.Color[] colours = ucs.getColours();
2654       UserColours uc = new UserColours();
2655       // UserColourScheme jbucs = new UserColourScheme();
2656       JalviewUserColours jbucs = new JalviewUserColours();
2657
2658       for (int i = 0; i < colours.length; i++)
2659       {
2660         Colour col = new Colour();
2661         col.setName(ResidueProperties.aa[i]);
2662         col.setRGB(jalview.util.Format.getHexString(colours[i]));
2663         // jbucs.addColour(col);
2664         jbucs.getColour().add(col);
2665       }
2666       if (ucs.getLowerCaseColours() != null)
2667       {
2668         colours = ucs.getLowerCaseColours();
2669         for (int i = 0; i < colours.length; i++)
2670         {
2671           Colour col = new Colour();
2672           col.setName(ResidueProperties.aa[i].toLowerCase());
2673           col.setRGB(jalview.util.Format.getHexString(colours[i]));
2674           // jbucs.addColour(col);
2675           jbucs.getColour().add(col);
2676         }
2677       }
2678
2679       uc.setId(id);
2680       uc.setUserColourScheme(jbucs);
2681       // jm.addUserColours(uc);
2682       jm.getUserColours().add(uc);
2683     }
2684
2685     return id;
2686   }
2687
2688   jalview.schemes.UserColourScheme getUserColourScheme(
2689           JalviewModel jm, String id)
2690   {
2691     List<UserColours> uc = jm.getUserColours();
2692     UserColours colours = null;
2693 /*
2694     for (int i = 0; i < uc.length; i++)
2695     {
2696       if (uc[i].getId().equals(id))
2697       {
2698         colours = uc[i];
2699         break;
2700       }
2701     }
2702 */
2703     for (UserColours c : uc)
2704     {
2705       if (c.getId().equals(id))
2706       {
2707         colours = c;
2708         break;
2709       }
2710     }
2711
2712     java.awt.Color[] newColours = new java.awt.Color[24];
2713
2714     for (int i = 0; i < 24; i++)
2715     {
2716       newColours[i] = new java.awt.Color(Integer.parseInt(
2717               // colours.getUserColourScheme().getColour(i).getRGB(), 16));
2718               colours.getUserColourScheme().getColour().get(i).getRGB(),
2719               16));
2720     }
2721
2722     jalview.schemes.UserColourScheme ucs = new jalview.schemes.UserColourScheme(
2723             newColours);
2724
2725     if (colours.getUserColourScheme().getColour().size()/*Count()*/ > 24)
2726     {
2727       newColours = new java.awt.Color[23];
2728       for (int i = 0; i < 23; i++)
2729       {
2730         newColours[i] = new java.awt.Color(Integer.parseInt(
2731                 colours.getUserColourScheme().getColour().get(i + 24)
2732                         .getRGB(),
2733                 16));
2734       }
2735       ucs.setLowerCaseColours(newColours);
2736     }
2737
2738     return ucs;
2739   }
2740
2741   /**
2742    * contains last error message (if any) encountered by XML loader.
2743    */
2744   String errorMessage = null;
2745
2746   /**
2747    * flag to control whether the Jalview2XML_V1 parser should be deferred to if
2748    * exceptions are raised during project XML parsing
2749    */
2750   public boolean attemptversion1parse = false;
2751
2752   /**
2753    * Load a jalview project archive from a jar file
2754    *
2755    * @param file
2756    *          - HTTP URL or filename
2757    */
2758   public AlignFrame loadJalviewAlign(final String file)
2759   {
2760
2761     jalview.gui.AlignFrame af = null;
2762
2763     try
2764     {
2765       // create list to store references for any new Jmol viewers created
2766       newStructureViewers = new Vector<>();
2767       // UNMARSHALLER SEEMS TO CLOSE JARINPUTSTREAM, MOST ANNOYING
2768       // Workaround is to make sure caller implements the JarInputStreamProvider
2769       // interface
2770       // so we can re-open the jar input stream for each entry.
2771
2772       jarInputStreamProvider jprovider = createjarInputStreamProvider(file);
2773       af = loadJalviewAlign(jprovider);
2774       if (af != null)
2775       {
2776         af.setMenusForViewport();
2777       }
2778     } catch (MalformedURLException e)
2779     {
2780       errorMessage = "Invalid URL format for '" + file + "'";
2781       reportErrors();
2782     } finally
2783     {
2784       try
2785       {
2786         SwingUtilities.invokeAndWait(new Runnable()
2787         {
2788           @Override
2789           public void run()
2790           {
2791             setLoadingFinishedForNewStructureViewers();
2792           };
2793         });
2794       } catch (Exception x)
2795       {
2796         System.err.println("Error loading alignment: " + x.getMessage());
2797       }
2798     }
2799     return af;
2800   }
2801
2802   private jarInputStreamProvider createjarInputStreamProvider(
2803           final String file) throws MalformedURLException
2804   {
2805     URL url = null;
2806     errorMessage = null;
2807     uniqueSetSuffix = null;
2808     seqRefIds = null;
2809     viewportsAdded.clear();
2810     frefedSequence = null;
2811
2812     if (file.startsWith("http://"))
2813     {
2814       url = new URL(file);
2815     }
2816     final URL _url = url;
2817     return new jarInputStreamProvider()
2818     {
2819
2820       @Override
2821       public JarInputStream getJarInputStream() throws IOException
2822       {
2823         if (_url != null)
2824         {
2825           return new JarInputStream(_url.openStream());
2826         }
2827         else
2828         {
2829           return new JarInputStream(new FileInputStream(file));
2830         }
2831       }
2832
2833       @Override
2834       public String getFilename()
2835       {
2836         return file;
2837       }
2838     };
2839   }
2840
2841   /**
2842    * Recover jalview session from a jalview project archive. Caller may
2843    * initialise uniqueSetSuffix, seqRefIds, viewportsAdded and frefedSequence
2844    * themselves. Any null fields will be initialised with default values,
2845    * non-null fields are left alone.
2846    *
2847    * @param jprovider
2848    * @return
2849    */
2850   public AlignFrame loadJalviewAlign(final jarInputStreamProvider jprovider)
2851   {
2852     errorMessage = null;
2853     if (uniqueSetSuffix == null)
2854     {
2855       uniqueSetSuffix = System.currentTimeMillis() % 100000 + "";
2856     }
2857     if (seqRefIds == null)
2858     {
2859       initSeqRefs();
2860     }
2861     AlignFrame af = null, _af = null;
2862     IdentityHashMap<AlignmentI, AlignmentI> importedDatasets = new IdentityHashMap<>();
2863     Map<String, AlignFrame> gatherToThisFrame = new HashMap<>();
2864     final String file = jprovider.getFilename();
2865     try
2866     {
2867       JarInputStream jin = null;
2868       JarEntry jarentry = null;
2869       int entryCount = 1;
2870
2871       do
2872       {
2873         jin = jprovider.getJarInputStream();
2874         for (int i = 0; i < entryCount; i++)
2875         {
2876           jarentry = jin.getNextJarEntry();
2877         }
2878
2879         if (jarentry != null && jarentry.getName().endsWith(".xml"))
2880         {
2881           InputStreamReader in = new InputStreamReader(jin, UTF_8);
2882           // JalviewModel object = new JalviewModel();
2883
2884           JAXBContext jc = JAXBContext
2885                   .newInstance("jalview.xml.binding.jalview");
2886           XMLStreamReader streamReader = XMLInputFactory.newInstance()
2887                   .createXMLStreamReader(jin);
2888           javax.xml.bind.Unmarshaller um = jc.createUnmarshaller();
2889           JAXBElement<JalviewModel> jbe = um
2890                   .unmarshal(streamReader, JalviewModel.class);
2891           JalviewModel object = jbe.getValue();
2892
2893           /*
2894           Unmarshaller unmar = new Unmarshaller(object);
2895           unmar.setValidation(false);
2896           object = (JalviewModel) unmar.unmarshal(in);
2897           */
2898           if (true) // !skipViewport(object))
2899           {
2900             _af = loadFromObject(object, file, true, jprovider);
2901             if (_af != null && object.getViewport().size() > 0)
2902             // getJalviewModelSequence().getViewportCount() > 0)
2903             {
2904               if (af == null)
2905               {
2906                 // store a reference to the first view
2907                 af = _af;
2908               }
2909               if (_af.getViewport().isGatherViewsHere())
2910               {
2911                 // if this is a gathered view, keep its reference since
2912                 // after gathering views, only this frame will remain
2913                 af = _af;
2914                 gatherToThisFrame.put(_af.getViewport().getSequenceSetId(),
2915                         _af);
2916               }
2917               // Save dataset to register mappings once all resolved
2918               importedDatasets.put(
2919                       af.getViewport().getAlignment().getDataset(),
2920                       af.getViewport().getAlignment().getDataset());
2921             }
2922           }
2923           entryCount++;
2924         }
2925         else if (jarentry != null)
2926         {
2927           // Some other file here.
2928           entryCount++;
2929         }
2930       } while (jarentry != null);
2931       resolveFrefedSequences();
2932     } catch (IOException ex)
2933     {
2934       ex.printStackTrace();
2935       errorMessage = "Couldn't locate Jalview XML file : " + file;
2936       System.err.println(
2937               "Exception whilst loading jalview XML file : " + ex + "\n");
2938     } catch (Exception ex)
2939     {
2940       System.err.println("Parsing as Jalview Version 2 file failed.");
2941       ex.printStackTrace(System.err);
2942       if (attemptversion1parse)
2943       {
2944         // used to attempt to parse as V1 castor-generated xml
2945       }
2946       if (Desktop.instance != null)
2947       {
2948         Desktop.instance.stopLoading();
2949       }
2950       if (af != null)
2951       {
2952         System.out.println("Successfully loaded archive file");
2953         return af;
2954       }
2955       ex.printStackTrace();
2956
2957       System.err.println(
2958               "Exception whilst loading jalview XML file : " + ex + "\n");
2959     } catch (OutOfMemoryError e)
2960     {
2961       // Don't use the OOM Window here
2962       errorMessage = "Out of memory loading jalview XML file";
2963       System.err.println("Out of memory whilst loading jalview XML file");
2964       e.printStackTrace();
2965     }
2966
2967     /*
2968      * Regather multiple views (with the same sequence set id) to the frame (if
2969      * any) that is flagged as the one to gather to, i.e. convert them to tabbed
2970      * views instead of separate frames. Note this doesn't restore a state where
2971      * some expanded views in turn have tabbed views - the last "first tab" read
2972      * in will play the role of gatherer for all.
2973      */
2974     for (AlignFrame fr : gatherToThisFrame.values())
2975     {
2976       Desktop.instance.gatherViews(fr);
2977     }
2978
2979     restoreSplitFrames();
2980     for (AlignmentI ds : importedDatasets.keySet())
2981     {
2982       if (ds.getCodonFrames() != null)
2983       {
2984         StructureSelectionManager
2985                 .getStructureSelectionManager(Desktop.instance)
2986                 .registerMappings(ds.getCodonFrames());
2987       }
2988     }
2989     if (errorMessage != null)
2990     {
2991       reportErrors();
2992     }
2993
2994     if (Desktop.instance != null)
2995     {
2996       Desktop.instance.stopLoading();
2997     }
2998
2999     return af;
3000   }
3001
3002   /**
3003    * Try to reconstruct and display SplitFrame windows, where each contains
3004    * complementary dna and protein alignments. Done by pairing up AlignFrame
3005    * objects (created earlier) which have complementary viewport ids associated.
3006    */
3007   protected void restoreSplitFrames()
3008   {
3009     List<SplitFrame> gatherTo = new ArrayList<>();
3010     List<AlignFrame> addedToSplitFrames = new ArrayList<>();
3011     Map<String, AlignFrame> dna = new HashMap<>();
3012
3013     /*
3014      * Identify the DNA alignments
3015      */
3016     for (Entry<Viewport, AlignFrame> candidate : splitFrameCandidates
3017             .entrySet())
3018     {
3019       AlignFrame af = candidate.getValue();
3020       if (af.getViewport().getAlignment().isNucleotide())
3021       {
3022         dna.put(candidate.getKey().getId(), af);
3023       }
3024     }
3025
3026     /*
3027      * Try to match up the protein complements
3028      */
3029     for (Entry<Viewport, AlignFrame> candidate : splitFrameCandidates
3030             .entrySet())
3031     {
3032       AlignFrame af = candidate.getValue();
3033       if (!af.getViewport().getAlignment().isNucleotide())
3034       {
3035         String complementId = candidate.getKey().getComplementId();
3036         // only non-null complements should be in the Map
3037         if (complementId != null && dna.containsKey(complementId))
3038         {
3039           final AlignFrame dnaFrame = dna.get(complementId);
3040           SplitFrame sf = createSplitFrame(dnaFrame, af);
3041           addedToSplitFrames.add(dnaFrame);
3042           addedToSplitFrames.add(af);
3043           dnaFrame.setMenusForViewport();
3044           af.setMenusForViewport();
3045           if (af.getViewport().isGatherViewsHere())
3046           {
3047             gatherTo.add(sf);
3048           }
3049         }
3050       }
3051     }
3052
3053     /*
3054      * Open any that we failed to pair up (which shouldn't happen!) as
3055      * standalone AlignFrame's.
3056      */
3057     for (Entry<Viewport, AlignFrame> candidate : splitFrameCandidates
3058             .entrySet())
3059     {
3060       AlignFrame af = candidate.getValue();
3061       if (!addedToSplitFrames.contains(af))
3062       {
3063         Viewport view = candidate.getKey();
3064         Desktop.addInternalFrame(af, view.getTitle(),
3065                 safeInt(view.getWidth()), safeInt(view.getHeight()));
3066         af.setMenusForViewport();
3067         System.err.println("Failed to restore view " + view.getTitle()
3068                 + " to split frame");
3069       }
3070     }
3071
3072     /*
3073      * Gather back into tabbed views as flagged.
3074      */
3075     for (SplitFrame sf : gatherTo)
3076     {
3077       Desktop.instance.gatherViews(sf);
3078     }
3079
3080     splitFrameCandidates.clear();
3081   }
3082
3083   /**
3084    * Construct and display one SplitFrame holding DNA and protein alignments.
3085    *
3086    * @param dnaFrame
3087    * @param proteinFrame
3088    * @return
3089    */
3090   protected SplitFrame createSplitFrame(AlignFrame dnaFrame,
3091           AlignFrame proteinFrame)
3092   {
3093     SplitFrame splitFrame = new SplitFrame(dnaFrame, proteinFrame);
3094     String title = MessageManager.getString("label.linked_view_title");
3095     int width = (int) dnaFrame.getBounds().getWidth();
3096     int height = (int) (dnaFrame.getBounds().getHeight()
3097             + proteinFrame.getBounds().getHeight() + 50);
3098
3099     /*
3100      * SplitFrame location is saved to both enclosed frames
3101      */
3102     splitFrame.setLocation(dnaFrame.getX(), dnaFrame.getY());
3103     Desktop.addInternalFrame(splitFrame, title, width, height);
3104
3105     /*
3106      * And compute cDNA consensus (couldn't do earlier with consensus as
3107      * mappings were not yet present)
3108      */
3109     proteinFrame.getViewport().alignmentChanged(proteinFrame.alignPanel);
3110
3111     return splitFrame;
3112   }
3113
3114   /**
3115    * check errorMessage for a valid error message and raise an error box in the
3116    * GUI or write the current errorMessage to stderr and then clear the error
3117    * state.
3118    */
3119   protected void reportErrors()
3120   {
3121     reportErrors(false);
3122   }
3123
3124   protected void reportErrors(final boolean saving)
3125   {
3126     if (errorMessage != null)
3127     {
3128       final String finalErrorMessage = errorMessage;
3129       if (raiseGUI)
3130       {
3131         javax.swing.SwingUtilities.invokeLater(new Runnable()
3132         {
3133           @Override
3134           public void run()
3135           {
3136             JvOptionPane.showInternalMessageDialog(Desktop.desktop,
3137                     finalErrorMessage,
3138                     "Error " + (saving ? "saving" : "loading")
3139                             + " Jalview file",
3140                     JvOptionPane.WARNING_MESSAGE);
3141           }
3142         });
3143       }
3144       else
3145       {
3146         System.err.println("Problem loading Jalview file: " + errorMessage);
3147       }
3148     }
3149     errorMessage = null;
3150   }
3151
3152   Map<String, String> alreadyLoadedPDB = new HashMap<>();
3153
3154   /**
3155    * when set, local views will be updated from view stored in JalviewXML
3156    * Currently (28th Sep 2008) things will go horribly wrong in vamsas document
3157    * sync if this is set to true.
3158    */
3159   private final boolean updateLocalViews = false;
3160
3161   /**
3162    * Returns the path to a temporary file holding the PDB file for the given PDB
3163    * id. The first time of asking, searches for a file of that name in the
3164    * Jalview project jar, and copies it to a new temporary file. Any repeat
3165    * requests just return the path to the file previously created.
3166    *
3167    * @param jprovider
3168    * @param pdbId
3169    * @return
3170    */
3171   String loadPDBFile(jarInputStreamProvider jprovider, String pdbId,
3172           String origFile)
3173   {
3174     if (alreadyLoadedPDB.containsKey(pdbId))
3175     {
3176       return alreadyLoadedPDB.get(pdbId).toString();
3177     }
3178
3179     String tempFile = copyJarEntry(jprovider, pdbId, "jalview_pdb",
3180             origFile);
3181     if (tempFile != null)
3182     {
3183       alreadyLoadedPDB.put(pdbId, tempFile);
3184     }
3185     return tempFile;
3186   }
3187
3188   /**
3189    * Copies the jar entry of given name to a new temporary file and returns the
3190    * path to the file, or null if the entry is not found.
3191    *
3192    * @param jprovider
3193    * @param jarEntryName
3194    * @param prefix
3195    *          a prefix for the temporary file name, must be at least three
3196    *          characters long
3197    * @param origFile
3198    *          null or original file - so new file can be given the same suffix
3199    *          as the old one
3200    * @return
3201    */
3202   protected String copyJarEntry(jarInputStreamProvider jprovider,
3203           String jarEntryName, String prefix, String origFile)
3204   {
3205     BufferedReader in = null;
3206     PrintWriter out = null;
3207     String suffix = ".tmp";
3208     if (origFile == null)
3209     {
3210       origFile = jarEntryName;
3211     }
3212     int sfpos = origFile.lastIndexOf(".");
3213     if (sfpos > -1 && sfpos < (origFile.length() - 3))
3214     {
3215       suffix = "." + origFile.substring(sfpos + 1);
3216     }
3217     try
3218     {
3219       JarInputStream jin = jprovider.getJarInputStream();
3220       /*
3221        * if (jprovider.startsWith("http://")) { jin = new JarInputStream(new
3222        * URL(jprovider).openStream()); } else { jin = new JarInputStream(new
3223        * FileInputStream(jprovider)); }
3224        */
3225
3226       JarEntry entry = null;
3227       do
3228       {
3229         entry = jin.getNextJarEntry();
3230       } while (entry != null && !entry.getName().equals(jarEntryName));
3231       if (entry != null)
3232       {
3233         in = new BufferedReader(new InputStreamReader(jin, UTF_8));
3234         File outFile = File.createTempFile(prefix, suffix);
3235         outFile.deleteOnExit();
3236         out = new PrintWriter(new FileOutputStream(outFile));
3237         String data;
3238
3239         while ((data = in.readLine()) != null)
3240         {
3241           out.println(data);
3242         }
3243         out.flush();
3244         String t = outFile.getAbsolutePath();
3245         return t;
3246       }
3247       else
3248       {
3249         warn("Couldn't find entry in Jalview Jar for " + jarEntryName);
3250       }
3251     } catch (Exception ex)
3252     {
3253       ex.printStackTrace();
3254     } finally
3255     {
3256       if (in != null)
3257       {
3258         try
3259         {
3260           in.close();
3261         } catch (IOException e)
3262         {
3263           // ignore
3264         }
3265       }
3266       if (out != null)
3267       {
3268         out.close();
3269       }
3270     }
3271
3272     return null;
3273   }
3274
3275   private class JvAnnotRow
3276   {
3277     public JvAnnotRow(int i, AlignmentAnnotation jaa)
3278     {
3279       order = i;
3280       template = jaa;
3281     }
3282
3283     /**
3284      * persisted version of annotation row from which to take vis properties
3285      */
3286     public jalview.datamodel.AlignmentAnnotation template;
3287
3288     /**
3289      * original position of the annotation row in the alignment
3290      */
3291     public int order;
3292   }
3293
3294   /**
3295    * Load alignment frame from jalview XML DOM object
3296    *
3297    * @param jalviewModel
3298    *          DOM
3299    * @param file
3300    *          filename source string
3301    * @param loadTreesAndStructures
3302    *          when false only create Viewport
3303    * @param jprovider
3304    *          data source provider
3305    * @return alignment frame created from view stored in DOM
3306    */
3307   AlignFrame loadFromObject(JalviewModel jalviewModel, String file,
3308           boolean loadTreesAndStructures, jarInputStreamProvider jprovider)
3309   {
3310     SequenceSet vamsasSet = jalviewModel.getVamsasModel().getSequenceSet().get(0);
3311     List<Sequence> vamsasSeqs = vamsasSet.getSequence();
3312
3313     // JalviewModelSequence jms = object.getJalviewModelSequence();
3314
3315     // Viewport view = (jms.getViewportCount() > 0) ? jms.getViewport(0)
3316     // : null;
3317     Viewport view = (jalviewModel.getViewport().size() > 0)
3318             ? jalviewModel.getViewport().get(0)
3319             : null;
3320
3321     // ////////////////////////////////
3322     // INITIALISE ALIGNMENT SEQUENCESETID AND VIEWID
3323     //
3324     //
3325     // If we just load in the same jar file again, the sequenceSetId
3326     // will be the same, and we end up with multiple references
3327     // to the same sequenceSet. We must modify this id on load
3328     // so that each load of the file gives a unique id
3329
3330     /**
3331      * used to resolve correct alignment dataset for alignments with multiple
3332      * views
3333      */
3334     String uniqueSeqSetId = null;
3335     String viewId = null;
3336     if (view != null)
3337     {
3338       uniqueSeqSetId = view.getSequenceSetId() + uniqueSetSuffix;
3339       viewId = (view.getId() == null ? null
3340               : view.getId() + uniqueSetSuffix);
3341     }
3342
3343     // ////////////////////////////////
3344     // LOAD SEQUENCES
3345
3346     List<SequenceI> hiddenSeqs = null;
3347
3348     List<SequenceI> tmpseqs = new ArrayList<>();
3349
3350     boolean multipleView = false;
3351     SequenceI referenceseqForView = null;
3352     // JSeq[] jseqs = object.getJalviewModelSequence().getJSeq();
3353     List<JSeq> jseqs = jalviewModel.getJSeq();
3354     int vi = 0; // counter in vamsasSeq array
3355     for (int i = 0; i < jseqs.size(); i++)
3356     {
3357       JSeq jseq = jseqs.get(i);
3358       String seqId = jseq.getId();
3359
3360       SequenceI tmpSeq = seqRefIds.get(seqId);
3361       if (tmpSeq != null)
3362       {
3363         if (!incompleteSeqs.containsKey(seqId))
3364         {
3365           // may not need this check, but keep it for at least 2.9,1 release
3366           if (tmpSeq.getStart() != jseq.getStart()
3367                   || tmpSeq.getEnd() != jseq.getEnd())
3368           {
3369             System.err.println(
3370                     "Warning JAL-2154 regression: updating start/end for sequence "
3371                             + tmpSeq.toString() + " to " + jseq);
3372           }
3373         }
3374         else
3375         {
3376           incompleteSeqs.remove(seqId);
3377         }
3378         if (vamsasSeqs.size() > vi
3379                 && vamsasSeqs.get(vi).getId().equals(seqId))
3380         {
3381           // most likely we are reading a dataset XML document so
3382           // update from vamsasSeq section of XML for this sequence
3383           tmpSeq.setName(vamsasSeqs.get(vi).getName());
3384           tmpSeq.setDescription(vamsasSeqs.get(vi).getDescription());
3385           tmpSeq.setSequence(vamsasSeqs.get(vi).getSequence());
3386           vi++;
3387         }
3388         else
3389         {
3390           // reading multiple views, so vamsasSeq set is a subset of JSeq
3391           multipleView = true;
3392         }
3393         tmpSeq.setStart(jseq.getStart());
3394         tmpSeq.setEnd(jseq.getEnd());
3395         tmpseqs.add(tmpSeq);
3396       }
3397       else
3398       {
3399         Sequence vamsasSeq = vamsasSeqs.get(vi);
3400         tmpSeq = new jalview.datamodel.Sequence(vamsasSeq.getName(),
3401                 vamsasSeq.getSequence());
3402         tmpSeq.setDescription(vamsasSeq.getDescription());
3403         tmpSeq.setStart(jseq.getStart());
3404         tmpSeq.setEnd(jseq.getEnd());
3405         tmpSeq.setVamsasId(uniqueSetSuffix + seqId);
3406         seqRefIds.put(vamsasSeq.getId(), tmpSeq);
3407         tmpseqs.add(tmpSeq);
3408         vi++;
3409       }
3410
3411       if (safeBoolean(jseq.isViewreference()))
3412       {
3413         referenceseqForView = tmpseqs.get(tmpseqs.size() - 1);
3414       }
3415
3416       if (jseq.isHidden() != null && jseq.isHidden().booleanValue())
3417       {
3418         if (hiddenSeqs == null)
3419         {
3420           hiddenSeqs = new ArrayList<>();
3421         }
3422
3423         hiddenSeqs.add(tmpSeq);
3424       }
3425     }
3426
3427     // /
3428     // Create the alignment object from the sequence set
3429     // ///////////////////////////////
3430     SequenceI[] orderedSeqs = tmpseqs
3431             .toArray(new SequenceI[tmpseqs.size()]);
3432
3433     AlignmentI al = null;
3434     // so we must create or recover the dataset alignment before going further
3435     // ///////////////////////////////
3436     if (vamsasSet.getDatasetId() == null || vamsasSet.getDatasetId() == "")
3437     {
3438       // older jalview projects do not have a dataset - so creat alignment and
3439       // dataset
3440       al = new Alignment(orderedSeqs);
3441       al.setDataset(null);
3442     }
3443     else
3444     {
3445       boolean isdsal = jalviewModel.getViewport().isEmpty();
3446       if (isdsal)
3447       {
3448         // we are importing a dataset record, so
3449         // recover reference to an alignment already materialsed as dataset
3450         al = getDatasetFor(vamsasSet.getDatasetId());
3451       }
3452       if (al == null)
3453       {
3454         // materialse the alignment
3455         al = new Alignment(orderedSeqs);
3456       }
3457       if (isdsal)
3458       {
3459         addDatasetRef(vamsasSet.getDatasetId(), al);
3460       }
3461
3462       // finally, verify all data in vamsasSet is actually present in al
3463       // passing on flag indicating if it is actually a stored dataset
3464       recoverDatasetFor(vamsasSet, al, isdsal, uniqueSeqSetId);
3465     }
3466
3467     if (referenceseqForView != null)
3468     {
3469       al.setSeqrep(referenceseqForView);
3470     }
3471     // / Add the alignment properties
3472     for (int i = 0; i < vamsasSet.getSequenceSetProperties().size(); i++)
3473     {
3474       SequenceSetProperties ssp = vamsasSet.getSequenceSetProperties()
3475               .get(i);
3476       al.setProperty(ssp.getKey(), ssp.getValue());
3477     }
3478
3479     // ///////////////////////////////
3480
3481     Hashtable pdbloaded = new Hashtable(); // TODO nothing writes to this??
3482     if (!multipleView)
3483     {
3484       // load sequence features, database references and any associated PDB
3485       // structures for the alignment
3486       //
3487       // prior to 2.10, this part would only be executed the first time a
3488       // sequence was encountered, but not afterwards.
3489       // now, for 2.10 projects, this is also done if the xml doc includes
3490       // dataset sequences not actually present in any particular view.
3491       //
3492       for (int i = 0; i < vamsasSeqs.size(); i++)
3493       {
3494         JSeq jseq = jseqs.get(i);
3495         if (jseq.getFeatures().size() > 0)
3496         {
3497           List<Feature> features = jseq.getFeatures();
3498           for (int f = 0; f < features.size(); f++)
3499           {
3500             Feature feat = features.get(f);
3501             SequenceFeature sf = new SequenceFeature(feat.getType(),
3502                     feat.getDescription(), feat.getBegin(), feat.getEnd(),
3503                     safeFloat(feat.getScore()), feat.getFeatureGroup());
3504             sf.setStatus(feat.getStatus());
3505
3506             /*
3507              * load any feature attributes - include map-valued attributes
3508              */
3509             Map<String, Map<String, String>> mapAttributes = new HashMap<>();
3510             for (int od = 0; od < feat.getOtherData().size(); od++)
3511             {
3512               OtherData keyValue = feat.getOtherData().get(od);
3513               String attributeName = keyValue.getKey();
3514               String attributeValue = keyValue.getValue();
3515               if (attributeName.startsWith("LINK"))
3516               {
3517                 sf.addLink(attributeValue);
3518               }
3519               else
3520               {
3521                 String subAttribute = keyValue.getKey2();
3522                 if (subAttribute == null)
3523                 {
3524                   // simple string-valued attribute
3525                   sf.setValue(attributeName, attributeValue);
3526                 }
3527                 else
3528                 {
3529                   // attribute 'key' has sub-attribute 'key2'
3530                   if (!mapAttributes.containsKey(attributeName))
3531                   {
3532                     mapAttributes.put(attributeName, new HashMap<>());
3533                   }
3534                   mapAttributes.get(attributeName).put(subAttribute,
3535                           attributeValue);
3536                 }
3537               }
3538             }
3539             for (Entry<String, Map<String, String>> mapAttribute : mapAttributes
3540                     .entrySet())
3541             {
3542               sf.setValue(mapAttribute.getKey(), mapAttribute.getValue());
3543             }
3544
3545             // adds feature to datasequence's feature set (since Jalview 2.10)
3546             al.getSequenceAt(i).addSequenceFeature(sf);
3547           }
3548         }
3549         if (vamsasSeqs.get(i).getDBRef().size() > 0)
3550         {
3551           // adds dbrefs to datasequence's set (since Jalview 2.10)
3552           addDBRefs(
3553                   al.getSequenceAt(i).getDatasetSequence() == null
3554                           ? al.getSequenceAt(i)
3555                           : al.getSequenceAt(i).getDatasetSequence(),
3556                   vamsasSeqs.get(i));
3557         }
3558         if (jseq.getPdbids().size() > 0)
3559         {
3560           List<Pdbids> ids = jseq.getPdbids();
3561           for (int p = 0; p < ids.size(); p++)
3562           {
3563             Pdbids pdbid = ids.get(p);
3564             jalview.datamodel.PDBEntry entry = new jalview.datamodel.PDBEntry();
3565             entry.setId(pdbid.getId());
3566             if (pdbid.getType() != null)
3567             {
3568               if (PDBEntry.Type.getType(pdbid.getType()) != null)
3569               {
3570                 entry.setType(PDBEntry.Type.getType(pdbid.getType()));
3571               }
3572               else
3573               {
3574                 entry.setType(PDBEntry.Type.FILE);
3575               }
3576             }
3577             // jprovider is null when executing 'New View'
3578             if (pdbid.getFile() != null && jprovider != null)
3579             {
3580               if (!pdbloaded.containsKey(pdbid.getFile()))
3581               {
3582                 entry.setFile(loadPDBFile(jprovider, pdbid.getId(),
3583                         pdbid.getFile()));
3584               }
3585               else
3586               {
3587                 entry.setFile(pdbloaded.get(pdbid.getId()).toString());
3588               }
3589             }
3590             /*
3591             if (pdbid.getPdbentryItem() != null)
3592             {
3593               for (PdbentryItem item : pdbid.getPdbentryItem())
3594               {
3595                 for (Property pr : item.getProperty())
3596                 {
3597                   entry.setProperty(pr.getName(), pr.getValue());
3598                 }
3599               }
3600             }
3601             */
3602             for (Property prop : pdbid.getProperty())
3603             {
3604               entry.setProperty(prop.getName(), prop.getValue());
3605             }
3606             StructureSelectionManager
3607                     .getStructureSelectionManager(Desktop.instance)
3608                     .registerPDBEntry(entry);
3609             // adds PDBEntry to datasequence's set (since Jalview 2.10)
3610             if (al.getSequenceAt(i).getDatasetSequence() != null)
3611             {
3612               al.getSequenceAt(i).getDatasetSequence().addPDBId(entry);
3613             }
3614             else
3615             {
3616               al.getSequenceAt(i).addPDBId(entry);
3617             }
3618           }
3619         }
3620
3621         /*
3622          * load any HMMER profile
3623          */
3624                                 String hmmJarFile = jseqs.get(i).getHmmerProfile();
3625         if (hmmJarFile != null && jprovider != null)
3626         {
3627           loadHmmerProfile(jprovider, hmmJarFile, al.getSequenceAt(i));
3628         }
3629       }
3630     } // end !multipleview
3631
3632     // ///////////////////////////////
3633     // LOAD SEQUENCE MAPPINGS
3634
3635     if (vamsasSet.getAlcodonFrame().size() > 0)
3636     {
3637       // TODO Potentially this should only be done once for all views of an
3638       // alignment
3639       List<AlcodonFrame> alc = vamsasSet.getAlcodonFrame();
3640       for (int i = 0; i < alc.size(); i++)
3641       {
3642         AlignedCodonFrame cf = new AlignedCodonFrame();
3643         if (alc.get(i).getAlcodMap().size() > 0)
3644         {
3645           List<AlcodMap> maps = alc.get(i).getAlcodMap();
3646           for (int m = 0; m < maps.size(); m++)
3647           {
3648             AlcodMap map = maps.get(m);
3649             SequenceI dnaseq = seqRefIds.get(map.getDnasq());
3650             // Load Mapping
3651             jalview.datamodel.Mapping mapping = null;
3652             // attach to dna sequence reference.
3653             if (map.getMapping() != null)
3654             {
3655               mapping = addMapping(map.getMapping());
3656               if (dnaseq != null && mapping.getTo() != null)
3657               {
3658                 cf.addMap(dnaseq, mapping.getTo(), mapping.getMap());
3659               }
3660               else
3661               {
3662                 // defer to later
3663                 frefedSequence.add(
3664                         newAlcodMapRef(map.getDnasq(), cf, mapping));
3665               }
3666             }
3667           }
3668           al.addCodonFrame(cf);
3669         }
3670       }
3671     }
3672
3673     // ////////////////////////////////
3674     // LOAD ANNOTATIONS
3675     List<JvAnnotRow> autoAlan = new ArrayList<>();
3676
3677     /*
3678      * store any annotations which forward reference a group's ID
3679      */
3680     Map<String, List<AlignmentAnnotation>> groupAnnotRefs = new Hashtable<>();
3681
3682     if (vamsasSet.getAnnotation().size()/*Count()*/ > 0)
3683     {
3684       List<Annotation> an = vamsasSet.getAnnotation();
3685
3686       for (int i = 0; i < an.size(); i++)
3687       {
3688         Annotation annotation = an.get(i);
3689
3690         /**
3691          * test if annotation is automatically calculated for this view only
3692          */
3693         boolean autoForView = false;
3694         if (annotation.getLabel().equals("Quality")
3695                 || annotation.getLabel().equals("Conservation")
3696                 || annotation.getLabel().equals("Consensus"))
3697         {
3698           // Kludge for pre 2.5 projects which lacked the autocalculated flag
3699           autoForView = true;
3700           // JAXB has no has() test; schema defaults value to false
3701           // if (!annotation.hasAutoCalculated())
3702           // {
3703           // annotation.setAutoCalculated(true);
3704           // }
3705         }
3706         if (autoForView || annotation.isAutoCalculated())
3707         {
3708           // remove ID - we don't recover annotation from other views for
3709           // view-specific annotation
3710           annotation.setId(null);
3711         }
3712
3713         // set visibility for other annotation in this view
3714         String annotationId = annotation.getId();
3715         if (annotationId != null && annotationIds.containsKey(annotationId))
3716         {
3717           AlignmentAnnotation jda = annotationIds.get(annotationId);
3718           // in principle Visible should always be true for annotation displayed
3719           // in multiple views
3720           if (annotation.isVisible() != null)
3721           {
3722             jda.visible = annotation.isVisible();
3723           }
3724
3725           al.addAnnotation(jda);
3726
3727           continue;
3728         }
3729         // Construct new annotation from model.
3730         List<AnnotationElement> ae = annotation.getAnnotationElement();
3731         jalview.datamodel.Annotation[] anot = null;
3732         java.awt.Color firstColour = null;
3733         int anpos;
3734         if (!annotation.isScoreOnly())
3735         {
3736           anot = new jalview.datamodel.Annotation[al.getWidth()];
3737           for (int aa = 0; aa < ae.size() && aa < anot.length; aa++)
3738           {
3739             AnnotationElement annElement = ae.get(aa);
3740             anpos = annElement.getPosition();
3741
3742             if (anpos >= anot.length)
3743             {
3744               continue;
3745             }
3746
3747             float value = safeFloat(annElement.getValue());
3748             anot[anpos] = new jalview.datamodel.Annotation(
3749                     annElement.getDisplayCharacter(),
3750                     annElement.getDescription(),
3751                     (annElement.getSecondaryStructure() == null
3752                             || annElement.getSecondaryStructure()
3753                                     .length() == 0)
3754                                             ? ' '
3755                                             : annElement
3756                                                     .getSecondaryStructure()
3757                                                     .charAt(0),
3758                     value);
3759             anot[anpos].colour = new Color(safeInt(annElement.getColour()));
3760             if (firstColour == null)
3761             {
3762               firstColour = anot[anpos].colour;
3763             }
3764           }
3765         }
3766         jalview.datamodel.AlignmentAnnotation jaa = null;
3767
3768         if (annotation.isGraph())
3769         {
3770           float llim = 0, hlim = 0;
3771           // if (autoForView || an[i].isAutoCalculated()) {
3772           // hlim=11f;
3773           // }
3774           jaa = new jalview.datamodel.AlignmentAnnotation(
3775                   annotation.getLabel(), annotation.getDescription(), anot,
3776                   llim, hlim, safeInt(annotation.getGraphType()));
3777
3778           jaa.graphGroup = safeInt(annotation.getGraphGroup());
3779           jaa._linecolour = firstColour;
3780           if (annotation.getThresholdLine() != null)
3781           {
3782             jaa.setThreshold(new jalview.datamodel.GraphLine(
3783                     safeFloat(annotation.getThresholdLine().getValue()),
3784                     annotation.getThresholdLine().getLabel(),
3785                     new java.awt.Color(safeInt(
3786                             annotation.getThresholdLine().getColour()))));
3787           }
3788           if (autoForView || annotation.isAutoCalculated())
3789           {
3790             // Hardwire the symbol display line to ensure that labels for
3791             // histograms are displayed
3792             jaa.hasText = true;
3793           }
3794         }
3795         else
3796         {
3797           jaa = new jalview.datamodel.AlignmentAnnotation(
3798                   annotation.getLabel(), annotation.getDescription(), anot);
3799           jaa._linecolour = firstColour;
3800         }
3801         // register new annotation
3802         if (annotation.getId() != null)
3803         {
3804           annotationIds.put(annotation.getId(), jaa);
3805           jaa.annotationId = annotation.getId();
3806         }
3807         // recover sequence association
3808         String sequenceRef = annotation.getSequenceRef();
3809         if (sequenceRef != null)
3810         {
3811           // from 2.9 sequenceRef is to sequence id (JAL-1781)
3812           SequenceI sequence = seqRefIds.get(sequenceRef);
3813           if (sequence == null)
3814           {
3815             // in pre-2.9 projects sequence ref is to sequence name
3816             sequence = al.findName(sequenceRef);
3817           }
3818           if (sequence != null)
3819           {
3820             jaa.createSequenceMapping(sequence, 1, true);
3821             sequence.addAlignmentAnnotation(jaa);
3822           }
3823         }
3824         // and make a note of any group association
3825         if (annotation.getGroupRef() != null
3826                 && annotation.getGroupRef().length() > 0)
3827         {
3828           List<jalview.datamodel.AlignmentAnnotation> aal = groupAnnotRefs
3829                   .get(annotation.getGroupRef());
3830           if (aal == null)
3831           {
3832             aal = new ArrayList<>();
3833             groupAnnotRefs.put(annotation.getGroupRef(), aal);
3834           }
3835           aal.add(jaa);
3836         }
3837
3838         if (annotation.getScore() != null)
3839         {
3840           jaa.setScore(annotation.getScore().doubleValue());
3841         }
3842         if (annotation.isVisible() != null)
3843         {
3844           jaa.visible = annotation.isVisible().booleanValue();
3845         }
3846
3847         if (annotation.isCentreColLabels() != null)
3848         {
3849           jaa.centreColLabels = annotation.isCentreColLabels()
3850                   .booleanValue();
3851         }
3852
3853         if (annotation.isScaleColLabels() != null)
3854         {
3855           jaa.scaleColLabel = annotation.isScaleColLabels().booleanValue();
3856         }
3857         if (annotation.isAutoCalculated())
3858         {
3859           // newer files have an 'autoCalculated' flag and store calculation
3860           // state in viewport properties
3861           jaa.autoCalculated = true; // means annotation will be marked for
3862           // update at end of load.
3863         }
3864         if (annotation.getGraphHeight() != null)
3865         {
3866           jaa.graphHeight = annotation.getGraphHeight().intValue();
3867         }
3868         jaa.belowAlignment = annotation.isBelowAlignment();
3869         jaa.setCalcId(annotation.getCalcId());
3870         if (annotation.getProperty().size() > 0)
3871         {
3872           for (Annotation.Property prop : annotation
3873                   .getProperty())
3874           {
3875             jaa.setProperty(prop.getName(), prop.getValue());
3876           }
3877         }
3878         if (jaa.autoCalculated)
3879         {
3880           autoAlan.add(new JvAnnotRow(i, jaa));
3881         }
3882         else
3883         // if (!autoForView)
3884         {
3885           // add autocalculated group annotation and any user created annotation
3886           // for the view
3887           al.addAnnotation(jaa);
3888         }
3889       }
3890     }
3891     // ///////////////////////
3892     // LOAD GROUPS
3893     // Create alignment markup and styles for this view
3894     if (jalviewModel.getJGroup().size() > 0)
3895     {
3896       List<JGroup> groups = jalviewModel.getJGroup();
3897       boolean addAnnotSchemeGroup = false;
3898       for (int i = 0; i < groups.size(); i++)
3899       {
3900         JGroup jGroup = groups.get(i);
3901         ColourSchemeI cs = null;
3902         if (jGroup.getColour() != null)
3903         {
3904           if (jGroup.getColour().startsWith("ucs"))
3905           {
3906             cs = getUserColourScheme(jalviewModel, jGroup.getColour());
3907           }
3908           else if (jGroup.getColour().equals("AnnotationColourGradient")
3909                   && jGroup.getAnnotationColours() != null)
3910           {
3911             addAnnotSchemeGroup = true;
3912           }
3913           else
3914           {
3915             cs = ColourSchemeProperty.getColourScheme(null, al,
3916                     jGroup.getColour());
3917           }
3918         }
3919         int pidThreshold = safeInt(jGroup.getPidThreshold());
3920
3921         Vector<SequenceI> seqs = new Vector<>();
3922
3923         for (int s = 0; s < jGroup.getSeq().size(); s++)
3924         {
3925           String seqId = jGroup.getSeq().get(s);
3926           SequenceI ts = seqRefIds.get(seqId);
3927
3928           if (ts != null)
3929           {
3930             seqs.addElement(ts);
3931           }
3932         }
3933
3934         if (seqs.size() < 1)
3935         {
3936           continue;
3937         }
3938
3939         SequenceGroup sg = new SequenceGroup(seqs, jGroup.getName(), cs,
3940                 safeBoolean(jGroup.isDisplayBoxes()),
3941                 safeBoolean(jGroup.isDisplayText()),
3942                 safeBoolean(jGroup.isColourText()),
3943                 safeInt(jGroup.getStart()), safeInt(jGroup.getEnd()));
3944         sg.getGroupColourScheme().setThreshold(pidThreshold, true);
3945         sg.getGroupColourScheme()
3946                 .setConservationInc(safeInt(jGroup.getConsThreshold()));
3947         sg.setOutlineColour(new Color(safeInt(jGroup.getOutlineColour())));
3948
3949         sg.textColour = new Color(safeInt(jGroup.getTextCol1()));
3950         sg.textColour2 = new Color(safeInt(jGroup.getTextCol2()));
3951         sg.setShowNonconserved(safeBoolean(jGroup.isShowUnconserved()));
3952         sg.thresholdTextColour = safeInt(jGroup.getTextColThreshold());
3953         // attributes with a default in the schema are never null
3954           sg.setShowConsensusHistogram(jGroup.isShowConsensusHistogram());
3955           sg.setshowSequenceLogo(jGroup.isShowSequenceLogo());
3956           sg.setNormaliseSequenceLogo(jGroup.isNormaliseSequenceLogo());
3957         sg.setIgnoreGapsConsensus(jGroup.isIgnoreGapsinConsensus());
3958         if (jGroup.getConsThreshold() != null
3959                 && jGroup.getConsThreshold().intValue() != 0)
3960         {
3961           Conservation c = new Conservation("All", sg.getSequences(null), 0,
3962                   sg.getWidth() - 1);
3963           c.calculate();
3964           c.verdict(false, 25);
3965           sg.cs.setConservation(c);
3966         }
3967
3968         if (jGroup.getId() != null && groupAnnotRefs.size() > 0)
3969         {
3970           // re-instate unique group/annotation row reference
3971           List<AlignmentAnnotation> jaal = groupAnnotRefs
3972                   .get(jGroup.getId());
3973           if (jaal != null)
3974           {
3975             for (AlignmentAnnotation jaa : jaal)
3976             {
3977               jaa.groupRef = sg;
3978               if (jaa.autoCalculated)
3979               {
3980                 // match up and try to set group autocalc alignment row for this
3981                 // annotation
3982                 if (jaa.label.startsWith("Consensus for "))
3983                 {
3984                   sg.setConsensus(jaa);
3985                 }
3986                 // match up and try to set group autocalc alignment row for this
3987                 // annotation
3988                 if (jaa.label.startsWith("Conservation for "))
3989                 {
3990                   sg.setConservationRow(jaa);
3991                 }
3992               }
3993             }
3994           }
3995         }
3996         al.addGroup(sg);
3997         if (addAnnotSchemeGroup)
3998         {
3999           // reconstruct the annotation colourscheme
4000           sg.setColourScheme(constructAnnotationColour(
4001                   jGroup.getAnnotationColours(), null, al, jalviewModel, false));
4002         }
4003       }
4004     }
4005     if (view == null)
4006     {
4007       // only dataset in this model, so just return.
4008       return null;
4009     }
4010     // ///////////////////////////////
4011     // LOAD VIEWPORT
4012
4013     AlignFrame af = null;
4014     AlignViewport av = null;
4015     // now check to see if we really need to create a new viewport.
4016     if (multipleView && viewportsAdded.size() == 0)
4017     {
4018       // We recovered an alignment for which a viewport already exists.
4019       // TODO: fix up any settings necessary for overlaying stored state onto
4020       // state recovered from another document. (may not be necessary).
4021       // we may need a binding from a viewport in memory to one recovered from
4022       // XML.
4023       // and then recover its containing af to allow the settings to be applied.
4024       // TODO: fix for vamsas demo
4025       System.err.println(
4026               "About to recover a viewport for existing alignment: Sequence set ID is "
4027                       + uniqueSeqSetId);
4028       Object seqsetobj = retrieveExistingObj(uniqueSeqSetId);
4029       if (seqsetobj != null)
4030       {
4031         if (seqsetobj instanceof String)
4032         {
4033           uniqueSeqSetId = (String) seqsetobj;
4034           System.err.println(
4035                   "Recovered extant sequence set ID mapping for ID : New Sequence set ID is "
4036                           + uniqueSeqSetId);
4037         }
4038         else
4039         {
4040           System.err.println(
4041                   "Warning : Collision between sequence set ID string and existing jalview object mapping.");
4042         }
4043
4044       }
4045     }
4046     /**
4047      * indicate that annotation colours are applied across all groups (pre
4048      * Jalview 2.8.1 behaviour)
4049      */
4050     boolean doGroupAnnColour = Jalview2XML.isVersionStringLaterThan("2.8.1",
4051             jalviewModel.getVersion());
4052
4053     AlignmentPanel ap = null;
4054     boolean isnewview = true;
4055     if (viewId != null)
4056     {
4057       // Check to see if this alignment already has a view id == viewId
4058       jalview.gui.AlignmentPanel views[] = Desktop
4059               .getAlignmentPanels(uniqueSeqSetId);
4060       if (views != null && views.length > 0)
4061       {
4062         for (int v = 0; v < views.length; v++)
4063         {
4064           if (views[v].av.getViewId().equalsIgnoreCase(viewId))
4065           {
4066             // recover the existing alignpanel, alignframe, viewport
4067             af = views[v].alignFrame;
4068             av = views[v].av;
4069             ap = views[v];
4070             // TODO: could even skip resetting view settings if we don't want to
4071             // change the local settings from other jalview processes
4072             isnewview = false;
4073           }
4074         }
4075       }
4076     }
4077
4078     if (isnewview)
4079     {
4080       af = loadViewport(file, jseqs, hiddenSeqs, al, jalviewModel, view,
4081               uniqueSeqSetId, viewId, autoAlan);
4082       av = af.getViewport();
4083       ap = af.alignPanel;
4084     }
4085
4086     /*
4087      * Load any trees, PDB structures and viewers
4088      *
4089      * Not done if flag is false (when this method is used for New View)
4090      */
4091     if (loadTreesAndStructures)
4092     {
4093       loadTrees(jalviewModel, view, af, av, ap);
4094       loadPCAViewers(jalviewModel, ap);
4095       loadPDBStructures(jprovider, jseqs, af, ap);
4096       loadRnaViewers(jprovider, jseqs, ap);
4097     }
4098     // and finally return.
4099     return af;
4100   }
4101
4102   /**
4103    * Loads a HMMER profile from a file stored in the project, and associates it
4104    * with the specified sequence
4105    *
4106    * @param jprovider
4107    * @param hmmJarFile
4108    * @param seq
4109    */
4110   protected void loadHmmerProfile(jarInputStreamProvider jprovider,
4111           String hmmJarFile, SequenceI seq)
4112   {
4113     try
4114     {
4115       String hmmFile = copyJarEntry(jprovider, hmmJarFile, "hmm", null);
4116       HMMFile parser = new HMMFile(hmmFile, DataSourceType.FILE);
4117       HiddenMarkovModel hmmModel = parser.getHMM();
4118       hmmModel = new HiddenMarkovModel(hmmModel, seq);
4119       seq.setHMM(hmmModel);
4120     } catch (IOException e)
4121     {
4122       warn("Error loading HMM profile for " + seq.getName() + ": "
4123               + e.getMessage());
4124     }
4125   }
4126
4127   /**
4128    * Instantiate and link any saved RNA (Varna) viewers. The state of the Varna
4129    * panel is restored from separate jar entries, two (gapped and trimmed) per
4130    * sequence and secondary structure.
4131    *
4132    * Currently each viewer shows just one sequence and structure (gapped and
4133    * trimmed), however this method is designed to support multiple sequences or
4134    * structures in viewers if wanted in future.
4135    *
4136    * @param jprovider
4137    * @param jseqs
4138    * @param ap
4139    */
4140   private void loadRnaViewers(jarInputStreamProvider jprovider,
4141           List<JSeq> jseqs, AlignmentPanel ap)
4142   {
4143     /*
4144      * scan the sequences for references to viewers; create each one the first
4145      * time it is referenced, add Rna models to existing viewers
4146      */
4147     for (JSeq jseq : jseqs)
4148     {
4149       for (int i = 0; i < jseq.getRnaViewer().size(); i++)
4150       {
4151         RnaViewer viewer = jseq.getRnaViewer().get(i);
4152         AppVarna appVarna = findOrCreateVarnaViewer(viewer, uniqueSetSuffix,
4153                 ap);
4154
4155         for (int j = 0; j < viewer.getSecondaryStructure().size(); j++)
4156         {
4157           SecondaryStructure ss = viewer.getSecondaryStructure().get(j);
4158           SequenceI seq = seqRefIds.get(jseq.getId());
4159           AlignmentAnnotation ann = this.annotationIds
4160                   .get(ss.getAnnotationId());
4161
4162           /*
4163            * add the structure to the Varna display (with session state copied
4164            * from the jar to a temporary file)
4165            */
4166           boolean gapped = safeBoolean(ss.isGapped());
4167           String rnaTitle = ss.getTitle();
4168           String sessionState = ss.getViewerState();
4169           String tempStateFile = copyJarEntry(jprovider, sessionState,
4170                   "varna", null);
4171           RnaModel rna = new RnaModel(rnaTitle, ann, seq, null, gapped);
4172           appVarna.addModelSession(rna, rnaTitle, tempStateFile);
4173         }
4174         appVarna.setInitialSelection(safeInt(viewer.getSelectedRna()));
4175       }
4176     }
4177   }
4178
4179   /**
4180    * Locate and return an already instantiated matching AppVarna, or create one
4181    * if not found
4182    *
4183    * @param viewer
4184    * @param viewIdSuffix
4185    * @param ap
4186    * @return
4187    */
4188   protected AppVarna findOrCreateVarnaViewer(RnaViewer viewer,
4189           String viewIdSuffix, AlignmentPanel ap)
4190   {
4191     /*
4192      * on each load a suffix is appended to the saved viewId, to avoid conflicts
4193      * if load is repeated
4194      */
4195     String postLoadId = viewer.getViewId() + viewIdSuffix;
4196     for (JInternalFrame frame : getAllFrames())
4197     {
4198       if (frame instanceof AppVarna)
4199       {
4200         AppVarna varna = (AppVarna) frame;
4201         if (postLoadId.equals(varna.getViewId()))
4202         {
4203           // this viewer is already instantiated
4204           // could in future here add ap as another 'parent' of the
4205           // AppVarna window; currently just 1-to-many
4206           return varna;
4207         }
4208       }
4209     }
4210
4211     /*
4212      * viewer not found - make it
4213      */
4214     RnaViewerModel model = new RnaViewerModel(postLoadId, viewer.getTitle(),
4215             safeInt(viewer.getXpos()), safeInt(viewer.getYpos()),
4216             safeInt(viewer.getWidth()), safeInt(viewer.getHeight()),
4217             safeInt(viewer.getDividerLocation()));
4218     AppVarna varna = new AppVarna(model, ap);
4219
4220     return varna;
4221   }
4222
4223   /**
4224    * Load any saved trees
4225    *
4226    * @param jm
4227    * @param view
4228    * @param af
4229    * @param av
4230    * @param ap
4231    */
4232   protected void loadTrees(JalviewModel jm, Viewport view,
4233           AlignFrame af, AlignViewport av, AlignmentPanel ap)
4234   {
4235     // TODO result of automated refactoring - are all these parameters needed?
4236     try
4237     {
4238       for (int t = 0; t < jm.getTree().size(); t++)
4239       {
4240
4241         Tree tree = jm.getTree().get(t);
4242
4243         TreePanel tp = (TreePanel) retrieveExistingObj(tree.getId());
4244         if (tp == null)
4245         {
4246           tp = af.showNewickTree(new NewickFile(tree.getNewick()),
4247                   tree.getTitle(), safeInt(tree.getWidth()),
4248                   safeInt(tree.getHeight()), safeInt(tree.getXpos()),
4249                   safeInt(tree.getYpos()));
4250           if (tree.getId() != null)
4251           {
4252             // perhaps bind the tree id to something ?
4253           }
4254         }
4255         else
4256         {
4257           // update local tree attributes ?
4258           // TODO: should check if tp has been manipulated by user - if so its
4259           // settings shouldn't be modified
4260           tp.setTitle(tree.getTitle());
4261           tp.setBounds(new Rectangle(safeInt(tree.getXpos()),
4262                   safeInt(tree.getYpos()), safeInt(tree.getWidth()),
4263                   safeInt(tree.getHeight())));
4264           tp.setViewport(av); // af.viewport;
4265           // TODO: verify 'associate with all views' works still
4266           tp.getTreeCanvas().setViewport(av); // af.viewport;
4267           tp.getTreeCanvas().setAssociatedPanel(ap); // af.alignPanel;
4268         }
4269         tp.getTreeCanvas().setApplyToAllViews(tree.isLinkToAllViews());
4270         if (tp == null)
4271         {
4272           warn("There was a problem recovering stored Newick tree: \n"
4273                   + tree.getNewick());
4274           continue;
4275         }
4276
4277         tp.fitToWindow.setState(safeBoolean(tree.isFitToWindow()));
4278         tp.fitToWindow_actionPerformed(null);
4279
4280         if (tree.getFontName() != null)
4281         {
4282           tp.setTreeFont(
4283                   new Font(tree.getFontName(), safeInt(tree.getFontStyle()),
4284                           safeInt(tree.getFontSize())));
4285         }
4286         else
4287         {
4288           tp.setTreeFont(
4289                   new Font(view.getFontName(), safeInt(view.getFontStyle()),
4290                           safeInt(view.getFontSize())));
4291         }
4292
4293         tp.showPlaceholders(safeBoolean(tree.isMarkUnlinked()));
4294         tp.showBootstrap(safeBoolean(tree.isShowBootstrap()));
4295         tp.showDistances(safeBoolean(tree.isShowDistances()));
4296
4297         tp.getTreeCanvas().setThreshold(safeFloat(tree.getThreshold()));
4298
4299         if (safeBoolean(tree.isCurrentTree()))
4300         {
4301           af.getViewport().setCurrentTree(tp.getTree());
4302         }
4303       }
4304
4305     } catch (Exception ex)
4306     {
4307       ex.printStackTrace();
4308     }
4309   }
4310
4311   /**
4312    * Load and link any saved structure viewers.
4313    *
4314    * @param jprovider
4315    * @param jseqs
4316    * @param af
4317    * @param ap
4318    */
4319   protected void loadPDBStructures(jarInputStreamProvider jprovider,
4320           List<JSeq> jseqs, AlignFrame af, AlignmentPanel ap)
4321   {
4322     /*
4323      * Run through all PDB ids on the alignment, and collect mappings between
4324      * distinct view ids and all sequences referring to that view.
4325      */
4326     Map<String, StructureViewerModel> structureViewers = new LinkedHashMap<>();
4327
4328     for (int i = 0; i < jseqs.size(); i++)
4329     {
4330       JSeq jseq = jseqs.get(i);
4331       if (jseq.getPdbids().size() > 0)
4332       {
4333         List<Pdbids> ids = jseq.getPdbids();
4334         for (int p = 0; p < ids.size(); p++)
4335         {
4336           Pdbids pdbid = ids.get(p);
4337           final int structureStateCount = pdbid.getStructureState().size();
4338           for (int s = 0; s < structureStateCount; s++)
4339           {
4340             // check to see if we haven't already created this structure view
4341             final StructureState structureState = pdbid
4342                     .getStructureState().get(s);
4343             String sviewid = (structureState.getViewId() == null) ? null
4344                     : structureState.getViewId() + uniqueSetSuffix;
4345             jalview.datamodel.PDBEntry jpdb = new jalview.datamodel.PDBEntry();
4346             // Originally : pdbid.getFile()
4347             // : TODO: verify external PDB file recovery still works in normal
4348             // jalview project load
4349             jpdb.setFile(
4350                     loadPDBFile(jprovider, pdbid.getId(), pdbid.getFile()));
4351             jpdb.setId(pdbid.getId());
4352
4353             int x = safeInt(structureState.getXpos());
4354             int y = safeInt(structureState.getYpos());
4355             int width = safeInt(structureState.getWidth());
4356             int height = safeInt(structureState.getHeight());
4357
4358             // Probably don't need to do this anymore...
4359             // Desktop.desktop.getComponentAt(x, y);
4360             // TODO: NOW: check that this recovers the PDB file correctly.
4361             String pdbFile = loadPDBFile(jprovider, pdbid.getId(),
4362                     pdbid.getFile());
4363             jalview.datamodel.SequenceI seq = seqRefIds
4364                     .get(jseq.getId() + "");
4365             if (sviewid == null)
4366             {
4367               sviewid = "_jalview_pre2_4_" + x + "," + y + "," + width + ","
4368                       + height;
4369             }
4370             if (!structureViewers.containsKey(sviewid))
4371             {
4372               structureViewers.put(sviewid,
4373                       new StructureViewerModel(x, y, width, height, false,
4374                               false, true, structureState.getViewId(),
4375                               structureState.getType()));
4376               // Legacy pre-2.7 conversion JAL-823 :
4377               // do not assume any view has to be linked for colour by
4378               // sequence
4379             }
4380
4381             // assemble String[] { pdb files }, String[] { id for each
4382             // file }, orig_fileloc, SequenceI[][] {{ seqs_file 1 }, {
4383             // seqs_file 2}, boolean[] {
4384             // linkAlignPanel,superposeWithAlignpanel}} from hash
4385             StructureViewerModel jmoldat = structureViewers.get(sviewid);
4386             jmoldat.setAlignWithPanel(jmoldat.isAlignWithPanel()
4387                     || structureState.isAlignwithAlignPanel());
4388
4389             /*
4390              * Default colour by linked panel to false if not specified (e.g.
4391              * for pre-2.7 projects)
4392              */
4393             boolean colourWithAlignPanel = jmoldat.isColourWithAlignPanel();
4394             colourWithAlignPanel |= structureState.isColourwithAlignPanel();
4395             jmoldat.setColourWithAlignPanel(colourWithAlignPanel);
4396
4397             /*
4398              * Default colour by viewer to true if not specified (e.g. for
4399              * pre-2.7 projects)
4400              */
4401             boolean colourByViewer = jmoldat.isColourByViewer();
4402             colourByViewer &= structureState.isColourByJmol();
4403             jmoldat.setColourByViewer(colourByViewer);
4404
4405             if (jmoldat.getStateData().length() < structureState
4406                     .getValue()/*Content()*/.length())
4407             {
4408               jmoldat.setStateData(structureState.getValue());// Content());
4409             }
4410             if (pdbid.getFile() != null)
4411             {
4412               File mapkey = new File(pdbid.getFile());
4413               StructureData seqstrmaps = jmoldat.getFileData().get(mapkey);
4414               if (seqstrmaps == null)
4415               {
4416                 jmoldat.getFileData().put(mapkey,
4417                         seqstrmaps = jmoldat.new StructureData(pdbFile,
4418                                 pdbid.getId()));
4419               }
4420               if (!seqstrmaps.getSeqList().contains(seq))
4421               {
4422                 seqstrmaps.getSeqList().add(seq);
4423                 // TODO and chains?
4424               }
4425             }
4426             else
4427             {
4428               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");
4429               warn(errorMessage);
4430             }
4431           }
4432         }
4433       }
4434     }
4435     // Instantiate the associated structure views
4436     for (Entry<String, StructureViewerModel> entry : structureViewers
4437             .entrySet())
4438     {
4439       try
4440       {
4441         createOrLinkStructureViewer(entry, af, ap, jprovider);
4442       } catch (Exception e)
4443       {
4444         System.err.println(
4445                 "Error loading structure viewer: " + e.getMessage());
4446         // failed - try the next one
4447       }
4448     }
4449   }
4450
4451   /**
4452    *
4453    * @param viewerData
4454    * @param af
4455    * @param ap
4456    * @param jprovider
4457    */
4458   protected void createOrLinkStructureViewer(
4459           Entry<String, StructureViewerModel> viewerData, AlignFrame af,
4460           AlignmentPanel ap, jarInputStreamProvider jprovider)
4461   {
4462     final StructureViewerModel stateData = viewerData.getValue();
4463
4464     /*
4465      * Search for any viewer windows already open from other alignment views
4466      * that exactly match the stored structure state
4467      */
4468     StructureViewerBase comp = findMatchingViewer(viewerData);
4469
4470     if (comp != null)
4471     {
4472       linkStructureViewer(ap, comp, stateData);
4473       return;
4474     }
4475
4476     /*
4477      * From 2.9: stateData.type contains JMOL or CHIMERA, data is in jar entry
4478      * "viewer_"+stateData.viewId
4479      */
4480     if (ViewerType.CHIMERA.toString().equals(stateData.getType()))
4481     {
4482       createChimeraViewer(viewerData, af, jprovider);
4483     }
4484     else
4485     {
4486       /*
4487        * else Jmol (if pre-2.9, stateData contains JMOL state string)
4488        */
4489       createJmolViewer(viewerData, af, jprovider);
4490     }
4491   }
4492
4493   /**
4494    * Create a new Chimera viewer.
4495    *
4496    * @param data
4497    * @param af
4498    * @param jprovider
4499    */
4500   protected void createChimeraViewer(
4501           Entry<String, StructureViewerModel> viewerData, AlignFrame af,
4502           jarInputStreamProvider jprovider)
4503   {
4504     StructureViewerModel data = viewerData.getValue();
4505     String chimeraSessionFile = data.getStateData();
4506
4507     /*
4508      * Copy Chimera session from jar entry "viewer_"+viewId to a temporary file
4509      *
4510      * NB this is the 'saved' viewId as in the project file XML, _not_ the
4511      * 'uniquified' sviewid used to reconstruct the viewer here
4512      */
4513     String viewerJarEntryName = getViewerJarEntryName(data.getViewId());
4514     chimeraSessionFile = copyJarEntry(jprovider, viewerJarEntryName,
4515             "chimera", null);
4516
4517     Set<Entry<File, StructureData>> fileData = data.getFileData()
4518             .entrySet();
4519     List<PDBEntry> pdbs = new ArrayList<>();
4520     List<SequenceI[]> allseqs = new ArrayList<>();
4521     for (Entry<File, StructureData> pdb : fileData)
4522     {
4523       String filePath = pdb.getValue().getFilePath();
4524       String pdbId = pdb.getValue().getPdbId();
4525       // pdbs.add(new PDBEntry(filePath, pdbId));
4526       pdbs.add(new PDBEntry(pdbId, null, PDBEntry.Type.PDB, filePath));
4527       final List<SequenceI> seqList = pdb.getValue().getSeqList();
4528       SequenceI[] seqs = seqList.toArray(new SequenceI[seqList.size()]);
4529       allseqs.add(seqs);
4530     }
4531
4532     boolean colourByChimera = data.isColourByViewer();
4533     boolean colourBySequence = data.isColourWithAlignPanel();
4534
4535     // TODO use StructureViewer as a factory here, see JAL-1761
4536     final PDBEntry[] pdbArray = pdbs.toArray(new PDBEntry[pdbs.size()]);
4537     final SequenceI[][] seqsArray = allseqs
4538             .toArray(new SequenceI[allseqs.size()][]);
4539     String newViewId = viewerData.getKey();
4540
4541     ChimeraViewFrame cvf = new ChimeraViewFrame(chimeraSessionFile,
4542             af.alignPanel, pdbArray, seqsArray, colourByChimera,
4543             colourBySequence, newViewId);
4544     cvf.setSize(data.getWidth(), data.getHeight());
4545     cvf.setLocation(data.getX(), data.getY());
4546   }
4547
4548   /**
4549    * Create a new Jmol window. First parse the Jmol state to translate filenames
4550    * loaded into the view, and record the order in which files are shown in the
4551    * Jmol view, so we can add the sequence mappings in same order.
4552    *
4553    * @param viewerData
4554    * @param af
4555    * @param jprovider
4556    */
4557   protected void createJmolViewer(
4558           final Entry<String, StructureViewerModel> viewerData,
4559           AlignFrame af, jarInputStreamProvider jprovider)
4560   {
4561     final StructureViewerModel svattrib = viewerData.getValue();
4562     String state = svattrib.getStateData();
4563
4564     /*
4565      * Pre-2.9: state element value is the Jmol state string
4566      *
4567      * 2.9+: @type is "JMOL", state data is in a Jar file member named "viewer_"
4568      * + viewId
4569      */
4570     if (ViewerType.JMOL.toString().equals(svattrib.getType()))
4571     {
4572       state = readJarEntry(jprovider,
4573               getViewerJarEntryName(svattrib.getViewId()));
4574     }
4575
4576     List<String> pdbfilenames = new ArrayList<>();
4577     List<SequenceI[]> seqmaps = new ArrayList<>();
4578     List<String> pdbids = new ArrayList<>();
4579     StringBuilder newFileLoc = new StringBuilder(64);
4580     int cp = 0, ncp, ecp;
4581     Map<File, StructureData> oldFiles = svattrib.getFileData();
4582     while ((ncp = state.indexOf("load ", cp)) > -1)
4583     {
4584       do
4585       {
4586         // look for next filename in load statement
4587         newFileLoc.append(state.substring(cp,
4588                 ncp = (state.indexOf("\"", ncp + 1) + 1)));
4589         String oldfilenam = state.substring(ncp,
4590                 ecp = state.indexOf("\"", ncp));
4591         // recover the new mapping data for this old filename
4592         // have to normalize filename - since Jmol and jalview do
4593         // filename
4594         // translation differently.
4595         StructureData filedat = oldFiles.get(new File(oldfilenam));
4596         if (filedat == null)
4597         {
4598           String reformatedOldFilename = oldfilenam.replaceAll("/", "\\\\");
4599           filedat = oldFiles.get(new File(reformatedOldFilename));
4600         }
4601         newFileLoc.append(Platform.escapeBackslashes(filedat.getFilePath()));
4602         pdbfilenames.add(filedat.getFilePath());
4603         pdbids.add(filedat.getPdbId());
4604         seqmaps.add(filedat.getSeqList().toArray(new SequenceI[0]));
4605         newFileLoc.append("\"");
4606         cp = ecp + 1; // advance beyond last \" and set cursor so we can
4607                       // look for next file statement.
4608       } while ((ncp = state.indexOf("/*file*/", cp)) > -1);
4609     }
4610     if (cp > 0)
4611     {
4612       // just append rest of state
4613       newFileLoc.append(state.substring(cp));
4614     }
4615     else
4616     {
4617       System.err.print("Ignoring incomplete Jmol state for PDB ids: ");
4618       newFileLoc = new StringBuilder(state);
4619       newFileLoc.append("; load append ");
4620       for (File id : oldFiles.keySet())
4621       {
4622         // add this and any other pdb files that should be present in
4623         // the viewer
4624         StructureData filedat = oldFiles.get(id);
4625         newFileLoc.append(filedat.getFilePath());
4626         pdbfilenames.add(filedat.getFilePath());
4627         pdbids.add(filedat.getPdbId());
4628         seqmaps.add(filedat.getSeqList().toArray(new SequenceI[0]));
4629         newFileLoc.append(" \"");
4630         newFileLoc.append(filedat.getFilePath());
4631         newFileLoc.append("\"");
4632
4633       }
4634       newFileLoc.append(";");
4635     }
4636
4637     if (newFileLoc.length() == 0)
4638     {
4639       return;
4640     }
4641     int histbug = newFileLoc.indexOf("history = ");
4642     if (histbug > -1)
4643     {
4644       /*
4645        * change "history = [true|false];" to "history = [1|0];"
4646        */
4647       histbug += 10;
4648       int diff = histbug == -1 ? -1 : newFileLoc.indexOf(";", histbug);
4649       String val = (diff == -1) ? null
4650               : newFileLoc.substring(histbug, diff);
4651       if (val != null && val.length() >= 4)
4652       {
4653         if (val.contains("e")) // eh? what can it be?
4654         {
4655           if (val.trim().equals("true"))
4656           {
4657             val = "1";
4658           }
4659           else
4660           {
4661             val = "0";
4662           }
4663           newFileLoc.replace(histbug, diff, val);
4664         }
4665       }
4666     }
4667
4668     final String[] pdbf = pdbfilenames
4669             .toArray(new String[pdbfilenames.size()]);
4670     final String[] id = pdbids.toArray(new String[pdbids.size()]);
4671     final SequenceI[][] sq = seqmaps
4672             .toArray(new SequenceI[seqmaps.size()][]);
4673     final String fileloc = newFileLoc.toString();
4674     final String sviewid = viewerData.getKey();
4675     final AlignFrame alf = af;
4676     final Rectangle rect = new Rectangle(svattrib.getX(), svattrib.getY(),
4677             svattrib.getWidth(), svattrib.getHeight());
4678     try
4679     {
4680       javax.swing.SwingUtilities.invokeAndWait(new Runnable()
4681       {
4682         @Override
4683         public void run()
4684         {
4685           JalviewStructureDisplayI sview = null;
4686           try
4687           {
4688             sview = new StructureViewer(
4689                     alf.alignPanel.getStructureSelectionManager())
4690                             .createView(StructureViewer.ViewerType.JMOL,
4691                                     pdbf, id, sq, alf.alignPanel, svattrib,
4692                                     fileloc, rect, sviewid);
4693             addNewStructureViewer(sview);
4694           } catch (OutOfMemoryError ex)
4695           {
4696             new OOMWarning("restoring structure view for PDB id " + id,
4697                     (OutOfMemoryError) ex.getCause());
4698             if (sview != null && sview.isVisible())
4699             {
4700               sview.closeViewer(false);
4701               sview.setVisible(false);
4702               sview.dispose();
4703             }
4704           }
4705         }
4706       });
4707     } catch (InvocationTargetException ex)
4708     {
4709       warn("Unexpected error when opening Jmol view.", ex);
4710
4711     } catch (InterruptedException e)
4712     {
4713       // e.printStackTrace();
4714     }
4715
4716   }
4717
4718   /**
4719    * Generates a name for the entry in the project jar file to hold state
4720    * information for a structure viewer
4721    *
4722    * @param viewId
4723    * @return
4724    */
4725   protected String getViewerJarEntryName(String viewId)
4726   {
4727     return VIEWER_PREFIX + viewId;
4728   }
4729
4730   /**
4731    * Returns any open frame that matches given structure viewer data. The match
4732    * is based on the unique viewId, or (for older project versions) the frame's
4733    * geometry.
4734    *
4735    * @param viewerData
4736    * @return
4737    */
4738   protected StructureViewerBase findMatchingViewer(
4739           Entry<String, StructureViewerModel> viewerData)
4740   {
4741     final String sviewid = viewerData.getKey();
4742     final StructureViewerModel svattrib = viewerData.getValue();
4743     StructureViewerBase comp = null;
4744     JInternalFrame[] frames = getAllFrames();
4745     for (JInternalFrame frame : frames)
4746     {
4747       if (frame instanceof StructureViewerBase)
4748       {
4749         /*
4750          * Post jalview 2.4 schema includes structure view id
4751          */
4752         if (sviewid != null && ((StructureViewerBase) frame).getViewId()
4753                 .equals(sviewid))
4754         {
4755           comp = (StructureViewerBase) frame;
4756           break; // break added in 2.9
4757         }
4758         /*
4759          * Otherwise test for matching position and size of viewer frame
4760          */
4761         else if (frame.getX() == svattrib.getX()
4762                 && frame.getY() == svattrib.getY()
4763                 && frame.getHeight() == svattrib.getHeight()
4764                 && frame.getWidth() == svattrib.getWidth())
4765         {
4766           comp = (StructureViewerBase) frame;
4767           // no break in faint hope of an exact match on viewId
4768         }
4769       }
4770     }
4771     return comp;
4772   }
4773
4774   /**
4775    * Link an AlignmentPanel to an existing structure viewer.
4776    *
4777    * @param ap
4778    * @param viewer
4779    * @param oldFiles
4780    * @param useinViewerSuperpos
4781    * @param usetoColourbyseq
4782    * @param viewerColouring
4783    */
4784   protected void linkStructureViewer(AlignmentPanel ap,
4785           StructureViewerBase viewer, StructureViewerModel stateData)
4786   {
4787     // NOTE: if the jalview project is part of a shared session then
4788     // view synchronization should/could be done here.
4789
4790     final boolean useinViewerSuperpos = stateData.isAlignWithPanel();
4791     final boolean usetoColourbyseq = stateData.isColourWithAlignPanel();
4792     final boolean viewerColouring = stateData.isColourByViewer();
4793     Map<File, StructureData> oldFiles = stateData.getFileData();
4794
4795     /*
4796      * Add mapping for sequences in this view to an already open viewer
4797      */
4798     final AAStructureBindingModel binding = viewer.getBinding();
4799     for (File id : oldFiles.keySet())
4800     {
4801       // add this and any other pdb files that should be present in the
4802       // viewer
4803       StructureData filedat = oldFiles.get(id);
4804       String pdbFile = filedat.getFilePath();
4805       SequenceI[] seq = filedat.getSeqList().toArray(new SequenceI[0]);
4806       binding.getSsm().setMapping(seq, null, pdbFile, DataSourceType.FILE,
4807               null);
4808       binding.addSequenceForStructFile(pdbFile, seq);
4809     }
4810     // and add the AlignmentPanel's reference to the view panel
4811     viewer.addAlignmentPanel(ap);
4812     if (useinViewerSuperpos)
4813     {
4814       viewer.useAlignmentPanelForSuperposition(ap);
4815     }
4816     else
4817     {
4818       viewer.excludeAlignmentPanelForSuperposition(ap);
4819     }
4820     if (usetoColourbyseq)
4821     {
4822       viewer.useAlignmentPanelForColourbyseq(ap, !viewerColouring);
4823     }
4824     else
4825     {
4826       viewer.excludeAlignmentPanelForColourbyseq(ap);
4827     }
4828   }
4829
4830   /**
4831    * Get all frames within the Desktop.
4832    *
4833    * @return
4834    */
4835   protected JInternalFrame[] getAllFrames()
4836   {
4837     JInternalFrame[] frames = null;
4838     // TODO is this necessary - is it safe - risk of hanging?
4839     do
4840     {
4841       try
4842       {
4843         frames = Desktop.desktop.getAllFrames();
4844       } catch (ArrayIndexOutOfBoundsException e)
4845       {
4846         // occasional No such child exceptions are thrown here...
4847         try
4848         {
4849           Thread.sleep(10);
4850         } catch (InterruptedException f)
4851         {
4852         }
4853       }
4854     } while (frames == null);
4855     return frames;
4856   }
4857
4858   /**
4859    * Answers true if 'version' is equal to or later than 'supported', where each
4860    * is formatted as major/minor versions like "2.8.3" or "2.3.4b1" for bugfix
4861    * changes. Development and test values for 'version' are leniently treated
4862    * i.e. answer true.
4863    *
4864    * @param supported
4865    *          - minimum version we are comparing against
4866    * @param version
4867    *          - version of data being processsed
4868    * @return
4869    */
4870   public static boolean isVersionStringLaterThan(String supported,
4871           String version)
4872   {
4873     if (supported == null || version == null
4874             || version.equalsIgnoreCase("DEVELOPMENT BUILD")
4875             || version.equalsIgnoreCase("Test")
4876             || version.equalsIgnoreCase("AUTOMATED BUILD"))
4877     {
4878       System.err.println("Assuming project file with "
4879               + (version == null ? "null" : version)
4880               + " is compatible with Jalview version " + supported);
4881       return true;
4882     }
4883     else
4884     {
4885       return StringUtils.compareVersions(version, supported, "b") >= 0;
4886     }
4887   }
4888
4889   Vector<JalviewStructureDisplayI> newStructureViewers = null;
4890
4891   protected void addNewStructureViewer(JalviewStructureDisplayI sview)
4892   {
4893     if (newStructureViewers != null)
4894     {
4895       sview.getBinding().setFinishedLoadingFromArchive(false);
4896       newStructureViewers.add(sview);
4897     }
4898   }
4899
4900   protected void setLoadingFinishedForNewStructureViewers()
4901   {
4902     if (newStructureViewers != null)
4903     {
4904       for (JalviewStructureDisplayI sview : newStructureViewers)
4905       {
4906         sview.getBinding().setFinishedLoadingFromArchive(true);
4907       }
4908       newStructureViewers.clear();
4909       newStructureViewers = null;
4910     }
4911   }
4912
4913   AlignFrame loadViewport(String file, List<JSeq> JSEQ,
4914           List<SequenceI> hiddenSeqs, AlignmentI al,
4915           JalviewModel jm, Viewport view, String uniqueSeqSetId,
4916           String viewId, List<JvAnnotRow> autoAlan)
4917   {
4918     AlignFrame af = null;
4919     af = new AlignFrame(al, safeInt(view.getWidth()),
4920             safeInt(view.getHeight()), uniqueSeqSetId, viewId);
4921
4922     af.setFileName(file, FileFormat.Jalview);
4923
4924     final AlignViewport viewport = af.getViewport();
4925     for (int i = 0; i < JSEQ.size(); i++)
4926     {
4927       int colour = safeInt(JSEQ.get(i).getColour());
4928       viewport.setSequenceColour(viewport.getAlignment().getSequenceAt(i),
4929               new Color(colour));
4930     }
4931
4932     if (al.hasSeqrep())
4933     {
4934       viewport.setColourByReferenceSeq(true);
4935       viewport.setDisplayReferenceSeq(true);
4936     }
4937
4938     viewport.setGatherViewsHere(safeBoolean(view.isGatheredViews()));
4939
4940     if (view.getSequenceSetId() != null)
4941     {
4942       AlignmentViewport av = viewportsAdded.get(uniqueSeqSetId);
4943
4944       viewport.setSequenceSetId(uniqueSeqSetId);
4945       if (av != null)
4946       {
4947         // propagate shared settings to this new view
4948         viewport.setHistoryList(av.getHistoryList());
4949         viewport.setRedoList(av.getRedoList());
4950       }
4951       else
4952       {
4953         viewportsAdded.put(uniqueSeqSetId, viewport);
4954       }
4955       // TODO: check if this method can be called repeatedly without
4956       // side-effects if alignpanel already registered.
4957       PaintRefresher.Register(af.alignPanel, uniqueSeqSetId);
4958     }
4959     // apply Hidden regions to view.
4960     if (hiddenSeqs != null)
4961     {
4962       for (int s = 0; s < JSEQ.size(); s++)
4963       {
4964         SequenceGroup hidden = new SequenceGroup();
4965         boolean isRepresentative = false;
4966         for (int r = 0; r < JSEQ.get(s).getHiddenSequences().size(); r++)
4967         {
4968           isRepresentative = true;
4969           SequenceI sequenceToHide = al
4970                   .getSequenceAt(JSEQ.get(s).getHiddenSequences().get(r));
4971           hidden.addSequence(sequenceToHide, false);
4972           // remove from hiddenSeqs list so we don't try to hide it twice
4973           hiddenSeqs.remove(sequenceToHide);
4974         }
4975         if (isRepresentative)
4976         {
4977           SequenceI representativeSequence = al.getSequenceAt(s);
4978           hidden.addSequence(representativeSequence, false);
4979           viewport.hideRepSequences(representativeSequence, hidden);
4980         }
4981       }
4982
4983       SequenceI[] hseqs = hiddenSeqs
4984               .toArray(new SequenceI[hiddenSeqs.size()]);
4985       viewport.hideSequence(hseqs);
4986
4987     }
4988     // recover view properties and display parameters
4989
4990     viewport.setShowAnnotation(safeBoolean(view.isShowAnnotation()));
4991     viewport.setAbovePIDThreshold(safeBoolean(view.isPidSelected()));
4992     final int pidThreshold = safeInt(view.getPidThreshold());
4993     viewport.setThreshold(pidThreshold);
4994
4995     viewport.setColourText(safeBoolean(view.isShowColourText()));
4996
4997     viewport
4998             .setConservationSelected(
4999                     safeBoolean(view.isConservationSelected()));
5000     viewport.setIncrement(safeInt(view.getConsThreshold()));
5001     viewport.setShowJVSuffix(safeBoolean(view.isShowFullId()));
5002     viewport.setRightAlignIds(safeBoolean(view.isRightAlignIds()));
5003     viewport.setFont(new Font(view.getFontName(),
5004             safeInt(view.getFontStyle()), safeInt(view.getFontSize())),
5005             true);
5006     ViewStyleI vs = viewport.getViewStyle();
5007     vs.setScaleProteinAsCdna(view.isScaleProteinAsCdna());
5008     viewport.setViewStyle(vs);
5009     // TODO: allow custom charWidth/Heights to be restored by updating them
5010     // after setting font - which means set above to false
5011     viewport.setRenderGaps(safeBoolean(view.isRenderGaps()));
5012     viewport.setWrapAlignment(safeBoolean(view.isWrapAlignment()));
5013     viewport.setShowAnnotation(safeBoolean(view.isShowAnnotation()));
5014
5015     viewport.setShowBoxes(safeBoolean(view.isShowBoxes()));
5016
5017     viewport.setShowText(safeBoolean(view.isShowText()));
5018
5019     viewport.setTextColour(new Color(safeInt(view.getTextCol1())));
5020     viewport.setTextColour2(new Color(safeInt(view.getTextCol2())));
5021     viewport.setThresholdTextColour(safeInt(view.getTextColThreshold()));
5022     viewport.setShowUnconserved(view.isShowUnconserved());
5023     viewport.getRanges().setStartRes(safeInt(view.getStartRes()));
5024
5025     if (view.getViewName() != null)
5026     {
5027       viewport.setViewName(view.getViewName());
5028       af.setInitialTabVisible();
5029     }
5030     af.setBounds(safeInt(view.getXpos()), safeInt(view.getYpos()),
5031             safeInt(view.getWidth()), safeInt(view.getHeight()));
5032     // startSeq set in af.alignPanel.updateLayout below
5033     af.alignPanel.updateLayout();
5034     ColourSchemeI cs = null;
5035     // apply colourschemes
5036     if (view.getBgColour() != null)
5037     {
5038       if (view.getBgColour().startsWith("ucs"))
5039       {
5040         cs = getUserColourScheme(jm, view.getBgColour());
5041       }
5042       else if (view.getBgColour().startsWith("Annotation"))
5043       {
5044         AnnotationColourScheme viewAnnColour = view.getAnnotationColours();
5045         cs = constructAnnotationColour(viewAnnColour, af, al, jm, true);
5046
5047         // annpos
5048
5049       }
5050       else
5051       {
5052         cs = ColourSchemeProperty.getColourScheme(af.getViewport(), al,
5053                 view.getBgColour());
5054       }
5055     }
5056
5057     /*
5058      * turn off 'alignment colour applies to all groups'
5059      * while restoring global colour scheme
5060      */
5061     viewport.setColourAppliesToAllGroups(false);
5062     viewport.setGlobalColourScheme(cs);
5063     viewport.getResidueShading().setThreshold(pidThreshold,
5064             view.isIgnoreGapsinConsensus());
5065     viewport.getResidueShading()
5066             .setConsensus(viewport.getSequenceConsensusHash());
5067     if (safeBoolean(view.isConservationSelected()) && cs != null)
5068     {
5069       viewport.getResidueShading()
5070               .setConservationInc(safeInt(view.getConsThreshold()));
5071     }
5072     af.changeColour(cs);
5073     viewport.setColourAppliesToAllGroups(true);
5074
5075     viewport
5076             .setShowSequenceFeatures(
5077                     safeBoolean(view.isShowSequenceFeatures()));
5078
5079     viewport.setCentreColumnLabels(view.isCentreColumnLabels());
5080     viewport.setIgnoreGapsConsensus(view.isIgnoreGapsinConsensus(), null);
5081     viewport.setFollowHighlight(view.isFollowHighlight());
5082     viewport.followSelection = view.isFollowSelection();
5083     viewport.setShowConsensusHistogram(view.isShowConsensusHistogram());
5084     viewport.setShowSequenceLogo(view.isShowSequenceLogo());
5085     viewport.setNormaliseSequenceLogo(view.isNormaliseSequenceLogo());
5086     viewport.setShowDBRefs(safeBoolean(view.isShowDbRefTooltip()));
5087     viewport.setShowNPFeats(safeBoolean(view.isShowNPfeatureTooltip()));
5088     viewport.setShowGroupConsensus(view.isShowGroupConsensus());
5089     viewport.setShowGroupConservation(view.isShowGroupConservation());
5090
5091     // recover feature settings
5092     if (jm.getFeatureSettings() != null)
5093     {
5094       FeatureRenderer fr = af.alignPanel.getSeqPanel().seqCanvas
5095               .getFeatureRenderer();
5096       FeaturesDisplayed fdi;
5097       viewport.setFeaturesDisplayed(fdi = new FeaturesDisplayed());
5098       String[] renderOrder = new String[jm.getFeatureSettings()
5099               .getSetting().size()];
5100       Map<String, FeatureColourI> featureColours = new Hashtable<>();
5101       Map<String, Float> featureOrder = new Hashtable<>();
5102
5103       for (int fs = 0; fs < jm.getFeatureSettings()
5104               .getSetting().size(); fs++)
5105       {
5106         Setting setting = jm.getFeatureSettings().getSetting().get(fs);
5107         String featureType = setting.getType();
5108
5109         /*
5110          * restore feature filters (if any)
5111          */
5112         jalview.xml.binding.jalview.FeatureMatcherSet filters = setting
5113                 .getMatcherSet();
5114         if (filters != null)
5115         {
5116           FeatureMatcherSetI filter = Jalview2XML
5117                   .parseFilter(featureType, filters);
5118           if (!filter.isEmpty())
5119           {
5120             fr.setFeatureFilter(featureType, filter);
5121           }
5122         }
5123
5124         /*
5125          * restore feature colour scheme
5126          */
5127         Color maxColour = new Color(setting.getColour());
5128         if (setting.getMincolour() != null)
5129         {
5130           /*
5131            * minColour is always set unless a simple colour
5132            * (including for colour by label though it doesn't use it)
5133            */
5134           Color minColour = new Color(setting.getMincolour().intValue());
5135           Color noValueColour = minColour;
5136           NoValueColour noColour = setting.getNoValueColour();
5137           if (noColour == NoValueColour.NONE)
5138           {
5139             noValueColour = null;
5140           }
5141           else if (noColour == NoValueColour.MAX)
5142           {
5143             noValueColour = maxColour;
5144           }
5145           float min = safeFloat(safeFloat(setting.getMin()));
5146           float max = setting.getMax() == null ? 1f
5147                   : setting.getMax().floatValue();
5148           FeatureColourI gc = new FeatureColour(maxColour, minColour,
5149                   maxColour,
5150                   noValueColour, min, max);
5151           if (setting.getAttributeName().size() > 0)
5152           {
5153             gc.setAttributeName(setting.getAttributeName().toArray(
5154                     new String[setting.getAttributeName().size()]));
5155           }
5156           if (setting.getThreshold() != null)
5157           {
5158             gc.setThreshold(setting.getThreshold().floatValue());
5159             int threshstate = safeInt(setting.getThreshstate());
5160             // -1 = None, 0 = Below, 1 = Above threshold
5161             if (threshstate == 0)
5162             {
5163               gc.setBelowThreshold(true);
5164             }
5165             else if (threshstate == 1)
5166             {
5167               gc.setAboveThreshold(true);
5168             }
5169           }
5170           gc.setAutoScaled(true); // default
5171           if (setting.isAutoScale() != null)
5172           {
5173             gc.setAutoScaled(setting.isAutoScale());
5174           }
5175           if (setting.isColourByLabel() != null)
5176           {
5177             gc.setColourByLabel(setting.isColourByLabel());
5178           }
5179           // and put in the feature colour table.
5180           featureColours.put(featureType, gc);
5181         }
5182         else
5183         {
5184           featureColours.put(featureType,
5185                   new FeatureColour(maxColour));
5186         }
5187         renderOrder[fs] = featureType;
5188         if (setting.getOrder() != null)
5189         {
5190           featureOrder.put(featureType, setting.getOrder().floatValue());
5191         }
5192         else
5193         {
5194           featureOrder.put(featureType, Float.valueOf(
5195                   fs / jm.getFeatureSettings().getSetting().size()));
5196         }
5197         if (safeBoolean(setting.isDisplay()))
5198         {
5199           fdi.setVisible(featureType);
5200         }
5201       }
5202       Map<String, Boolean> fgtable = new Hashtable<>();
5203       for (int gs = 0; gs < jm.getFeatureSettings().getGroup().size(); gs++)
5204       {
5205         Group grp = jm.getFeatureSettings().getGroup().get(gs);
5206         fgtable.put(grp.getName(), Boolean.valueOf(grp.isDisplay()));
5207       }
5208       // FeatureRendererSettings frs = new FeatureRendererSettings(renderOrder,
5209       // fgtable, featureColours, jms.getFeatureSettings().hasTransparency() ?
5210       // jms.getFeatureSettings().getTransparency() : 0.0, featureOrder);
5211       FeatureRendererSettings frs = new FeatureRendererSettings(renderOrder,
5212               fgtable, featureColours, 1.0f, featureOrder);
5213       fr.transferSettings(frs);
5214     }
5215
5216     if (view.getHiddenColumns().size() > 0)
5217     {
5218       for (int c = 0; c < view.getHiddenColumns().size(); c++)
5219       {
5220         final HiddenColumns hc = view.getHiddenColumns().get(c);
5221         viewport.hideColumns(safeInt(hc.getStart()),
5222                 safeInt(hc.getEnd()) /* +1 */);
5223       }
5224     }
5225     if (view.getCalcIdParam() != null)
5226     {
5227       for (CalcIdParam calcIdParam : view.getCalcIdParam())
5228       {
5229         if (calcIdParam != null)
5230         {
5231           if (recoverCalcIdParam(calcIdParam, viewport))
5232           {
5233           }
5234           else
5235           {
5236             warn("Couldn't recover parameters for "
5237                     + calcIdParam.getCalcId());
5238           }
5239         }
5240       }
5241     }
5242     af.setMenusFromViewport(viewport);
5243     af.setTitle(view.getTitle());
5244     // TODO: we don't need to do this if the viewport is aready visible.
5245     /*
5246      * Add the AlignFrame to the desktop (it may be 'gathered' later), unless it
5247      * has a 'cdna/protein complement' view, in which case save it in order to
5248      * populate a SplitFrame once all views have been read in.
5249      */
5250     String complementaryViewId = view.getComplementId();
5251     if (complementaryViewId == null)
5252     {
5253       Desktop.addInternalFrame(af, view.getTitle(),
5254               safeInt(view.getWidth()), safeInt(view.getHeight()));
5255       // recompute any autoannotation
5256       af.alignPanel.updateAnnotation(false, true);
5257       reorderAutoannotation(af, al, autoAlan);
5258       af.alignPanel.alignmentChanged();
5259     }
5260     else
5261     {
5262       splitFrameCandidates.put(view, af);
5263     }
5264     return af;
5265   }
5266
5267   /**
5268    * Reads saved data to restore Colour by Annotation settings
5269    *
5270    * @param viewAnnColour
5271    * @param af
5272    * @param al
5273    * @param model
5274    * @param checkGroupAnnColour
5275    * @return
5276    */
5277   private ColourSchemeI constructAnnotationColour(
5278           AnnotationColourScheme viewAnnColour, AlignFrame af,
5279           AlignmentI al, JalviewModel model, boolean checkGroupAnnColour)
5280   {
5281     boolean propagateAnnColour = false;
5282     AlignmentI annAlignment = af != null ? af.getViewport().getAlignment()
5283             : al;
5284     if (checkGroupAnnColour && al.getGroups() != null
5285             && al.getGroups().size() > 0)
5286     {
5287       // pre 2.8.1 behaviour
5288       // check to see if we should transfer annotation colours
5289       propagateAnnColour = true;
5290       for (SequenceGroup sg : al.getGroups())
5291       {
5292         if (sg.getColourScheme() instanceof AnnotationColourGradient)
5293         {
5294           propagateAnnColour = false;
5295         }
5296       }
5297     }
5298
5299     /*
5300      * 2.10.2- : saved annotationId is AlignmentAnnotation.annotationId
5301      */
5302     String annotationId = viewAnnColour.getAnnotation();
5303     AlignmentAnnotation matchedAnnotation = annotationIds.get(annotationId);
5304
5305     /*
5306      * pre 2.10.2: saved annotationId is AlignmentAnnotation.label
5307      */
5308     if (matchedAnnotation == null
5309             && annAlignment.getAlignmentAnnotation() != null)
5310     {
5311       for (int i = 0; i < annAlignment.getAlignmentAnnotation().length; i++)
5312       {
5313         if (annotationId
5314                 .equals(annAlignment.getAlignmentAnnotation()[i].label))
5315         {
5316           matchedAnnotation = annAlignment.getAlignmentAnnotation()[i];
5317           break;
5318         }
5319       }
5320     }
5321     if (matchedAnnotation == null)
5322     {
5323       System.err.println("Failed to match annotation colour scheme for "
5324               + annotationId);
5325       return null;
5326     }
5327     if (matchedAnnotation.getThreshold() == null)
5328     {
5329       matchedAnnotation.setThreshold(
5330               new GraphLine(safeFloat(viewAnnColour.getThreshold()),
5331                       "Threshold", Color.black));
5332     }
5333
5334     AnnotationColourGradient cs = null;
5335     if (viewAnnColour.getColourScheme().equals("None"))
5336     {
5337       cs = new AnnotationColourGradient(matchedAnnotation,
5338               new Color(safeInt(viewAnnColour.getMinColour())),
5339               new Color(safeInt(viewAnnColour.getMaxColour())),
5340               safeInt(viewAnnColour.getAboveThreshold()));
5341     }
5342     else if (viewAnnColour.getColourScheme().startsWith("ucs"))
5343     {
5344       cs = new AnnotationColourGradient(matchedAnnotation,
5345               getUserColourScheme(model, viewAnnColour.getColourScheme()),
5346               safeInt(viewAnnColour.getAboveThreshold()));
5347     }
5348     else
5349     {
5350       cs = new AnnotationColourGradient(matchedAnnotation,
5351               ColourSchemeProperty.getColourScheme(af.getViewport(), al,
5352                       viewAnnColour.getColourScheme()),
5353               safeInt(viewAnnColour.getAboveThreshold()));
5354     }
5355
5356     boolean perSequenceOnly = safeBoolean(viewAnnColour.isPerSequence());
5357     boolean useOriginalColours = safeBoolean(
5358             viewAnnColour.isPredefinedColours());
5359     cs.setSeqAssociated(perSequenceOnly);
5360     cs.setPredefinedColours(useOriginalColours);
5361
5362     if (propagateAnnColour && al.getGroups() != null)
5363     {
5364       // Also use these settings for all the groups
5365       for (int g = 0; g < al.getGroups().size(); g++)
5366       {
5367         SequenceGroup sg = al.getGroups().get(g);
5368         if (sg.getGroupColourScheme() == null)
5369         {
5370           continue;
5371         }
5372
5373         AnnotationColourGradient groupScheme = new AnnotationColourGradient(
5374                 matchedAnnotation, sg.getColourScheme(),
5375                 safeInt(viewAnnColour.getAboveThreshold()));
5376         sg.setColourScheme(groupScheme);
5377         groupScheme.setSeqAssociated(perSequenceOnly);
5378         groupScheme.setPredefinedColours(useOriginalColours);
5379       }
5380     }
5381     return cs;
5382   }
5383
5384   private void reorderAutoannotation(AlignFrame af, AlignmentI al,
5385           List<JvAnnotRow> autoAlan)
5386   {
5387     // copy over visualization settings for autocalculated annotation in the
5388     // view
5389     if (al.getAlignmentAnnotation() != null)
5390     {
5391       /**
5392        * Kludge for magic autoannotation names (see JAL-811)
5393        */
5394       String[] magicNames = new String[] { "Consensus", "Quality",
5395           "Conservation" };
5396       JvAnnotRow nullAnnot = new JvAnnotRow(-1, null);
5397       Hashtable<String, JvAnnotRow> visan = new Hashtable<>();
5398       for (String nm : magicNames)
5399       {
5400         visan.put(nm, nullAnnot);
5401       }
5402       for (JvAnnotRow auan : autoAlan)
5403       {
5404         visan.put(auan.template.label
5405                 + (auan.template.getCalcId() == null ? ""
5406                         : "\t" + auan.template.getCalcId()),
5407                 auan);
5408       }
5409       int hSize = al.getAlignmentAnnotation().length;
5410       List<JvAnnotRow> reorder = new ArrayList<>();
5411       // work through any autoCalculated annotation already on the view
5412       // removing it if it should be placed in a different location on the
5413       // annotation panel.
5414       List<String> remains = new ArrayList<>(visan.keySet());
5415       for (int h = 0; h < hSize; h++)
5416       {
5417         jalview.datamodel.AlignmentAnnotation jalan = al
5418                 .getAlignmentAnnotation()[h];
5419         if (jalan.autoCalculated)
5420         {
5421           String k;
5422           JvAnnotRow valan = visan.get(k = jalan.label);
5423           if (jalan.getCalcId() != null)
5424           {
5425             valan = visan.get(k = jalan.label + "\t" + jalan.getCalcId());
5426           }
5427
5428           if (valan != null)
5429           {
5430             // delete the auto calculated row from the alignment
5431             al.deleteAnnotation(jalan, false);
5432             remains.remove(k);
5433             hSize--;
5434             h--;
5435             if (valan != nullAnnot)
5436             {
5437               if (jalan != valan.template)
5438               {
5439                 // newly created autoannotation row instance
5440                 // so keep a reference to the visible annotation row
5441                 // and copy over all relevant attributes
5442                 if (valan.template.graphHeight >= 0)
5443
5444                 {
5445                   jalan.graphHeight = valan.template.graphHeight;
5446                 }
5447                 jalan.visible = valan.template.visible;
5448               }
5449               reorder.add(new JvAnnotRow(valan.order, jalan));
5450             }
5451           }
5452         }
5453       }
5454       // Add any (possibly stale) autocalculated rows that were not appended to
5455       // the view during construction
5456       for (String other : remains)
5457       {
5458         JvAnnotRow othera = visan.get(other);
5459         if (othera != nullAnnot && othera.template.getCalcId() != null
5460                 && othera.template.getCalcId().length() > 0)
5461         {
5462           reorder.add(othera);
5463         }
5464       }
5465       // now put the automatic annotation in its correct place
5466       int s = 0, srt[] = new int[reorder.size()];
5467       JvAnnotRow[] rws = new JvAnnotRow[reorder.size()];
5468       for (JvAnnotRow jvar : reorder)
5469       {
5470         rws[s] = jvar;
5471         srt[s++] = jvar.order;
5472       }
5473       reorder.clear();
5474       jalview.util.QuickSort.sort(srt, rws);
5475       // and re-insert the annotation at its correct position
5476       for (JvAnnotRow jvar : rws)
5477       {
5478         al.addAnnotation(jvar.template, jvar.order);
5479       }
5480       af.alignPanel.adjustAnnotationHeight();
5481     }
5482   }
5483
5484   Hashtable skipList = null;
5485
5486   /**
5487    * TODO remove this method
5488    *
5489    * @param view
5490    * @return AlignFrame bound to sequenceSetId from view, if one exists. private
5491    *         AlignFrame getSkippedFrame(Viewport view) { if (skipList==null) {
5492    *         throw new Error("Implementation Error. No skipList defined for this
5493    *         Jalview2XML instance."); } return (AlignFrame)
5494    *         skipList.get(view.getSequenceSetId()); }
5495    */
5496
5497   /**
5498    * Check if the Jalview view contained in object should be skipped or not.
5499    *
5500    * @param object
5501    * @return true if view's sequenceSetId is a key in skipList
5502    */
5503   private boolean skipViewport(JalviewModel object)
5504   {
5505     if (skipList == null)
5506     {
5507       return false;
5508     }
5509     String id = object.getViewport().get(0).getSequenceSetId();
5510     if (skipList.containsKey(id))
5511     {
5512         if (Cache.log != null && Cache.log.isDebugEnabled())
5513         {
5514           Cache.log.debug("Skipping seuqence set id " + id);
5515         }
5516       return true;
5517     }
5518     return false;
5519   }
5520
5521   public void addToSkipList(AlignFrame af)
5522   {
5523     if (skipList == null)
5524     {
5525       skipList = new Hashtable();
5526     }
5527     skipList.put(af.getViewport().getSequenceSetId(), af);
5528   }
5529
5530   public void clearSkipList()
5531   {
5532     if (skipList != null)
5533     {
5534       skipList.clear();
5535       skipList = null;
5536     }
5537   }
5538
5539   private void recoverDatasetFor(SequenceSet vamsasSet, AlignmentI al,
5540           boolean ignoreUnrefed, String uniqueSeqSetId)
5541   {
5542     jalview.datamodel.AlignmentI ds = getDatasetFor(
5543             vamsasSet.getDatasetId());
5544     AlignmentI xtant_ds = ds;
5545     if (xtant_ds == null)
5546     {
5547       // good chance we are about to create a new dataset, but check if we've
5548       // seen some of the dataset sequence IDs before.
5549       // TODO: skip this check if we are working with project generated by
5550       // version 2.11 or later
5551       xtant_ds = checkIfHasDataset(vamsasSet.getSequence());
5552       if (xtant_ds != null)
5553       {
5554         ds = xtant_ds;
5555         addDatasetRef(vamsasSet.getDatasetId(), ds);
5556       }
5557     }
5558     Vector dseqs = null;
5559     if (!ignoreUnrefed)
5560     {
5561       // recovering an alignment View
5562       AlignmentI seqSetDS = getDatasetFor(UNIQSEQSETID + uniqueSeqSetId);
5563       if (seqSetDS != null)
5564       {
5565         if (ds != null && ds != seqSetDS)
5566         {
5567           warn("JAL-3171 regression: Overwriting a dataset reference for an alignment"
5568                   + " - CDS/Protein crossreference data may be lost");
5569           if (xtant_ds != null)
5570           {
5571             // This can only happen if the unique sequence set ID was bound to a
5572             // dataset that did not contain any of the sequences in the view
5573             // currently being restored.
5574             warn("JAL-3171 SERIOUS!  TOTAL CONFUSION - please consider contacting the Jalview Development team so they can investigate why your project caused this message to be displayed.");
5575           }
5576         }
5577         ds = seqSetDS;
5578         addDatasetRef(vamsasSet.getDatasetId(), ds);
5579       }
5580     }
5581     if (ds == null)
5582     {
5583       // try even harder to restore dataset
5584       AlignmentI xtantDS = checkIfHasDataset(vamsasSet.getSequence());
5585       // create a list of new dataset sequences
5586       dseqs = new Vector();
5587     }
5588     for (int i = 0, iSize = vamsasSet.getSequence().size(); i < iSize; i++)
5589     {
5590       Sequence vamsasSeq = vamsasSet.getSequence().get(i);
5591       ensureJalviewDatasetSequence(vamsasSeq, ds, dseqs, ignoreUnrefed, i);
5592     }
5593     // create a new dataset
5594     if (ds == null)
5595     {
5596       SequenceI[] dsseqs = new SequenceI[dseqs.size()];
5597       dseqs.copyInto(dsseqs);
5598       ds = new jalview.datamodel.Alignment(dsseqs);
5599       debug("Created new dataset " + vamsasSet.getDatasetId()
5600               + " for alignment " + System.identityHashCode(al));
5601       addDatasetRef(vamsasSet.getDatasetId(), ds);
5602     }
5603     // set the dataset for the newly imported alignment.
5604     if (al.getDataset() == null && !ignoreUnrefed)
5605     {
5606       al.setDataset(ds);
5607       // register dataset for the alignment's uniqueSeqSetId for legacy projects
5608       addDatasetRef(UNIQSEQSETID + uniqueSeqSetId, ds);
5609     }
5610     updateSeqDatasetBinding(vamsasSet.getSequence(), ds);
5611   }
5612
5613   /**
5614    * XML dataset sequence ID to materialised dataset reference
5615    */
5616   HashMap<String, AlignmentI> seqToDataset = new HashMap<>();
5617
5618   /**
5619    * @return the first materialised dataset reference containing a dataset
5620    *         sequence referenced in the given view
5621    * @param list
5622    *          - sequences from the view
5623    */
5624   AlignmentI checkIfHasDataset(List<Sequence> list)
5625   {
5626     for (Sequence restoredSeq : list)
5627     {
5628       AlignmentI datasetFor = seqToDataset.get(restoredSeq.getDsseqid());
5629       if (datasetFor != null)
5630       {
5631         return datasetFor;
5632       }
5633     }
5634     return null;
5635   }
5636
5637   /**
5638    * Register ds as the containing dataset for the dataset sequences referenced
5639    * by sequences in list
5640    *
5641    * @param list
5642    *          - sequences in a view
5643    * @param ds
5644    */
5645   void updateSeqDatasetBinding(List<Sequence> list, AlignmentI ds)
5646   {
5647     for (Sequence restoredSeq : list)
5648     {
5649       AlignmentI prevDS = seqToDataset.put(restoredSeq.getDsseqid(), ds);
5650       if (prevDS != null && prevDS != ds)
5651       {
5652         warn("Dataset sequence appears in many datasets: "
5653                 + restoredSeq.getDsseqid());
5654         // TODO: try to merge!
5655       }
5656     }
5657   }
5658   /**
5659    *
5660    * @param vamsasSeq
5661    *          sequence definition to create/merge dataset sequence for
5662    * @param ds
5663    *          dataset alignment
5664    * @param dseqs
5665    *          vector to add new dataset sequence to
5666    * @param ignoreUnrefed
5667    *          - when true, don't create new sequences from vamsasSeq if it's id
5668    *          doesn't already have an asssociated Jalview sequence.
5669    * @param vseqpos
5670    *          - used to reorder the sequence in the alignment according to the
5671    *          vamsasSeq array ordering, to preserve ordering of dataset
5672    */
5673   private void ensureJalviewDatasetSequence(Sequence vamsasSeq,
5674           AlignmentI ds, Vector dseqs, boolean ignoreUnrefed, int vseqpos)
5675   {
5676     // JBP TODO: Check this is called for AlCodonFrames to support recovery of
5677     // xRef Codon Maps
5678     SequenceI sq = seqRefIds.get(vamsasSeq.getId());
5679     boolean reorder = false;
5680     SequenceI dsq = null;
5681     if (sq != null && sq.getDatasetSequence() != null)
5682     {
5683       dsq = sq.getDatasetSequence();
5684     }
5685     else
5686     {
5687       reorder = true;
5688     }
5689     if (sq == null && ignoreUnrefed)
5690     {
5691       return;
5692     }
5693     String sqid = vamsasSeq.getDsseqid();
5694     if (dsq == null)
5695     {
5696       // need to create or add a new dataset sequence reference to this sequence
5697       if (sqid != null)
5698       {
5699         dsq = seqRefIds.get(sqid);
5700       }
5701       // check again
5702       if (dsq == null)
5703       {
5704         // make a new dataset sequence
5705         dsq = sq.createDatasetSequence();
5706         if (sqid == null)
5707         {
5708           // make up a new dataset reference for this sequence
5709           sqid = seqHash(dsq);
5710         }
5711         dsq.setVamsasId(uniqueSetSuffix + sqid);
5712         seqRefIds.put(sqid, dsq);
5713         if (ds == null)
5714         {
5715           if (dseqs != null)
5716           {
5717             dseqs.addElement(dsq);
5718           }
5719         }
5720         else
5721         {
5722           ds.addSequence(dsq);
5723         }
5724       }
5725       else
5726       {
5727         if (sq != dsq)
5728         { // make this dataset sequence sq's dataset sequence
5729           sq.setDatasetSequence(dsq);
5730           // and update the current dataset alignment
5731           if (ds == null)
5732           {
5733             if (dseqs != null)
5734             {
5735               if (!dseqs.contains(dsq))
5736               {
5737                 dseqs.add(dsq);
5738               }
5739             }
5740             else
5741             {
5742               if (ds.findIndex(dsq) < 0)
5743               {
5744                 ds.addSequence(dsq);
5745               }
5746             }
5747           }
5748         }
5749       }
5750     }
5751     // TODO: refactor this as a merge dataset sequence function
5752     // now check that sq (the dataset sequence) sequence really is the union of
5753     // all references to it
5754     // boolean pre = sq.getStart() < dsq.getStart();
5755     // boolean post = sq.getEnd() > dsq.getEnd();
5756     // if (pre || post)
5757     if (sq != dsq)
5758     {
5759       // StringBuffer sb = new StringBuffer();
5760       String newres = jalview.analysis.AlignSeq.extractGaps(
5761               jalview.util.Comparison.GapChars, sq.getSequenceAsString());
5762       if (!newres.equalsIgnoreCase(dsq.getSequenceAsString())
5763               && newres.length() > dsq.getLength())
5764       {
5765         // Update with the longer sequence.
5766         synchronized (dsq)
5767         {
5768           /*
5769            * if (pre) { sb.insert(0, newres .substring(0, dsq.getStart() -
5770            * sq.getStart())); dsq.setStart(sq.getStart()); } if (post) {
5771            * sb.append(newres.substring(newres.length() - sq.getEnd() -
5772            * dsq.getEnd())); dsq.setEnd(sq.getEnd()); }
5773            */
5774           dsq.setSequence(newres);
5775         }
5776         // TODO: merges will never happen if we 'know' we have the real dataset
5777         // sequence - this should be detected when id==dssid
5778         System.err.println(
5779                 "DEBUG Notice:  Merged dataset sequence (if you see this often, post at http://issues.jalview.org/browse/JAL-1474)"); // ("
5780         // + (pre ? "prepended" : "") + " "
5781         // + (post ? "appended" : ""));
5782       }
5783     }
5784     else
5785     {
5786       // sequence refs are identical. We may need to update the existing dataset
5787       // alignment with this one, though.
5788       if (ds != null && dseqs == null)
5789       {
5790         int opos = ds.findIndex(dsq);
5791         SequenceI tseq = null;
5792         if (opos != -1 && vseqpos != opos)
5793         {
5794           // remove from old position
5795           ds.deleteSequence(dsq);
5796         }
5797         if (vseqpos < ds.getHeight())
5798         {
5799           if (vseqpos != opos)
5800           {
5801             // save sequence at destination position
5802             tseq = ds.getSequenceAt(vseqpos);
5803             ds.replaceSequenceAt(vseqpos, dsq);
5804             ds.addSequence(tseq);
5805           }
5806         }
5807         else
5808         {
5809           ds.addSequence(dsq);
5810         }
5811       }
5812     }
5813   }
5814
5815   /*
5816    * TODO use AlignmentI here and in related methods - needs
5817    * AlignmentI.getDataset() changed to return AlignmentI instead of Alignment
5818    */
5819   Hashtable<String, AlignmentI> datasetIds = null;
5820
5821   IdentityHashMap<AlignmentI, String> dataset2Ids = null;
5822
5823   private AlignmentI getDatasetFor(String datasetId)
5824   {
5825     if (datasetIds == null)
5826     {
5827       datasetIds = new Hashtable<>();
5828       return null;
5829     }
5830     if (datasetIds.containsKey(datasetId))
5831     {
5832       return datasetIds.get(datasetId);
5833     }
5834     return null;
5835   }
5836
5837   private void addDatasetRef(String datasetId, AlignmentI dataset)
5838   {
5839     if (datasetIds == null)
5840     {
5841       datasetIds = new Hashtable<>();
5842     }
5843     datasetIds.put(datasetId, dataset);
5844   }
5845
5846   /**
5847    * make a new dataset ID for this jalview dataset alignment
5848    *
5849    * @param dataset
5850    * @return
5851    */
5852   private String getDatasetIdRef(AlignmentI dataset)
5853   {
5854     if (dataset.getDataset() != null)
5855     {
5856       warn("Serious issue!  Dataset Object passed to getDatasetIdRef is not a Jalview DATASET alignment...");
5857     }
5858     String datasetId = makeHashCode(dataset, null);
5859     if (datasetId == null)
5860     {
5861       // make a new datasetId and record it
5862       if (dataset2Ids == null)
5863       {
5864         dataset2Ids = new IdentityHashMap<>();
5865       }
5866       else
5867       {
5868         datasetId = dataset2Ids.get(dataset);
5869       }
5870       if (datasetId == null)
5871       {
5872         datasetId = "ds" + dataset2Ids.size() + 1;
5873         dataset2Ids.put(dataset, datasetId);
5874       }
5875     }
5876     return datasetId;
5877   }
5878
5879   private void addDBRefs(SequenceI datasetSequence, Sequence sequence)
5880   {
5881     for (int d = 0; d < sequence.getDBRef().size(); d++)
5882     {
5883       DBRef dr = sequence.getDBRef().get(d);
5884       jalview.datamodel.DBRefEntry entry = new jalview.datamodel.DBRefEntry(
5885               dr.getSource(), dr.getVersion(), dr.getAccessionId());
5886       if (dr.getMapping() != null)
5887       {
5888         entry.setMap(addMapping(dr.getMapping()));
5889       }
5890       datasetSequence.addDBRef(entry);
5891     }
5892   }
5893
5894   private jalview.datamodel.Mapping addMapping(Mapping m)
5895   {
5896     SequenceI dsto = null;
5897     // Mapping m = dr.getMapping();
5898     int fr[] = new int[m.getMapListFrom().size() * 2];
5899     Iterator<MapListFrom> from = m.getMapListFrom().iterator();// enumerateMapListFrom();
5900     for (int _i = 0; from.hasNext(); _i += 2)
5901     {
5902       MapListFrom mf = from.next();
5903       fr[_i] = mf.getStart();
5904       fr[_i + 1] = mf.getEnd();
5905     }
5906     int fto[] = new int[m.getMapListTo().size() * 2];
5907     Iterator<MapListTo> to = m.getMapListTo().iterator();// enumerateMapListTo();
5908     for (int _i = 0; to.hasNext(); _i += 2)
5909     {
5910       MapListTo mf = to.next();
5911       fto[_i] = mf.getStart();
5912       fto[_i + 1] = mf.getEnd();
5913     }
5914     jalview.datamodel.Mapping jmap = new jalview.datamodel.Mapping(dsto, fr,
5915             fto, m.getMapFromUnit().intValue(),
5916             m.getMapToUnit().intValue());
5917
5918     /*
5919      * (optional) choice of dseqFor or Sequence
5920      */
5921     if (m.getDseqFor() != null)
5922     {
5923       String dsfor = m.getDseqFor();
5924       if (seqRefIds.containsKey(dsfor))
5925       {
5926         /*
5927          * recover from hash
5928          */
5929         jmap.setTo(seqRefIds.get(dsfor));
5930       }
5931       else
5932       {
5933         frefedSequence.add(newMappingRef(dsfor, jmap));
5934       }
5935     }
5936     else if (m.getSequence() != null)
5937     {
5938       /*
5939        * local sequence definition
5940        */
5941       Sequence ms = m.getSequence();
5942       SequenceI djs = null;
5943       String sqid = ms.getDsseqid();
5944       if (sqid != null && sqid.length() > 0)
5945       {
5946         /*
5947          * recover dataset sequence
5948          */
5949         djs = seqRefIds.get(sqid);
5950       }
5951       else
5952       {
5953         System.err.println(
5954                 "Warning - making up dataset sequence id for DbRef sequence map reference");
5955         sqid = ((Object) ms).toString(); // make up a new hascode for
5956         // undefined dataset sequence hash
5957         // (unlikely to happen)
5958       }
5959
5960       if (djs == null)
5961       {
5962         /**
5963          * make a new dataset sequence and add it to refIds hash
5964          */
5965         djs = new jalview.datamodel.Sequence(ms.getName(),
5966                 ms.getSequence());
5967         djs.setStart(jmap.getMap().getToLowest());
5968         djs.setEnd(jmap.getMap().getToHighest());
5969         djs.setVamsasId(uniqueSetSuffix + sqid);
5970         jmap.setTo(djs);
5971         incompleteSeqs.put(sqid, djs);
5972         seqRefIds.put(sqid, djs);
5973       }
5974       jalview.bin.Cache.log.debug("about to recurse on addDBRefs.");
5975       addDBRefs(djs, ms);
5976
5977     }
5978
5979     return jmap;
5980   }
5981
5982   /**
5983    * Provides a 'copy' of an alignment view (on action New View) by 'saving' the
5984    * view as XML (but not to file), and then reloading it
5985    *
5986    * @param ap
5987    * @return
5988    */
5989   public AlignmentPanel copyAlignPanel(AlignmentPanel ap)
5990   {
5991     initSeqRefs();
5992     JalviewModel jm = saveState(ap, null, null, null);
5993
5994     addDatasetRef(
5995             jm.getVamsasModel().getSequenceSet().get(0).getDatasetId(),
5996             ap.getAlignment().getDataset());
5997
5998     uniqueSetSuffix = "";
5999     // jm.getJalviewModelSequence().getViewport(0).setId(null);
6000     jm.getViewport().get(0).setId(null);
6001     // we don't overwrite the view we just copied
6002
6003     if (this.frefedSequence == null)
6004     {
6005       frefedSequence = new Vector<>();
6006     }
6007
6008     viewportsAdded.clear();
6009
6010     AlignFrame af = loadFromObject(jm, null, false, null);
6011     af.getAlignPanels().clear();
6012     af.closeMenuItem_actionPerformed(true);
6013
6014     /*
6015      * if(ap.av.getAlignment().getAlignmentAnnotation()!=null) { for(int i=0;
6016      * i<ap.av.getAlignment().getAlignmentAnnotation().length; i++) {
6017      * if(!ap.av.getAlignment().getAlignmentAnnotation()[i].autoCalculated) {
6018      * af.alignPanel.av.getAlignment().getAlignmentAnnotation()[i] =
6019      * ap.av.getAlignment().getAlignmentAnnotation()[i]; } } }
6020      */
6021
6022     return af.alignPanel;
6023   }
6024
6025   private Hashtable jvids2vobj;
6026
6027   private void warn(String msg)
6028   {
6029     warn(msg, null);
6030   }
6031
6032   private void warn(String msg, Exception e)
6033   {
6034     if (Cache.log != null)
6035     {
6036       if (e != null)
6037       {
6038         Cache.log.warn(msg, e);
6039       }
6040       else
6041       {
6042         Cache.log.warn(msg);
6043       }
6044     }
6045     else
6046     {
6047       System.err.println("Warning: " + msg);
6048       if (e != null)
6049       {
6050         e.printStackTrace();
6051       }
6052     }
6053   }
6054
6055   private void debug(String string)
6056   {
6057     debug(string, null);
6058   }
6059
6060   private void debug(String msg, Exception e)
6061   {
6062     if (Cache.log != null)
6063     {
6064       if (e != null)
6065       {
6066         Cache.log.debug(msg, e);
6067       }
6068       else
6069       {
6070         Cache.log.debug(msg);
6071       }
6072     }
6073     else
6074     {
6075       System.err.println("Warning: " + msg);
6076       if (e != null)
6077       {
6078         e.printStackTrace();
6079       }
6080     }
6081   }
6082
6083   /**
6084    * set the object to ID mapping tables used to write/recover objects and XML
6085    * ID strings for the jalview project. If external tables are provided then
6086    * finalize and clearSeqRefs will not clear the tables when the Jalview2XML
6087    * object goes out of scope. - also populates the datasetIds hashtable with
6088    * alignment objects containing dataset sequences
6089    *
6090    * @param vobj2jv
6091    *          Map from ID strings to jalview datamodel
6092    * @param jv2vobj
6093    *          Map from jalview datamodel to ID strings
6094    *
6095    *
6096    */
6097   public void setObjectMappingTables(Hashtable vobj2jv,
6098           IdentityHashMap jv2vobj)
6099   {
6100     this.jv2vobj = jv2vobj;
6101     this.vobj2jv = vobj2jv;
6102     Iterator ds = jv2vobj.keySet().iterator();
6103     String id;
6104     while (ds.hasNext())
6105     {
6106       Object jvobj = ds.next();
6107       id = jv2vobj.get(jvobj).toString();
6108       if (jvobj instanceof jalview.datamodel.Alignment)
6109       {
6110         if (((jalview.datamodel.Alignment) jvobj).getDataset() == null)
6111         {
6112           addDatasetRef(id, (jalview.datamodel.Alignment) jvobj);
6113         }
6114       }
6115       else if (jvobj instanceof jalview.datamodel.Sequence)
6116       {
6117         // register sequence object so the XML parser can recover it.
6118         if (seqRefIds == null)
6119         {
6120           seqRefIds = new HashMap<>();
6121         }
6122         if (seqsToIds == null)
6123         {
6124           seqsToIds = new IdentityHashMap<>();
6125         }
6126         seqRefIds.put(jv2vobj.get(jvobj).toString(), (SequenceI) jvobj);
6127         seqsToIds.put((SequenceI) jvobj, id);
6128       }
6129       else if (jvobj instanceof jalview.datamodel.AlignmentAnnotation)
6130       {
6131         String anid;
6132         AlignmentAnnotation jvann = (AlignmentAnnotation) jvobj;
6133         annotationIds.put(anid = jv2vobj.get(jvobj).toString(), jvann);
6134         if (jvann.annotationId == null)
6135         {
6136           jvann.annotationId = anid;
6137         }
6138         if (!jvann.annotationId.equals(anid))
6139         {
6140           // TODO verify that this is the correct behaviour
6141           this.warn("Overriding Annotation ID for " + anid
6142                   + " from different id : " + jvann.annotationId);
6143           jvann.annotationId = anid;
6144         }
6145       }
6146       else if (jvobj instanceof String)
6147       {
6148         if (jvids2vobj == null)
6149         {
6150           jvids2vobj = new Hashtable();
6151           jvids2vobj.put(jvobj, jv2vobj.get(jvobj).toString());
6152         }
6153       }
6154       else
6155       {
6156           Cache.log.debug("Ignoring " + jvobj.getClass() + " (ID = " + id);
6157       }
6158     }
6159   }
6160
6161   /**
6162    * set the uniqueSetSuffix used to prefix/suffix object IDs for jalview
6163    * objects created from the project archive. If string is null (default for
6164    * construction) then suffix will be set automatically.
6165    *
6166    * @param string
6167    */
6168   public void setUniqueSetSuffix(String string)
6169   {
6170     uniqueSetSuffix = string;
6171
6172   }
6173
6174   /**
6175    * uses skipList2 as the skipList for skipping views on sequence sets
6176    * associated with keys in the skipList
6177    *
6178    * @param skipList2
6179    */
6180   public void setSkipList(Hashtable skipList2)
6181   {
6182     skipList = skipList2;
6183   }
6184
6185   /**
6186    * Reads the jar entry of given name and returns its contents, or null if the
6187    * entry is not found.
6188    *
6189    * @param jprovider
6190    * @param jarEntryName
6191    * @return
6192    */
6193   protected String readJarEntry(jarInputStreamProvider jprovider,
6194           String jarEntryName)
6195   {
6196     String result = null;
6197     BufferedReader in = null;
6198
6199     try
6200     {
6201       /*
6202        * Reopen the jar input stream and traverse its entries to find a matching
6203        * name
6204        */
6205       JarInputStream jin = jprovider.getJarInputStream();
6206       JarEntry entry = null;
6207       do
6208       {
6209         entry = jin.getNextJarEntry();
6210       } while (entry != null && !entry.getName().equals(jarEntryName));
6211
6212       if (entry != null)
6213       {
6214         StringBuilder out = new StringBuilder(256);
6215         in = new BufferedReader(new InputStreamReader(jin, UTF_8));
6216         String data;
6217
6218         while ((data = in.readLine()) != null)
6219         {
6220           out.append(data);
6221         }
6222         result = out.toString();
6223       }
6224       else
6225       {
6226         warn("Couldn't find entry in Jalview Jar for " + jarEntryName);
6227       }
6228     } catch (Exception ex)
6229     {
6230       ex.printStackTrace();
6231     } finally
6232     {
6233       if (in != null)
6234       {
6235         try
6236         {
6237           in.close();
6238         } catch (IOException e)
6239         {
6240           // ignore
6241         }
6242       }
6243     }
6244
6245     return result;
6246   }
6247
6248   /**
6249    * Returns an incrementing counter (0, 1, 2...)
6250    *
6251    * @return
6252    */
6253   private synchronized int nextCounter()
6254   {
6255     return counter++;
6256   }
6257
6258   /**
6259    * Loads any saved PCA viewers
6260    *
6261    * @param jms
6262    * @param ap
6263    */
6264   protected void loadPCAViewers(JalviewModel model, AlignmentPanel ap)
6265   {
6266     try
6267     {
6268       List<PcaViewer> pcaviewers = model.getPcaViewer();
6269       for (PcaViewer viewer : pcaviewers)
6270       {
6271         String modelName = viewer.getScoreModelName();
6272         SimilarityParamsI params = new SimilarityParams(
6273                 viewer.isIncludeGappedColumns(), viewer.isMatchGaps(),
6274                 viewer.isIncludeGaps(),
6275                 viewer.isDenominateByShortestLength());
6276
6277         /*
6278          * create the panel (without computing the PCA)
6279          */
6280         PCAPanel panel = new PCAPanel(ap, modelName, params);
6281
6282         panel.setTitle(viewer.getTitle());
6283         panel.setBounds(new Rectangle(viewer.getXpos(), viewer.getYpos(),
6284                 viewer.getWidth(), viewer.getHeight()));
6285
6286         boolean showLabels = viewer.isShowLabels();
6287         panel.setShowLabels(showLabels);
6288         panel.getRotatableCanvas().setShowLabels(showLabels);
6289         panel.getRotatableCanvas()
6290                 .setBgColour(new Color(viewer.getBgColour()));
6291         panel.getRotatableCanvas()
6292                 .setApplyToAllViews(viewer.isLinkToAllViews());
6293
6294         /*
6295          * load PCA output data
6296          */
6297         ScoreModelI scoreModel = ScoreModels.getInstance()
6298                 .getScoreModel(modelName, ap);
6299         PCA pca = new PCA(null, scoreModel, params);
6300         PcaDataType pcaData = viewer.getPcaData();
6301
6302         MatrixI pairwise = loadDoubleMatrix(pcaData.getPairwiseMatrix());
6303         pca.setPairwiseScores(pairwise);
6304
6305         MatrixI triDiag = loadDoubleMatrix(pcaData.getTridiagonalMatrix());
6306         pca.setTridiagonal(triDiag);
6307
6308         MatrixI result = loadDoubleMatrix(pcaData.getEigenMatrix());
6309         pca.setEigenmatrix(result);
6310
6311         panel.getPcaModel().setPCA(pca);
6312
6313         /*
6314          * we haven't saved the input data! (JAL-2647 to do)
6315          */
6316         panel.setInputData(null);
6317
6318         /*
6319          * add the sequence points for the PCA display
6320          */
6321         List<jalview.datamodel.SequencePoint> seqPoints = new ArrayList<>();
6322         for (SequencePoint sp : viewer.getSequencePoint())
6323         {
6324           String seqId = sp.getSequenceRef();
6325           SequenceI seq = seqRefIds.get(seqId);
6326           if (seq == null)
6327           {
6328             throw new IllegalStateException(
6329                     "Unmatched seqref for PCA: " + seqId);
6330           }
6331           Point pt = new Point(sp.getXPos(), sp.getYPos(), sp.getZPos());
6332           jalview.datamodel.SequencePoint seqPoint = new jalview.datamodel.SequencePoint(
6333                   seq, pt);
6334           seqPoints.add(seqPoint);
6335         }
6336         panel.getRotatableCanvas().setPoints(seqPoints, seqPoints.size());
6337
6338         /*
6339          * set min-max ranges and scale after setPoints (which recomputes them)
6340          */
6341         panel.getRotatableCanvas().setScaleFactor(viewer.getScaleFactor());
6342         SeqPointMin spMin = viewer.getSeqPointMin();
6343         float[] min = new float[] { spMin.getXPos(), spMin.getYPos(),
6344             spMin.getZPos() };
6345         SeqPointMax spMax = viewer.getSeqPointMax();
6346         float[] max = new float[] { spMax.getXPos(), spMax.getYPos(),
6347             spMax.getZPos() };
6348         panel.getRotatableCanvas().setSeqMinMax(min, max);
6349
6350         // todo: hold points list in PCAModel only
6351         panel.getPcaModel().setSequencePoints(seqPoints);
6352
6353         panel.setSelectedDimensionIndex(viewer.getXDim(), X);
6354         panel.setSelectedDimensionIndex(viewer.getYDim(), Y);
6355         panel.setSelectedDimensionIndex(viewer.getZDim(), Z);
6356
6357         // is this duplication needed?
6358         panel.setTop(seqPoints.size() - 1);
6359         panel.getPcaModel().setTop(seqPoints.size() - 1);
6360
6361         /*
6362          * add the axes' end points for the display
6363          */
6364         for (int i = 0; i < 3; i++)
6365         {
6366           Axis axis = viewer.getAxis().get(i);
6367           panel.getRotatableCanvas().getAxisEndPoints()[i] = new Point(
6368                   axis.getXPos(), axis.getYPos(), axis.getZPos());
6369         }
6370
6371         Desktop.addInternalFrame(panel, MessageManager.formatMessage(
6372                 "label.calc_title", "PCA", modelName), 475, 450);
6373       }
6374     } catch (Exception ex)
6375     {
6376       Cache.log.error("Error loading PCA: " + ex.toString());
6377     }
6378   }
6379
6380   /**
6381    * Populates an XML model of the feature colour scheme for one feature type
6382    *
6383    * @param featureType
6384    * @param fcol
6385    * @return
6386    */
6387   public static Colour marshalColour(
6388           String featureType, FeatureColourI fcol)
6389   {
6390     Colour col = new Colour();
6391     if (fcol.isSimpleColour())
6392     {
6393       col.setRGB(Format.getHexString(fcol.getColour()));
6394     }
6395     else
6396     {
6397       col.setRGB(Format.getHexString(fcol.getMaxColour()));
6398       col.setMin(fcol.getMin());
6399       col.setMax(fcol.getMax());
6400       col.setMinRGB(jalview.util.Format.getHexString(fcol.getMinColour()));
6401       col.setAutoScale(fcol.isAutoScaled());
6402       col.setThreshold(fcol.getThreshold());
6403       col.setColourByLabel(fcol.isColourByLabel());
6404       col.setThreshType(fcol.isAboveThreshold() ? ThresholdType.ABOVE
6405               : (fcol.isBelowThreshold() ? ThresholdType.BELOW
6406                       : ThresholdType.NONE));
6407       if (fcol.isColourByAttribute())
6408       {
6409         final String[] attName = fcol.getAttributeName();
6410         col.getAttributeName().add(attName[0]);
6411         if (attName.length > 1)
6412         {
6413           col.getAttributeName().add(attName[1]);
6414         }
6415       }
6416       Color noColour = fcol.getNoColour();
6417       if (noColour == null)
6418       {
6419         col.setNoValueColour(NoValueColour.NONE);
6420       }
6421       else if (noColour == fcol.getMaxColour())
6422       {
6423         col.setNoValueColour(NoValueColour.MAX);
6424       }
6425       else
6426       {
6427         col.setNoValueColour(NoValueColour.MIN);
6428       }
6429     }
6430     col.setName(featureType);
6431     return col;
6432   }
6433
6434   /**
6435    * Populates an XML model of the feature filter(s) for one feature type
6436    *
6437    * @param firstMatcher
6438    *          the first (or only) match condition)
6439    * @param filter
6440    *          remaining match conditions (if any)
6441    * @param and
6442    *          if true, conditions are and-ed, else or-ed
6443    */
6444   public static jalview.xml.binding.jalview.FeatureMatcherSet marshalFilter(
6445           FeatureMatcherI firstMatcher, Iterator<FeatureMatcherI> filters,
6446           boolean and)
6447   {
6448     jalview.xml.binding.jalview.FeatureMatcherSet result = new jalview.xml.binding.jalview.FeatureMatcherSet();
6449
6450     if (filters.hasNext())
6451     {
6452       /*
6453        * compound matcher
6454        */
6455       CompoundMatcher compound = new CompoundMatcher();
6456       compound.setAnd(and);
6457       jalview.xml.binding.jalview.FeatureMatcherSet matcher1 = marshalFilter(
6458               firstMatcher, Collections.emptyIterator(), and);
6459       // compound.addMatcherSet(matcher1);
6460       compound.getMatcherSet().add(matcher1);
6461       FeatureMatcherI nextMatcher = filters.next();
6462       jalview.xml.binding.jalview.FeatureMatcherSet matcher2 = marshalFilter(
6463               nextMatcher, filters, and);
6464       // compound.addMatcherSet(matcher2);
6465       compound.getMatcherSet().add(matcher2);
6466       result.setCompoundMatcher(compound);
6467     }
6468     else
6469     {
6470       /*
6471        * single condition matcher
6472        */
6473       // MatchCondition matcherModel = new MatchCondition();
6474       jalview.xml.binding.jalview.FeatureMatcher matcherModel = new jalview.xml.binding.jalview.FeatureMatcher();
6475       matcherModel.setCondition(
6476               firstMatcher.getMatcher().getCondition().getStableName());
6477       matcherModel.setValue(firstMatcher.getMatcher().getPattern());
6478       if (firstMatcher.isByAttribute())
6479       {
6480         matcherModel.setBy(FilterBy.BY_ATTRIBUTE);
6481         // matcherModel.setAttributeName(firstMatcher.getAttribute());
6482         String[] attName = firstMatcher.getAttribute();
6483         matcherModel.getAttributeName().add(attName[0]); // attribute
6484         if (attName.length > 1)
6485         {
6486           matcherModel.getAttributeName().add(attName[1]); // sub-attribute
6487         }
6488       }
6489       else if (firstMatcher.isByLabel())
6490       {
6491         matcherModel.setBy(FilterBy.BY_LABEL);
6492       }
6493       else if (firstMatcher.isByScore())
6494       {
6495         matcherModel.setBy(FilterBy.BY_SCORE);
6496       }
6497       result.setMatchCondition(matcherModel);
6498     }
6499
6500     return result;
6501   }
6502
6503   /**
6504    * Loads one XML model of a feature filter to a Jalview object
6505    *
6506    * @param featureType
6507    * @param matcherSetModel
6508    * @return
6509    */
6510   public static FeatureMatcherSetI parseFilter(
6511           String featureType,
6512           jalview.xml.binding.jalview.FeatureMatcherSet matcherSetModel)
6513   {
6514     FeatureMatcherSetI result = new FeatureMatcherSet();
6515     try
6516     {
6517       parseFilterConditions(result, matcherSetModel, true);
6518     } catch (IllegalStateException e)
6519     {
6520       // mixing AND and OR conditions perhaps
6521       System.err.println(
6522               String.format("Error reading filter conditions for '%s': %s",
6523                       featureType, e.getMessage()));
6524       // return as much as was parsed up to the error
6525     }
6526
6527     return result;
6528   }
6529
6530   /**
6531    * Adds feature match conditions to matcherSet as unmarshalled from XML
6532    * (possibly recursively for compound conditions)
6533    *
6534    * @param matcherSet
6535    * @param matcherSetModel
6536    * @param and
6537    *          if true, multiple conditions are AND-ed, else they are OR-ed
6538    * @throws IllegalStateException
6539    *           if AND and OR conditions are mixed
6540    */
6541   protected static void parseFilterConditions(
6542           FeatureMatcherSetI matcherSet,
6543           jalview.xml.binding.jalview.FeatureMatcherSet matcherSetModel,
6544           boolean and)
6545   {
6546     jalview.xml.binding.jalview.FeatureMatcher mc = matcherSetModel
6547             .getMatchCondition();
6548     if (mc != null)
6549     {
6550       /*
6551        * single condition
6552        */
6553       FilterBy filterBy = mc.getBy();
6554       Condition cond = Condition.fromString(mc.getCondition());
6555       String pattern = mc.getValue();
6556       FeatureMatcherI matchCondition = null;
6557       if (filterBy == FilterBy.BY_LABEL)
6558       {
6559         matchCondition = FeatureMatcher.byLabel(cond, pattern);
6560       }
6561       else if (filterBy == FilterBy.BY_SCORE)
6562       {
6563         matchCondition = FeatureMatcher.byScore(cond, pattern);
6564
6565       }
6566       else if (filterBy == FilterBy.BY_ATTRIBUTE)
6567       {
6568         final List<String> attributeName = mc.getAttributeName();
6569         String[] attNames = attributeName
6570                 .toArray(new String[attributeName.size()]);
6571         matchCondition = FeatureMatcher.byAttribute(cond, pattern,
6572                 attNames);
6573       }
6574
6575       /*
6576        * note this throws IllegalStateException if AND-ing to a
6577        * previously OR-ed compound condition, or vice versa
6578        */
6579       if (and)
6580       {
6581         matcherSet.and(matchCondition);
6582       }
6583       else
6584       {
6585         matcherSet.or(matchCondition);
6586       }
6587     }
6588     else
6589     {
6590       /*
6591        * compound condition
6592        */
6593       List<jalview.xml.binding.jalview.FeatureMatcherSet> matchers = matcherSetModel
6594               .getCompoundMatcher().getMatcherSet();
6595       boolean anded = matcherSetModel.getCompoundMatcher().isAnd();
6596       if (matchers.size() == 2)
6597       {
6598         parseFilterConditions(matcherSet, matchers.get(0), anded);
6599         parseFilterConditions(matcherSet, matchers.get(1), anded);
6600       }
6601       else
6602       {
6603         System.err.println("Malformed compound filter condition");
6604       }
6605     }
6606   }
6607
6608   /**
6609    * Loads one XML model of a feature colour to a Jalview object
6610    *
6611    * @param colourModel
6612    * @return
6613    */
6614   public static FeatureColourI parseColour(Colour colourModel)
6615   {
6616     FeatureColourI colour = null;
6617
6618     if (colourModel.getMax() != null)
6619     {
6620       Color mincol = null;
6621       Color maxcol = null;
6622       Color noValueColour = null;
6623
6624       try
6625       {
6626         mincol = new Color(Integer.parseInt(colourModel.getMinRGB(), 16));
6627         maxcol = new Color(Integer.parseInt(colourModel.getRGB(), 16));
6628       } catch (Exception e)
6629       {
6630           Cache.log.warn("Couldn't parse out graduated feature color.", e);
6631       }
6632
6633       NoValueColour noCol = colourModel.getNoValueColour();
6634       if (noCol == NoValueColour.MIN)
6635       {
6636         noValueColour = mincol;
6637       }
6638       else if (noCol == NoValueColour.MAX)
6639       {
6640         noValueColour = maxcol;
6641       }
6642
6643       colour = new FeatureColour(maxcol, mincol, maxcol, noValueColour,
6644               safeFloat(colourModel.getMin()),
6645               safeFloat(colourModel.getMax()));
6646       final List<String> attributeName = colourModel.getAttributeName();
6647       String[] attributes = attributeName
6648               .toArray(new String[attributeName.size()]);
6649       if (attributes != null && attributes.length > 0)
6650       {
6651         colour.setAttributeName(attributes);
6652       }
6653       if (colourModel.isAutoScale() != null)
6654       {
6655         colour.setAutoScaled(colourModel.isAutoScale().booleanValue());
6656       }
6657       if (colourModel.isColourByLabel() != null)
6658       {
6659         colour.setColourByLabel(
6660                 colourModel.isColourByLabel().booleanValue());
6661       }
6662       if (colourModel.getThreshold() != null)
6663       {
6664         colour.setThreshold(colourModel.getThreshold().floatValue());
6665       }
6666       ThresholdType ttyp = colourModel.getThreshType();
6667       if (ttyp == ThresholdType.ABOVE)
6668       {
6669         colour.setAboveThreshold(true);
6670       }
6671       else if (ttyp == ThresholdType.BELOW)
6672       {
6673         colour.setBelowThreshold(true);
6674       }
6675     }
6676     else
6677     {
6678       Color color = new Color(Integer.parseInt(colourModel.getRGB(), 16));
6679       colour = new FeatureColour(color);
6680     }
6681
6682     return colour;
6683   }
6684 }