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.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.getStructureSelectionManager().registerPDBEntry(entry);
3577             // adds PDBEntry to datasequence's set (since Jalview 2.10)
3578             if (al.getSequenceAt(i).getDatasetSequence() != null)
3579             {
3580               al.getSequenceAt(i).getDatasetSequence().addPDBId(entry);
3581             }
3582             else
3583             {
3584               al.getSequenceAt(i).addPDBId(entry);
3585             }
3586           }
3587         }
3588       }
3589     } // end !multipleview
3590
3591     // ///////////////////////////////
3592     // LOAD SEQUENCE MAPPINGS
3593
3594     if (vamsasSet.getAlcodonFrame().size() > 0)
3595     {
3596       // TODO Potentially this should only be done once for all views of an
3597       // alignment
3598       List<AlcodonFrame> alc = vamsasSet.getAlcodonFrame();
3599       for (int i = 0; i < alc.size(); i++)
3600       {
3601         AlignedCodonFrame cf = new AlignedCodonFrame();
3602         if (alc.get(i).getAlcodMap().size() > 0)
3603         {
3604           List<AlcodMap> maps = alc.get(i).getAlcodMap();
3605           for (int m = 0; m < maps.size(); m++)
3606           {
3607             AlcodMap map = maps.get(m);
3608             SequenceI dnaseq = seqRefIds.get(map.getDnasq());
3609             // Load Mapping
3610             jalview.datamodel.Mapping mapping = null;
3611             // attach to dna sequence reference.
3612             if (map.getMapping() != null)
3613             {
3614               mapping = addMapping(map.getMapping());
3615               if (dnaseq != null && mapping.getTo() != null)
3616               {
3617                 cf.addMap(dnaseq, mapping.getTo(), mapping.getMap());
3618               }
3619               else
3620               {
3621                 // defer to later
3622                 frefedSequence.add(
3623                         newAlcodMapRef(map.getDnasq(), cf, mapping));
3624               }
3625             }
3626           }
3627           al.addCodonFrame(cf);
3628         }
3629       }
3630     }
3631
3632     // ////////////////////////////////
3633     // LOAD ANNOTATIONS
3634     List<JvAnnotRow> autoAlan = new ArrayList<>();
3635
3636     /*
3637      * store any annotations which forward reference a group's ID
3638      */
3639     Map<String, List<AlignmentAnnotation>> groupAnnotRefs = new Hashtable<>();
3640
3641     if (vamsasSet.getAnnotation().size()/*Count()*/ > 0)
3642     {
3643       List<Annotation> an = vamsasSet.getAnnotation();
3644
3645       for (int i = 0; i < an.size(); i++)
3646       {
3647         Annotation annotation = an.get(i);
3648
3649         /**
3650          * test if annotation is automatically calculated for this view only
3651          */
3652         boolean autoForView = false;
3653         if (annotation.getLabel().equals("Quality")
3654                 || annotation.getLabel().equals("Conservation")
3655                 || annotation.getLabel().equals("Consensus"))
3656         {
3657           // Kludge for pre 2.5 projects which lacked the autocalculated flag
3658           autoForView = true;
3659           // JAXB has no has() test; schema defaults value to false
3660           // if (!annotation.hasAutoCalculated())
3661           // {
3662           // annotation.setAutoCalculated(true);
3663           // }
3664         }
3665         if (autoForView || annotation.isAutoCalculated())
3666         {
3667           // remove ID - we don't recover annotation from other views for
3668           // view-specific annotation
3669           annotation.setId(null);
3670         }
3671
3672         // set visibility for other annotation in this view
3673         String annotationId = annotation.getId();
3674         if (annotationId != null && annotationIds.containsKey(annotationId))
3675         {
3676           AlignmentAnnotation jda = annotationIds.get(annotationId);
3677           // in principle Visible should always be true for annotation displayed
3678           // in multiple views
3679           if (annotation.isVisible() != null)
3680           {
3681             jda.visible = annotation.isVisible();
3682           }
3683
3684           al.addAnnotation(jda);
3685
3686           continue;
3687         }
3688         // Construct new annotation from model.
3689         List<AnnotationElement> ae = annotation.getAnnotationElement();
3690         jalview.datamodel.Annotation[] anot = null;
3691         java.awt.Color firstColour = null;
3692         int anpos;
3693         if (!annotation.isScoreOnly())
3694         {
3695           anot = new jalview.datamodel.Annotation[al.getWidth()];
3696           for (int aa = 0; aa < ae.size() && aa < anot.length; aa++)
3697           {
3698             AnnotationElement annElement = ae.get(aa);
3699             anpos = annElement.getPosition();
3700
3701             if (anpos >= anot.length)
3702             {
3703               continue;
3704             }
3705
3706             float value = safeFloat(annElement.getValue());
3707             anot[anpos] = new jalview.datamodel.Annotation(
3708                     annElement.getDisplayCharacter(),
3709                     annElement.getDescription(),
3710                     (annElement.getSecondaryStructure() == null
3711                             || annElement.getSecondaryStructure()
3712                                     .length() == 0)
3713                                             ? ' '
3714                                             : annElement
3715                                                     .getSecondaryStructure()
3716                                                     .charAt(0),
3717                     value);
3718             anot[anpos].colour = new Color(safeInt(annElement.getColour()));
3719             if (firstColour == null)
3720             {
3721               firstColour = anot[anpos].colour;
3722             }
3723           }
3724         }
3725         jalview.datamodel.AlignmentAnnotation jaa = null;
3726
3727         if (annotation.isGraph())
3728         {
3729           float llim = 0, hlim = 0;
3730           // if (autoForView || an[i].isAutoCalculated()) {
3731           // hlim=11f;
3732           // }
3733           jaa = new jalview.datamodel.AlignmentAnnotation(
3734                   annotation.getLabel(), annotation.getDescription(), anot,
3735                   llim, hlim, safeInt(annotation.getGraphType()));
3736
3737           jaa.graphGroup = safeInt(annotation.getGraphGroup());
3738           jaa._linecolour = firstColour;
3739           if (annotation.getThresholdLine() != null)
3740           {
3741             jaa.setThreshold(new jalview.datamodel.GraphLine(
3742                     safeFloat(annotation.getThresholdLine().getValue()),
3743                     annotation.getThresholdLine().getLabel(),
3744                     new java.awt.Color(safeInt(
3745                             annotation.getThresholdLine().getColour()))));
3746           }
3747           if (autoForView || annotation.isAutoCalculated())
3748           {
3749             // Hardwire the symbol display line to ensure that labels for
3750             // histograms are displayed
3751             jaa.hasText = true;
3752           }
3753         }
3754         else
3755         {
3756           jaa = new jalview.datamodel.AlignmentAnnotation(
3757                   annotation.getLabel(), annotation.getDescription(), anot);
3758           jaa._linecolour = firstColour;
3759         }
3760         // register new annotation
3761         if (annotation.getId() != null)
3762         {
3763           annotationIds.put(annotation.getId(), jaa);
3764           jaa.annotationId = annotation.getId();
3765         }
3766         // recover sequence association
3767         String sequenceRef = annotation.getSequenceRef();
3768         if (sequenceRef != null)
3769         {
3770           // from 2.9 sequenceRef is to sequence id (JAL-1781)
3771           SequenceI sequence = seqRefIds.get(sequenceRef);
3772           if (sequence == null)
3773           {
3774             // in pre-2.9 projects sequence ref is to sequence name
3775             sequence = al.findName(sequenceRef);
3776           }
3777           if (sequence != null)
3778           {
3779             jaa.createSequenceMapping(sequence, 1, true);
3780             sequence.addAlignmentAnnotation(jaa);
3781           }
3782         }
3783         // and make a note of any group association
3784         if (annotation.getGroupRef() != null
3785                 && annotation.getGroupRef().length() > 0)
3786         {
3787           List<jalview.datamodel.AlignmentAnnotation> aal = groupAnnotRefs
3788                   .get(annotation.getGroupRef());
3789           if (aal == null)
3790           {
3791             aal = new ArrayList<>();
3792             groupAnnotRefs.put(annotation.getGroupRef(), aal);
3793           }
3794           aal.add(jaa);
3795         }
3796
3797         if (annotation.getScore() != null)
3798         {
3799           jaa.setScore(annotation.getScore().doubleValue());
3800         }
3801         if (annotation.isVisible() != null)
3802         {
3803           jaa.visible = annotation.isVisible().booleanValue();
3804         }
3805
3806         if (annotation.isCentreColLabels() != null)
3807         {
3808           jaa.centreColLabels = annotation.isCentreColLabels()
3809                   .booleanValue();
3810         }
3811
3812         if (annotation.isScaleColLabels() != null)
3813         {
3814           jaa.scaleColLabel = annotation.isScaleColLabels().booleanValue();
3815         }
3816         if (annotation.isAutoCalculated())
3817         {
3818           // newer files have an 'autoCalculated' flag and store calculation
3819           // state in viewport properties
3820           jaa.autoCalculated = true; // means annotation will be marked for
3821           // update at end of load.
3822         }
3823         if (annotation.getGraphHeight() != null)
3824         {
3825           jaa.graphHeight = annotation.getGraphHeight().intValue();
3826         }
3827         jaa.belowAlignment = annotation.isBelowAlignment();
3828         jaa.setCalcId(annotation.getCalcId());
3829         if (annotation.getProperty().size() > 0)
3830         {
3831           for (Annotation.Property prop : annotation
3832                   .getProperty())
3833           {
3834             jaa.setProperty(prop.getName(), prop.getValue());
3835           }
3836         }
3837         if (jaa.autoCalculated)
3838         {
3839           autoAlan.add(new JvAnnotRow(i, jaa));
3840         }
3841         else
3842         // if (!autoForView)
3843         {
3844           // add autocalculated group annotation and any user created annotation
3845           // for the view
3846           al.addAnnotation(jaa);
3847         }
3848       }
3849     }
3850     // ///////////////////////
3851     // LOAD GROUPS
3852     // Create alignment markup and styles for this view
3853     if (jalviewModel.getJGroup().size() > 0)
3854     {
3855       List<JGroup> groups = jalviewModel.getJGroup();
3856       boolean addAnnotSchemeGroup = false;
3857       for (int i = 0; i < groups.size(); i++)
3858       {
3859         JGroup jGroup = groups.get(i);
3860         ColourSchemeI cs = null;
3861         if (jGroup.getColour() != null)
3862         {
3863           if (jGroup.getColour().startsWith("ucs"))
3864           {
3865             cs = getUserColourScheme(jalviewModel, jGroup.getColour());
3866           }
3867           else if (jGroup.getColour().equals("AnnotationColourGradient")
3868                   && jGroup.getAnnotationColours() != null)
3869           {
3870             addAnnotSchemeGroup = true;
3871           }
3872           else
3873           {
3874             cs = ColourSchemeProperty.getColourScheme(null, al,
3875                     jGroup.getColour());
3876           }
3877         }
3878         int pidThreshold = safeInt(jGroup.getPidThreshold());
3879
3880         Vector<SequenceI> seqs = new Vector<>();
3881
3882         for (int s = 0; s < jGroup.getSeq().size(); s++)
3883         {
3884           String seqId = jGroup.getSeq().get(s);
3885           SequenceI ts = seqRefIds.get(seqId);
3886
3887           if (ts != null)
3888           {
3889             seqs.addElement(ts);
3890           }
3891         }
3892
3893         if (seqs.size() < 1)
3894         {
3895           continue;
3896         }
3897
3898         SequenceGroup sg = new SequenceGroup(seqs, jGroup.getName(), cs,
3899                 safeBoolean(jGroup.isDisplayBoxes()),
3900                 safeBoolean(jGroup.isDisplayText()),
3901                 safeBoolean(jGroup.isColourText()),
3902                 safeInt(jGroup.getStart()), safeInt(jGroup.getEnd()));
3903         sg.getGroupColourScheme().setThreshold(pidThreshold, true);
3904         sg.getGroupColourScheme()
3905                 .setConservationInc(safeInt(jGroup.getConsThreshold()));
3906         sg.setOutlineColour(new Color(safeInt(jGroup.getOutlineColour())));
3907
3908         sg.textColour = new Color(safeInt(jGroup.getTextCol1()));
3909         sg.textColour2 = new Color(safeInt(jGroup.getTextCol2()));
3910         sg.setShowNonconserved(safeBoolean(jGroup.isShowUnconserved()));
3911         sg.thresholdTextColour = safeInt(jGroup.getTextColThreshold());
3912         // attributes with a default in the schema are never null
3913           sg.setShowConsensusHistogram(jGroup.isShowConsensusHistogram());
3914           sg.setshowSequenceLogo(jGroup.isShowSequenceLogo());
3915           sg.setNormaliseSequenceLogo(jGroup.isNormaliseSequenceLogo());
3916         sg.setIgnoreGapsConsensus(jGroup.isIgnoreGapsinConsensus());
3917         if (jGroup.getConsThreshold() != null
3918                 && jGroup.getConsThreshold().intValue() != 0)
3919         {
3920           Conservation c = new Conservation("All", sg.getSequences(null), 0,
3921                   sg.getWidth() - 1);
3922           c.calculate();
3923           c.verdict(false, 25);
3924           sg.cs.setConservation(c);
3925         }
3926
3927         if (jGroup.getId() != null && groupAnnotRefs.size() > 0)
3928         {
3929           // re-instate unique group/annotation row reference
3930           List<AlignmentAnnotation> jaal = groupAnnotRefs
3931                   .get(jGroup.getId());
3932           if (jaal != null)
3933           {
3934             for (AlignmentAnnotation jaa : jaal)
3935             {
3936               jaa.groupRef = sg;
3937               if (jaa.autoCalculated)
3938               {
3939                 // match up and try to set group autocalc alignment row for this
3940                 // annotation
3941                 if (jaa.label.startsWith("Consensus for "))
3942                 {
3943                   sg.setConsensus(jaa);
3944                 }
3945                 // match up and try to set group autocalc alignment row for this
3946                 // annotation
3947                 if (jaa.label.startsWith("Conservation for "))
3948                 {
3949                   sg.setConservationRow(jaa);
3950                 }
3951               }
3952             }
3953           }
3954         }
3955         al.addGroup(sg);
3956         if (addAnnotSchemeGroup)
3957         {
3958           // reconstruct the annotation colourscheme
3959           sg.setColourScheme(constructAnnotationColour(
3960                   jGroup.getAnnotationColours(), null, al, jalviewModel, false));
3961         }
3962       }
3963     }
3964     if (view == null)
3965     {
3966       // only dataset in this model, so just return.
3967       return null;
3968     }
3969     // ///////////////////////////////
3970     // LOAD VIEWPORT
3971
3972     AlignFrame af = null;
3973     AlignViewport av = null;
3974     // now check to see if we really need to create a new viewport.
3975     if (multipleView && viewportsAdded.size() == 0)
3976     {
3977       // We recovered an alignment for which a viewport already exists.
3978       // TODO: fix up any settings necessary for overlaying stored state onto
3979       // state recovered from another document. (may not be necessary).
3980       // we may need a binding from a viewport in memory to one recovered from
3981       // XML.
3982       // and then recover its containing af to allow the settings to be applied.
3983       // TODO: fix for vamsas demo
3984       System.err.println(
3985               "About to recover a viewport for existing alignment: Sequence set ID is "
3986                       + uniqueSeqSetId);
3987       Object seqsetobj = retrieveExistingObj(uniqueSeqSetId);
3988       if (seqsetobj != null)
3989       {
3990         if (seqsetobj instanceof String)
3991         {
3992           uniqueSeqSetId = (String) seqsetobj;
3993           System.err.println(
3994                   "Recovered extant sequence set ID mapping for ID : New Sequence set ID is "
3995                           + uniqueSeqSetId);
3996         }
3997         else
3998         {
3999           System.err.println(
4000                   "Warning : Collision between sequence set ID string and existing jalview object mapping.");
4001         }
4002
4003       }
4004     }
4005     /**
4006      * indicate that annotation colours are applied across all groups (pre
4007      * Jalview 2.8.1 behaviour)
4008      */
4009     boolean doGroupAnnColour = Jalview2XML.isVersionStringLaterThan("2.8.1",
4010             jalviewModel.getVersion());
4011
4012     AlignmentPanel ap = null;
4013     boolean isnewview = true;
4014     if (viewId != null)
4015     {
4016       // Check to see if this alignment already has a view id == viewId
4017       jalview.gui.AlignmentPanel views[] = Desktop
4018               .getAlignmentPanels(uniqueSeqSetId);
4019       if (views != null && views.length > 0)
4020       {
4021         for (int v = 0; v < views.length; v++)
4022         {
4023           if (views[v].av.getViewId().equalsIgnoreCase(viewId))
4024           {
4025             // recover the existing alignpanel, alignframe, viewport
4026             af = views[v].alignFrame;
4027             av = views[v].av;
4028             ap = views[v];
4029             // TODO: could even skip resetting view settings if we don't want to
4030             // change the local settings from other jalview processes
4031             isnewview = false;
4032           }
4033         }
4034       }
4035     }
4036
4037     if (isnewview)
4038     {
4039       af = loadViewport(file, jseqs, hiddenSeqs, al, jalviewModel, view,
4040               uniqueSeqSetId, viewId, autoAlan);
4041       av = af.getViewport();
4042       ap = af.alignPanel;
4043     }
4044
4045     /*
4046      * Load any trees, PDB structures and viewers
4047      *
4048      * Not done if flag is false (when this method is used for New View)
4049      */
4050     if (loadTreesAndStructures)
4051     {
4052       loadTrees(jalviewModel, view, af, av, ap);
4053       loadPCAViewers(jalviewModel, ap);
4054       loadPDBStructures(jprovider, jseqs, af, ap);
4055       loadRnaViewers(jprovider, jseqs, ap);
4056     }
4057     // and finally return.
4058     return af;
4059   }
4060
4061   /**
4062    * Instantiate and link any saved RNA (Varna) viewers. The state of the Varna
4063    * panel is restored from separate jar entries, two (gapped and trimmed) per
4064    * sequence and secondary structure.
4065    *
4066    * Currently each viewer shows just one sequence and structure (gapped and
4067    * trimmed), however this method is designed to support multiple sequences or
4068    * structures in viewers if wanted in future.
4069    *
4070    * @param jprovider
4071    * @param jseqs
4072    * @param ap
4073    */
4074   private void loadRnaViewers(jarInputStreamProvider jprovider,
4075           List<JSeq> jseqs, AlignmentPanel ap)
4076   {
4077     /*
4078      * scan the sequences for references to viewers; create each one the first
4079      * time it is referenced, add Rna models to existing viewers
4080      */
4081     for (JSeq jseq : jseqs)
4082     {
4083       for (int i = 0; i < jseq.getRnaViewer().size(); i++)
4084       {
4085         RnaViewer viewer = jseq.getRnaViewer().get(i);
4086         AppVarna appVarna = findOrCreateVarnaViewer(viewer, uniqueSetSuffix,
4087                 ap);
4088
4089         for (int j = 0; j < viewer.getSecondaryStructure().size(); j++)
4090         {
4091           SecondaryStructure ss = viewer.getSecondaryStructure().get(j);
4092           SequenceI seq = seqRefIds.get(jseq.getId());
4093           AlignmentAnnotation ann = this.annotationIds
4094                   .get(ss.getAnnotationId());
4095
4096           /*
4097            * add the structure to the Varna display (with session state copied
4098            * from the jar to a temporary file)
4099            */
4100           boolean gapped = safeBoolean(ss.isGapped());
4101           String rnaTitle = ss.getTitle();
4102           String sessionState = ss.getViewerState();
4103           String tempStateFile = copyJarEntry(jprovider, sessionState,
4104                   "varna", null);
4105           RnaModel rna = new RnaModel(rnaTitle, ann, seq, null, gapped);
4106           appVarna.addModelSession(rna, rnaTitle, tempStateFile);
4107         }
4108         appVarna.setInitialSelection(safeInt(viewer.getSelectedRna()));
4109       }
4110     }
4111   }
4112
4113   /**
4114    * Locate and return an already instantiated matching AppVarna, or create one
4115    * if not found
4116    *
4117    * @param viewer
4118    * @param viewIdSuffix
4119    * @param ap
4120    * @return
4121    */
4122   protected AppVarna findOrCreateVarnaViewer(RnaViewer viewer,
4123           String viewIdSuffix, AlignmentPanel ap)
4124   {
4125     /*
4126      * on each load a suffix is appended to the saved viewId, to avoid conflicts
4127      * if load is repeated
4128      */
4129     String postLoadId = viewer.getViewId() + viewIdSuffix;
4130     for (JInternalFrame frame : getAllFrames())
4131     {
4132       if (frame instanceof AppVarna)
4133       {
4134         AppVarna varna = (AppVarna) frame;
4135         if (postLoadId.equals(varna.getViewId()))
4136         {
4137           // this viewer is already instantiated
4138           // could in future here add ap as another 'parent' of the
4139           // AppVarna window; currently just 1-to-many
4140           return varna;
4141         }
4142       }
4143     }
4144
4145     /*
4146      * viewer not found - make it
4147      */
4148     RnaViewerModel model = new RnaViewerModel(postLoadId, viewer.getTitle(),
4149             safeInt(viewer.getXpos()), safeInt(viewer.getYpos()),
4150             safeInt(viewer.getWidth()), safeInt(viewer.getHeight()),
4151             safeInt(viewer.getDividerLocation()));
4152     AppVarna varna = new AppVarna(model, ap);
4153
4154     return varna;
4155   }
4156
4157   /**
4158    * Load any saved trees
4159    *
4160    * @param jm
4161    * @param view
4162    * @param af
4163    * @param av
4164    * @param ap
4165    */
4166   protected void loadTrees(JalviewModel jm, Viewport view,
4167           AlignFrame af, AlignViewport av, AlignmentPanel ap)
4168   {
4169     // TODO result of automated refactoring - are all these parameters needed?
4170     try
4171     {
4172       for (int t = 0; t < jm.getTree().size(); t++)
4173       {
4174
4175         Tree tree = jm.getTree().get(t);
4176
4177         TreePanel tp = (TreePanel) retrieveExistingObj(tree.getId());
4178         if (tp == null)
4179         {
4180           tp = af.showNewickTree(new NewickFile(tree.getNewick()),
4181                   tree.getTitle(), safeInt(tree.getWidth()),
4182                   safeInt(tree.getHeight()), safeInt(tree.getXpos()),
4183                   safeInt(tree.getYpos()));
4184           if (tree.getId() != null)
4185           {
4186             // perhaps bind the tree id to something ?
4187           }
4188         }
4189         else
4190         {
4191           // update local tree attributes ?
4192           // TODO: should check if tp has been manipulated by user - if so its
4193           // settings shouldn't be modified
4194           tp.setTitle(tree.getTitle());
4195           tp.setBounds(new Rectangle(safeInt(tree.getXpos()),
4196                   safeInt(tree.getYpos()), safeInt(tree.getWidth()),
4197                   safeInt(tree.getHeight())));
4198           tp.setViewport(av); // af.viewport;
4199           // TODO: verify 'associate with all views' works still
4200           tp.getTreeCanvas().setViewport(av); // af.viewport;
4201           tp.getTreeCanvas().setAssociatedPanel(ap); // af.alignPanel;
4202         }
4203         tp.getTreeCanvas().setApplyToAllViews(tree.isLinkToAllViews());
4204         if (tp == null)
4205         {
4206           warn("There was a problem recovering stored Newick tree: \n"
4207                   + tree.getNewick());
4208           continue;
4209         }
4210
4211         tp.fitToWindow.setState(safeBoolean(tree.isFitToWindow()));
4212         tp.fitToWindow_actionPerformed(null);
4213
4214         if (tree.getFontName() != null)
4215         {
4216           tp.setTreeFont(
4217                   new Font(tree.getFontName(), safeInt(tree.getFontStyle()),
4218                           safeInt(tree.getFontSize())));
4219         }
4220         else
4221         {
4222           tp.setTreeFont(
4223                   new Font(view.getFontName(), safeInt(view.getFontStyle()),
4224                           safeInt(view.getFontSize())));
4225         }
4226
4227         tp.showPlaceholders(safeBoolean(tree.isMarkUnlinked()));
4228         tp.showBootstrap(safeBoolean(tree.isShowBootstrap()));
4229         tp.showDistances(safeBoolean(tree.isShowDistances()));
4230
4231         tp.getTreeCanvas().setThreshold(safeFloat(tree.getThreshold()));
4232
4233         if (safeBoolean(tree.isCurrentTree()))
4234         {
4235           af.getViewport().setCurrentTree(tp.getTree());
4236         }
4237       }
4238
4239     } catch (Exception ex)
4240     {
4241       ex.printStackTrace();
4242     }
4243   }
4244
4245   /**
4246    * Load and link any saved structure viewers.
4247    *
4248    * @param jprovider
4249    * @param jseqs
4250    * @param af
4251    * @param ap
4252    */
4253   protected void loadPDBStructures(jarInputStreamProvider jprovider,
4254           List<JSeq> jseqs, AlignFrame af, AlignmentPanel ap)
4255   {
4256     /*
4257      * Run through all PDB ids on the alignment, and collect mappings between
4258      * distinct view ids and all sequences referring to that view.
4259      */
4260     Map<String, StructureViewerModel> structureViewers = new LinkedHashMap<>();
4261
4262     for (int i = 0; i < jseqs.size(); i++)
4263     {
4264       JSeq jseq = jseqs.get(i);
4265       if (jseq.getPdbids().size() > 0)
4266       {
4267         List<Pdbids> ids = jseq.getPdbids();
4268         for (int p = 0; p < ids.size(); p++)
4269         {
4270           Pdbids pdbid = ids.get(p);
4271           final int structureStateCount = pdbid.getStructureState().size();
4272           for (int s = 0; s < structureStateCount; s++)
4273           {
4274             // check to see if we haven't already created this structure view
4275             final StructureState structureState = pdbid
4276                     .getStructureState().get(s);
4277             String sviewid = (structureState.getViewId() == null) ? null
4278                     : structureState.getViewId() + uniqueSetSuffix;
4279             jalview.datamodel.PDBEntry jpdb = new jalview.datamodel.PDBEntry();
4280             // Originally : pdbid.getFile()
4281             // : TODO: verify external PDB file recovery still works in normal
4282             // jalview project load
4283             jpdb.setFile(
4284                     loadPDBFile(jprovider, pdbid.getId(), pdbid.getFile()));
4285             jpdb.setId(pdbid.getId());
4286
4287             int x = safeInt(structureState.getXpos());
4288             int y = safeInt(structureState.getYpos());
4289             int width = safeInt(structureState.getWidth());
4290             int height = safeInt(structureState.getHeight());
4291
4292             // Probably don't need to do this anymore...
4293             // Desktop.getDesktop().getComponentAt(x, y);
4294             // TODO: NOW: check that this recovers the PDB file correctly.
4295             String pdbFile = loadPDBFile(jprovider, pdbid.getId(),
4296                     pdbid.getFile());
4297             jalview.datamodel.SequenceI seq = seqRefIds
4298                     .get(jseq.getId() + "");
4299             if (sviewid == null)
4300             {
4301               sviewid = "_jalview_pre2_4_" + x + "," + y + "," + width + ","
4302                       + height;
4303             }
4304             if (!structureViewers.containsKey(sviewid))
4305             {
4306               structureViewers.put(sviewid,
4307                       new StructureViewerModel(x, y, width, height, false,
4308                               false, true, structureState.getViewId(),
4309                               structureState.getType()));
4310               // Legacy pre-2.7 conversion JAL-823 :
4311               // do not assume any view has to be linked for colour by
4312               // sequence
4313             }
4314
4315             // assemble String[] { pdb files }, String[] { id for each
4316             // file }, orig_fileloc, SequenceI[][] {{ seqs_file 1 }, {
4317             // seqs_file 2}, boolean[] {
4318             // linkAlignPanel,superposeWithAlignpanel}} from hash
4319             StructureViewerModel jmoldat = structureViewers.get(sviewid);
4320             jmoldat.setAlignWithPanel(jmoldat.isAlignWithPanel()
4321                     || structureState.isAlignwithAlignPanel());
4322
4323             /*
4324              * Default colour by linked panel to false if not specified (e.g.
4325              * for pre-2.7 projects)
4326              */
4327             boolean colourWithAlignPanel = jmoldat.isColourWithAlignPanel();
4328             colourWithAlignPanel |= structureState.isColourwithAlignPanel();
4329             jmoldat.setColourWithAlignPanel(colourWithAlignPanel);
4330
4331             /*
4332              * Default colour by viewer to true if not specified (e.g. for
4333              * pre-2.7 projects)
4334              */
4335             boolean colourByViewer = jmoldat.isColourByViewer();
4336             colourByViewer &= structureState.isColourByJmol();
4337             jmoldat.setColourByViewer(colourByViewer);
4338
4339             if (jmoldat.getStateData().length() < structureState
4340                     .getValue()/*Content()*/.length())
4341             {
4342               jmoldat.setStateData(structureState.getValue());// Content());
4343             }
4344             if (pdbid.getFile() != null)
4345             {
4346               File mapkey = new File(pdbid.getFile());
4347               StructureData seqstrmaps = jmoldat.getFileData().get(mapkey);
4348               if (seqstrmaps == null)
4349               {
4350                 jmoldat.getFileData().put(mapkey,
4351                         seqstrmaps = jmoldat.new StructureData(pdbFile,
4352                                 pdbid.getId()));
4353               }
4354               if (!seqstrmaps.getSeqList().contains(seq))
4355               {
4356                 seqstrmaps.getSeqList().add(seq);
4357                 // TODO and chains?
4358               }
4359             }
4360             else
4361             {
4362               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");
4363               warn(errorMessage);
4364             }
4365           }
4366         }
4367       }
4368     }
4369     // Instantiate the associated structure views
4370     for (Entry<String, StructureViewerModel> entry : structureViewers
4371             .entrySet())
4372     {
4373       try
4374       {
4375         createOrLinkStructureViewer(entry, af, ap, jprovider);
4376       } catch (Exception e)
4377       {
4378         System.err.println(
4379                 "Error loading structure viewer: " + e.getMessage());
4380         // failed - try the next one
4381       }
4382     }
4383   }
4384
4385   /**
4386    *
4387    * @param viewerData
4388    * @param af
4389    * @param ap
4390    * @param jprovider
4391    */
4392   protected void createOrLinkStructureViewer(
4393           Entry<String, StructureViewerModel> viewerData, AlignFrame af,
4394           AlignmentPanel ap, jarInputStreamProvider jprovider)
4395   {
4396     final StructureViewerModel stateData = viewerData.getValue();
4397
4398     /*
4399      * Search for any viewer windows already open from other alignment views
4400      * that exactly match the stored structure state
4401      */
4402     StructureViewerBase comp = findMatchingViewer(viewerData);
4403
4404     if (comp != null)
4405     {
4406       linkStructureViewer(ap, comp, stateData);
4407       return;
4408     }
4409
4410     /*
4411      * From 2.9: stateData.type contains JMOL or CHIMERA, data is in jar entry
4412      * "viewer_"+stateData.viewId
4413      */
4414     if (ViewerType.CHIMERA.toString().equals(stateData.getType()))
4415     {
4416       createChimeraViewer(viewerData, af, jprovider);
4417     }
4418     else
4419     {
4420       /*
4421        * else Jmol (if pre-2.9, stateData contains JMOL state string)
4422        */
4423       createJmolViewer(viewerData, af, jprovider);
4424     }
4425   }
4426
4427   /**
4428    * Create a new Chimera viewer.
4429    *
4430    * @param data
4431    * @param af
4432    * @param jprovider
4433    */
4434   protected void createChimeraViewer(
4435           Entry<String, StructureViewerModel> viewerData, AlignFrame af,
4436           jarInputStreamProvider jprovider)
4437   {
4438     StructureViewerModel data = viewerData.getValue();
4439     String chimeraSessionFile = data.getStateData();
4440
4441     /*
4442      * Copy Chimera session from jar entry "viewer_"+viewId to a temporary file
4443      *
4444      * NB this is the 'saved' viewId as in the project file XML, _not_ the
4445      * 'uniquified' sviewid used to reconstruct the viewer here
4446      */
4447     String viewerJarEntryName = getViewerJarEntryName(data.getViewId());
4448     chimeraSessionFile = copyJarEntry(jprovider, viewerJarEntryName,
4449             "chimera", null);
4450
4451     Set<Entry<File, StructureData>> fileData = data.getFileData()
4452             .entrySet();
4453     List<PDBEntry> pdbs = new ArrayList<>();
4454     List<SequenceI[]> allseqs = new ArrayList<>();
4455     for (Entry<File, StructureData> pdb : fileData)
4456     {
4457       String filePath = pdb.getValue().getFilePath();
4458       String pdbId = pdb.getValue().getPdbId();
4459       // pdbs.add(new PDBEntry(filePath, pdbId));
4460       pdbs.add(new PDBEntry(pdbId, null, PDBEntry.Type.PDB, filePath));
4461       final List<SequenceI> seqList = pdb.getValue().getSeqList();
4462       SequenceI[] seqs = seqList.toArray(new SequenceI[seqList.size()]);
4463       allseqs.add(seqs);
4464     }
4465
4466     boolean colourByChimera = data.isColourByViewer();
4467     boolean colourBySequence = data.isColourWithAlignPanel();
4468
4469     // TODO use StructureViewer as a factory here, see JAL-1761
4470     final PDBEntry[] pdbArray = pdbs.toArray(new PDBEntry[pdbs.size()]);
4471     final SequenceI[][] seqsArray = allseqs
4472             .toArray(new SequenceI[allseqs.size()][]);
4473     String newViewId = viewerData.getKey();
4474
4475     ChimeraViewFrame cvf = new ChimeraViewFrame(chimeraSessionFile,
4476             af.alignPanel, pdbArray, seqsArray, colourByChimera,
4477             colourBySequence, newViewId);
4478     cvf.setSize(data.getWidth(), data.getHeight());
4479     cvf.setLocation(data.getX(), data.getY());
4480   }
4481
4482   /**
4483    * Create a new Jmol window. First parse the Jmol state to translate filenames
4484    * loaded into the view, and record the order in which files are shown in the
4485    * Jmol view, so we can add the sequence mappings in same order.
4486    *
4487    * @param viewerData
4488    * @param af
4489    * @param jprovider
4490    */
4491   protected void createJmolViewer(
4492           final Entry<String, StructureViewerModel> viewerData,
4493           AlignFrame af, jarInputStreamProvider jprovider)
4494   {
4495     final StructureViewerModel svattrib = viewerData.getValue();
4496     String state = svattrib.getStateData();
4497
4498     /*
4499      * Pre-2.9: state element value is the Jmol state string
4500      *
4501      * 2.9+: @type is "JMOL", state data is in a Jar file member named "viewer_"
4502      * + viewId
4503      */
4504     if (ViewerType.JMOL.toString().equals(svattrib.getType()))
4505     {
4506       state = readJarEntry(jprovider,
4507               getViewerJarEntryName(svattrib.getViewId()));
4508     }
4509
4510     List<String> pdbfilenames = new ArrayList<>();
4511     List<SequenceI[]> seqmaps = new ArrayList<>();
4512     List<String> pdbids = new ArrayList<>();
4513     StringBuilder newFileLoc = new StringBuilder(64);
4514     int cp = 0, ncp, ecp;
4515     Map<File, StructureData> oldFiles = svattrib.getFileData();
4516     while ((ncp = state.indexOf("load ", cp)) > -1)
4517     {
4518       do
4519       {
4520         // look for next filename in load statement
4521         newFileLoc.append(state.substring(cp,
4522                 ncp = (state.indexOf("\"", ncp + 1) + 1)));
4523         String oldfilenam = state.substring(ncp,
4524                 ecp = state.indexOf("\"", ncp));
4525         // recover the new mapping data for this old filename
4526         // have to normalize filename - since Jmol and jalview do
4527         // filename
4528         // translation differently.
4529         StructureData filedat = oldFiles.get(new File(oldfilenam));
4530         if (filedat == null)
4531         {
4532           String reformatedOldFilename = oldfilenam.replaceAll("/", "\\\\");
4533           filedat = oldFiles.get(new File(reformatedOldFilename));
4534         }
4535         newFileLoc.append(Platform.escapeString(filedat.getFilePath()));
4536         pdbfilenames.add(filedat.getFilePath());
4537         pdbids.add(filedat.getPdbId());
4538         seqmaps.add(filedat.getSeqList().toArray(new SequenceI[0]));
4539         newFileLoc.append("\"");
4540         cp = ecp + 1; // advance beyond last \" and set cursor so we can
4541                       // look for next file statement.
4542       } while ((ncp = state.indexOf("/*file*/", cp)) > -1);
4543     }
4544     if (cp > 0)
4545     {
4546       // just append rest of state
4547       newFileLoc.append(state.substring(cp));
4548     }
4549     else
4550     {
4551       System.err.print("Ignoring incomplete Jmol state for PDB ids: ");
4552       newFileLoc = new StringBuilder(state);
4553       newFileLoc.append("; load append ");
4554       for (File id : oldFiles.keySet())
4555       {
4556         // add this and any other pdb files that should be present in
4557         // the viewer
4558         StructureData filedat = oldFiles.get(id);
4559         newFileLoc.append(filedat.getFilePath());
4560         pdbfilenames.add(filedat.getFilePath());
4561         pdbids.add(filedat.getPdbId());
4562         seqmaps.add(filedat.getSeqList().toArray(new SequenceI[0]));
4563         newFileLoc.append(" \"");
4564         newFileLoc.append(filedat.getFilePath());
4565         newFileLoc.append("\"");
4566
4567       }
4568       newFileLoc.append(";");
4569     }
4570
4571     if (newFileLoc.length() == 0)
4572     {
4573       return;
4574     }
4575     int histbug = newFileLoc.indexOf("history = ");
4576     if (histbug > -1)
4577     {
4578       /*
4579        * change "history = [true|false];" to "history = [1|0];"
4580        */
4581       histbug += 10;
4582       int diff = histbug == -1 ? -1 : newFileLoc.indexOf(";", histbug);
4583       String val = (diff == -1) ? null
4584               : newFileLoc.substring(histbug, diff);
4585       if (val != null && val.length() >= 4)
4586       {
4587         if (val.contains("e")) // eh? what can it be?
4588         {
4589           if (val.trim().equals("true"))
4590           {
4591             val = "1";
4592           }
4593           else
4594           {
4595             val = "0";
4596           }
4597           newFileLoc.replace(histbug, diff, val);
4598         }
4599       }
4600     }
4601
4602     final String[] pdbf = pdbfilenames
4603             .toArray(new String[pdbfilenames.size()]);
4604     final String[] id = pdbids.toArray(new String[pdbids.size()]);
4605     final SequenceI[][] sq = seqmaps
4606             .toArray(new SequenceI[seqmaps.size()][]);
4607     final String fileloc = newFileLoc.toString();
4608     final String sviewid = viewerData.getKey();
4609     final AlignFrame alf = af;
4610     final Rectangle rect = new Rectangle(svattrib.getX(), svattrib.getY(),
4611             svattrib.getWidth(), svattrib.getHeight());
4612     try
4613     {
4614       javax.swing.SwingUtilities.invokeAndWait(new Runnable()
4615       {
4616         @Override
4617         public void run()
4618         {
4619           JalviewStructureDisplayI sview = null;
4620           try
4621           {
4622             sview = new StructureViewer(
4623                     alf.alignPanel.getStructureSelectionManager())
4624                             .createView(StructureViewer.ViewerType.JMOL,
4625                                     pdbf, id, sq, alf.alignPanel, svattrib,
4626                                     fileloc, rect, sviewid);
4627             addNewStructureViewer(sview);
4628           } catch (OutOfMemoryError ex)
4629           {
4630             new OOMWarning("restoring structure view for PDB id " + id,
4631                     (OutOfMemoryError) ex.getCause());
4632             if (sview != null && sview.isVisible())
4633             {
4634               sview.closeViewer(false);
4635               sview.setVisible(false);
4636               sview.dispose();
4637             }
4638           }
4639         }
4640       });
4641     } catch (InvocationTargetException ex)
4642     {
4643       warn("Unexpected error when opening Jmol view.", ex);
4644
4645     } catch (InterruptedException e)
4646     {
4647       // e.printStackTrace();
4648     }
4649
4650   }
4651
4652   /**
4653    * Generates a name for the entry in the project jar file to hold state
4654    * information for a structure viewer
4655    *
4656    * @param viewId
4657    * @return
4658    */
4659   protected String getViewerJarEntryName(String viewId)
4660   {
4661     return VIEWER_PREFIX + viewId;
4662   }
4663
4664   /**
4665    * Returns any open frame that matches given structure viewer data. The match
4666    * is based on the unique viewId, or (for older project versions) the frame's
4667    * geometry.
4668    *
4669    * @param viewerData
4670    * @return
4671    */
4672   protected StructureViewerBase findMatchingViewer(
4673           Entry<String, StructureViewerModel> viewerData)
4674   {
4675     final String sviewid = viewerData.getKey();
4676     final StructureViewerModel svattrib = viewerData.getValue();
4677     StructureViewerBase comp = null;
4678     JInternalFrame[] frames = getAllFrames();
4679     for (JInternalFrame frame : frames)
4680     {
4681       if (frame instanceof StructureViewerBase)
4682       {
4683         /*
4684          * Post jalview 2.4 schema includes structure view id
4685          */
4686         if (sviewid != null && ((StructureViewerBase) frame).getViewId()
4687                 .equals(sviewid))
4688         {
4689           comp = (StructureViewerBase) frame;
4690           break; // break added in 2.9
4691         }
4692         /*
4693          * Otherwise test for matching position and size of viewer frame
4694          */
4695         else if (frame.getX() == svattrib.getX()
4696                 && frame.getY() == svattrib.getY()
4697                 && frame.getHeight() == svattrib.getHeight()
4698                 && frame.getWidth() == svattrib.getWidth())
4699         {
4700           comp = (StructureViewerBase) frame;
4701           // no break in faint hope of an exact match on viewId
4702         }
4703       }
4704     }
4705     return comp;
4706   }
4707
4708   /**
4709    * Link an AlignmentPanel to an existing structure viewer.
4710    *
4711    * @param ap
4712    * @param viewer
4713    * @param oldFiles
4714    * @param useinViewerSuperpos
4715    * @param usetoColourbyseq
4716    * @param viewerColouring
4717    */
4718   protected void linkStructureViewer(AlignmentPanel ap,
4719           StructureViewerBase viewer, StructureViewerModel stateData)
4720   {
4721     // NOTE: if the jalview project is part of a shared session then
4722     // view synchronization should/could be done here.
4723
4724     final boolean useinViewerSuperpos = stateData.isAlignWithPanel();
4725     final boolean usetoColourbyseq = stateData.isColourWithAlignPanel();
4726     final boolean viewerColouring = stateData.isColourByViewer();
4727     Map<File, StructureData> oldFiles = stateData.getFileData();
4728
4729     /*
4730      * Add mapping for sequences in this view to an already open viewer
4731      */
4732     final AAStructureBindingModel binding = viewer.getBinding();
4733     for (File id : oldFiles.keySet())
4734     {
4735       // add this and any other pdb files that should be present in the
4736       // viewer
4737       StructureData filedat = oldFiles.get(id);
4738       String pdbFile = filedat.getFilePath();
4739       SequenceI[] seq = filedat.getSeqList().toArray(new SequenceI[0]);
4740       binding.getSsm().setMapping(seq, null, pdbFile, DataSourceType.FILE,
4741               null);
4742       binding.addSequenceForStructFile(pdbFile, seq);
4743     }
4744     // and add the AlignmentPanel's reference to the view panel
4745     viewer.addAlignmentPanel(ap);
4746     if (useinViewerSuperpos)
4747     {
4748       viewer.useAlignmentPanelForSuperposition(ap);
4749     }
4750     else
4751     {
4752       viewer.excludeAlignmentPanelForSuperposition(ap);
4753     }
4754     if (usetoColourbyseq)
4755     {
4756       viewer.useAlignmentPanelForColourbyseq(ap, !viewerColouring);
4757     }
4758     else
4759     {
4760       viewer.excludeAlignmentPanelForColourbyseq(ap);
4761     }
4762   }
4763
4764   /**
4765    * Get all frames within the Desktop.
4766    *
4767    * @return
4768    */
4769   protected JInternalFrame[] getAllFrames()
4770   {
4771     JInternalFrame[] frames = null;
4772     // TODO is this necessary - is it safe - risk of hanging?
4773     do
4774     {
4775       try
4776       {
4777         frames = Desktop.getDesktopPane().getAllFrames();
4778       } catch (ArrayIndexOutOfBoundsException e)
4779       {
4780         // occasional No such child exceptions are thrown here...
4781         try
4782         {
4783           Thread.sleep(10);
4784         } catch (InterruptedException f)
4785         {
4786         }
4787       }
4788     } while (frames == null);
4789     return frames;
4790   }
4791
4792   /**
4793    * Answers true if 'version' is equal to or later than 'supported', where each
4794    * is formatted as major/minor versions like "2.8.3" or "2.3.4b1" for bugfix
4795    * changes. Development and test values for 'version' are leniently treated
4796    * i.e. answer true.
4797    *
4798    * @param supported
4799    *          - minimum version we are comparing against
4800    * @param version
4801    *          - version of data being processsed
4802    * @return
4803    */
4804   public static boolean isVersionStringLaterThan(String supported,
4805           String version)
4806   {
4807     if (supported == null || version == null
4808             || version.equalsIgnoreCase("DEVELOPMENT BUILD")
4809             || version.equalsIgnoreCase("Test")
4810             || version.equalsIgnoreCase("AUTOMATED BUILD"))
4811     {
4812       System.err.println("Assuming project file with "
4813               + (version == null ? "null" : version)
4814               + " is compatible with Jalview version " + supported);
4815       return true;
4816     }
4817     else
4818     {
4819       return StringUtils.compareVersions(version, supported, "b") >= 0;
4820     }
4821   }
4822
4823   Vector<JalviewStructureDisplayI> newStructureViewers = null;
4824
4825   protected void addNewStructureViewer(JalviewStructureDisplayI sview)
4826   {
4827     if (newStructureViewers != null)
4828     {
4829       sview.getBinding().setFinishedLoadingFromArchive(false);
4830       newStructureViewers.add(sview);
4831     }
4832   }
4833
4834   protected void setLoadingFinishedForNewStructureViewers()
4835   {
4836     if (newStructureViewers != null)
4837     {
4838       for (JalviewStructureDisplayI sview : newStructureViewers)
4839       {
4840         sview.getBinding().setFinishedLoadingFromArchive(true);
4841       }
4842       newStructureViewers.clear();
4843       newStructureViewers = null;
4844     }
4845   }
4846
4847   AlignFrame loadViewport(String file, List<JSeq> JSEQ,
4848           List<SequenceI> hiddenSeqs, AlignmentI al,
4849           JalviewModel jm, Viewport view, String uniqueSeqSetId,
4850           String viewId, List<JvAnnotRow> autoAlan)
4851   {
4852     AlignFrame af = null;
4853     af = new AlignFrame(al, safeInt(view.getWidth()),
4854             safeInt(view.getHeight()), uniqueSeqSetId, viewId)
4855 //    {
4856 //
4857 //      @Override
4858 //      protected void processKeyEvent(java.awt.event.KeyEvent e) {
4859 //              System.out.println("Jalview2XML   AF " + e);
4860 //              super.processKeyEvent(e);
4861 //
4862 //      }
4863 //
4864 //    }
4865     ;
4866
4867     af.setFileName(file, FileFormat.Jalview);
4868
4869     final AlignViewport viewport = af.getViewport();
4870     for (int i = 0; i < JSEQ.size(); i++)
4871     {
4872       int colour = safeInt(JSEQ.get(i).getColour());
4873       viewport.setSequenceColour(viewport.getAlignment().getSequenceAt(i),
4874               new Color(colour));
4875     }
4876
4877     if (al.hasSeqrep())
4878     {
4879       viewport.setColourByReferenceSeq(true);
4880       viewport.setDisplayReferenceSeq(true);
4881     }
4882
4883     viewport.setGatherViewsHere(safeBoolean(view.isGatheredViews()));
4884
4885     if (view.getSequenceSetId() != null)
4886     {
4887       AlignmentViewport av = viewportsAdded.get(uniqueSeqSetId);
4888
4889       viewport.setSequenceSetId(uniqueSeqSetId);
4890       if (av != null)
4891       {
4892         // propagate shared settings to this new view
4893         viewport.setHistoryList(av.getHistoryList());
4894         viewport.setRedoList(av.getRedoList());
4895       }
4896       else
4897       {
4898         viewportsAdded.put(uniqueSeqSetId, viewport);
4899       }
4900       // TODO: check if this method can be called repeatedly without
4901       // side-effects if alignpanel already registered.
4902       PaintRefresher.Register(af.alignPanel, uniqueSeqSetId);
4903     }
4904     // apply Hidden regions to view.
4905     if (hiddenSeqs != null)
4906     {
4907       for (int s = 0; s < JSEQ.size(); s++)
4908       {
4909         SequenceGroup hidden = new SequenceGroup();
4910         boolean isRepresentative = false;
4911         for (int r = 0; r < JSEQ.get(s).getHiddenSequences().size(); r++)
4912         {
4913           isRepresentative = true;
4914           SequenceI sequenceToHide = al
4915                   .getSequenceAt(JSEQ.get(s).getHiddenSequences().get(r));
4916           hidden.addSequence(sequenceToHide, false);
4917           // remove from hiddenSeqs list so we don't try to hide it twice
4918           hiddenSeqs.remove(sequenceToHide);
4919         }
4920         if (isRepresentative)
4921         {
4922           SequenceI representativeSequence = al.getSequenceAt(s);
4923           hidden.addSequence(representativeSequence, false);
4924           viewport.hideRepSequences(representativeSequence, hidden);
4925         }
4926       }
4927
4928       SequenceI[] hseqs = hiddenSeqs
4929               .toArray(new SequenceI[hiddenSeqs.size()]);
4930       viewport.hideSequence(hseqs);
4931
4932     }
4933     // recover view properties and display parameters
4934
4935     viewport.setShowAnnotation(safeBoolean(view.isShowAnnotation()));
4936     viewport.setAbovePIDThreshold(safeBoolean(view.isPidSelected()));
4937     final int pidThreshold = safeInt(view.getPidThreshold());
4938     viewport.setThreshold(pidThreshold);
4939
4940     viewport.setColourText(safeBoolean(view.isShowColourText()));
4941
4942     viewport
4943             .setConservationSelected(
4944                     safeBoolean(view.isConservationSelected()));
4945     viewport.setIncrement(safeInt(view.getConsThreshold()));
4946     viewport.setShowJVSuffix(safeBoolean(view.isShowFullId()));
4947     viewport.setRightAlignIds(safeBoolean(view.isRightAlignIds()));
4948     viewport.setFont(new Font(view.getFontName(),
4949             safeInt(view.getFontStyle()), safeInt(view.getFontSize())),
4950             true);
4951     ViewStyleI vs = viewport.getViewStyle();
4952     vs.setScaleProteinAsCdna(view.isScaleProteinAsCdna());
4953     viewport.setViewStyle(vs);
4954     // TODO: allow custom charWidth/Heights to be restored by updating them
4955     // after setting font - which means set above to false
4956     viewport.setRenderGaps(safeBoolean(view.isRenderGaps()));
4957     viewport.setWrapAlignment(safeBoolean(view.isWrapAlignment()));
4958     viewport.setShowAnnotation(safeBoolean(view.isShowAnnotation()));
4959
4960     viewport.setShowBoxes(safeBoolean(view.isShowBoxes()));
4961
4962     viewport.setShowText(safeBoolean(view.isShowText()));
4963
4964     viewport.setTextColour(new Color(safeInt(view.getTextCol1())));
4965     viewport.setTextColour2(new Color(safeInt(view.getTextCol2())));
4966     viewport.setThresholdTextColour(safeInt(view.getTextColThreshold()));
4967     viewport.setShowUnconserved(view.isShowUnconserved());
4968     viewport.getRanges().setStartRes(safeInt(view.getStartRes()));
4969
4970     if (view.getViewName() != null)
4971     {
4972       viewport.setViewName(view.getViewName());
4973       af.setInitialTabVisible();
4974     }
4975     af.setBounds(safeInt(view.getXpos()), safeInt(view.getYpos()),
4976             safeInt(view.getWidth()), safeInt(view.getHeight()));
4977     // startSeq set in af.alignPanel.updateLayout below
4978     af.alignPanel.updateLayout();
4979     ColourSchemeI cs = null;
4980     // apply colourschemes
4981     if (view.getBgColour() != null)
4982     {
4983       if (view.getBgColour().startsWith("ucs"))
4984       {
4985         cs = getUserColourScheme(jm, view.getBgColour());
4986       }
4987       else if (view.getBgColour().startsWith("Annotation"))
4988       {
4989         AnnotationColourScheme viewAnnColour = view.getAnnotationColours();
4990         cs = constructAnnotationColour(viewAnnColour, af, al, jm, true);
4991
4992         // annpos
4993
4994       }
4995       else
4996       {
4997         cs = ColourSchemeProperty.getColourScheme(af.getViewport(), al,
4998                 view.getBgColour());
4999       }
5000     }
5001
5002     /*
5003      * turn off 'alignment colour applies to all groups'
5004      * while restoring global colour scheme
5005      */
5006     viewport.setColourAppliesToAllGroups(false);
5007     viewport.setGlobalColourScheme(cs);
5008     viewport.getResidueShading().setThreshold(pidThreshold,
5009             view.isIgnoreGapsinConsensus());
5010     viewport.getResidueShading()
5011             .setConsensus(viewport.getSequenceConsensusHash());
5012     if (safeBoolean(view.isConservationSelected()) && cs != null)
5013     {
5014       viewport.getResidueShading()
5015               .setConservationInc(safeInt(view.getConsThreshold()));
5016     }
5017     af.changeColour(cs);
5018     viewport.setColourAppliesToAllGroups(true);
5019
5020     viewport
5021             .setShowSequenceFeatures(
5022                     safeBoolean(view.isShowSequenceFeatures()));
5023
5024     viewport.setCentreColumnLabels(view.isCentreColumnLabels());
5025     viewport.setIgnoreGapsConsensus(view.isIgnoreGapsinConsensus(), null);
5026     viewport.setFollowHighlight(view.isFollowHighlight());
5027     viewport.followSelection = view.isFollowSelection();
5028     viewport.setShowConsensusHistogram(view.isShowConsensusHistogram());
5029     viewport.setShowSequenceLogo(view.isShowSequenceLogo());
5030     viewport.setNormaliseSequenceLogo(view.isNormaliseSequenceLogo());
5031     viewport.setShowDBRefs(safeBoolean(view.isShowDbRefTooltip()));
5032     viewport.setShowNPFeats(safeBoolean(view.isShowNPfeatureTooltip()));
5033     viewport.setShowGroupConsensus(view.isShowGroupConsensus());
5034     viewport.setShowGroupConservation(view.isShowGroupConservation());
5035
5036     // recover feature settings
5037     if (jm.getFeatureSettings() != null)
5038     {
5039       FeatureRenderer fr = af.alignPanel.getSeqPanel().seqCanvas
5040               .getFeatureRenderer();
5041       FeaturesDisplayed fdi;
5042       viewport.setFeaturesDisplayed(fdi = new FeaturesDisplayed());
5043       String[] renderOrder = new String[jm.getFeatureSettings()
5044               .getSetting().size()];
5045       Map<String, FeatureColourI> featureColours = new Hashtable<>();
5046       Map<String, Float> featureOrder = new Hashtable<>();
5047
5048       for (int fs = 0; fs < jm.getFeatureSettings()
5049               .getSetting().size(); fs++)
5050       {
5051         Setting setting = jm.getFeatureSettings().getSetting().get(fs);
5052         String featureType = setting.getType();
5053
5054         /*
5055          * restore feature filters (if any)
5056          */
5057         jalview.xml.binding.jalview.FeatureMatcherSet filters = setting
5058                 .getMatcherSet();
5059         if (filters != null)
5060         {
5061           FeatureMatcherSetI filter = Jalview2XML
5062                   .parseFilter(featureType, filters);
5063           if (!filter.isEmpty())
5064           {
5065             fr.setFeatureFilter(featureType, filter);
5066           }
5067         }
5068
5069         /*
5070          * restore feature colour scheme
5071          */
5072         Color maxColour = new Color(setting.getColour());
5073         if (setting.getMincolour() != null)
5074         {
5075           /*
5076            * minColour is always set unless a simple colour
5077            * (including for colour by label though it doesn't use it)
5078            */
5079           Color minColour = new Color(setting.getMincolour().intValue());
5080           Color noValueColour = minColour;
5081           NoValueColour noColour = setting.getNoValueColour();
5082           if (noColour == NoValueColour.NONE)
5083           {
5084             noValueColour = null;
5085           }
5086           else if (noColour == NoValueColour.MAX)
5087           {
5088             noValueColour = maxColour;
5089           }
5090           float min = safeFloat(safeFloat(setting.getMin()));
5091           float max = setting.getMax() == null ? 1f
5092                   : setting.getMax().floatValue();
5093           FeatureColourI gc = new FeatureColour(maxColour, minColour,
5094                   maxColour,
5095                   noValueColour, min, max);
5096           if (setting.getAttributeName().size() > 0)
5097           {
5098             gc.setAttributeName(setting.getAttributeName().toArray(
5099                     new String[setting.getAttributeName().size()]));
5100           }
5101           if (setting.getThreshold() != null)
5102           {
5103             gc.setThreshold(setting.getThreshold().floatValue());
5104             int threshstate = safeInt(setting.getThreshstate());
5105             // -1 = None, 0 = Below, 1 = Above threshold
5106             if (threshstate == 0)
5107             {
5108               gc.setBelowThreshold(true);
5109             }
5110             else if (threshstate == 1)
5111             {
5112               gc.setAboveThreshold(true);
5113             }
5114           }
5115           gc.setAutoScaled(true); // default
5116           if (setting.isAutoScale() != null)
5117           {
5118             gc.setAutoScaled(setting.isAutoScale());
5119           }
5120           if (setting.isColourByLabel() != null)
5121           {
5122             gc.setColourByLabel(setting.isColourByLabel());
5123           }
5124           // and put in the feature colour table.
5125           featureColours.put(featureType, gc);
5126         }
5127         else
5128         {
5129           featureColours.put(featureType,
5130                   new FeatureColour(maxColour));
5131         }
5132         renderOrder[fs] = featureType;
5133         if (setting.getOrder() != null)
5134         {
5135           featureOrder.put(featureType, setting.getOrder().floatValue());
5136         }
5137         else
5138         {
5139           featureOrder.put(featureType, new Float(
5140                   fs / jm.getFeatureSettings().getSetting().size()));
5141         }
5142         if (safeBoolean(setting.isDisplay()))
5143         {
5144           fdi.setVisible(featureType);
5145         }
5146       }
5147       Map<String, Boolean> fgtable = new Hashtable<>();
5148       for (int gs = 0; gs < jm.getFeatureSettings().getGroup().size(); gs++)
5149       {
5150         Group grp = jm.getFeatureSettings().getGroup().get(gs);
5151         fgtable.put(grp.getName(), new Boolean(grp.isDisplay()));
5152       }
5153       // FeatureRendererSettings frs = new FeatureRendererSettings(renderOrder,
5154       // fgtable, featureColours, jms.getFeatureSettings().hasTransparency() ?
5155       // jms.getFeatureSettings().getTransparency() : 0.0, featureOrder);
5156       FeatureRendererSettings frs = new FeatureRendererSettings(renderOrder,
5157               fgtable, featureColours, 1.0f, featureOrder);
5158       fr.transferSettings(frs);
5159     }
5160
5161     if (view.getHiddenColumns().size() > 0)
5162     {
5163       for (int c = 0; c < view.getHiddenColumns().size(); c++)
5164       {
5165         final HiddenColumns hc = view.getHiddenColumns().get(c);
5166         viewport.hideColumns(safeInt(hc.getStart()),
5167                 safeInt(hc.getEnd()) /* +1 */);
5168       }
5169     }
5170     if (view.getCalcIdParam() != null)
5171     {
5172       for (CalcIdParam calcIdParam : view.getCalcIdParam())
5173       {
5174         if (calcIdParam != null)
5175         {
5176           if (recoverCalcIdParam(calcIdParam, viewport))
5177           {
5178           }
5179           else
5180           {
5181             warn("Couldn't recover parameters for "
5182                     + calcIdParam.getCalcId());
5183           }
5184         }
5185       }
5186     }
5187     af.setMenusFromViewport(viewport);
5188     af.setTitle(view.getTitle());
5189     // TODO: we don't need to do this if the viewport is aready visible.
5190     /*
5191      * Add the AlignFrame to the desktop (it may be 'gathered' later), unless it
5192      * has a 'cdna/protein complement' view, in which case save it in order to
5193      * populate a SplitFrame once all views have been read in.
5194      */
5195     String complementaryViewId = view.getComplementId();
5196     if (complementaryViewId == null)
5197     {
5198       Desktop.addInternalFrame(af, view.getTitle(),
5199               safeInt(view.getWidth()), safeInt(view.getHeight()));
5200       // recompute any autoannotation
5201       af.alignPanel.updateAnnotation(false, true);
5202       reorderAutoannotation(af, al, autoAlan);
5203       af.alignPanel.alignmentChanged();
5204     }
5205     else
5206     {
5207       splitFrameCandidates.put(view, af);
5208     }
5209     return af;
5210   }
5211
5212   /**
5213    * Reads saved data to restore Colour by Annotation settings
5214    *
5215    * @param viewAnnColour
5216    * @param af
5217    * @param al
5218    * @param model
5219    * @param checkGroupAnnColour
5220    * @return
5221    */
5222   private ColourSchemeI constructAnnotationColour(
5223           AnnotationColourScheme viewAnnColour, AlignFrame af,
5224           AlignmentI al, JalviewModel model, boolean checkGroupAnnColour)
5225   {
5226     boolean propagateAnnColour = false;
5227     AlignmentI annAlignment = af != null ? af.getViewport().getAlignment()
5228             : al;
5229     if (checkGroupAnnColour && al.getGroups() != null
5230             && al.getGroups().size() > 0)
5231     {
5232       // pre 2.8.1 behaviour
5233       // check to see if we should transfer annotation colours
5234       propagateAnnColour = true;
5235       for (SequenceGroup sg : al.getGroups())
5236       {
5237         if (sg.getColourScheme() instanceof AnnotationColourGradient)
5238         {
5239           propagateAnnColour = false;
5240         }
5241       }
5242     }
5243
5244     /*
5245      * 2.10.2- : saved annotationId is AlignmentAnnotation.annotationId
5246      */
5247     String annotationId = viewAnnColour.getAnnotation();
5248     AlignmentAnnotation matchedAnnotation = annotationIds.get(annotationId);
5249
5250     /*
5251      * pre 2.10.2: saved annotationId is AlignmentAnnotation.label
5252      */
5253     if (matchedAnnotation == null
5254             && annAlignment.getAlignmentAnnotation() != null)
5255     {
5256       for (int i = 0; i < annAlignment.getAlignmentAnnotation().length; i++)
5257       {
5258         if (annotationId
5259                 .equals(annAlignment.getAlignmentAnnotation()[i].label))
5260         {
5261           matchedAnnotation = annAlignment.getAlignmentAnnotation()[i];
5262           break;
5263         }
5264       }
5265     }
5266     if (matchedAnnotation == null)
5267     {
5268       System.err.println("Failed to match annotation colour scheme for "
5269               + annotationId);
5270       return null;
5271     }
5272     if (matchedAnnotation.getThreshold() == null)
5273     {
5274       matchedAnnotation.setThreshold(
5275               new GraphLine(safeFloat(viewAnnColour.getThreshold()),
5276                       "Threshold", Color.black));
5277     }
5278
5279     AnnotationColourGradient cs = null;
5280     if (viewAnnColour.getColourScheme().equals("None"))
5281     {
5282       cs = new AnnotationColourGradient(matchedAnnotation,
5283               new Color(safeInt(viewAnnColour.getMinColour())),
5284               new Color(safeInt(viewAnnColour.getMaxColour())),
5285               safeInt(viewAnnColour.getAboveThreshold()));
5286     }
5287     else if (viewAnnColour.getColourScheme().startsWith("ucs"))
5288     {
5289       cs = new AnnotationColourGradient(matchedAnnotation,
5290               getUserColourScheme(model, viewAnnColour.getColourScheme()),
5291               safeInt(viewAnnColour.getAboveThreshold()));
5292     }
5293     else
5294     {
5295       cs = new AnnotationColourGradient(matchedAnnotation,
5296               ColourSchemeProperty.getColourScheme(af.getViewport(), al,
5297                       viewAnnColour.getColourScheme()),
5298               safeInt(viewAnnColour.getAboveThreshold()));
5299     }
5300
5301     boolean perSequenceOnly = safeBoolean(viewAnnColour.isPerSequence());
5302     boolean useOriginalColours = safeBoolean(
5303             viewAnnColour.isPredefinedColours());
5304     cs.setSeqAssociated(perSequenceOnly);
5305     cs.setPredefinedColours(useOriginalColours);
5306
5307     if (propagateAnnColour && al.getGroups() != null)
5308     {
5309       // Also use these settings for all the groups
5310       for (int g = 0; g < al.getGroups().size(); g++)
5311       {
5312         SequenceGroup sg = al.getGroups().get(g);
5313         if (sg.getGroupColourScheme() == null)
5314         {
5315           continue;
5316         }
5317
5318         AnnotationColourGradient groupScheme = new AnnotationColourGradient(
5319                 matchedAnnotation, sg.getColourScheme(),
5320                 safeInt(viewAnnColour.getAboveThreshold()));
5321         sg.setColourScheme(groupScheme);
5322         groupScheme.setSeqAssociated(perSequenceOnly);
5323         groupScheme.setPredefinedColours(useOriginalColours);
5324       }
5325     }
5326     return cs;
5327   }
5328
5329   private void reorderAutoannotation(AlignFrame af, AlignmentI al,
5330           List<JvAnnotRow> autoAlan)
5331   {
5332     // copy over visualization settings for autocalculated annotation in the
5333     // view
5334     if (al.getAlignmentAnnotation() != null)
5335     {
5336       /**
5337        * Kludge for magic autoannotation names (see JAL-811)
5338        */
5339       String[] magicNames = new String[] { "Consensus", "Quality",
5340           "Conservation" };
5341       JvAnnotRow nullAnnot = new JvAnnotRow(-1, null);
5342       Hashtable<String, JvAnnotRow> visan = new Hashtable<>();
5343       for (String nm : magicNames)
5344       {
5345         visan.put(nm, nullAnnot);
5346       }
5347       for (JvAnnotRow auan : autoAlan)
5348       {
5349         visan.put(auan.template.label
5350                 + (auan.template.getCalcId() == null ? ""
5351                         : "\t" + auan.template.getCalcId()),
5352                 auan);
5353       }
5354       int hSize = al.getAlignmentAnnotation().length;
5355       List<JvAnnotRow> reorder = new ArrayList<>();
5356       // work through any autoCalculated annotation already on the view
5357       // removing it if it should be placed in a different location on the
5358       // annotation panel.
5359       List<String> remains = new ArrayList<>(visan.keySet());
5360       for (int h = 0; h < hSize; h++)
5361       {
5362         jalview.datamodel.AlignmentAnnotation jalan = al
5363                 .getAlignmentAnnotation()[h];
5364         if (jalan.autoCalculated)
5365         {
5366           String k;
5367           JvAnnotRow valan = visan.get(k = jalan.label);
5368           if (jalan.getCalcId() != null)
5369           {
5370             valan = visan.get(k = jalan.label + "\t" + jalan.getCalcId());
5371           }
5372
5373           if (valan != null)
5374           {
5375             // delete the auto calculated row from the alignment
5376             al.deleteAnnotation(jalan, false);
5377             remains.remove(k);
5378             hSize--;
5379             h--;
5380             if (valan != nullAnnot)
5381             {
5382               if (jalan != valan.template)
5383               {
5384                 // newly created autoannotation row instance
5385                 // so keep a reference to the visible annotation row
5386                 // and copy over all relevant attributes
5387                 if (valan.template.graphHeight >= 0)
5388
5389                 {
5390                   jalan.graphHeight = valan.template.graphHeight;
5391                 }
5392                 jalan.visible = valan.template.visible;
5393               }
5394               reorder.add(new JvAnnotRow(valan.order, jalan));
5395             }
5396           }
5397         }
5398       }
5399       // Add any (possibly stale) autocalculated rows that were not appended to
5400       // the view during construction
5401       for (String other : remains)
5402       {
5403         JvAnnotRow othera = visan.get(other);
5404         if (othera != nullAnnot && othera.template.getCalcId() != null
5405                 && othera.template.getCalcId().length() > 0)
5406         {
5407           reorder.add(othera);
5408         }
5409       }
5410       // now put the automatic annotation in its correct place
5411       int s = 0, srt[] = new int[reorder.size()];
5412       JvAnnotRow[] rws = new JvAnnotRow[reorder.size()];
5413       for (JvAnnotRow jvar : reorder)
5414       {
5415         rws[s] = jvar;
5416         srt[s++] = jvar.order;
5417       }
5418       reorder.clear();
5419       jalview.util.QuickSort.sort(srt, rws);
5420       // and re-insert the annotation at its correct position
5421       for (JvAnnotRow jvar : rws)
5422       {
5423         al.addAnnotation(jvar.template, jvar.order);
5424       }
5425       af.alignPanel.adjustAnnotationHeight();
5426     }
5427   }
5428
5429   Hashtable skipList = null;
5430
5431   /**
5432    * TODO remove this method
5433    *
5434    * @param view
5435    * @return AlignFrame bound to sequenceSetId from view, if one exists. private
5436    *         AlignFrame getSkippedFrame(Viewport view) { if (skipList==null) {
5437    *         throw new Error("Implementation Error. No skipList defined for this
5438    *         Jalview2XML instance."); } return (AlignFrame)
5439    *         skipList.get(view.getSequenceSetId()); }
5440    */
5441
5442   /**
5443    * Check if the Jalview view contained in object should be skipped or not.
5444    *
5445    * @param object
5446    * @return true if view's sequenceSetId is a key in skipList
5447    */
5448   private boolean skipViewport(JalviewModel object)
5449   {
5450     if (skipList == null)
5451     {
5452       return false;
5453     }
5454     String id = object.getViewport().get(0).getSequenceSetId();
5455     if (skipList.containsKey(id))
5456     {
5457       if (Cache.log != null && Cache.log.isDebugEnabled())
5458       {
5459         Cache.log.debug("Skipping seuqence set id " + id);
5460       }
5461       return true;
5462     }
5463     return false;
5464   }
5465
5466   public void addToSkipList(AlignFrame af)
5467   {
5468     if (skipList == null)
5469     {
5470       skipList = new Hashtable();
5471     }
5472     skipList.put(af.getViewport().getSequenceSetId(), af);
5473   }
5474
5475   public void clearSkipList()
5476   {
5477     if (skipList != null)
5478     {
5479       skipList.clear();
5480       skipList = null;
5481     }
5482   }
5483
5484   private void recoverDatasetFor(SequenceSet vamsasSet, AlignmentI al,
5485           boolean ignoreUnrefed, String uniqueSeqSetId)
5486   {
5487     jalview.datamodel.AlignmentI ds = getDatasetFor(
5488             vamsasSet.getDatasetId());
5489     AlignmentI xtant_ds = ds;
5490     if (xtant_ds == null)
5491     {
5492       // good chance we are about to create a new dataset, but check if we've
5493       // seen some of the dataset sequence IDs before.
5494       // TODO: skip this check if we are working with project generated by
5495       // version 2.11 or later
5496       xtant_ds = checkIfHasDataset(vamsasSet.getSequence());
5497       if (xtant_ds != null)
5498       {
5499         ds = xtant_ds;
5500         addDatasetRef(vamsasSet.getDatasetId(), ds);
5501       }
5502     }
5503     Vector dseqs = null;
5504     if (!ignoreUnrefed)
5505     {
5506       // recovering an alignment View
5507       AlignmentI seqSetDS = getDatasetFor(UNIQSEQSETID + uniqueSeqSetId);
5508       if (seqSetDS != null)
5509       {
5510         if (ds != null && ds != seqSetDS)
5511         {
5512           warn("JAL-3171 regression: Overwriting a dataset reference for an alignment"
5513                   + " - CDS/Protein crossreference data may be lost");
5514           if (xtant_ds != null)
5515           {
5516             // This can only happen if the unique sequence set ID was bound to a
5517             // dataset that did not contain any of the sequences in the view
5518             // currently being restored.
5519             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.");
5520           }
5521         }
5522         ds = seqSetDS;
5523         addDatasetRef(vamsasSet.getDatasetId(), ds);
5524       }
5525     }
5526     if (ds == null)
5527     {
5528       // try even harder to restore dataset
5529       AlignmentI xtantDS = checkIfHasDataset(vamsasSet.getSequence());
5530       // create a list of new dataset sequences
5531       dseqs = new Vector();
5532     }
5533     for (int i = 0, iSize = vamsasSet.getSequence().size(); i < iSize; i++)
5534     {
5535       Sequence vamsasSeq = vamsasSet.getSequence().get(i);
5536       ensureJalviewDatasetSequence(vamsasSeq, ds, dseqs, ignoreUnrefed, i);
5537     }
5538     // create a new dataset
5539     if (ds == null)
5540     {
5541       SequenceI[] dsseqs = new SequenceI[dseqs.size()];
5542       dseqs.copyInto(dsseqs);
5543       ds = new jalview.datamodel.Alignment(dsseqs);
5544       debug("Created new dataset " + vamsasSet.getDatasetId()
5545               + " for alignment " + System.identityHashCode(al));
5546       addDatasetRef(vamsasSet.getDatasetId(), ds);
5547     }
5548     // set the dataset for the newly imported alignment.
5549     if (al.getDataset() == null && !ignoreUnrefed)
5550     {
5551       al.setDataset(ds);
5552       // register dataset for the alignment's uniqueSeqSetId for legacy projects
5553       addDatasetRef(UNIQSEQSETID + uniqueSeqSetId, ds);
5554     }
5555     updateSeqDatasetBinding(vamsasSet.getSequence(), ds);
5556   }
5557
5558   /**
5559    * XML dataset sequence ID to materialised dataset reference
5560    */
5561   HashMap<String, AlignmentI> seqToDataset = new HashMap<>();
5562
5563   /**
5564    * @return the first materialised dataset reference containing a dataset
5565    *         sequence referenced in the given view
5566    * @param list
5567    *          - sequences from the view
5568    */
5569   AlignmentI checkIfHasDataset(List<Sequence> list)
5570   {
5571     for (Sequence restoredSeq : list)
5572     {
5573       AlignmentI datasetFor = seqToDataset.get(restoredSeq.getDsseqid());
5574       if (datasetFor != null)
5575       {
5576         return datasetFor;
5577       }
5578     }
5579     return null;
5580   }
5581
5582   /**
5583    * Register ds as the containing dataset for the dataset sequences referenced
5584    * by sequences in list
5585    *
5586    * @param list
5587    *          - sequences in a view
5588    * @param ds
5589    */
5590   void updateSeqDatasetBinding(List<Sequence> list, AlignmentI ds)
5591   {
5592     for (Sequence restoredSeq : list)
5593     {
5594       AlignmentI prevDS = seqToDataset.put(restoredSeq.getDsseqid(), ds);
5595       if (prevDS != null && prevDS != ds)
5596       {
5597         warn("Dataset sequence appears in many datasets: "
5598                 + restoredSeq.getDsseqid());
5599         // TODO: try to merge!
5600       }
5601     }
5602   }
5603   /**
5604    *
5605    * @param vamsasSeq
5606    *          sequence definition to create/merge dataset sequence for
5607    * @param ds
5608    *          dataset alignment
5609    * @param dseqs
5610    *          vector to add new dataset sequence to
5611    * @param ignoreUnrefed
5612    *          - when true, don't create new sequences from vamsasSeq if it's id
5613    *          doesn't already have an asssociated Jalview sequence.
5614    * @param vseqpos
5615    *          - used to reorder the sequence in the alignment according to the
5616    *          vamsasSeq array ordering, to preserve ordering of dataset
5617    */
5618   private void ensureJalviewDatasetSequence(Sequence vamsasSeq,
5619           AlignmentI ds, Vector dseqs, boolean ignoreUnrefed, int vseqpos)
5620   {
5621     // JBP TODO: Check this is called for AlCodonFrames to support recovery of
5622     // xRef Codon Maps
5623     SequenceI sq = seqRefIds.get(vamsasSeq.getId());
5624     boolean reorder = false;
5625     SequenceI dsq = null;
5626     if (sq != null && sq.getDatasetSequence() != null)
5627     {
5628       dsq = sq.getDatasetSequence();
5629     }
5630     else
5631     {
5632       reorder = true;
5633     }
5634     if (sq == null && ignoreUnrefed)
5635     {
5636       return;
5637     }
5638     String sqid = vamsasSeq.getDsseqid();
5639     if (dsq == null)
5640     {
5641       // need to create or add a new dataset sequence reference to this sequence
5642       if (sqid != null)
5643       {
5644         dsq = seqRefIds.get(sqid);
5645       }
5646       // check again
5647       if (dsq == null)
5648       {
5649         // make a new dataset sequence
5650         dsq = sq.createDatasetSequence();
5651         if (sqid == null)
5652         {
5653           // make up a new dataset reference for this sequence
5654           sqid = seqHash(dsq);
5655         }
5656         dsq.setVamsasId(uniqueSetSuffix + sqid);
5657         seqRefIds.put(sqid, dsq);
5658         if (ds == null)
5659         {
5660           if (dseqs != null)
5661           {
5662             dseqs.addElement(dsq);
5663           }
5664         }
5665         else
5666         {
5667           ds.addSequence(dsq);
5668         }
5669       }
5670       else
5671       {
5672         if (sq != dsq)
5673         { // make this dataset sequence sq's dataset sequence
5674           sq.setDatasetSequence(dsq);
5675           // and update the current dataset alignment
5676           if (ds == null)
5677           {
5678             if (dseqs != null)
5679             {
5680               if (!dseqs.contains(dsq))
5681               {
5682                 dseqs.add(dsq);
5683               }
5684             }
5685             else
5686             {
5687               if (ds.findIndex(dsq) < 0)
5688               {
5689                 ds.addSequence(dsq);
5690               }
5691             }
5692           }
5693         }
5694       }
5695     }
5696     // TODO: refactor this as a merge dataset sequence function
5697     // now check that sq (the dataset sequence) sequence really is the union of
5698     // all references to it
5699     // boolean pre = sq.getStart() < dsq.getStart();
5700     // boolean post = sq.getEnd() > dsq.getEnd();
5701     // if (pre || post)
5702     if (sq != dsq)
5703     {
5704       // StringBuffer sb = new StringBuffer();
5705       String newres = jalview.analysis.AlignSeq.extractGaps(
5706               jalview.util.Comparison.GapChars, sq.getSequenceAsString());
5707       if (!newres.equalsIgnoreCase(dsq.getSequenceAsString())
5708               && newres.length() > dsq.getLength())
5709       {
5710         // Update with the longer sequence.
5711         synchronized (dsq)
5712         {
5713           /*
5714            * if (pre) { sb.insert(0, newres .substring(0, dsq.getStart() -
5715            * sq.getStart())); dsq.setStart(sq.getStart()); } if (post) {
5716            * sb.append(newres.substring(newres.length() - sq.getEnd() -
5717            * dsq.getEnd())); dsq.setEnd(sq.getEnd()); }
5718            */
5719           dsq.setSequence(newres);
5720         }
5721         // TODO: merges will never happen if we 'know' we have the real dataset
5722         // sequence - this should be detected when id==dssid
5723         System.err.println(
5724                 "DEBUG Notice:  Merged dataset sequence (if you see this often, post at http://issues.jalview.org/browse/JAL-1474)"); // ("
5725         // + (pre ? "prepended" : "") + " "
5726         // + (post ? "appended" : ""));
5727       }
5728     }
5729     else
5730     {
5731       // sequence refs are identical. We may need to update the existing dataset
5732       // alignment with this one, though.
5733       if (ds != null && dseqs == null)
5734       {
5735         int opos = ds.findIndex(dsq);
5736         SequenceI tseq = null;
5737         if (opos != -1 && vseqpos != opos)
5738         {
5739           // remove from old position
5740           ds.deleteSequence(dsq);
5741         }
5742         if (vseqpos < ds.getHeight())
5743         {
5744           if (vseqpos != opos)
5745           {
5746             // save sequence at destination position
5747             tseq = ds.getSequenceAt(vseqpos);
5748             ds.replaceSequenceAt(vseqpos, dsq);
5749             ds.addSequence(tseq);
5750           }
5751         }
5752         else
5753         {
5754           ds.addSequence(dsq);
5755         }
5756       }
5757     }
5758   }
5759
5760   /*
5761    * TODO use AlignmentI here and in related methods - needs
5762    * AlignmentI.getDataset() changed to return AlignmentI instead of Alignment
5763    */
5764   Hashtable<String, AlignmentI> datasetIds = null;
5765
5766   IdentityHashMap<AlignmentI, String> dataset2Ids = null;
5767
5768   private AlignmentI getDatasetFor(String datasetId)
5769   {
5770     if (datasetIds == null)
5771     {
5772       datasetIds = new Hashtable<>();
5773       return null;
5774     }
5775     if (datasetIds.containsKey(datasetId))
5776     {
5777       return datasetIds.get(datasetId);
5778     }
5779     return null;
5780   }
5781
5782   private void addDatasetRef(String datasetId, AlignmentI dataset)
5783   {
5784     if (datasetIds == null)
5785     {
5786       datasetIds = new Hashtable<>();
5787     }
5788     datasetIds.put(datasetId, dataset);
5789   }
5790
5791   /**
5792    * make a new dataset ID for this jalview dataset alignment
5793    *
5794    * @param dataset
5795    * @return
5796    */
5797   private String getDatasetIdRef(AlignmentI dataset)
5798   {
5799     if (dataset.getDataset() != null)
5800     {
5801       warn("Serious issue!  Dataset Object passed to getDatasetIdRef is not a Jalview DATASET alignment...");
5802     }
5803     String datasetId = makeHashCode(dataset, null);
5804     if (datasetId == null)
5805     {
5806       // make a new datasetId and record it
5807       if (dataset2Ids == null)
5808       {
5809         dataset2Ids = new IdentityHashMap<>();
5810       }
5811       else
5812       {
5813         datasetId = dataset2Ids.get(dataset);
5814       }
5815       if (datasetId == null)
5816       {
5817         datasetId = "ds" + dataset2Ids.size() + 1;
5818         dataset2Ids.put(dataset, datasetId);
5819       }
5820     }
5821     return datasetId;
5822   }
5823
5824   private void addDBRefs(SequenceI datasetSequence, Sequence sequence)
5825   {
5826     for (int d = 0; d < sequence.getDBRef().size(); d++)
5827     {
5828       DBRef dr = sequence.getDBRef().get(d);
5829       jalview.datamodel.DBRefEntry entry = new jalview.datamodel.DBRefEntry(
5830               dr.getSource(), dr.getVersion(), dr.getAccessionId());
5831       if (dr.getMapping() != null)
5832       {
5833         entry.setMap(addMapping(dr.getMapping()));
5834       }
5835       datasetSequence.addDBRef(entry);
5836     }
5837   }
5838
5839   private jalview.datamodel.Mapping addMapping(Mapping m)
5840   {
5841     SequenceI dsto = null;
5842     // Mapping m = dr.getMapping();
5843     int fr[] = new int[m.getMapListFrom().size() * 2];
5844     Iterator<MapListFrom> from = m.getMapListFrom().iterator();// enumerateMapListFrom();
5845     for (int _i = 0; from.hasNext(); _i += 2)
5846     {
5847       MapListFrom mf = from.next();
5848       fr[_i] = mf.getStart();
5849       fr[_i + 1] = mf.getEnd();
5850     }
5851     int fto[] = new int[m.getMapListTo().size() * 2];
5852     Iterator<MapListTo> to = m.getMapListTo().iterator();// enumerateMapListTo();
5853     for (int _i = 0; to.hasNext(); _i += 2)
5854     {
5855       MapListTo mf = to.next();
5856       fto[_i] = mf.getStart();
5857       fto[_i + 1] = mf.getEnd();
5858     }
5859     jalview.datamodel.Mapping jmap = new jalview.datamodel.Mapping(dsto, fr,
5860             fto, m.getMapFromUnit().intValue(),
5861             m.getMapToUnit().intValue());
5862
5863     /*
5864      * (optional) choice of dseqFor or Sequence
5865      */
5866     if (m.getDseqFor() != null)
5867     {
5868       String dsfor = m.getDseqFor();
5869       if (seqRefIds.containsKey(dsfor))
5870       {
5871         /*
5872          * recover from hash
5873          */
5874         jmap.setTo(seqRefIds.get(dsfor));
5875       }
5876       else
5877       {
5878         frefedSequence.add(newMappingRef(dsfor, jmap));
5879       }
5880     }
5881     else if (m.getSequence() != null)
5882     {
5883       /*
5884        * local sequence definition
5885        */
5886       Sequence ms = m.getSequence();
5887       SequenceI djs = null;
5888       String sqid = ms.getDsseqid();
5889       if (sqid != null && sqid.length() > 0)
5890       {
5891         /*
5892          * recover dataset sequence
5893          */
5894         djs = seqRefIds.get(sqid);
5895       }
5896       else
5897       {
5898         System.err.println(
5899                 "Warning - making up dataset sequence id for DbRef sequence map reference");
5900         sqid = ((Object) ms).toString(); // make up a new hascode for
5901         // undefined dataset sequence hash
5902         // (unlikely to happen)
5903       }
5904
5905       if (djs == null)
5906       {
5907         /**
5908          * make a new dataset sequence and add it to refIds hash
5909          */
5910         djs = new jalview.datamodel.Sequence(ms.getName(),
5911                 ms.getSequence());
5912         djs.setStart(jmap.getMap().getToLowest());
5913         djs.setEnd(jmap.getMap().getToHighest());
5914         djs.setVamsasId(uniqueSetSuffix + sqid);
5915         jmap.setTo(djs);
5916         incompleteSeqs.put(sqid, djs);
5917         seqRefIds.put(sqid, djs);
5918
5919       }
5920       jalview.bin.Cache.log.debug("about to recurse on addDBRefs.");
5921       addDBRefs(djs, ms);
5922
5923     }
5924
5925     return jmap;
5926   }
5927
5928   /**
5929    * Provides a 'copy' of an alignment view (on action New View) by 'saving' the
5930    * view as XML (but not to file), and then reloading it
5931    *
5932    * @param ap
5933    * @return
5934    */
5935   public AlignmentPanel copyAlignPanel(AlignmentPanel ap)
5936   {
5937     initSeqRefs();
5938     JalviewModel jm = saveState(ap, null, null, null);
5939
5940     addDatasetRef(
5941             jm.getVamsasModel().getSequenceSet().get(0).getDatasetId(),
5942             ap.getAlignment().getDataset());
5943
5944     uniqueSetSuffix = "";
5945     // jm.getJalviewModelSequence().getViewport(0).setId(null);
5946     jm.getViewport().get(0).setId(null);
5947     // we don't overwrite the view we just copied
5948
5949     if (this.frefedSequence == null)
5950     {
5951       frefedSequence = new Vector<>();
5952     }
5953
5954     viewportsAdded.clear();
5955
5956     AlignFrame af = loadFromObject(jm, null, false, null);
5957     af.getAlignPanels().clear();
5958     af.closeMenuItem_actionPerformed(true);
5959
5960     /*
5961      * if(ap.av.getAlignment().getAlignmentAnnotation()!=null) { for(int i=0;
5962      * i<ap.av.getAlignment().getAlignmentAnnotation().length; i++) {
5963      * if(!ap.av.getAlignment().getAlignmentAnnotation()[i].autoCalculated) {
5964      * af.alignPanel.av.getAlignment().getAlignmentAnnotation()[i] =
5965      * ap.av.getAlignment().getAlignmentAnnotation()[i]; } } }
5966      */
5967
5968     return af.alignPanel;
5969   }
5970
5971   private Hashtable jvids2vobj;
5972
5973   private void warn(String msg)
5974   {
5975     warn(msg, null);
5976   }
5977
5978   private void warn(String msg, Exception e)
5979   {
5980     if (Cache.log != null)
5981     {
5982       if (e != null)
5983       {
5984         Cache.log.warn(msg, e);
5985       }
5986       else
5987       {
5988         Cache.log.warn(msg);
5989       }
5990     }
5991     else
5992     {
5993       System.err.println("Warning: " + msg);
5994       if (e != null)
5995       {
5996         e.printStackTrace();
5997       }
5998     }
5999   }
6000
6001   private void debug(String string)
6002   {
6003     debug(string, null);
6004   }
6005
6006   private void debug(String msg, Exception e)
6007   {
6008     if (Cache.log != null)
6009     {
6010       if (e != null)
6011       {
6012         Cache.log.debug(msg, e);
6013       }
6014       else
6015       {
6016         Cache.log.debug(msg);
6017       }
6018     }
6019     else
6020     {
6021       System.err.println("Warning: " + msg);
6022       if (e != null)
6023       {
6024         e.printStackTrace();
6025       }
6026     }
6027   }
6028
6029   /**
6030    * set the object to ID mapping tables used to write/recover objects and XML
6031    * ID strings for the jalview project. If external tables are provided then
6032    * finalize and clearSeqRefs will not clear the tables when the Jalview2XML
6033    * object goes out of scope. - also populates the datasetIds hashtable with
6034    * alignment objects containing dataset sequences
6035    *
6036    * @param vobj2jv
6037    *          Map from ID strings to jalview datamodel
6038    * @param jv2vobj
6039    *          Map from jalview datamodel to ID strings
6040    *
6041    *
6042    */
6043   public void setObjectMappingTables(Hashtable vobj2jv,
6044           IdentityHashMap jv2vobj)
6045   {
6046     this.jv2vobj = jv2vobj;
6047     this.vobj2jv = vobj2jv;
6048     Iterator ds = jv2vobj.keySet().iterator();
6049     String id;
6050     while (ds.hasNext())
6051     {
6052       Object jvobj = ds.next();
6053       id = jv2vobj.get(jvobj).toString();
6054       if (jvobj instanceof jalview.datamodel.Alignment)
6055       {
6056         if (((jalview.datamodel.Alignment) jvobj).getDataset() == null)
6057         {
6058           addDatasetRef(id, (jalview.datamodel.Alignment) jvobj);
6059         }
6060       }
6061       else if (jvobj instanceof jalview.datamodel.Sequence)
6062       {
6063         // register sequence object so the XML parser can recover it.
6064         if (seqRefIds == null)
6065         {
6066           seqRefIds = new HashMap<>();
6067         }
6068         if (seqsToIds == null)
6069         {
6070           seqsToIds = new IdentityHashMap<>();
6071         }
6072         seqRefIds.put(jv2vobj.get(jvobj).toString(), (SequenceI) jvobj);
6073         seqsToIds.put((SequenceI) jvobj, id);
6074       }
6075       else if (jvobj instanceof jalview.datamodel.AlignmentAnnotation)
6076       {
6077         String anid;
6078         AlignmentAnnotation jvann = (AlignmentAnnotation) jvobj;
6079         annotationIds.put(anid = jv2vobj.get(jvobj).toString(), jvann);
6080         if (jvann.annotationId == null)
6081         {
6082           jvann.annotationId = anid;
6083         }
6084         if (!jvann.annotationId.equals(anid))
6085         {
6086           // TODO verify that this is the correct behaviour
6087           this.warn("Overriding Annotation ID for " + anid
6088                   + " from different id : " + jvann.annotationId);
6089           jvann.annotationId = anid;
6090         }
6091       }
6092       else if (jvobj instanceof String)
6093       {
6094         if (jvids2vobj == null)
6095         {
6096           jvids2vobj = new Hashtable();
6097           jvids2vobj.put(jvobj, jv2vobj.get(jvobj).toString());
6098         }
6099       }
6100       else
6101       {
6102         Cache.log.debug("Ignoring " + jvobj.getClass() + " (ID = " + id);
6103       }
6104     }
6105   }
6106
6107   /**
6108    * set the uniqueSetSuffix used to prefix/suffix object IDs for jalview
6109    * objects created from the project archive. If string is null (default for
6110    * construction) then suffix will be set automatically.
6111    *
6112    * @param string
6113    */
6114   public void setUniqueSetSuffix(String string)
6115   {
6116     uniqueSetSuffix = string;
6117
6118   }
6119
6120   /**
6121    * uses skipList2 as the skipList for skipping views on sequence sets
6122    * associated with keys in the skipList
6123    *
6124    * @param skipList2
6125    */
6126   public void setSkipList(Hashtable skipList2)
6127   {
6128     skipList = skipList2;
6129   }
6130
6131   /**
6132    * Reads the jar entry of given name and returns its contents, or null if the
6133    * entry is not found.
6134    *
6135    * @param jprovider
6136    * @param jarEntryName
6137    * @return
6138    */
6139   protected String readJarEntry(jarInputStreamProvider jprovider,
6140           String jarEntryName)
6141   {
6142     String result = null;
6143     BufferedReader in = null;
6144
6145     try
6146     {
6147       /*
6148        * Reopen the jar input stream and traverse its entries to find a matching
6149        * name
6150        */
6151       JarInputStream jin = jprovider.getJarInputStream();
6152       JarEntry entry = null;
6153       do
6154       {
6155         entry = jin.getNextJarEntry();
6156       } while (entry != null && !entry.getName().equals(jarEntryName));
6157
6158       if (entry != null)
6159       {
6160         StringBuilder out = new StringBuilder(256);
6161         in = new BufferedReader(new InputStreamReader(jin, UTF_8));
6162         String data;
6163
6164         while ((data = in.readLine()) != null)
6165         {
6166           out.append(data);
6167         }
6168         result = out.toString();
6169       }
6170       else
6171       {
6172         warn("Couldn't find entry in Jalview Jar for " + jarEntryName);
6173       }
6174     } catch (Exception ex)
6175     {
6176       ex.printStackTrace();
6177     } finally
6178     {
6179       if (in != null)
6180       {
6181         try
6182         {
6183           in.close();
6184         } catch (IOException e)
6185         {
6186           // ignore
6187         }
6188       }
6189     }
6190
6191     return result;
6192   }
6193
6194   /**
6195    * Returns an incrementing counter (0, 1, 2...)
6196    *
6197    * @return
6198    */
6199   private synchronized int nextCounter()
6200   {
6201     return counter++;
6202   }
6203
6204   /**
6205    * Loads any saved PCA viewers
6206    *
6207    * @param jms
6208    * @param ap
6209    */
6210   protected void loadPCAViewers(JalviewModel model, AlignmentPanel ap)
6211   {
6212     try
6213     {
6214       List<PcaViewer> pcaviewers = model.getPcaViewer();
6215       for (PcaViewer viewer : pcaviewers)
6216       {
6217         String modelName = viewer.getScoreModelName();
6218         SimilarityParamsI params = new SimilarityParams(
6219                 viewer.isIncludeGappedColumns(), viewer.isMatchGaps(),
6220                 viewer.isIncludeGaps(),
6221                 viewer.isDenominateByShortestLength());
6222
6223         /*
6224          * create the panel (without computing the PCA)
6225          */
6226         PCAPanel panel = new PCAPanel(ap, modelName, params);
6227
6228         panel.setTitle(viewer.getTitle());
6229         panel.setBounds(new Rectangle(viewer.getXpos(), viewer.getYpos(),
6230                 viewer.getWidth(), viewer.getHeight()));
6231
6232         boolean showLabels = viewer.isShowLabels();
6233         panel.setShowLabels(showLabels);
6234         panel.getRotatableCanvas().setShowLabels(showLabels);
6235         panel.getRotatableCanvas()
6236                 .setBgColour(new Color(viewer.getBgColour()));
6237         panel.getRotatableCanvas()
6238                 .setApplyToAllViews(viewer.isLinkToAllViews());
6239
6240         /*
6241          * load PCA output data
6242          */
6243         ScoreModelI scoreModel = ScoreModels.getInstance()
6244                 .getScoreModel(modelName, ap);
6245         PCA pca = new PCA(null, scoreModel, params);
6246         PcaDataType pcaData = viewer.getPcaData();
6247
6248         MatrixI pairwise = loadDoubleMatrix(pcaData.getPairwiseMatrix());
6249         pca.setPairwiseScores(pairwise);
6250
6251         MatrixI triDiag = loadDoubleMatrix(pcaData.getTridiagonalMatrix());
6252         pca.setTridiagonal(triDiag);
6253
6254         MatrixI result = loadDoubleMatrix(pcaData.getEigenMatrix());
6255         pca.setEigenmatrix(result);
6256
6257         panel.getPcaModel().setPCA(pca);
6258
6259         /*
6260          * we haven't saved the input data! (JAL-2647 to do)
6261          */
6262         panel.setInputData(null);
6263
6264         /*
6265          * add the sequence points for the PCA display
6266          */
6267         List<jalview.datamodel.SequencePoint> seqPoints = new ArrayList<>();
6268         for (SequencePoint sp : viewer.getSequencePoint())
6269         {
6270           String seqId = sp.getSequenceRef();
6271           SequenceI seq = seqRefIds.get(seqId);
6272           if (seq == null)
6273           {
6274             throw new IllegalStateException(
6275                     "Unmatched seqref for PCA: " + seqId);
6276           }
6277           Point pt = new Point(sp.getXPos(), sp.getYPos(), sp.getZPos());
6278           jalview.datamodel.SequencePoint seqPoint = new jalview.datamodel.SequencePoint(
6279                   seq, pt);
6280           seqPoints.add(seqPoint);
6281         }
6282         panel.getRotatableCanvas().setPoints(seqPoints, seqPoints.size());
6283
6284         /*
6285          * set min-max ranges and scale after setPoints (which recomputes them)
6286          */
6287         panel.getRotatableCanvas().setScaleFactor(viewer.getScaleFactor());
6288         SeqPointMin spMin = viewer.getSeqPointMin();
6289         float[] min = new float[] { spMin.getXPos(), spMin.getYPos(),
6290             spMin.getZPos() };
6291         SeqPointMax spMax = viewer.getSeqPointMax();
6292         float[] max = new float[] { spMax.getXPos(), spMax.getYPos(),
6293             spMax.getZPos() };
6294         panel.getRotatableCanvas().setSeqMinMax(min, max);
6295
6296         // todo: hold points list in PCAModel only
6297         panel.getPcaModel().setSequencePoints(seqPoints);
6298
6299         panel.setSelectedDimensionIndex(viewer.getXDim(), X);
6300         panel.setSelectedDimensionIndex(viewer.getYDim(), Y);
6301         panel.setSelectedDimensionIndex(viewer.getZDim(), Z);
6302
6303         // is this duplication needed?
6304         panel.setTop(seqPoints.size() - 1);
6305         panel.getPcaModel().setTop(seqPoints.size() - 1);
6306
6307         /*
6308          * add the axes' end points for the display
6309          */
6310         for (int i = 0; i < 3; i++)
6311         {
6312           Axis axis = viewer.getAxis().get(i);
6313           panel.getRotatableCanvas().getAxisEndPoints()[i] = new Point(
6314                   axis.getXPos(), axis.getYPos(), axis.getZPos());
6315         }
6316
6317         Desktop.addInternalFrame(panel, MessageManager.formatMessage(
6318                 "label.calc_title", "PCA", modelName), 475, 450);
6319       }
6320     } catch (Exception ex)
6321     {
6322       Cache.log.error("Error loading PCA: " + ex.toString());
6323     }
6324   }
6325
6326   /**
6327    * Populates an XML model of the feature colour scheme for one feature type
6328    *
6329    * @param featureType
6330    * @param fcol
6331    * @return
6332    */
6333   public static Colour marshalColour(
6334           String featureType, FeatureColourI fcol)
6335   {
6336     Colour col = new Colour();
6337     if (fcol.isSimpleColour())
6338     {
6339       col.setRGB(Format.getHexString(fcol.getColour()));
6340     }
6341     else
6342     {
6343       col.setRGB(Format.getHexString(fcol.getMaxColour()));
6344       col.setMin(fcol.getMin());
6345       col.setMax(fcol.getMax());
6346       col.setMinRGB(jalview.util.Format.getHexString(fcol.getMinColour()));
6347       col.setAutoScale(fcol.isAutoScaled());
6348       col.setThreshold(fcol.getThreshold());
6349       col.setColourByLabel(fcol.isColourByLabel());
6350       col.setThreshType(fcol.isAboveThreshold() ? ThresholdType.ABOVE
6351               : (fcol.isBelowThreshold() ? ThresholdType.BELOW
6352                       : ThresholdType.NONE));
6353       if (fcol.isColourByAttribute())
6354       {
6355         final String[] attName = fcol.getAttributeName();
6356         col.getAttributeName().add(attName[0]);
6357         if (attName.length > 1)
6358         {
6359           col.getAttributeName().add(attName[1]);
6360         }
6361       }
6362       Color noColour = fcol.getNoColour();
6363       if (noColour == null)
6364       {
6365         col.setNoValueColour(NoValueColour.NONE);
6366       }
6367       else if (noColour == fcol.getMaxColour())
6368       {
6369         col.setNoValueColour(NoValueColour.MAX);
6370       }
6371       else
6372       {
6373         col.setNoValueColour(NoValueColour.MIN);
6374       }
6375     }
6376     col.setName(featureType);
6377     return col;
6378   }
6379
6380   /**
6381    * Populates an XML model of the feature filter(s) for one feature type
6382    *
6383    * @param firstMatcher
6384    *          the first (or only) match condition)
6385    * @param filter
6386    *          remaining match conditions (if any)
6387    * @param and
6388    *          if true, conditions are and-ed, else or-ed
6389    */
6390   public static jalview.xml.binding.jalview.FeatureMatcherSet marshalFilter(
6391           FeatureMatcherI firstMatcher, Iterator<FeatureMatcherI> filters,
6392           boolean and)
6393   {
6394     jalview.xml.binding.jalview.FeatureMatcherSet result = new jalview.xml.binding.jalview.FeatureMatcherSet();
6395
6396     if (filters.hasNext())
6397     {
6398       /*
6399        * compound matcher
6400        */
6401       CompoundMatcher compound = new CompoundMatcher();
6402       compound.setAnd(and);
6403       jalview.xml.binding.jalview.FeatureMatcherSet matcher1 = marshalFilter(
6404               firstMatcher, Collections.emptyIterator(), and);
6405       // compound.addMatcherSet(matcher1);
6406       compound.getMatcherSet().add(matcher1);
6407       FeatureMatcherI nextMatcher = filters.next();
6408       jalview.xml.binding.jalview.FeatureMatcherSet matcher2 = marshalFilter(
6409               nextMatcher, filters, and);
6410       // compound.addMatcherSet(matcher2);
6411       compound.getMatcherSet().add(matcher2);
6412       result.setCompoundMatcher(compound);
6413     }
6414     else
6415     {
6416       /*
6417        * single condition matcher
6418        */
6419       // MatchCondition matcherModel = new MatchCondition();
6420       jalview.xml.binding.jalview.FeatureMatcher matcherModel = new jalview.xml.binding.jalview.FeatureMatcher();
6421       matcherModel.setCondition(
6422               firstMatcher.getMatcher().getCondition().getStableName());
6423       matcherModel.setValue(firstMatcher.getMatcher().getPattern());
6424       if (firstMatcher.isByAttribute())
6425       {
6426         matcherModel.setBy(FilterBy.BY_ATTRIBUTE);
6427         // matcherModel.setAttributeName(firstMatcher.getAttribute());
6428         String[] attName = firstMatcher.getAttribute();
6429         matcherModel.getAttributeName().add(attName[0]); // attribute
6430         if (attName.length > 1)
6431         {
6432           matcherModel.getAttributeName().add(attName[1]); // sub-attribute
6433         }
6434       }
6435       else if (firstMatcher.isByLabel())
6436       {
6437         matcherModel.setBy(FilterBy.BY_LABEL);
6438       }
6439       else if (firstMatcher.isByScore())
6440       {
6441         matcherModel.setBy(FilterBy.BY_SCORE);
6442       }
6443       result.setMatchCondition(matcherModel);
6444     }
6445
6446     return result;
6447   }
6448
6449   /**
6450    * Loads one XML model of a feature filter to a Jalview object
6451    *
6452    * @param featureType
6453    * @param matcherSetModel
6454    * @return
6455    */
6456   public static FeatureMatcherSetI parseFilter(
6457           String featureType,
6458           jalview.xml.binding.jalview.FeatureMatcherSet matcherSetModel)
6459   {
6460     FeatureMatcherSetI result = new FeatureMatcherSet();
6461     try
6462     {
6463       parseFilterConditions(result, matcherSetModel, true);
6464     } catch (IllegalStateException e)
6465     {
6466       // mixing AND and OR conditions perhaps
6467       System.err.println(
6468               String.format("Error reading filter conditions for '%s': %s",
6469                       featureType, e.getMessage()));
6470       // return as much as was parsed up to the error
6471     }
6472
6473     return result;
6474   }
6475
6476   /**
6477    * Adds feature match conditions to matcherSet as unmarshalled from XML
6478    * (possibly recursively for compound conditions)
6479    *
6480    * @param matcherSet
6481    * @param matcherSetModel
6482    * @param and
6483    *          if true, multiple conditions are AND-ed, else they are OR-ed
6484    * @throws IllegalStateException
6485    *           if AND and OR conditions are mixed
6486    */
6487   protected static void parseFilterConditions(
6488           FeatureMatcherSetI matcherSet,
6489           jalview.xml.binding.jalview.FeatureMatcherSet matcherSetModel,
6490           boolean and)
6491   {
6492     jalview.xml.binding.jalview.FeatureMatcher mc = matcherSetModel
6493             .getMatchCondition();
6494     if (mc != null)
6495     {
6496       /*
6497        * single condition
6498        */
6499       FilterBy filterBy = mc.getBy();
6500       Condition cond = Condition.fromString(mc.getCondition());
6501       String pattern = mc.getValue();
6502       FeatureMatcherI matchCondition = null;
6503       if (filterBy == FilterBy.BY_LABEL)
6504       {
6505         matchCondition = FeatureMatcher.byLabel(cond, pattern);
6506       }
6507       else if (filterBy == FilterBy.BY_SCORE)
6508       {
6509         matchCondition = FeatureMatcher.byScore(cond, pattern);
6510
6511       }
6512       else if (filterBy == FilterBy.BY_ATTRIBUTE)
6513       {
6514         final List<String> attributeName = mc.getAttributeName();
6515         String[] attNames = attributeName
6516                 .toArray(new String[attributeName.size()]);
6517         matchCondition = FeatureMatcher.byAttribute(cond, pattern,
6518                 attNames);
6519       }
6520
6521       /*
6522        * note this throws IllegalStateException if AND-ing to a
6523        * previously OR-ed compound condition, or vice versa
6524        */
6525       if (and)
6526       {
6527         matcherSet.and(matchCondition);
6528       }
6529       else
6530       {
6531         matcherSet.or(matchCondition);
6532       }
6533     }
6534     else
6535     {
6536       /*
6537        * compound condition
6538        */
6539       List<jalview.xml.binding.jalview.FeatureMatcherSet> matchers = matcherSetModel
6540               .getCompoundMatcher().getMatcherSet();
6541       boolean anded = matcherSetModel.getCompoundMatcher().isAnd();
6542       if (matchers.size() == 2)
6543       {
6544         parseFilterConditions(matcherSet, matchers.get(0), anded);
6545         parseFilterConditions(matcherSet, matchers.get(1), anded);
6546       }
6547       else
6548       {
6549         System.err.println("Malformed compound filter condition");
6550       }
6551     }
6552   }
6553
6554   /**
6555    * Loads one XML model of a feature colour to a Jalview object
6556    *
6557    * @param colourModel
6558    * @return
6559    */
6560   public static FeatureColourI parseColour(Colour colourModel)
6561   {
6562     FeatureColourI colour = null;
6563
6564     if (colourModel.getMax() != null)
6565     {
6566       Color mincol = null;
6567       Color maxcol = null;
6568       Color noValueColour = null;
6569
6570       try
6571       {
6572         mincol = new Color(Integer.parseInt(colourModel.getMinRGB(), 16));
6573         maxcol = new Color(Integer.parseInt(colourModel.getRGB(), 16));
6574       } catch (Exception e)
6575       {
6576         Cache.log.warn("Couldn't parse out graduated feature color.", e);
6577       }
6578
6579       NoValueColour noCol = colourModel.getNoValueColour();
6580       if (noCol == NoValueColour.MIN)
6581       {
6582         noValueColour = mincol;
6583       }
6584       else if (noCol == NoValueColour.MAX)
6585       {
6586         noValueColour = maxcol;
6587       }
6588
6589       colour = new FeatureColour(maxcol, mincol, maxcol, noValueColour,
6590               safeFloat(colourModel.getMin()),
6591               safeFloat(colourModel.getMax()));
6592       final List<String> attributeName = colourModel.getAttributeName();
6593       String[] attributes = attributeName
6594               .toArray(new String[attributeName.size()]);
6595       if (attributes != null && attributes.length > 0)
6596       {
6597         colour.setAttributeName(attributes);
6598       }
6599       if (colourModel.isAutoScale() != null)
6600       {
6601         colour.setAutoScaled(colourModel.isAutoScale().booleanValue());
6602       }
6603       if (colourModel.isColourByLabel() != null)
6604       {
6605         colour.setColourByLabel(
6606                 colourModel.isColourByLabel().booleanValue());
6607       }
6608       if (colourModel.getThreshold() != null)
6609       {
6610         colour.setThreshold(colourModel.getThreshold().floatValue());
6611       }
6612       ThresholdType ttyp = colourModel.getThreshType();
6613       if (ttyp == ThresholdType.ABOVE)
6614       {
6615         colour.setAboveThreshold(true);
6616       }
6617       else if (ttyp == ThresholdType.BELOW)
6618       {
6619         colour.setBelowThreshold(true);
6620       }
6621     }
6622     else
6623     {
6624       Color color = new Color(Integer.parseInt(colourModel.getRGB(), 16));
6625       colour = new FeatureColour(color);
6626     }
6627
6628     return colour;
6629   }
6630 }