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