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