src/jalview/gui/Jalview2XML.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.5)
   3  * Copyright (C) 2010 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle
   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 of the License, or (at your option) any later version.
  10  *
  11  * Jalview is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty
  13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14  * PURPOSE.  See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 package jalview.gui;
  19
  20 import java.awt.Rectangle;
  21 import java.io.*;
  22 import java.lang.reflect.InvocationTargetException;
  23 import java.net.*;
  24 import java.util.*;
  25 import java.util.jar.*;
  26
  27 import javax.swing.*;
  28
  29 import org.exolab.castor.xml.*;
  30
  31 import uk.ac.vamsas.objects.utils.MapList;
  32 import jalview.bin.Cache;
  33 import jalview.datamodel.Alignment;
  34 import jalview.datamodel.AlignmentI;
  35 import jalview.datamodel.SequenceI;
  36 import jalview.schemabinding.version2.*;
  37 import jalview.schemes.*;
  38 import jalview.structure.StructureSelectionManager;
  39 import jalview.util.jarInputStreamProvider;
  40
  41 /**
  42  * Write out the current jalview desktop state as a Jalview XML stream.
  43  *
  44  * Note: the vamsas objects referred to here are primitive versions of the
  45  * VAMSAS project schema elements - they are not the same and most likely never
  46  * will be :)
  47  *
  48  * @author $author$
  49  * @version $Revision$
  50  */
  51 public class Jalview2XML
  52 {
  53   /**
  54    * create/return unique hash string for sq
  55    *
  56    * @param sq
  57    * @return new or existing unique string for sq
  58    */
  59   String seqHash(SequenceI sq)
  60   {
  61     if (seqsToIds == null)
  62     {
  63       initSeqRefs();
  64     }
  65     if (seqsToIds.containsKey(sq))
  66     {
  67       return (String) seqsToIds.get(sq);
  68     }
  69     else
  70     {
  71       // create sequential key
  72       String key = "sq" + (seqsToIds.size() + 1);
  73       key = makeHashCode(sq, key); // check we don't have an external reference
  74       // for it already.
  75       seqsToIds.put(sq, key);
  76       return key;
  77     }
  78   }
  79
  80   void clearSeqRefs()
  81   {
  82     if (_cleartables)
  83     {
  84       if (seqRefIds != null)
  85       {
  86         seqRefIds.clear();
  87       }
  88       if (seqsToIds != null)
  89       {
  90         seqsToIds.clear();
  91       }
  92       // seqRefIds = null;
  93       // seqsToIds = null;
  94     }
  95     else
  96     {
  97       // do nothing
  98       warn("clearSeqRefs called when _cleartables was not set. Doing nothing.");
  99       // seqRefIds = new Hashtable();
 100       // seqsToIds = new IdentityHashMap();
 101     }
 102   }
 103
 104   void initSeqRefs()
 105   {
 106     if (seqsToIds == null)
 107     {
 108       seqsToIds = new IdentityHashMap();
 109     }
 110     if (seqRefIds == null)
 111     {
 112       seqRefIds = new Hashtable();
 113     }
 114   }
 115
 116   /**
 117    * SequenceI reference -> XML ID string in jalview XML. Populated as XML reps
 118    * of sequence objects are created.
 119    */
 120   java.util.IdentityHashMap seqsToIds = null;
 121
 122   /**
 123    * jalview XML Sequence ID to jalview sequence object reference (both dataset
 124    * and alignment sequences. Populated as XML reps of sequence objects are
 125    * created.)
 126    */
 127   java.util.Hashtable seqRefIds = null; // key->SequenceI resolution
 128
 129   Vector frefedSequence = null;
 130
 131   boolean raiseGUI = true; // whether errors are raised in dialog boxes or not
 132
 133   public Jalview2XML()
 134   {
 135   }
 136
 137   public Jalview2XML(boolean raiseGUI)
 138   {
 139     this.raiseGUI = raiseGUI;
 140   }
 141
 142   public void resolveFrefedSequences()
 143   {
 144     if (frefedSequence.size() > 0)
 145     {
 146       int r = 0, rSize = frefedSequence.size();
 147       while (r < rSize)
 148       {
 149         Object[] ref = (Object[]) frefedSequence.elementAt(r);
 150         if (ref != null)
 151         {
 152           String sref = (String) ref[0];
 153           if (seqRefIds.containsKey(sref))
 154           {
 155             if (ref[1] instanceof jalview.datamodel.Mapping)
 156             {
 157               SequenceI seq = (SequenceI) seqRefIds.get(sref);
 158               while (seq.getDatasetSequence() != null)
 159               {
 160                 seq = seq.getDatasetSequence();
 161               }
 162               ((jalview.datamodel.Mapping) ref[1]).setTo(seq);
 163             }
 164             else
 165             {
 166               if (ref[1] instanceof jalview.datamodel.AlignedCodonFrame)
 167               {
 168                 SequenceI seq = (SequenceI) seqRefIds.get(sref);
 169                 while (seq.getDatasetSequence() != null)
 170                 {
 171                   seq = seq.getDatasetSequence();
 172                 }
 173                 if (ref[2] != null
 174                         && ref[2] instanceof jalview.datamodel.Mapping)
 175                 {
 176                   jalview.datamodel.Mapping mp = (jalview.datamodel.Mapping) ref[2];
 177                   ((jalview.datamodel.AlignedCodonFrame) ref[1]).addMap(
 178                           seq, mp.getTo(), mp.getMap());
 179                 }
 180                 else
 181                 {
 182                   System.err
 183                           .println("IMPLEMENTATION ERROR: Unimplemented forward sequence references for AlcodonFrames involving "
 184                                   + ref[2].getClass() + " type objects.");
 185                 }
 186               }
 187               else
 188               {
 189                 System.err
 190                         .println("IMPLEMENTATION ERROR: Unimplemented forward sequence references for "
 191                                 + ref[1].getClass() + " type objects.");
 192               }
 193             }
 194             frefedSequence.remove(r);
 195             rSize--;
 196           }
 197           else
 198           {
 199             System.err
 200                     .println("IMPLEMENTATION WARNING: Unresolved forward reference for hash string "
 201                             + ref[0]
 202                             + " with objecttype "
 203                             + ref[1].getClass());
 204             r++;
 205           }
 206         }
 207         else
 208         {
 209           // empty reference
 210           frefedSequence.remove(r);
 211           rSize--;
 212         }
 213       }
 214     }
 215   }
 216
 217   /**
 218    * This maintains a list of viewports, the key being the seqSetId. Important
 219    * to set historyItem and redoList for multiple views
 220    */
 221   Hashtable viewportsAdded;
 222
 223   Hashtable annotationIds = new Hashtable();
 224
 225   String uniqueSetSuffix = "";
 226
 227   /**
 228    * List of pdbfiles added to Jar
 229    */
 230   Vector pdbfiles = null;
 231
 232   // SAVES SEVERAL ALIGNMENT WINDOWS TO SAME JARFILE
 233   public void SaveState(File statefile)
 234   {
 235     try
 236     {
 237       FileOutputStream fos = new FileOutputStream(statefile);
 238       JarOutputStream jout = new JarOutputStream(fos);
 239       SaveState(jout);
 240
 241     } catch (Exception e)
 242     {
 243       // TODO: inform user of the problem - they need to know if their data was
 244       // not saved !
 245       if (errorMessage == null)
 246       {
 247         errorMessage = "Couldn't write Jalview Archive to output file '"
 248                 + statefile + "' - See console error log for details";
 249       }
 250       else
 251       {
 252         errorMessage += "(output file was '" + statefile + "')";
 253       }
 254       e.printStackTrace();
 255     }
 256     reportErrors();
 257   }
 258
 259   /**
 260    * Writes a jalview project archive to the given Jar output stream.
 261    *
 262    * @param jout
 263    */
 264   public void SaveState(JarOutputStream jout)
 265   {
 266     JInternalFrame[] frames = Desktop.desktop.getAllFrames();
 267
 268     if (frames == null)
 269     {
 270       return;
 271     }
 272
 273     try
 274     {
 275
 276       // NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS
 277       // //////////////////////////////////////////////////
 278       // NOTE ALSO new PrintWriter must be used for each new JarEntry
 279       PrintWriter out = null;
 280
 281       Vector shortNames = new Vector();
 282
 283       // REVERSE ORDER
 284       for (int i = frames.length - 1; i > -1; i--)
 285       {
 286         if (frames[i] instanceof AlignFrame)
 287         {
 288           AlignFrame af = (AlignFrame) frames[i];
 289           // skip ?
 290           if (skipList != null
 291                   && skipList.containsKey(af.getViewport()
 292                           .getSequenceSetId()))
 293           {
 294             continue;
 295           }
 296
 297           String shortName = af.getTitle();
 298
 299           if (shortName.indexOf(File.separatorChar) > -1)
 300           {
 301             shortName = shortName.substring(shortName
 302                     .lastIndexOf(File.separatorChar) + 1);
 303           }
 304
 305           int count = 1;
 306
 307           while (shortNames.contains(shortName))
 308           {
 309             if (shortName.endsWith("_" + (count - 1)))
 310             {
 311               shortName = shortName
 312                       .substring(0, shortName.lastIndexOf("_"));
 313             }
 314
 315             shortName = shortName.concat("_" + count);
 316             count++;
 317           }
 318
 319           shortNames.addElement(shortName);
 320
 321           if (!shortName.endsWith(".xml"))
 322           {
 323             shortName = shortName + ".xml";
 324           }
 325
 326           int ap, apSize = af.alignPanels.size();
 327           for (ap = 0; ap < apSize; ap++)
 328           {
 329             AlignmentPanel apanel = (AlignmentPanel) af.alignPanels
 330                     .elementAt(ap);
 331             String fileName = apSize == 1 ? shortName : ap + shortName;
 332             if (!fileName.endsWith(".xml"))
 333             {
 334               fileName = fileName + ".xml";
 335             }
 336
 337             SaveState(apanel, fileName, jout);
 338           }
 339         }
 340       }
 341       try
 342       {
 343         jout.flush();
 344       } catch (Exception foo)
 345       {
 346       }
 347       ;
 348       jout.close();
 349     } catch (Exception ex)
 350     {
 351       // TODO: inform user of the problem - they need to know if their data was
 352       // not saved !
 353       if (errorMessage == null)
 354       {
 355         errorMessage = "Couldn't write Jalview Archive - see error output for details";
 356       }
 357       ex.printStackTrace();
 358     }
 359   }
 360
 361   // USE THIS METHOD TO SAVE A SINGLE ALIGNMENT WINDOW
 362   public boolean SaveAlignment(AlignFrame af, String jarFile,
 363           String fileName)
 364   {
 365     try
 366     {
 367       int ap, apSize = af.alignPanels.size();
 368       FileOutputStream fos = new FileOutputStream(jarFile);
 369       JarOutputStream jout = new JarOutputStream(fos);
 370       for (ap = 0; ap < apSize; ap++)
 371       {
 372         AlignmentPanel apanel = (AlignmentPanel) af.alignPanels
 373                 .elementAt(ap);
 374         String jfileName = apSize == 1 ? fileName : fileName + ap;
 375         if (!jfileName.endsWith(".xml"))
 376         {
 377           jfileName = jfileName + ".xml";
 378         }
 379         SaveState(apanel, jfileName, jout);
 380       }
 381
 382       try
 383       {
 384         jout.flush();
 385       } catch (Exception foo)
 386       {
 387       }
 388       ;
 389       jout.close();
 390       return true;
 391     } catch (Exception ex)
 392     {
 393       errorMessage = "Couldn't Write alignment view to Jalview Archive - see error output for details";
 394       ex.printStackTrace();
 395       return false;
 396     }
 397   }
 398
 399   /**
 400    * create a JalviewModel from an algnment view and marshall it to a
 401    * JarOutputStream
 402    *
 403    * @param ap
 404    *          panel to create jalview model for
 405    * @param fileName
 406    *          name of alignment panel written to output stream
 407    * @param jout
 408    *          jar output stream
 409    * @param out
 410    *          jar entry name
 411    */
 412   public JalviewModel SaveState(AlignmentPanel ap, String fileName,
 413           JarOutputStream jout)
 414   {
 415     initSeqRefs();
 416
 417     Vector userColours = new Vector();
 418
 419     AlignViewport av = ap.av;
 420
 421     JalviewModel object = new JalviewModel();
 422     object.setVamsasModel(new jalview.schemabinding.version2.VamsasModel());
 423
 424     object.setCreationDate(new java.util.Date(System.currentTimeMillis()));
 425     object.setVersion(jalview.bin.Cache.getProperty("VERSION"));
 426
 427     jalview.datamodel.AlignmentI jal = av.alignment;
 428
 429     if (av.hasHiddenRows)
 430     {
 431       jal = jal.getHiddenSequences().getFullAlignment();
 432     }
 433
 434     SequenceSet vamsasSet = new SequenceSet();
 435     Sequence vamsasSeq;
 436     JalviewModelSequence jms = new JalviewModelSequence();
 437
 438     vamsasSet.setGapChar(jal.getGapCharacter() + "");
 439
 440     if (jal.getDataset() != null)
 441     {
 442       // dataset id is the dataset's hashcode
 443       vamsasSet.setDatasetId(getDatasetIdRef(jal.getDataset()));
 444     }
 445     if (jal.getProperties() != null)
 446     {
 447       Enumeration en = jal.getProperties().keys();
 448       while (en.hasMoreElements())
 449       {
 450         String key = en.nextElement().toString();
 451         SequenceSetProperties ssp = new SequenceSetProperties();
 452         ssp.setKey(key);
 453         ssp.setValue(jal.getProperties().get(key).toString());
 454         vamsasSet.addSequenceSetProperties(ssp);
 455       }
 456     }
 457
 458     JSeq jseq;
 459
 460     // SAVE SEQUENCES
 461     String id = "";
 462     jalview.datamodel.SequenceI jds;
 463     for (int i = 0; i < jal.getHeight(); i++)
 464     {
 465       jds = jal.getSequenceAt(i);
 466       id = seqHash(jds);
 467
 468       if (seqRefIds.get(id) != null)
 469       {
 470         // This happens for two reasons: 1. multiple views are being serialised.
 471         // 2. the hashCode has collided with another sequence's code. This DOES
 472         // HAPPEN! (PF00072.15.stk does this)
 473         // JBPNote: Uncomment to debug writing out of files that do not read
 474         // back in due to ArrayOutOfBoundExceptions.
 475         // System.err.println("vamsasSeq backref: "+id+"");
 476         // System.err.println(jds.getName()+"
 477         // "+jds.getStart()+"-"+jds.getEnd()+" "+jds.getSequenceAsString());
 478         // System.err.println("Hashcode: "+seqHash(jds));
 479         // SequenceI rsq = (SequenceI) seqRefIds.get(id + "");
 480         // System.err.println(rsq.getName()+"
 481         // "+rsq.getStart()+"-"+rsq.getEnd()+" "+rsq.getSequenceAsString());
 482         // System.err.println("Hashcode: "+seqHash(rsq));
 483       }
 484       else
 485       {
 486         vamsasSeq = createVamsasSequence(id, jds);
 487         vamsasSet.addSequence(vamsasSeq);
 488         seqRefIds.put(id, jds);
 489       }
 490
 491       jseq = new JSeq();
 492       jseq.setStart(jds.getStart());
 493       jseq.setEnd(jds.getEnd());
 494       jseq.setColour(av.getSequenceColour(jds).getRGB());
 495
 496       jseq.setId(id); // jseq id should be a string not a number
 497
 498       if (av.hasHiddenRows)
 499       {
 500         jseq.setHidden(av.alignment.getHiddenSequences().isHidden(jds));
 501
 502         if (av.hiddenRepSequences != null
 503                 && av.hiddenRepSequences.containsKey(jal.getSequenceAt(i)))
 504         {
 505           jalview.datamodel.SequenceI[] reps = ((jalview.datamodel.SequenceGroup) av.hiddenRepSequences
 506                   .get(jal.getSequenceAt(i))).getSequencesInOrder(jal);
 507
 508           for (int h = 0; h < reps.length; h++)
 509           {
 510             if (reps[h] != jal.getSequenceAt(i))
 511             {
 512               jseq.addHiddenSequences(jal.findIndex(reps[h]));
 513             }
 514           }
 515         }
 516       }
 517
 518       if (jds.getDatasetSequence().getSequenceFeatures() != null)
 519       {
 520         jalview.datamodel.SequenceFeature[] sf = jds.getDatasetSequence()
 521                 .getSequenceFeatures();
 522         int index = 0;
 523         while (index < sf.length)
 524         {
 525           Features features = new Features();
 526
 527           features.setBegin(sf[index].getBegin());
 528           features.setEnd(sf[index].getEnd());
 529           features.setDescription(sf[index].getDescription());
 530           features.setType(sf[index].getType());
 531           features.setFeatureGroup(sf[index].getFeatureGroup());
 532           features.setScore(sf[index].getScore());
 533           if (sf[index].links != null)
 534           {
 535             for (int l = 0; l < sf[index].links.size(); l++)
 536             {
 537               OtherData keyValue = new OtherData();
 538               keyValue.setKey("LINK_" + l);
 539               keyValue.setValue(sf[index].links.elementAt(l).toString());
 540               features.addOtherData(keyValue);
 541             }
 542           }
 543           if (sf[index].otherDetails != null)
 544           {
 545             String key;
 546             Enumeration keys = sf[index].otherDetails.keys();
 547             while (keys.hasMoreElements())
 548             {
 549               key = keys.nextElement().toString();
 550               OtherData keyValue = new OtherData();
 551               keyValue.setKey(key);
 552               keyValue.setValue(sf[index].otherDetails.get(key).toString());
 553               features.addOtherData(keyValue);
 554             }
 555           }
 556
 557           jseq.addFeatures(features);
 558           index++;
 559         }
 560       }
 561
 562       if (jds.getDatasetSequence().getPDBId() != null)
 563       {
 564         Enumeration en = jds.getDatasetSequence().getPDBId().elements();
 565         while (en.hasMoreElements())
 566         {
 567           Pdbids pdb = new Pdbids();
 568           jalview.datamodel.PDBEntry entry = (jalview.datamodel.PDBEntry) en
 569                   .nextElement();
 570
 571           pdb.setId(entry.getId());
 572           pdb.setType(entry.getType());
 573
 574           AppJmol jmol;
 575           // This must have been loaded, is it still visible?
 576           JInternalFrame[] frames = Desktop.desktop.getAllFrames();
 577           String matchedFile = null;
 578           for (int f = frames.length - 1; f > -1; f--)
 579           {
 580             if (frames[f] instanceof AppJmol)
 581             {
 582               // TODO: revise schema to allow many:one PDB id binding to viewer
 583               jmol = (AppJmol) frames[f];
 584               if (!jmol.jmb.pdbentry[0].getId().equals(entry.getId())
 585                       && !(entry.getId().length() > 4 && entry.getId()
 586                               .toLowerCase().startsWith(
 587                                       jmol.jmb.pdbentry[0].getId().toLowerCase())))
 588                 continue;
 589               matchedFile = jmol.jmb.pdbentry[0].getFile(); // record the file so we
 590               // can get at it if the ID
 591               // match is ambiguous (e.g.
 592               // 1QIP==1qipA)
 593               StructureState state = new StructureState();
 594               state.setVisible(true);
 595               state.setXpos(jmol.getX());
 596               state.setYpos(jmol.getY());
 597               state.setWidth(jmol.getWidth());
 598               state.setHeight(jmol.getHeight());
 599               state.setViewId(jmol.getViewId());
 600               String statestring = jmol.jmb.viewer.getStateInfo();
 601               if (state != null)
 602               {
 603                 state.setContent(statestring.replaceAll("\n", ""));
 604               }
 605               for (int s = 0; s < jmol.jmb.sequence.length; s++)
 606               {
 607                 if (jal.findIndex(jmol.jmb.sequence[s]) > -1)
 608                 {
 609                   pdb.addStructureState(state);
 610                 }
 611               }
 612             }
 613           }
 614
 615           if (matchedFile != null || entry.getFile() != null)
 616           {
 617             if (entry.getFile() != null)
 618             {
 619               // use entry's file
 620               matchedFile = entry.getFile();
 621             }
 622             pdb.setFile(matchedFile); // entry.getFile());
 623             if (pdbfiles == null)
 624             {
 625               pdbfiles = new Vector();
 626             }
 627
 628             if (!pdbfiles.contains(entry.getId()))
 629             {
 630               pdbfiles.addElement(entry.getId());
 631               try
 632               {
 633                 File file = new File(matchedFile);
 634                 if (file.exists() && jout != null)
 635                 {
 636                   byte[] data = new byte[(int) file.length()];
 637                   jout.putNextEntry(new JarEntry(entry.getId()));
 638                   DataInputStream dis = new DataInputStream(
 639                           new FileInputStream(file));
 640                   dis.readFully(data);
 641
 642                   DataOutputStream dout = new DataOutputStream(jout);
 643                   dout.write(data, 0, data.length);
 644                   dout.flush();
 645                   jout.closeEntry();
 646                 }
 647               } catch (Exception ex)
 648               {
 649                 ex.printStackTrace();
 650               }
 651
 652             }
 653           }
 654
 655           if (entry.getProperty() != null)
 656           {
 657             PdbentryItem item = new PdbentryItem();
 658             Hashtable properties = entry.getProperty();
 659             Enumeration en2 = properties.keys();
 660             while (en2.hasMoreElements())
 661             {
 662               Property prop = new Property();
 663               String key = en2.nextElement().toString();
 664               prop.setName(key);
 665               prop.setValue(properties.get(key).toString());
 666               item.addProperty(prop);
 667             }
 668             pdb.addPdbentryItem(item);
 669           }
 670
 671           jseq.addPdbids(pdb);
 672         }
 673       }
 674
 675       jms.addJSeq(jseq);
 676     }
 677
 678     if (av.hasHiddenRows)
 679     {
 680       jal = av.alignment;
 681     }
 682     // SAVE MAPPINGS
 683     if (jal.getCodonFrames() != null && jal.getCodonFrames().length > 0)
 684     {
 685       jalview.datamodel.AlignedCodonFrame[] jac = jal.getCodonFrames();
 686       for (int i = 0; i < jac.length; i++)
 687       {
 688         AlcodonFrame alc = new AlcodonFrame();
 689         vamsasSet.addAlcodonFrame(alc);
 690         for (int p = 0; p < jac[i].aaWidth; p++)
 691         {
 692           Alcodon cmap = new Alcodon();
 693           if (jac[i].codons[p] != null)
 694           {
 695             // Null codons indicate a gapped column in the translated peptide
 696             // alignment.
 697             cmap.setPos1(jac[i].codons[p][0]);
 698             cmap.setPos2(jac[i].codons[p][1]);
 699             cmap.setPos3(jac[i].codons[p][2]);
 700           }
 701           alc.addAlcodon(cmap);
 702         }
 703         if (jac[i].getProtMappings() != null
 704                 && jac[i].getProtMappings().length > 0)
 705         {
 706           SequenceI[] dnas = jac[i].getdnaSeqs();
 707           jalview.datamodel.Mapping[] pmaps = jac[i].getProtMappings();
 708           for (int m = 0; m < pmaps.length; m++)
 709           {
 710             AlcodMap alcmap = new AlcodMap();
 711             alcmap.setDnasq(seqHash(dnas[m]));
 712             alcmap.setMapping(createVamsasMapping(pmaps[m], dnas[m], null,
 713                     false));
 714             alc.addAlcodMap(alcmap);
 715           }
 716         }
 717       }
 718     }
 719
 720     // SAVE TREES
 721     // /////////////////////////////////
 722     if (av.currentTree != null)
 723     {
 724       // FIND ANY ASSOCIATED TREES
 725       // NOT IMPLEMENTED FOR HEADLESS STATE AT PRESENT
 726       if (Desktop.desktop != null)
 727       {
 728         JInternalFrame[] frames = Desktop.desktop.getAllFrames();
 729
 730         for (int t = 0; t < frames.length; t++)
 731         {
 732           if (frames[t] instanceof TreePanel)
 733           {
 734             TreePanel tp = (TreePanel) frames[t];
 735
 736             if (tp.treeCanvas.av.alignment == jal)
 737             {
 738               Tree tree = new Tree();
 739               tree.setTitle(tp.getTitle());
 740               tree.setCurrentTree((av.currentTree == tp.getTree()));
 741               tree.setNewick(tp.getTree().toString());
 742               tree.setThreshold(tp.treeCanvas.threshold);
 743
 744               tree.setFitToWindow(tp.fitToWindow.getState());
 745               tree.setFontName(tp.getTreeFont().getName());
 746               tree.setFontSize(tp.getTreeFont().getSize());
 747               tree.setFontStyle(tp.getTreeFont().getStyle());
 748               tree.setMarkUnlinked(tp.placeholdersMenu.getState());
 749
 750               tree.setShowBootstrap(tp.bootstrapMenu.getState());
 751               tree.setShowDistances(tp.distanceMenu.getState());
 752
 753               tree.setHeight(tp.getHeight());
 754               tree.setWidth(tp.getWidth());
 755               tree.setXpos(tp.getX());
 756               tree.setYpos(tp.getY());
 757               tree.setId(makeHashCode(tp, null));
 758               jms.addTree(tree);
 759             }
 760           }
 761         }
 762       }
 763     }
 764
 765     // SAVE ANNOTATIONS
 766     /**
 767      * store forward refs from an annotationRow to any groups
 768      */
 769     IdentityHashMap groupRefs = new IdentityHashMap();
 770     if (jal.getAlignmentAnnotation() != null)
 771     {
 772       jalview.datamodel.AlignmentAnnotation[] aa = jal
 773               .getAlignmentAnnotation();
 774
 775       for (int i = 0; i < aa.length; i++)
 776       {
 777         Annotation an = new Annotation();
 778
 779         if (aa[i].annotationId != null)
 780         {
 781           annotationIds.put(aa[i].annotationId, aa[i]);
 782         }
 783
 784         an.setId(aa[i].annotationId);
 785
 786         an.setVisible(aa[i].visible);
 787
 788         an.setDescription(aa[i].description);
 789
 790         if (aa[i].sequenceRef != null)
 791         {
 792           // TODO later annotation sequenceRef should be the XML ID of the
 793           // sequence rather than its display name
 794           an.setSequenceRef(aa[i].sequenceRef.getName());
 795         }
 796         if (aa[i].groupRef != null)
 797         {
 798           Object groupIdr = groupRefs.get(aa[i].groupRef);
 799           if (groupIdr == null)
 800           {
 801             // make a locally unique String
 802             groupRefs.put(aa[i].groupRef,
 803                     groupIdr = ("" + System.currentTimeMillis()
 804                             + aa[i].groupRef.getName() + groupRefs.size()));
 805           }
 806           an.setGroupRef(groupIdr.toString());
 807         }
 808         if (aa[i] == av.quality || aa[i] == av.conservation
 809                 || aa[i] == av.consensus || aa[i].autoCalculated)
 810         {
 811           // new way of indicating autocalculated annotation -
 812           an.setAutoCalculated(aa[i].autoCalculated);
 813           // write a stub for this annotation - indicate presence of autocalc
 814           // rows
 815           an.setLabel(aa[i].label);
 816           an.setGraph(true);
 817           vamsasSet.addAnnotation(an);
 818           continue;
 819         }
 820
 821         if (aa[i].graph > 0)
 822         {
 823           an.setGraph(true);
 824           an.setGraphType(aa[i].graph);
 825           an.setGraphGroup(aa[i].graphGroup);
 826           if (aa[i].getThreshold() != null)
 827           {
 828             ThresholdLine line = new ThresholdLine();
 829             line.setLabel(aa[i].getThreshold().label);
 830             line.setValue(aa[i].getThreshold().value);
 831             line.setColour(aa[i].getThreshold().colour.getRGB());
 832             an.setThresholdLine(line);
 833           }
 834         }
 835         else
 836         {
 837           an.setGraph(false);
 838         }
 839
 840         an.setLabel(aa[i].label);
 841         if (aa[i].hasScore())
 842         {
 843           an.setScore(aa[i].getScore());
 844         }
 845         AnnotationElement ae;
 846         if (aa[i].annotations != null)
 847         {
 848           an.setScoreOnly(false);
 849           for (int a = 0; a < aa[i].annotations.length; a++)
 850           {
 851             if ((aa[i] == null) || (aa[i].annotations[a] == null))
 852             {
 853               continue;
 854             }
 855
 856             ae = new AnnotationElement();
 857             if (aa[i].annotations[a].description != null)
 858               ae.setDescription(aa[i].annotations[a].description);
 859             if (aa[i].annotations[a].displayCharacter != null)
 860               ae.setDisplayCharacter(aa[i].annotations[a].displayCharacter);
 861
 862             if (!Float.isNaN(aa[i].annotations[a].value))
 863               ae.setValue(aa[i].annotations[a].value);
 864
 865             ae.setPosition(a);
 866             if (aa[i].annotations[a].secondaryStructure != ' '
 867                     && aa[i].annotations[a].secondaryStructure != '\0')
 868               ae
 869                       .setSecondaryStructure(aa[i].annotations[a].secondaryStructure
 870                               + "");
 871
 872             if (aa[i].annotations[a].colour != null
 873                     && aa[i].annotations[a].colour != java.awt.Color.black)
 874             {
 875               ae.setColour(aa[i].annotations[a].colour.getRGB());
 876             }
 877
 878             an.addAnnotationElement(ae);
 879           }
 880         }
 881         else
 882         {
 883           an.setScoreOnly(true);
 884         }
 885         vamsasSet.addAnnotation(an);
 886       }
 887     }
 888     // SAVE GROUPS
 889     if (jal.getGroups() != null)
 890     {
 891       JGroup[] groups = new JGroup[jal.getGroups().size()];
 892
 893       for (int i = 0; i < groups.length; i++)
 894       {
 895         groups[i] = new JGroup();
 896
 897         jalview.datamodel.SequenceGroup sg = (jalview.datamodel.SequenceGroup) jal
 898                 .getGroups().elementAt(i);
 899         groups[i].setStart(sg.getStartRes());
 900         groups[i].setEnd(sg.getEndRes());
 901         groups[i].setName(sg.getName());
 902         if (groupRefs.containsKey(sg))
 903         {
 904           // group has references so set it's ID field
 905           groups[i].setId(groupRefs.get(sg).toString());
 906         }
 907         if (sg.cs != null)
 908         {
 909           if (sg.cs.conservationApplied())
 910           {
 911             groups[i].setConsThreshold(sg.cs.getConservationInc());
 912
 913             if (sg.cs instanceof jalview.schemes.UserColourScheme)
 914             {
 915               groups[i].setColour(SetUserColourScheme(sg.cs, userColours,
 916                       jms));
 917             }
 918             else
 919             {
 920               groups[i]
 921                       .setColour(ColourSchemeProperty.getColourName(sg.cs));
 922             }
 923           }
 924           else if (sg.cs instanceof jalview.schemes.AnnotationColourGradient)
 925           {
 926             groups[i]
 927                     .setColour(ColourSchemeProperty
 928                             .getColourName(((jalview.schemes.AnnotationColourGradient) sg.cs)
 929                                     .getBaseColour()));
 930           }
 931           else if (sg.cs instanceof jalview.schemes.UserColourScheme)
 932           {
 933             groups[i]
 934                     .setColour(SetUserColourScheme(sg.cs, userColours, jms));
 935           }
 936           else
 937           {
 938             groups[i].setColour(ColourSchemeProperty.getColourName(sg.cs));
 939           }
 940
 941           groups[i].setPidThreshold(sg.cs.getThreshold());
 942         }
 943
 944         groups[i].setOutlineColour(sg.getOutlineColour().getRGB());
 945         groups[i].setDisplayBoxes(sg.getDisplayBoxes());
 946         groups[i].setDisplayText(sg.getDisplayText());
 947         groups[i].setColourText(sg.getColourText());
 948         groups[i].setTextCol1(sg.textColour.getRGB());
 949         groups[i].setTextCol2(sg.textColour2.getRGB());
 950         groups[i].setTextColThreshold(sg.thresholdTextColour);
 951         groups[i].setShowUnconserved(sg.getShowNonconserved());
 952         groups[i].setIgnoreGapsinConsensus(sg.getIgnoreGapsConsensus());
 953         groups[i].setShowConsensusHistogram(sg.isShowConsensusHistogram());
 954         groups[i].setShowSequenceLogo(sg.isShowSequenceLogo());
 955         for (int s = 0; s < sg.getSize(); s++)
 956         {
 957           jalview.datamodel.Sequence seq = (jalview.datamodel.Sequence) sg
 958                   .getSequenceAt(s);
 959           groups[i].addSeq(seqHash(seq));
 960         }
 961       }
 962
 963       jms.setJGroup(groups);
 964     }
 965
 966     // /////////SAVE VIEWPORT
 967     Viewport view = new Viewport();
 968     view.setTitle(ap.alignFrame.getTitle());
 969     view.setSequenceSetId(makeHashCode(av.getSequenceSetId(), av
 970             .getSequenceSetId()));
 971     view.setId(av.getViewId());
 972     view.setViewName(av.viewName);
 973     view.setGatheredViews(av.gatherViewsHere);
 974
 975     if (ap.av.explodedPosition != null)
 976     {
 977       view.setXpos(av.explodedPosition.x);
 978       view.setYpos(av.explodedPosition.y);
 979       view.setWidth(av.explodedPosition.width);
 980       view.setHeight(av.explodedPosition.height);
 981     }
 982     else
 983     {
 984       view.setXpos(ap.alignFrame.getBounds().x);
 985       view.setYpos(ap.alignFrame.getBounds().y);
 986       view.setWidth(ap.alignFrame.getBounds().width);
 987       view.setHeight(ap.alignFrame.getBounds().height);
 988     }
 989
 990     view.setStartRes(av.startRes);
 991     view.setStartSeq(av.startSeq);
 992
 993     if (av.getGlobalColourScheme() instanceof jalview.schemes.UserColourScheme)
 994     {
 995       view.setBgColour(SetUserColourScheme(av.getGlobalColourScheme(),
 996               userColours, jms));
 997     }
 998     else if (av.getGlobalColourScheme() instanceof jalview.schemes.AnnotationColourGradient)
 999     {
1000       jalview.schemes.AnnotationColourGradient acg = (jalview.schemes.AnnotationColourGradient) av
1001               .getGlobalColourScheme();
1002
1003       AnnotationColours ac = new AnnotationColours();
1004       ac.setAboveThreshold(acg.getAboveThreshold());
1005       ac.setThreshold(acg.getAnnotationThreshold());
1006       ac.setAnnotation(acg.getAnnotation());
1007       if (acg.getBaseColour() instanceof jalview.schemes.UserColourScheme)
1008       {
1009         ac.setColourScheme(SetUserColourScheme(acg.getBaseColour(),
1010                 userColours, jms));
1011       }
1012       else
1013       {
1014         ac.setColourScheme(ColourSchemeProperty.getColourName(acg
1015                 .getBaseColour()));
1016       }
1017
1018       ac.setMaxColour(acg.getMaxColour().getRGB());
1019       ac.setMinColour(acg.getMinColour().getRGB());
1020       view.setAnnotationColours(ac);
1021       view.setBgColour("AnnotationColourGradient");
1022     }
1023     else
1024     {
1025       view.setBgColour(ColourSchemeProperty.getColourName(av
1026               .getGlobalColourScheme()));
1027     }
1028
1029     ColourSchemeI cs = av.getGlobalColourScheme();
1030
1031     if (cs != null)
1032     {
1033       if (cs.conservationApplied())
1034       {
1035         view.setConsThreshold(cs.getConservationInc());
1036         if (cs instanceof jalview.schemes.UserColourScheme)
1037         {
1038           view.setBgColour(SetUserColourScheme(cs, userColours, jms));
1039         }
1040       }
1041
1042       if (cs instanceof ResidueColourScheme)
1043       {
1044         view.setPidThreshold(cs.getThreshold());
1045       }
1046     }
1047
1048     view.setConservationSelected(av.getConservationSelected());
1049     view.setPidSelected(av.getAbovePIDThreshold());
1050     view.setFontName(av.font.getName());
1051     view.setFontSize(av.font.getSize());
1052     view.setFontStyle(av.font.getStyle());
1053     view.setRenderGaps(av.renderGaps);
1054     view.setShowAnnotation(av.getShowAnnotation());
1055     view.setShowBoxes(av.getShowBoxes());
1056     view.setShowColourText(av.getColourText());
1057     view.setShowFullId(av.getShowJVSuffix());
1058     view.setRightAlignIds(av.rightAlignIds);
1059     view.setShowSequenceFeatures(av.showSequenceFeatures);
1060     view.setShowText(av.getShowText());
1061     view.setShowUnconserved(av.getShowUnconserved());
1062     view.setWrapAlignment(av.getWrapAlignment());
1063     view.setTextCol1(av.textColour.getRGB());
1064     view.setTextCol2(av.textColour2.getRGB());
1065     view.setTextColThreshold(av.thresholdTextColour);
1066     view.setShowConsensusHistogram(av.isShowConsensusHistogram());
1067     view.setShowSequenceLogo(av.isShowSequenceLogo());
1068     view.setShowGroupConsensus(av.isShowGroupConsensus());
1069     view.setShowGroupConservation(av.isShowGroupConservation());
1070     view.setShowNPfeatureTooltip(av.isShowNpFeats());
1071     view.setShowDbRefTooltip(av.isShowDbRefs());
1072     view.setFollowHighlight(av.followHighlight);
1073     view.setFollowSelection(av.followSelection);
1074     view.setIgnoreGapsinConsensus(av.getIgnoreGapsConsensus());
1075     if (av.featuresDisplayed != null)
1076     {
1077       jalview.schemabinding.version2.FeatureSettings fs = new jalview.schemabinding.version2.FeatureSettings();
1078
1079       String[] renderOrder = ap.seqPanel.seqCanvas.getFeatureRenderer().renderOrder;
1080
1081       Vector settingsAdded = new Vector();
1082       Object gstyle = null;
1083       GraduatedColor gcol = null;
1084       for (int ro = 0; ro < renderOrder.length; ro++)
1085       {
1086         gstyle = ap.seqPanel.seqCanvas.getFeatureRenderer()
1087                 .getFeatureStyle(renderOrder[ro]);
1088         Setting setting = new Setting();
1089         setting.setType(renderOrder[ro]);
1090         if (gstyle instanceof GraduatedColor)
1091         {
1092           gcol = (GraduatedColor) gstyle;
1093           setting.setColour(gcol.getMaxColor().getRGB());
1094           setting.setMincolour(gcol.getMinColor().getRGB());
1095           setting.setMin(gcol.getMin());
1096           setting.setMax(gcol.getMax());
1097           setting.setColourByLabel(gcol.isColourByLabel());
1098           setting.setAutoScale(gcol.isAutoScale());
1099           setting.setThreshold(gcol.getThresh());
1100           setting.setThreshstate(gcol.getThreshType());
1101         }
1102         else
1103         {
1104           setting.setColour(ap.seqPanel.seqCanvas.getFeatureRenderer()
1105                   .getColour(renderOrder[ro]).getRGB());
1106         }
1107
1108         setting.setDisplay(av.featuresDisplayed
1109                 .containsKey(renderOrder[ro]));
1110         float rorder = ap.seqPanel.seqCanvas.getFeatureRenderer().getOrder(
1111                 renderOrder[ro]);
1112         if (rorder > -1)
1113         {
1114           setting.setOrder(rorder);
1115         }
1116         fs.addSetting(setting);
1117         settingsAdded.addElement(renderOrder[ro]);
1118       }
1119
1120       // Make sure we save none displayed feature settings
1121       Enumeration en = ap.seqPanel.seqCanvas.getFeatureRenderer().featureColours
1122               .keys();
1123       while (en.hasMoreElements())
1124       {
1125         String key = en.nextElement().toString();
1126         if (settingsAdded.contains(key))
1127         {
1128           continue;
1129         }
1130
1131         Setting setting = new Setting();
1132         setting.setType(key);
1133         setting.setColour(ap.seqPanel.seqCanvas.getFeatureRenderer()
1134                 .getColour(key).getRGB());
1135
1136         setting.setDisplay(false);
1137         float rorder = ap.seqPanel.seqCanvas.getFeatureRenderer().getOrder(
1138                 key);
1139         if (rorder > -1)
1140         {
1141           setting.setOrder(rorder);
1142         }
1143         fs.addSetting(setting);
1144         settingsAdded.addElement(key);
1145       }
1146       en = ap.seqPanel.seqCanvas.getFeatureRenderer().featureGroups.keys();
1147       Vector groupsAdded = new Vector();
1148       while (en.hasMoreElements())
1149       {
1150         String grp = en.nextElement().toString();
1151         if (groupsAdded.contains(grp))
1152         {
1153           continue;
1154         }
1155         Group g = new Group();
1156         g.setName(grp);
1157         g
1158                 .setDisplay(((Boolean) ap.seqPanel.seqCanvas
1159                         .getFeatureRenderer().featureGroups.get(grp))
1160                         .booleanValue());
1161         fs.addGroup(g);
1162         groupsAdded.addElement(grp);
1163       }
1164       jms.setFeatureSettings(fs);
1165
1166     }
1167
1168     if (av.hasHiddenColumns)
1169     {
1170       if (av.getColumnSelection() == null
1171               || av.getColumnSelection().getHiddenColumns() == null)
1172       {
1173         warn("REPORT BUG: avoided null columnselection bug (DMAM reported). Please contact Jim about this.");
1174       }
1175       else
1176       {
1177         for (int c = 0; c < av.getColumnSelection().getHiddenColumns()
1178                 .size(); c++)
1179         {
1180           int[] region = (int[]) av.getColumnSelection().getHiddenColumns()
1181                   .elementAt(c);
1182           HiddenColumns hc = new HiddenColumns();
1183           hc.setStart(region[0]);
1184           hc.setEnd(region[1]);
1185           view.addHiddenColumns(hc);
1186         }
1187       }
1188     }
1189
1190     jms.addViewport(view);
1191
1192     object.setJalviewModelSequence(jms);
1193     object.getVamsasModel().addSequenceSet(vamsasSet);
1194
1195     if (jout != null && fileName != null)
1196     {
1197       // We may not want to write the object to disk,
1198       // eg we can copy the alignViewport to a new view object
1199       // using save and then load
1200       try
1201       {
1202         JarEntry entry = new JarEntry(fileName);
1203         jout.putNextEntry(entry);
1204         PrintWriter pout = new PrintWriter(new OutputStreamWriter(jout,
1205                 "UTF-8"));
1206         org.exolab.castor.xml.Marshaller marshaller = new org.exolab.castor.xml.Marshaller(
1207                 pout);
1208         marshaller.marshal(object);
1209         pout.flush();
1210         jout.closeEntry();
1211       } catch (Exception ex)
1212       {
1213         // TODO: raise error in GUI if marshalling failed.
1214         ex.printStackTrace();
1215       }
1216     }
1217     return object;
1218   }
1219
1220   /**
1221    * External mapping between jalview objects and objects yielding a valid and
1222    * unique object ID string. This is null for normal Jalview project IO, but
1223    * non-null when a jalview project is being read or written as part of a
1224    * vamsas session.
1225    */
1226   IdentityHashMap jv2vobj = null;
1227
1228   /**
1229    * Construct a unique ID for jvobj using either existing bindings or if none
1230    * exist, the result of the hashcode call for the object.
1231    *
1232    * @param jvobj
1233    *          jalview data object
1234    * @return unique ID for referring to jvobj
1235    */
1236   private String makeHashCode(Object jvobj, String altCode)
1237   {
1238     if (jv2vobj != null)
1239     {
1240       Object id = jv2vobj.get(jvobj);
1241       if (id != null)
1242       {
1243         return id.toString();
1244       }
1245       // check string ID mappings
1246       if (jvids2vobj != null && jvobj instanceof String)
1247       {
1248         id = jvids2vobj.get(jvobj);
1249       }
1250       if (id != null)
1251       {
1252         return id.toString();
1253       }
1254       // give up and warn that something has gone wrong
1255       warn("Cannot find ID for object in external mapping : " + jvobj);
1256     }
1257     return altCode;
1258   }
1259
1260   /**
1261    * return local jalview object mapped to ID, if it exists
1262    *
1263    * @param idcode
1264    *          (may be null)
1265    * @return null or object bound to idcode
1266    */
1267   private Object retrieveExistingObj(String idcode)
1268   {
1269     if (idcode != null && vobj2jv != null)
1270     {
1271       return vobj2jv.get(idcode);
1272     }
1273     return null;
1274   }
1275
1276   /**
1277    * binding from ID strings from external mapping table to jalview data model
1278    * objects.
1279    */
1280   private Hashtable vobj2jv;
1281
1282   private Sequence createVamsasSequence(String id, SequenceI jds)
1283   {
1284     return createVamsasSequence(true, id, jds, null);
1285   }
1286
1287   private Sequence createVamsasSequence(boolean recurse, String id,
1288           SequenceI jds, SequenceI parentseq)
1289   {
1290     Sequence vamsasSeq = new Sequence();
1291     vamsasSeq.setId(id);
1292     vamsasSeq.setName(jds.getName());
1293     vamsasSeq.setSequence(jds.getSequenceAsString());
1294     vamsasSeq.setDescription(jds.getDescription());
1295     jalview.datamodel.DBRefEntry[] dbrefs = null;
1296     if (jds.getDatasetSequence() != null)
1297     {
1298       vamsasSeq.setDsseqid(seqHash(jds.getDatasetSequence()));
1299       if (jds.getDatasetSequence().getDBRef() != null)
1300       {
1301         dbrefs = jds.getDatasetSequence().getDBRef();
1302       }
1303     }
1304     else
1305     {
1306       vamsasSeq.setDsseqid(id); // so we can tell which sequences really are
1307       // dataset sequences only
1308       dbrefs = jds.getDBRef();
1309     }
1310     if (dbrefs != null)
1311     {
1312       for (int d = 0; d < dbrefs.length; d++)
1313       {
1314         DBRef dbref = new DBRef();
1315         dbref.setSource(dbrefs[d].getSource());
1316         dbref.setVersion(dbrefs[d].getVersion());
1317         dbref.setAccessionId(dbrefs[d].getAccessionId());
1318         if (dbrefs[d].hasMap())
1319         {
1320           Mapping mp = createVamsasMapping(dbrefs[d].getMap(), parentseq,
1321                   jds, recurse);
1322           dbref.setMapping(mp);
1323         }
1324         vamsasSeq.addDBRef(dbref);
1325       }
1326     }
1327     return vamsasSeq;
1328   }
1329
1330   private Mapping createVamsasMapping(jalview.datamodel.Mapping jmp,
1331           SequenceI parentseq, SequenceI jds, boolean recurse)
1332   {
1333     Mapping mp = null;
1334     if (jmp.getMap() != null)
1335     {
1336       mp = new Mapping();
1337
1338       jalview.util.MapList mlst = jmp.getMap();
1339       int r[] = mlst.getFromRanges();
1340       for (int s = 0; s < r.length; s += 2)
1341       {
1342         MapListFrom mfrom = new MapListFrom();
1343         mfrom.setStart(r[s]);
1344         mfrom.setEnd(r[s + 1]);
1345         mp.addMapListFrom(mfrom);
1346       }
1347       r = mlst.getToRanges();
1348       for (int s = 0; s < r.length; s += 2)
1349       {
1350         MapListTo mto = new MapListTo();
1351         mto.setStart(r[s]);
1352         mto.setEnd(r[s + 1]);
1353         mp.addMapListTo(mto);
1354       }
1355       mp.setMapFromUnit(mlst.getFromRatio());
1356       mp.setMapToUnit(mlst.getToRatio());
1357       if (jmp.getTo() != null)
1358       {
1359         MappingChoice mpc = new MappingChoice();
1360         if (recurse
1361                 && (parentseq != jmp.getTo() || parentseq
1362                         .getDatasetSequence() != jmp.getTo()))
1363         {
1364           mpc.setSequence(createVamsasSequence(false, seqHash(jmp.getTo()),
1365                   jmp.getTo(), jds));
1366         }
1367         else
1368         {
1369           String jmpid = "";
1370           SequenceI ps = null;
1371           if (parentseq != jmp.getTo()
1372                   && parentseq.getDatasetSequence() != jmp.getTo())
1373           {
1374             // chaining dbref rather than a handshaking one
1375             jmpid = seqHash(ps = jmp.getTo());
1376           }
1377           else
1378           {
1379             jmpid = seqHash(ps = parentseq);
1380           }
1381           mpc.setDseqFor(jmpid);
1382           if (!seqRefIds.containsKey(mpc.getDseqFor()))
1383           {
1384             jalview.bin.Cache.log.debug("creatign new DseqFor ID");
1385             seqRefIds.put(mpc.getDseqFor(), ps);
1386           }
1387           else
1388           {
1389             jalview.bin.Cache.log.debug("reusing DseqFor ID");
1390           }
1391         }
1392         mp.setMappingChoice(mpc);
1393       }
1394     }
1395     return mp;
1396   }
1397
1398   String SetUserColourScheme(jalview.schemes.ColourSchemeI cs,
1399           Vector userColours, JalviewModelSequence jms)
1400   {
1401     String id = null;
1402     jalview.schemes.UserColourScheme ucs = (jalview.schemes.UserColourScheme) cs;
1403     boolean newucs = false;
1404     if (!userColours.contains(ucs))
1405     {
1406       userColours.add(ucs);
1407       newucs = true;
1408     }
1409     id = "ucs" + userColours.indexOf(ucs);
1410     if (newucs)
1411     {
1412       // actually create the scheme's entry in the XML model
1413       java.awt.Color[] colours = ucs.getColours();
1414       jalview.schemabinding.version2.UserColours uc = new jalview.schemabinding.version2.UserColours();
1415       jalview.schemabinding.version2.UserColourScheme jbucs = new jalview.schemabinding.version2.UserColourScheme();
1416
1417       for (int i = 0; i < colours.length; i++)
1418       {
1419         jalview.schemabinding.version2.Colour col = new jalview.schemabinding.version2.Colour();
1420         col.setName(ResidueProperties.aa[i]);
1421         col.setRGB(jalview.util.Format.getHexString(colours[i]));
1422         jbucs.addColour(col);
1423       }
1424       if (ucs.getLowerCaseColours() != null)
1425       {
1426         colours = ucs.getLowerCaseColours();
1427         for (int i = 0; i < colours.length; i++)
1428         {
1429           jalview.schemabinding.version2.Colour col = new jalview.schemabinding.version2.Colour();
1430           col.setName(ResidueProperties.aa[i].toLowerCase());
1431           col.setRGB(jalview.util.Format.getHexString(colours[i]));
1432           jbucs.addColour(col);
1433         }
1434       }
1435
1436       uc.setId(id);
1437       uc.setUserColourScheme(jbucs);
1438       jms.addUserColours(uc);
1439     }
1440
1441     return id;
1442   }
1443
1444   jalview.schemes.UserColourScheme GetUserColourScheme(
1445           JalviewModelSequence jms, String id)
1446   {
1447     UserColours[] uc = jms.getUserColours();
1448     UserColours colours = null;
1449
1450     for (int i = 0; i < uc.length; i++)
1451     {
1452       if (uc[i].getId().equals(id))
1453       {
1454         colours = uc[i];
1455
1456         break;
1457       }
1458     }
1459
1460     java.awt.Color[] newColours = new java.awt.Color[24];
1461
1462     for (int i = 0; i < 24; i++)
1463     {
1464       newColours[i] = new java.awt.Color(Integer.parseInt(colours
1465               .getUserColourScheme().getColour(i).getRGB(), 16));
1466     }
1467
1468     jalview.schemes.UserColourScheme ucs = new jalview.schemes.UserColourScheme(
1469             newColours);
1470
1471     if (colours.getUserColourScheme().getColourCount() > 24)
1472     {
1473       newColours = new java.awt.Color[23];
1474       for (int i = 0; i < 23; i++)
1475       {
1476         newColours[i] = new java.awt.Color(Integer.parseInt(colours
1477                 .getUserColourScheme().getColour(i + 24).getRGB(), 16));
1478       }
1479       ucs.setLowerCaseColours(newColours);
1480     }
1481
1482     return ucs;
1483   }
1484
1485   /**
1486    * contains last error message (if any) encountered by XML loader.
1487    */
1488   String errorMessage = null;
1489
1490   /**
1491    * flag to control whether the Jalview2XML_V1 parser should be deferred to if
1492    * exceptions are raised during project XML parsing
1493    */
1494   public boolean attemptversion1parse = true;
1495
1496   /**
1497    * Load a jalview project archive from a jar file
1498    *
1499    * @param file
1500    *          - HTTP URL or filename
1501    */
1502   public AlignFrame LoadJalviewAlign(final String file)
1503   {
1504
1505     jalview.gui.AlignFrame af = null;
1506
1507     try
1508     {
1509       // UNMARSHALLER SEEMS TO CLOSE JARINPUTSTREAM, MOST ANNOYING
1510       // Workaround is to make sure caller implements the JarInputStreamProvider
1511       // interface
1512       // so we can re-open the jar input stream for each entry.
1513
1514       jarInputStreamProvider jprovider = createjarInputStreamProvider(file);
1515       af = LoadJalviewAlign(jprovider);
1516     } catch (MalformedURLException e)
1517     {
1518       errorMessage = "Invalid URL format for '" + file + "'";
1519       reportErrors();
1520     }
1521     return af;
1522   }
1523
1524   private jarInputStreamProvider createjarInputStreamProvider(
1525           final String file) throws MalformedURLException
1526   {
1527     URL url = null;
1528     errorMessage = null;
1529     uniqueSetSuffix = null;
1530     seqRefIds = null;
1531     viewportsAdded = null;
1532     frefedSequence = null;
1533
1534     if (file.startsWith("http://"))
1535     {
1536       url = new URL(file);
1537     }
1538     final URL _url = url;
1539     return new jarInputStreamProvider()
1540     {
1541
1542       public JarInputStream getJarInputStream() throws IOException
1543       {
1544         if (_url != null)
1545         {
1546           return new JarInputStream(_url.openStream());
1547         }
1548         else
1549         {
1550           return new JarInputStream(new FileInputStream(file));
1551         }
1552       }
1553
1554       public String getFilename()
1555       {
1556         return file;
1557       }
1558     };
1559   }
1560
1561   /**
1562    * Recover jalview session from a jalview project archive. Caller may
1563    * initialise uniqueSetSuffix, seqRefIds, viewportsAdded and frefedSequence
1564    * themselves. Any null fields will be initialised with default values,
1565    * non-null fields are left alone.
1566    *
1567    * @param jprovider
1568    * @return
1569    */
1570   public AlignFrame LoadJalviewAlign(final jarInputStreamProvider jprovider)
1571   {
1572     errorMessage = null;
1573     if (uniqueSetSuffix == null)
1574     {
1575       uniqueSetSuffix = System.currentTimeMillis() % 100000 + "";
1576     }
1577     if (seqRefIds == null)
1578     {
1579       seqRefIds = new Hashtable();
1580     }
1581     if (viewportsAdded == null)
1582     {
1583       viewportsAdded = new Hashtable();
1584     }
1585     if (frefedSequence == null)
1586     {
1587       frefedSequence = new Vector();
1588     }
1589
1590     jalview.gui.AlignFrame af = null;
1591     Hashtable gatherToThisFrame = new Hashtable();
1592     final String file = jprovider.getFilename();
1593     try
1594     {
1595       JarInputStream jin = null;
1596       JarEntry jarentry = null;
1597       int entryCount = 1;
1598
1599       do
1600       {
1601         jin = jprovider.getJarInputStream();
1602         for (int i = 0; i < entryCount; i++)
1603         {
1604           jarentry = jin.getNextJarEntry();
1605         }
1606
1607         if (jarentry != null && jarentry.getName().endsWith(".xml"))
1608         {
1609           InputStreamReader in = new InputStreamReader(jin, "UTF-8");
1610           JalviewModel object = new JalviewModel();
1611
1612           Unmarshaller unmar = new Unmarshaller(object);
1613           unmar.setValidation(false);
1614           object = (JalviewModel) unmar.unmarshal(in);
1615           if (true) // !skipViewport(object))
1616           {
1617             af = LoadFromObject(object, file, true, jprovider);
1618             if (af.viewport.gatherViewsHere)
1619             {
1620               gatherToThisFrame.put(af.viewport.getSequenceSetId(), af);
1621             }
1622           }
1623           entryCount++;
1624         }
1625         else if (jarentry != null)
1626         {
1627           // Some other file here.
1628           entryCount++;
1629         }
1630       } while (jarentry != null);
1631       resolveFrefedSequences();
1632     } catch (java.io.FileNotFoundException ex)
1633     {
1634       ex.printStackTrace();
1635       errorMessage = "Couldn't locate Jalview XML file : " + file;
1636       System.err.println("Exception whilst loading jalview XML file : "
1637               + ex + "\n");
1638     } catch (java.net.UnknownHostException ex)
1639     {
1640       ex.printStackTrace();
1641       errorMessage = "Couldn't locate Jalview XML file : " + file;
1642       System.err.println("Exception whilst loading jalview XML file : "
1643               + ex + "\n");
1644     } catch (Exception ex)
1645     {
1646       System.err.println("Parsing as Jalview Version 2 file failed.");
1647       ex.printStackTrace(System.err);
1648       if (attemptversion1parse)
1649       {
1650         // Is Version 1 Jar file?
1651         try
1652         {
1653           af = new Jalview2XML_V1(raiseGUI).LoadJalviewAlign(jprovider);
1654         } catch (Exception ex2)
1655         {
1656           System.err.println("Exception whilst loading as jalviewXMLV1:");
1657           ex2.printStackTrace();
1658           af = null;
1659         }
1660       }
1661       if (Desktop.instance != null)
1662       {
1663         Desktop.instance.stopLoading();
1664       }
1665       if (af != null)
1666       {
1667         System.out.println("Successfully loaded archive file");
1668         return af;
1669       }
1670       ex.printStackTrace();
1671
1672       System.err.println("Exception whilst loading jalview XML file : "
1673               + ex + "\n");
1674     } catch (OutOfMemoryError e)
1675     {
1676       // Don't use the OOM Window here
1677       errorMessage = "Out of memory loading jalview XML file";
1678       System.err.println("Out of memory whilst loading jalview XML file");
1679       e.printStackTrace();
1680     }
1681
1682     if (Desktop.instance != null)
1683     {
1684       Desktop.instance.stopLoading();
1685     }
1686
1687     Enumeration en = gatherToThisFrame.elements();
1688     while (en.hasMoreElements())
1689     {
1690       Desktop.instance.gatherViews((AlignFrame) en.nextElement());
1691     }
1692     if (errorMessage != null)
1693     {
1694       reportErrors();
1695     }
1696     return af;
1697   }
1698
1699   /**
1700    * check errorMessage for a valid error message and raise an error box in the
1701    * GUI or write the current errorMessage to stderr and then clear the error
1702    * state.
1703    */
1704   protected void reportErrors()
1705   {
1706     reportErrors(false);
1707   }
1708
1709   protected void reportErrors(final boolean saving)
1710   {
1711     if (errorMessage != null)
1712     {
1713       final String finalErrorMessage = errorMessage;
1714       if (raiseGUI)
1715       {
1716         javax.swing.SwingUtilities.invokeLater(new Runnable()
1717         {
1718           public void run()
1719           {
1720             JOptionPane.showInternalMessageDialog(Desktop.desktop,
1721                     finalErrorMessage, "Error "
1722                             + (saving ? "saving" : "loading")
1723                             + " Jalview file", JOptionPane.WARNING_MESSAGE);
1724           }
1725         });
1726       }
1727       else
1728       {
1729         System.err.println("Problem loading Jalview file: " + errorMessage);
1730       }
1731     }
1732     errorMessage = null;
1733   }
1734
1735   Hashtable alreadyLoadedPDB;
1736
1737   /**
1738    * when set, local views will be updated from view stored in JalviewXML
1739    * Currently (28th Sep 2008) things will go horribly wrong in vamsas document
1740    * sync if this is set to true.
1741    */
1742   private boolean updateLocalViews = false;
1743
1744   String loadPDBFile(jarInputStreamProvider jprovider, String pdbId)
1745   {
1746     if (alreadyLoadedPDB == null)
1747       alreadyLoadedPDB = new Hashtable();
1748
1749     if (alreadyLoadedPDB.containsKey(pdbId))
1750       return alreadyLoadedPDB.get(pdbId).toString();
1751
1752     try
1753     {
1754       JarInputStream jin = jprovider.getJarInputStream();
1755       /*
1756        * if (jprovider.startsWith("http://")) { jin = new JarInputStream(new
1757        * URL(jprovider).openStream()); } else { jin = new JarInputStream(new
1758        * FileInputStream(jprovider)); }
1759        */
1760
1761       JarEntry entry = null;
1762       do
1763       {
1764         entry = jin.getNextJarEntry();
1765       } while (entry != null && !entry.getName().equals(pdbId));
1766       if (entry != null)
1767       {
1768         BufferedReader in = new BufferedReader(new InputStreamReader(jin));
1769         File outFile = File.createTempFile("jalview_pdb", ".txt");
1770         outFile.deleteOnExit();
1771         PrintWriter out = new PrintWriter(new FileOutputStream(outFile));
1772         String data;
1773
1774         while ((data = in.readLine()) != null)
1775         {
1776           out.println(data);
1777         }
1778         try
1779         {
1780           out.flush();
1781         } catch (Exception foo)
1782         {
1783         }
1784         ;
1785         out.close();
1786
1787         alreadyLoadedPDB.put(pdbId, outFile.getAbsolutePath());
1788         return outFile.getAbsolutePath();
1789       }
1790       else
1791       {
1792         warn("Couldn't find PDB file entry in Jalview Jar for " + pdbId);
1793       }
1794     } catch (Exception ex)
1795     {
1796       ex.printStackTrace();
1797     }
1798
1799     return null;
1800   }
1801
1802   /**
1803    * Load alignment frame from jalview XML DOM object
1804    *
1805    * @param object
1806    *          DOM
1807    * @param file
1808    *          filename source string
1809    * @param loadTreesAndStructures
1810    *          when false only create Viewport
1811    * @param jprovider
1812    *          data source provider
1813    * @return alignment frame created from view stored in DOM
1814    */
1815   AlignFrame LoadFromObject(JalviewModel object, String file,
1816           boolean loadTreesAndStructures, jarInputStreamProvider jprovider)
1817   {
1818     SequenceSet vamsasSet = object.getVamsasModel().getSequenceSet(0);
1819     Sequence[] vamsasSeq = vamsasSet.getSequence();
1820
1821     JalviewModelSequence jms = object.getJalviewModelSequence();
1822
1823     Viewport view = jms.getViewport(0);
1824     // ////////////////////////////////
1825     // LOAD SEQUENCES
1826
1827     Vector hiddenSeqs = null;
1828     jalview.datamodel.Sequence jseq;
1829
1830     ArrayList tmpseqs = new ArrayList();
1831
1832     boolean multipleView = false;
1833
1834     JSeq[] JSEQ = object.getJalviewModelSequence().getJSeq();
1835     int vi = 0; // counter in vamsasSeq array
1836     for (int i = 0; i < JSEQ.length; i++)
1837     {
1838       String seqId = JSEQ[i].getId();
1839
1840       if (seqRefIds.get(seqId) != null)
1841       {
1842         tmpseqs.add((jalview.datamodel.Sequence) seqRefIds.get(seqId));
1843         multipleView = true;
1844       }
1845       else
1846       {
1847         jseq = new jalview.datamodel.Sequence(vamsasSeq[vi].getName(),
1848                 vamsasSeq[vi].getSequence());
1849         jseq.setDescription(vamsasSeq[vi].getDescription());
1850         jseq.setStart(JSEQ[i].getStart());
1851         jseq.setEnd(JSEQ[i].getEnd());
1852         jseq.setVamsasId(uniqueSetSuffix + seqId);
1853         seqRefIds.put(vamsasSeq[vi].getId(), jseq);
1854         tmpseqs.add(jseq);
1855         vi++;
1856       }
1857
1858       if (JSEQ[i].getHidden())
1859       {
1860         if (hiddenSeqs == null)
1861         {
1862           hiddenSeqs = new Vector();
1863         }
1864
1865         hiddenSeqs.addElement((jalview.datamodel.Sequence) seqRefIds
1866                 .get(seqId));
1867       }
1868
1869     }
1870
1871     // /
1872     // Create the alignment object from the sequence set
1873     // ///////////////////////////////
1874     jalview.datamodel.Sequence[] orderedSeqs = new jalview.datamodel.Sequence[tmpseqs
1875             .size()];
1876
1877     tmpseqs.toArray(orderedSeqs);
1878
1879     jalview.datamodel.Alignment al = new jalview.datamodel.Alignment(
1880             orderedSeqs);
1881
1882     // / Add the alignment properties
1883     for (int i = 0; i < vamsasSet.getSequenceSetPropertiesCount(); i++)
1884     {
1885       SequenceSetProperties ssp = vamsasSet.getSequenceSetProperties(i);
1886       al.setProperty(ssp.getKey(), ssp.getValue());
1887     }
1888
1889     // /
1890     // SequenceFeatures are added to the DatasetSequence,
1891     // so we must create or recover the dataset before loading features
1892     // ///////////////////////////////
1893     if (vamsasSet.getDatasetId() == null || vamsasSet.getDatasetId() == "")
1894     {
1895       // older jalview projects do not have a dataset id.
1896       al.setDataset(null);
1897     }
1898     else
1899     {
1900       recoverDatasetFor(vamsasSet, al);
1901     }
1902     // ///////////////////////////////
1903
1904     Hashtable pdbloaded = new Hashtable();
1905     if (!multipleView)
1906     {
1907       // load sequence features, database references and any associated PDB
1908       // structures for the alignment
1909       for (int i = 0; i < vamsasSeq.length; i++)
1910       {
1911         if (JSEQ[i].getFeaturesCount() > 0)
1912         {
1913           Features[] features = JSEQ[i].getFeatures();
1914           for (int f = 0; f < features.length; f++)
1915           {
1916             jalview.datamodel.SequenceFeature sf = new jalview.datamodel.SequenceFeature(
1917                     features[f].getType(), features[f].getDescription(),
1918                     features[f].getStatus(), features[f].getBegin(),
1919                     features[f].getEnd(), features[f].getFeatureGroup());
1920
1921             sf.setScore(features[f].getScore());
1922             for (int od = 0; od < features[f].getOtherDataCount(); od++)
1923             {
1924               OtherData keyValue = features[f].getOtherData(od);
1925               if (keyValue.getKey().startsWith("LINK"))
1926               {
1927                 sf.addLink(keyValue.getValue());
1928               }
1929               else
1930               {
1931                 sf.setValue(keyValue.getKey(), keyValue.getValue());
1932               }
1933
1934             }
1935
1936             al.getSequenceAt(i).getDatasetSequence().addSequenceFeature(sf);
1937           }
1938         }
1939         if (vamsasSeq[i].getDBRefCount() > 0)
1940         {
1941           addDBRefs(al.getSequenceAt(i).getDatasetSequence(), vamsasSeq[i]);
1942         }
1943         if (JSEQ[i].getPdbidsCount() > 0)
1944         {
1945           Pdbids[] ids = JSEQ[i].getPdbids();
1946           for (int p = 0; p < ids.length; p++)
1947           {
1948             jalview.datamodel.PDBEntry entry = new jalview.datamodel.PDBEntry();
1949             entry.setId(ids[p].getId());
1950             entry.setType(ids[p].getType());
1951             if (ids[p].getFile() != null)
1952             {
1953               if (!pdbloaded.containsKey(ids[p].getFile()))
1954               {
1955                 entry.setFile(loadPDBFile(jprovider, ids[p].getId()));
1956               }
1957               else
1958               {
1959                 entry.setFile(pdbloaded.get(ids[p].getId()).toString());
1960               }
1961             }
1962
1963             al.getSequenceAt(i).getDatasetSequence().addPDBId(entry);
1964           }
1965         }
1966       }
1967     } // end !multipleview
1968
1969     // ///////////////////////////////
1970     // LOAD SEQUENCE MAPPINGS
1971
1972     if (vamsasSet.getAlcodonFrameCount() > 0)
1973     {
1974       // TODO Potentially this should only be done once for all views of an
1975       // alignment
1976       AlcodonFrame[] alc = vamsasSet.getAlcodonFrame();
1977       for (int i = 0; i < alc.length; i++)
1978       {
1979         jalview.datamodel.AlignedCodonFrame cf = new jalview.datamodel.AlignedCodonFrame(
1980                 alc[i].getAlcodonCount());
1981         if (alc[i].getAlcodonCount() > 0)
1982         {
1983           Alcodon[] alcods = alc[i].getAlcodon();
1984           for (int p = 0; p < cf.codons.length; p++)
1985           {
1986             if (alcods[p].hasPos1() && alcods[p].hasPos2()
1987                     && alcods[p].hasPos3())
1988             {
1989               // translated codons require three valid positions
1990               cf.codons[p] = new int[3];
1991               cf.codons[p][0] = (int) alcods[p].getPos1();
1992               cf.codons[p][1] = (int) alcods[p].getPos2();
1993               cf.codons[p][2] = (int) alcods[p].getPos3();
1994             }
1995             else
1996             {
1997               cf.codons[p] = null;
1998             }
1999           }
2000         }
2001         if (alc[i].getAlcodMapCount() > 0)
2002         {
2003           AlcodMap[] maps = alc[i].getAlcodMap();
2004           for (int m = 0; m < maps.length; m++)
2005           {
2006             SequenceI dnaseq = (SequenceI) seqRefIds
2007                     .get(maps[m].getDnasq());
2008             // Load Mapping
2009             jalview.datamodel.Mapping mapping = null;
2010             // attach to dna sequence reference.
2011             if (maps[m].getMapping() != null)
2012             {
2013               mapping = addMapping(maps[m].getMapping());
2014             }
2015             if (dnaseq != null)
2016             {
2017               cf.addMap(dnaseq, mapping.getTo(), mapping.getMap());
2018             }
2019             else
2020             {
2021               // defer to later
2022               frefedSequence.add(new Object[]
2023               { maps[m].getDnasq(), cf, mapping });
2024             }
2025           }
2026         }
2027         al.addCodonFrame(cf);
2028       }
2029
2030     }
2031
2032     // ////////////////////////////////
2033     // LOAD ANNOTATIONS
2034     boolean hideQuality = true, hideConservation = true, hideConsensus = true;
2035     /**
2036      * store any annotations which forward reference a group's ID
2037      */
2038     Hashtable groupAnnotRefs = new Hashtable();
2039
2040     if (vamsasSet.getAnnotationCount() > 0)
2041     {
2042       Annotation[] an = vamsasSet.getAnnotation();
2043
2044       for (int i = 0; i < an.length; i++)
2045       {
2046         // set visibility for automatic annotation for this view
2047         if (an[i].getLabel().equals("Quality"))
2048         {
2049           hideQuality = false;
2050           continue;
2051         }
2052         else if (an[i].getLabel().equals("Conservation"))
2053         {
2054           hideConservation = false;
2055           continue;
2056         }
2057         else if (an[i].getLabel().equals("Consensus"))
2058         {
2059           hideConsensus = false;
2060           continue;
2061         }
2062         // set visiblity for other annotation in this view
2063         if (an[i].getId() != null
2064                 && annotationIds.containsKey(an[i].getId()))
2065         {
2066           jalview.datamodel.AlignmentAnnotation jda = (jalview.datamodel.AlignmentAnnotation) annotationIds
2067                   .get(an[i].getId());
2068           // in principle Visible should always be true for annotation displayed
2069           // in multiple views
2070           if (an[i].hasVisible())
2071             jda.visible = an[i].getVisible();
2072
2073           al.addAnnotation(jda);
2074
2075           continue;
2076         }
2077         // Construct new annotation from model.
2078         AnnotationElement[] ae = an[i].getAnnotationElement();
2079         jalview.datamodel.Annotation[] anot = null;
2080
2081         if (!an[i].getScoreOnly())
2082         {
2083           anot = new jalview.datamodel.Annotation[al.getWidth()];
2084
2085           for (int aa = 0; aa < ae.length && aa < anot.length; aa++)
2086           {
2087             if (ae[aa].getPosition() >= anot.length)
2088               continue;
2089
2090             anot[ae[aa].getPosition()] = new jalview.datamodel.Annotation(
2091
2092             ae[aa].getDisplayCharacter(), ae[aa].getDescription(), (ae[aa]
2093                     .getSecondaryStructure() == null || ae[aa]
2094                     .getSecondaryStructure().length() == 0) ? ' ' : ae[aa]
2095                     .getSecondaryStructure().charAt(0), ae[aa].getValue()
2096
2097             );
2098             // JBPNote: Consider verifying dataflow for IO of secondary
2099             // structure annotation read from Stockholm files
2100             // this was added to try to ensure that
2101             // if (anot[ae[aa].getPosition()].secondaryStructure>' ')
2102             // {
2103             // anot[ae[aa].getPosition()].displayCharacter = "";
2104             // }
2105             anot[ae[aa].getPosition()].colour = new java.awt.Color(ae[aa]
2106                     .getColour());
2107           }
2108         }
2109         jalview.datamodel.AlignmentAnnotation jaa = null;
2110
2111         if (an[i].getGraph())
2112         {
2113           jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(),
2114                   an[i].getDescription(), anot, 0, 0, an[i].getGraphType());
2115
2116           jaa.graphGroup = an[i].getGraphGroup();
2117
2118           if (an[i].getThresholdLine() != null)
2119           {
2120             jaa.setThreshold(new jalview.datamodel.GraphLine(an[i]
2121                     .getThresholdLine().getValue(), an[i]
2122                     .getThresholdLine().getLabel(), new java.awt.Color(
2123                     an[i].getThresholdLine().getColour())));
2124
2125           }
2126
2127         }
2128         else
2129         {
2130           jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(),
2131                   an[i].getDescription(), anot);
2132         }
2133         // register new annotation
2134         if (an[i].getId() != null)
2135         {
2136           annotationIds.put(an[i].getId(), jaa);
2137           jaa.annotationId = an[i].getId();
2138         }
2139         // recover sequence association
2140         if (an[i].getSequenceRef() != null)
2141         {
2142           if (al.findName(an[i].getSequenceRef()) != null)
2143           {
2144             jaa.createSequenceMapping(al.findName(an[i].getSequenceRef()),
2145                     1, true);
2146             al.findName(an[i].getSequenceRef()).addAlignmentAnnotation(jaa);
2147           }
2148         }
2149         // and make a note of any group association
2150         if (an[i].getGroupRef() != null && an[i].getGroupRef().length() > 0)
2151         {
2152           groupAnnotRefs.put(an[i].getGroupRef(), jaa);
2153         }
2154
2155         if (an[i].hasScore())
2156         {
2157           jaa.setScore(an[i].getScore());
2158         }
2159         if (an[i].hasVisible())
2160           jaa.visible = an[i].getVisible();
2161
2162         if (an[i].hasCentreColLabels())
2163           jaa.centreColLabels = an[i].getCentreColLabels();
2164
2165         if (an[i].hasScaleColLabels())
2166         {
2167           jaa.scaleColLabel = an[i].getScaleColLabels();
2168         }
2169         if (an[i].hasAutoCalculated() && an[i].isAutoCalculated())
2170         {
2171           // newer files have an 'autoCalculated' flag and store calculation
2172           // state in viewport properties
2173           jaa.autoCalculated = true; // means annotation will be marked for
2174           // update at end of load.
2175         }
2176         al.addAnnotation(jaa);
2177       }
2178     }
2179
2180     // ///////////////////////
2181     // LOAD GROUPS
2182     // Create alignment markup and styles for this view
2183     if (jms.getJGroupCount() > 0)
2184     {
2185       JGroup[] groups = jms.getJGroup();
2186
2187       for (int i = 0; i < groups.length; i++)
2188       {
2189         ColourSchemeI cs = null;
2190
2191         if (groups[i].getColour() != null)
2192         {
2193           if (groups[i].getColour().startsWith("ucs"))
2194           {
2195             cs = GetUserColourScheme(jms, groups[i].getColour());
2196           }
2197           else
2198           {
2199             cs = ColourSchemeProperty.getColour(al, groups[i].getColour());
2200           }
2201
2202           if (cs != null)
2203           {
2204             cs.setThreshold(groups[i].getPidThreshold(), true);
2205           }
2206         }
2207
2208         Vector seqs = new Vector();
2209
2210         for (int s = 0; s < groups[i].getSeqCount(); s++)
2211         {
2212           String seqId = groups[i].getSeq(s) + "";
2213           jalview.datamodel.SequenceI ts = (jalview.datamodel.SequenceI) seqRefIds
2214                   .get(seqId);
2215
2216           if (ts != null)
2217           {
2218             seqs.addElement(ts);
2219           }
2220         }
2221
2222         if (seqs.size() < 1)
2223         {
2224           continue;
2225         }
2226
2227         jalview.datamodel.SequenceGroup sg = new jalview.datamodel.SequenceGroup(
2228                 seqs, groups[i].getName(), cs, groups[i].getDisplayBoxes(),
2229                 groups[i].getDisplayText(), groups[i].getColourText(),
2230                 groups[i].getStart(), groups[i].getEnd());
2231
2232         sg
2233                 .setOutlineColour(new java.awt.Color(groups[i]
2234                         .getOutlineColour()));
2235
2236         sg.textColour = new java.awt.Color(groups[i].getTextCol1());
2237         sg.textColour2 = new java.awt.Color(groups[i].getTextCol2());
2238         sg.setShowNonconserved(groups[i].hasShowUnconserved() ? groups[i]
2239                 .isShowUnconserved() : false);
2240         sg.thresholdTextColour = groups[i].getTextColThreshold();
2241         if (groups[i].hasShowConsensusHistogram())
2242         {
2243           sg
2244                   .setShowConsensusHistogram(groups[i]
2245                           .isShowConsensusHistogram());
2246         }
2247         ;
2248         if (groups[i].hasShowSequenceLogo())
2249         {
2250           sg.setshowSequenceLogo(groups[i].isShowSequenceLogo());
2251         }
2252         if (groups[i].hasIgnoreGapsinConsensus())
2253         {
2254           sg.setIgnoreGapsConsensus(groups[i].getIgnoreGapsinConsensus());
2255         }
2256         if (groups[i].getConsThreshold() != 0)
2257         {
2258           jalview.analysis.Conservation c = new jalview.analysis.Conservation(
2259                   "All", ResidueProperties.propHash, 3, sg
2260                           .getSequences(null), 0, sg.getWidth() - 1);
2261           c.calculate();
2262           c.verdict(false, 25);
2263           sg.cs.setConservation(c);
2264         }
2265
2266         if (groups[i].getId() != null && groupAnnotRefs.size() > 0)
2267         {
2268           // re-instate unique group/annotation row reference
2269           jalview.datamodel.AlignmentAnnotation jaa = (jalview.datamodel.AlignmentAnnotation) groupAnnotRefs
2270                   .get(groups[i].getId());
2271           if (jaa != null)
2272           {
2273             jaa.groupRef = sg;
2274           }
2275         }
2276         al.addGroup(sg);
2277
2278       }
2279     }
2280
2281     // ///////////////////////////////
2282     // LOAD VIEWPORT
2283
2284     // If we just load in the same jar file again, the sequenceSetId
2285     // will be the same, and we end up with multiple references
2286     // to the same sequenceSet. We must modify this id on load
2287     // so that each load of the file gives a unique id
2288     String uniqueSeqSetId = view.getSequenceSetId() + uniqueSetSuffix;
2289     String viewId = (view.getId() == null ? null : view.getId()
2290             + uniqueSetSuffix);
2291     AlignFrame af = null;
2292     AlignViewport av = null;
2293     // now check to see if we really need to create a new viewport.
2294     if (multipleView && viewportsAdded.size() == 0)
2295     {
2296       // We recovered an alignment for which a viewport already exists.
2297       // TODO: fix up any settings necessary for overlaying stored state onto
2298       // state recovered from another document. (may not be necessary).
2299       // we may need a binding from a viewport in memory to one recovered from
2300       // XML.
2301       // and then recover its containing af to allow the settings to be applied.
2302       // TODO: fix for vamsas demo
2303       System.err
2304               .println("About to recover a viewport for existing alignment: Sequence set ID is "
2305                       + uniqueSeqSetId);
2306       Object seqsetobj = retrieveExistingObj(uniqueSeqSetId);
2307       if (seqsetobj != null)
2308       {
2309         if (seqsetobj instanceof String)
2310         {
2311           uniqueSeqSetId = (String) seqsetobj;
2312           System.err
2313                   .println("Recovered extant sequence set ID mapping for ID : New Sequence set ID is "
2314                           + uniqueSeqSetId);
2315         }
2316         else
2317         {
2318           System.err
2319                   .println("Warning : Collision between sequence set ID string and existing jalview object mapping.");
2320         }
2321
2322       }
2323     }
2324     AlignmentPanel ap = null;
2325     boolean isnewview = true;
2326     if (viewId != null)
2327     {
2328       // Check to see if this alignment already has a view id == viewId
2329       jalview.gui.AlignmentPanel views[] = Desktop
2330               .getAlignmentPanels(uniqueSeqSetId);
2331       if (views != null && views.length > 0)
2332       {
2333         for (int v = 0; v < views.length; v++)
2334         {
2335           if (views[v].av.getViewId().equalsIgnoreCase(viewId))
2336           {
2337             // recover the existing alignpanel, alignframe, viewport
2338             af = views[v].alignFrame;
2339             av = views[v].av;
2340             ap = views[v];
2341             // TODO: could even skip resetting view settings if we don't want to
2342             // change the local settings from other jalview processes
2343             isnewview = false;
2344           }
2345         }
2346       }
2347     }
2348
2349     if (isnewview)
2350     {
2351       af = loadViewport(file, JSEQ, hiddenSeqs, al, hideConsensus,
2352               hideQuality, hideConservation, jms, view, uniqueSeqSetId,
2353               viewId);
2354       av = af.viewport;
2355       ap = af.alignPanel;
2356     }
2357     // LOAD TREES
2358     // /////////////////////////////////////
2359     if (loadTreesAndStructures && jms.getTreeCount() > 0)
2360     {
2361       try
2362       {
2363         for (int t = 0; t < jms.getTreeCount(); t++)
2364         {
2365
2366           Tree tree = jms.getTree(t);
2367
2368           TreePanel tp = (TreePanel) retrieveExistingObj(tree.getId());
2369           if (tp == null)
2370           {
2371             tp = af.ShowNewickTree(new jalview.io.NewickFile(tree
2372                     .getNewick()), tree.getTitle(), tree.getWidth(), tree
2373                     .getHeight(), tree.getXpos(), tree.getYpos());
2374             if (tree.getId() != null)
2375             {
2376               // perhaps bind the tree id to something ?
2377             }
2378           }
2379           else
2380           {
2381             // update local tree attributes ?
2382             // TODO: should check if tp has been manipulated by user - if so its
2383             // settings shouldn't be modified
2384             tp.setTitle(tree.getTitle());
2385             tp.setBounds(new Rectangle(tree.getXpos(), tree.getYpos(), tree
2386                     .getWidth(), tree.getHeight()));
2387             tp.av = av; // af.viewport; // TODO: verify 'associate with all
2388             // views'
2389             // works still
2390             tp.treeCanvas.av = av; // af.viewport;
2391             tp.treeCanvas.ap = ap; // af.alignPanel;
2392
2393           }
2394           if (tp == null)
2395           {
2396             warn("There was a problem recovering stored Newick tree: \n"
2397                     + tree.getNewick());
2398             continue;
2399           }
2400
2401           tp.fitToWindow.setState(tree.getFitToWindow());
2402           tp.fitToWindow_actionPerformed(null);
2403
2404           if (tree.getFontName() != null)
2405           {
2406             tp.setTreeFont(new java.awt.Font(tree.getFontName(), tree
2407                     .getFontStyle(), tree.getFontSize()));
2408           }
2409           else
2410           {
2411             tp.setTreeFont(new java.awt.Font(view.getFontName(), view
2412                     .getFontStyle(), tree.getFontSize()));
2413           }
2414
2415           tp.showPlaceholders(tree.getMarkUnlinked());
2416           tp.showBootstrap(tree.getShowBootstrap());
2417           tp.showDistances(tree.getShowDistances());
2418
2419           tp.treeCanvas.threshold = tree.getThreshold();
2420
2421           if (tree.getCurrentTree())
2422           {
2423             af.viewport.setCurrentTree(tp.getTree());
2424           }
2425         }
2426
2427       } catch (Exception ex)
2428       {
2429         ex.printStackTrace();
2430       }
2431     }
2432
2433     // //LOAD STRUCTURES
2434     if (loadTreesAndStructures)
2435     {
2436       for (int i = 0; i < JSEQ.length; i++)
2437       {
2438         if (JSEQ[i].getPdbidsCount() > 0)
2439         {
2440           Pdbids[] ids = JSEQ[i].getPdbids();
2441           for (int p = 0; p < ids.length; p++)
2442           {
2443             for (int s = 0; s < ids[p].getStructureStateCount(); s++)
2444             {
2445               // check to see if we haven't already created this structure view
2446               String sviewid = (ids[p].getStructureState(s).getViewId() == null) ? null
2447                       : ids[p].getStructureState(s).getViewId()
2448                               + uniqueSetSuffix;
2449               jalview.datamodel.PDBEntry jpdb = new jalview.datamodel.PDBEntry();
2450               // Originally : ids[p].getFile()
2451               // : TODO: verify external PDB file recovery still works in normal
2452               // jalview project load
2453               jpdb.setFile(loadPDBFile(jprovider, ids[p].getId()));
2454               jpdb.setId(ids[p].getId());
2455
2456               int x = ids[p].getStructureState(s).getXpos();
2457               int y = ids[p].getStructureState(s).getYpos();
2458               int width = ids[p].getStructureState(s).getWidth();
2459               int height = ids[p].getStructureState(s).getHeight();
2460               AppJmol comp = null;
2461               JInternalFrame[] frames = null;
2462               do
2463               {
2464                 try
2465                 {
2466                   frames = Desktop.desktop.getAllFrames();
2467                 } catch (ArrayIndexOutOfBoundsException e)
2468                 {
2469                   // occasional No such child exceptions are thrown here...
2470                   frames = null;
2471                   try
2472                   {
2473                     Thread.sleep(10);
2474                   } catch (Exception f)
2475                   {
2476                   }
2477                   ;
2478                 }
2479               } while (frames == null);
2480               // search for any Jmol windows already open from other
2481               // alignment views that exactly match the stored structure state
2482               for (int f = 0; comp == null && f < frames.length; f++)
2483               {
2484                 if (frames[f] instanceof AppJmol)
2485                 {
2486                   if (sviewid != null
2487                           && ((AppJmol) frames[f]).getViewId().equals(
2488                                   sviewid))
2489                   {
2490                     // post jalview 2.4 schema includes structure view id
2491                     comp = (AppJmol) frames[f];
2492                   }
2493                   else if (frames[f].getX() == x && frames[f].getY() == y
2494                           && frames[f].getHeight() == height
2495                           && frames[f].getWidth() == width)
2496                   {
2497                     comp = (AppJmol) frames[f];
2498                   }
2499                 }
2500               }
2501               // Probably don't need to do this anymore...
2502               // Desktop.desktop.getComponentAt(x, y);
2503               // TODO: NOW: check that this recovers the PDB file correctly.
2504               String pdbFile = loadPDBFile(jprovider, ids[p].getId());
2505
2506               jalview.datamodel.SequenceI[] seq = new jalview.datamodel.SequenceI[]
2507               { (jalview.datamodel.SequenceI) seqRefIds.get(JSEQ[i].getId()
2508                       + "") };
2509
2510               if (comp == null)
2511               {
2512                 // create a new Jmol window
2513                 String state = ids[p].getStructureState(s).getContent();
2514                 StringBuffer newFileLoc = null;
2515                 int cp=0;
2516                 if ((cp=state.indexOf("load ")) > -1)
2517                 {
2518                   newFileLoc = new StringBuffer(state.substring(0, (cp=state
2519                           .indexOf("\"", cp+1)+1)));
2520
2521                   newFileLoc.append(jpdb.getFile());
2522                   newFileLoc.append(state.substring(state.indexOf("\"",
2523                           cp+1)));
2524                 }
2525                 else
2526                 {
2527                   System.err
2528                           .println("Ignoring incomplete Jmol state for PDB "
2529                                   + ids[p].getId());
2530
2531                   newFileLoc = new StringBuffer(state);
2532                   newFileLoc.append("; load \"");
2533                   newFileLoc.append(jpdb.getFile());
2534                   newFileLoc.append("\";");
2535                 }
2536
2537                 if (newFileLoc != null)
2538                 {
2539                   int histbug = newFileLoc.indexOf("history = ");
2540                   histbug+=10;
2541                   int diff = histbug==-1 ? -1 : newFileLoc.indexOf(";",histbug);
2542                   String val = (diff==-1) ? null : newFileLoc.substring(histbug,diff);
2543                   if (val!=null && val.length()>=4)
2544                   {
2545                     if (val.contains("e")) {
2546                       if (val.trim().equals("true")) {
2547                         val = "1";
2548                       } else {
2549                         val = "0";
2550                       }
2551                       newFileLoc.replace(histbug, diff, val);
2552                     }
2553                   }
2554                   final String pdbf=pdbFile, id=ids[p].getId(), fileloc=newFileLoc.toString(),vid=sviewid;
2555                   final SequenceI[] sq=seq;
2556                   final AlignFrame alf = af;
2557                   final java.awt.Rectangle rect = new java.awt.Rectangle(x,
2558                           y, width, height);
2559                   try {
2560                   javax.swing.SwingUtilities.invokeAndWait(new Runnable() {
2561                     public void run() {
2562                       new AppJmol(pdbf, id, sq, alf.alignPanel,
2563                               fileloc, rect, vid);
2564                     }
2565                   });
2566                   }
2567                   catch (InvocationTargetException ex)
2568                   {
2569                     System.err.println("Unexpected error when opening Jmol view.");
2570                     ex.printStackTrace();
2571                   } catch (InterruptedException e)
2572                   {
2573                     // e.printStackTrace();
2574                   }
2575                 }
2576
2577               }
2578               else
2579               // if (comp != null)
2580               {
2581                 // NOTE: if the jalview project is part of a shared session then
2582                 // view synchronization should/could be done here.
2583
2584                 // add mapping for this sequence to the already open Jmol
2585                 // instance (if it doesn't already exist)
2586                 // These
2587                 StructureSelectionManager.getStructureSelectionManager()
2588                         .setMapping(seq, null, pdbFile,
2589                                 jalview.io.AppletFormatAdapter.FILE);
2590
2591                 ((AppJmol) comp).jmb.addSequence(seq);
2592               }
2593             }
2594           }
2595         }
2596       }
2597     }
2598
2599     return af;
2600   }
2601
2602   AlignFrame loadViewport(String file, JSeq[] JSEQ, Vector hiddenSeqs,
2603           Alignment al, boolean hideConsensus, boolean hideQuality,
2604           boolean hideConservation, JalviewModelSequence jms,
2605           Viewport view, String uniqueSeqSetId, String viewId)
2606   {
2607     AlignFrame af = null;
2608     af = new AlignFrame(al, view.getWidth(), view.getHeight(),
2609             uniqueSeqSetId, viewId);
2610
2611     af.setFileName(file, "Jalview");
2612
2613     for (int i = 0; i < JSEQ.length; i++)
2614     {
2615       af.viewport.setSequenceColour(af.viewport.alignment.getSequenceAt(i),
2616               new java.awt.Color(JSEQ[i].getColour()));
2617     }
2618
2619     af.viewport.gatherViewsHere = view.getGatheredViews();
2620
2621     if (view.getSequenceSetId() != null)
2622     {
2623       jalview.gui.AlignViewport av = (jalview.gui.AlignViewport) viewportsAdded
2624               .get(uniqueSeqSetId);
2625
2626       af.viewport.sequenceSetID = uniqueSeqSetId;
2627       if (av != null)
2628       {
2629         // propagate shared settings to this new view
2630         af.viewport.historyList = av.historyList;
2631         af.viewport.redoList = av.redoList;
2632       }
2633       else
2634       {
2635         viewportsAdded.put(uniqueSeqSetId, af.viewport);
2636       }
2637       // TODO: check if this method can be called repeatedly without
2638       // side-effects if alignpanel already registered.
2639       PaintRefresher.Register(af.alignPanel, uniqueSeqSetId);
2640     }
2641     // apply Hidden regions to view.
2642     if (hiddenSeqs != null)
2643     {
2644       for (int s = 0; s < JSEQ.length; s++)
2645       {
2646         jalview.datamodel.SequenceGroup hidden = new jalview.datamodel.SequenceGroup();
2647
2648         for (int r = 0; r < JSEQ[s].getHiddenSequencesCount(); r++)
2649         {
2650           hidden.addSequence(al
2651                   .getSequenceAt(JSEQ[s].getHiddenSequences(r)), false);
2652         }
2653         af.viewport.hideRepSequences(al.getSequenceAt(s), hidden);
2654       }
2655
2656       jalview.datamodel.SequenceI[] hseqs = new jalview.datamodel.SequenceI[hiddenSeqs
2657               .size()];
2658
2659       for (int s = 0; s < hiddenSeqs.size(); s++)
2660       {
2661         hseqs[s] = (jalview.datamodel.SequenceI) hiddenSeqs.elementAt(s);
2662       }
2663
2664       af.viewport.hideSequence(hseqs);
2665
2666     }
2667     // set visibility of annotation in view
2668     if ((hideConsensus || hideQuality || hideConservation)
2669             && al.getAlignmentAnnotation() != null)
2670     {
2671       int hSize = al.getAlignmentAnnotation().length;
2672       for (int h = 0; h < hSize; h++)
2673       {
2674         if ((hideConsensus && al.getAlignmentAnnotation()[h].label
2675                 .equals("Consensus"))
2676                 || (hideQuality && al.getAlignmentAnnotation()[h].label
2677                         .equals("Quality"))
2678                 || (hideConservation && al.getAlignmentAnnotation()[h].label
2679                         .equals("Conservation")))
2680         {
2681           al.deleteAnnotation(al.getAlignmentAnnotation()[h]);
2682           hSize--;
2683           h--;
2684         }
2685       }
2686       af.alignPanel.adjustAnnotationHeight();
2687     }
2688     // recover view properties and display parameters
2689     if (view.getViewName() != null)
2690     {
2691       af.viewport.viewName = view.getViewName();
2692       af.setInitialTabVisible();
2693     }
2694     af.setBounds(view.getXpos(), view.getYpos(), view.getWidth(), view
2695             .getHeight());
2696
2697     af.viewport.setShowAnnotation(view.getShowAnnotation());
2698     af.viewport.setAbovePIDThreshold(view.getPidSelected());
2699
2700     af.viewport.setColourText(view.getShowColourText());
2701
2702     af.viewport.setConservationSelected(view.getConservationSelected());
2703     af.viewport.setShowJVSuffix(view.getShowFullId());
2704     af.viewport.rightAlignIds = view.getRightAlignIds();
2705     af.viewport.setFont(new java.awt.Font(view.getFontName(), view
2706             .getFontStyle(), view.getFontSize()));
2707     af.alignPanel.fontChanged();
2708     af.viewport.setRenderGaps(view.getRenderGaps());
2709     af.viewport.setWrapAlignment(view.getWrapAlignment());
2710     af.alignPanel.setWrapAlignment(view.getWrapAlignment());
2711     af.viewport.setShowAnnotation(view.getShowAnnotation());
2712     af.alignPanel.setAnnotationVisible(view.getShowAnnotation());
2713
2714     af.viewport.setShowBoxes(view.getShowBoxes());
2715
2716     af.viewport.setShowText(view.getShowText());
2717
2718     af.viewport.textColour = new java.awt.Color(view.getTextCol1());
2719     af.viewport.textColour2 = new java.awt.Color(view.getTextCol2());
2720     af.viewport.thresholdTextColour = view.getTextColThreshold();
2721     af.viewport.setShowUnconserved(view.hasShowUnconserved() ? view
2722             .isShowUnconserved() : false);
2723     af.viewport.setStartRes(view.getStartRes());
2724     af.viewport.setStartSeq(view.getStartSeq());
2725
2726     ColourSchemeI cs = null;
2727     // apply colourschemes
2728     if (view.getBgColour() != null)
2729     {
2730       if (view.getBgColour().startsWith("ucs"))
2731       {
2732         cs = GetUserColourScheme(jms, view.getBgColour());
2733       }
2734       else if (view.getBgColour().startsWith("Annotation"))
2735       {
2736         // int find annotation
2737         if (af.viewport.alignment.getAlignmentAnnotation() != null)
2738         {
2739           for (int i = 0; i < af.viewport.alignment
2740                   .getAlignmentAnnotation().length; i++)
2741           {
2742             if (af.viewport.alignment.getAlignmentAnnotation()[i].label
2743                     .equals(view.getAnnotationColours().getAnnotation()))
2744             {
2745               if (af.viewport.alignment.getAlignmentAnnotation()[i]
2746                       .getThreshold() == null)
2747               {
2748                 af.viewport.alignment.getAlignmentAnnotation()[i]
2749                         .setThreshold(new jalview.datamodel.GraphLine(view
2750                                 .getAnnotationColours().getThreshold(),
2751                                 "Threshold", java.awt.Color.black)
2752
2753                         );
2754               }
2755
2756               if (view.getAnnotationColours().getColourScheme().equals(
2757                       "None"))
2758               {
2759                 cs = new AnnotationColourGradient(af.viewport.alignment
2760                         .getAlignmentAnnotation()[i], new java.awt.Color(
2761                         view.getAnnotationColours().getMinColour()),
2762                         new java.awt.Color(view.getAnnotationColours()
2763                                 .getMaxColour()), view
2764                                 .getAnnotationColours().getAboveThreshold());
2765               }
2766               else if (view.getAnnotationColours().getColourScheme()
2767                       .startsWith("ucs"))
2768               {
2769                 cs = new AnnotationColourGradient(af.viewport.alignment
2770                         .getAlignmentAnnotation()[i],
2771                         GetUserColourScheme(jms, view
2772                                 .getAnnotationColours().getColourScheme()),
2773                         view.getAnnotationColours().getAboveThreshold());
2774               }
2775               else
2776               {
2777                 cs = new AnnotationColourGradient(af.viewport.alignment
2778                         .getAlignmentAnnotation()[i], ColourSchemeProperty
2779                         .getColour(al, view.getAnnotationColours()
2780                                 .getColourScheme()), view
2781                         .getAnnotationColours().getAboveThreshold());
2782               }
2783
2784               // Also use these settings for all the groups
2785               if (al.getGroups() != null)
2786               {
2787                 for (int g = 0; g < al.getGroups().size(); g++)
2788                 {
2789                   jalview.datamodel.SequenceGroup sg = (jalview.datamodel.SequenceGroup) al
2790                           .getGroups().elementAt(g);
2791
2792                   if (sg.cs == null)
2793                   {
2794                     continue;
2795                   }
2796
2797                   /*
2798                    * if
2799                    * (view.getAnnotationColours().getColourScheme().equals("None"
2800                    * )) { sg.cs = new AnnotationColourGradient(
2801                    * af.viewport.alignment.getAlignmentAnnotation()[i], new
2802                    * java.awt.Color(view.getAnnotationColours().
2803                    * getMinColour()), new
2804                    * java.awt.Color(view.getAnnotationColours().
2805                    * getMaxColour()),
2806                    * view.getAnnotationColours().getAboveThreshold()); } else
2807                    */
2808                   {
2809                     sg.cs = new AnnotationColourGradient(
2810                             af.viewport.alignment.getAlignmentAnnotation()[i],
2811                             sg.cs, view.getAnnotationColours()
2812                                     .getAboveThreshold());
2813                   }
2814
2815                 }
2816               }
2817
2818               break;
2819             }
2820
2821           }
2822         }
2823       }
2824       else
2825       {
2826         cs = ColourSchemeProperty.getColour(al, view.getBgColour());
2827       }
2828
2829       if (cs != null)
2830       {
2831         cs.setThreshold(view.getPidThreshold(), true);
2832         cs.setConsensus(af.viewport.hconsensus);
2833       }
2834     }
2835
2836     af.viewport.setGlobalColourScheme(cs);
2837     af.viewport.setColourAppliesToAllGroups(false);
2838
2839     if (view.getConservationSelected() && cs != null)
2840     {
2841       cs.setConservationInc(view.getConsThreshold());
2842     }
2843
2844     af.changeColour(cs);
2845
2846     af.viewport.setColourAppliesToAllGroups(true);
2847
2848     if (view.getShowSequenceFeatures())
2849     {
2850       af.viewport.showSequenceFeatures = true;
2851     }
2852     if (view.hasCentreColumnLabels())
2853     {
2854       af.viewport.setCentreColumnLabels(view.getCentreColumnLabels());
2855     }
2856     if (view.hasIgnoreGapsinConsensus())
2857     {
2858       af.viewport.ignoreGapsInConsensusCalculation = view
2859               .getIgnoreGapsinConsensus();
2860     }
2861     if (view.hasFollowHighlight())
2862     {
2863       af.viewport.followHighlight = view.getFollowHighlight();
2864     }
2865     if (view.hasFollowSelection())
2866     {
2867       af.viewport.followSelection = view.getFollowSelection();
2868     }
2869     if (view.hasShowConsensusHistogram())
2870     {
2871       af.viewport.setShowConsensusHistogram(view
2872               .getShowConsensusHistogram());
2873     }
2874     else
2875     {
2876       af.viewport.setShowConsensusHistogram(true);
2877     }
2878     if (view.hasShowSequenceLogo())
2879     {
2880       af.viewport.showSequenceLogo = view.getShowSequenceLogo();
2881     }
2882     else
2883     {
2884       af.viewport.showSequenceLogo = false;
2885     }
2886     if (view.hasShowDbRefTooltip())
2887     {
2888       af.viewport.setShowDbRefs(view.getShowDbRefTooltip());
2889     }
2890     if (view.hasShowNPfeatureTooltip())
2891     {
2892       af.viewport.setShowNpFeats(view.hasShowNPfeatureTooltip());
2893     }
2894     if (view.hasShowGroupConsensus())
2895     {
2896       af.viewport.setShowGroupConsensus(view.getShowGroupConsensus());
2897     }
2898     else
2899     {
2900       af.viewport.setShowGroupConsensus(false);
2901     }
2902     if (view.hasShowGroupConservation())
2903     {
2904       af.viewport.setShowGroupConservation(view.getShowGroupConservation());
2905     }
2906     else
2907     {
2908       af.viewport.setShowGroupConservation(false);
2909     }
2910
2911     // recover featre settings
2912     if (jms.getFeatureSettings() != null)
2913     {
2914       af.viewport.featuresDisplayed = new Hashtable();
2915       String[] renderOrder = new String[jms.getFeatureSettings()
2916               .getSettingCount()];
2917       for (int fs = 0; fs < jms.getFeatureSettings().getSettingCount(); fs++)
2918       {
2919         Setting setting = jms.getFeatureSettings().getSetting(fs);
2920         if (setting.hasMincolour())
2921         {
2922           GraduatedColor gc = setting.hasMin() ? new GraduatedColor(
2923                   new java.awt.Color(setting.getMincolour()),
2924                   new java.awt.Color(setting.getColour()),
2925                   setting.getMin(), setting.getMax()) : new GraduatedColor(
2926                   new java.awt.Color(setting.getMincolour()),
2927                   new java.awt.Color(setting.getColour()), 0, 1);
2928           if (setting.hasThreshold())
2929           {
2930             gc.setThresh(setting.getThreshold());
2931             gc.setThreshType(setting.getThreshstate());
2932           }
2933           gc.setAutoScaled(true); // default
2934           if (setting.hasAutoScale())
2935           {
2936             gc.setAutoScaled(setting.getAutoScale());
2937           }
2938           if (setting.hasColourByLabel())
2939           {
2940             gc.setColourByLabel(setting.getColourByLabel());
2941           }
2942           // and put in the feature colour table.
2943           af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setColour(
2944                   setting.getType(), gc);
2945         }
2946         else
2947         {
2948           af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setColour(
2949                   setting.getType(),
2950                   new java.awt.Color(setting.getColour()));
2951         }
2952         renderOrder[fs] = setting.getType();
2953         if (setting.hasOrder())
2954           af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setOrder(
2955                   setting.getType(), setting.getOrder());
2956         else
2957           af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setOrder(
2958                   setting.getType(),
2959                   fs / jms.getFeatureSettings().getSettingCount());
2960         if (setting.getDisplay())
2961         {
2962           af.viewport.featuresDisplayed.put(setting.getType(), new Integer(
2963                   setting.getColour()));
2964         }
2965       }
2966       af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().renderOrder = renderOrder;
2967       Hashtable fgtable;
2968       af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().featureGroups = fgtable = new Hashtable();
2969       for (int gs = 0; gs < jms.getFeatureSettings().getGroupCount(); gs++)
2970       {
2971         Group grp = jms.getFeatureSettings().getGroup(gs);
2972         fgtable.put(grp.getName(), new Boolean(grp.getDisplay()));
2973       }
2974     }
2975
2976     if (view.getHiddenColumnsCount() > 0)
2977     {
2978       for (int c = 0; c < view.getHiddenColumnsCount(); c++)
2979       {
2980         af.viewport.hideColumns(view.getHiddenColumns(c).getStart(), view
2981                 .getHiddenColumns(c).getEnd() // +1
2982                 );
2983       }
2984     }
2985
2986     af.setMenusFromViewport(af.viewport);
2987     // TODO: we don't need to do this if the viewport is aready visible.
2988     Desktop.addInternalFrame(af, view.getTitle(), view.getWidth(), view
2989             .getHeight());
2990     af.alignPanel.updateAnnotation(false); // recompute any autoannotation
2991     return af;
2992   }
2993
2994   Hashtable skipList = null;
2995
2996   /**
2997    * TODO remove this method
2998    *
2999    * @param view
3000    * @return AlignFrame bound to sequenceSetId from view, if one exists. private
3001    *         AlignFrame getSkippedFrame(Viewport view) { if (skipList==null) {
3002    *         throw new Error("Implementation Error. No skipList defined for this
3003    *         Jalview2XML instance."); } return (AlignFrame)
3004    *         skipList.get(view.getSequenceSetId()); }
3005    */
3006
3007   /**
3008    * Check if the Jalview view contained in object should be skipped or not.
3009    *
3010    * @param object
3011    * @return true if view's sequenceSetId is a key in skipList
3012    */
3013   private boolean skipViewport(JalviewModel object)
3014   {
3015     if (skipList == null)
3016     {
3017       return false;
3018     }
3019     String id;
3020     if (skipList.containsKey(id = object.getJalviewModelSequence()
3021             .getViewport()[0].getSequenceSetId()))
3022     {
3023       if (Cache.log != null && Cache.log.isDebugEnabled())
3024       {
3025         Cache.log.debug("Skipping seuqence set id " + id);
3026       }
3027       return true;
3028     }
3029     return false;
3030   }
3031
3032   public void AddToSkipList(AlignFrame af)
3033   {
3034     if (skipList == null)
3035     {
3036       skipList = new Hashtable();
3037     }
3038     skipList.put(af.getViewport().getSequenceSetId(), af);
3039   }
3040
3041   public void clearSkipList()
3042   {
3043     if (skipList != null)
3044     {
3045       skipList.clear();
3046       skipList = null;
3047     }
3048   }
3049
3050   private void recoverDatasetFor(SequenceSet vamsasSet, Alignment al)
3051   {
3052     jalview.datamodel.Alignment ds = getDatasetFor(vamsasSet.getDatasetId());
3053     Vector dseqs = null;
3054     if (ds == null)
3055     {
3056       // create a list of new dataset sequences
3057       dseqs = new Vector();
3058     }
3059     for (int i = 0, iSize = vamsasSet.getSequenceCount(); i < iSize; i++)
3060     {
3061       Sequence vamsasSeq = vamsasSet.getSequence(i);
3062       ensureJalviewDatasetSequence(vamsasSeq, ds, dseqs);
3063     }
3064     // create a new dataset
3065     if (ds == null)
3066     {
3067       SequenceI[] dsseqs = new SequenceI[dseqs.size()];
3068       dseqs.copyInto(dsseqs);
3069       ds = new jalview.datamodel.Alignment(dsseqs);
3070       debug("Created new dataset " + vamsasSet.getDatasetId()
3071               + " for alignment " + System.identityHashCode(al));
3072       addDatasetRef(vamsasSet.getDatasetId(), ds);
3073     }
3074     // set the dataset for the newly imported alignment.
3075     if (al.getDataset() == null)
3076     {
3077       al.setDataset(ds);
3078     }
3079   }
3080
3081   /**
3082    *
3083    * @param vamsasSeq
3084    *          sequence definition to create/merge dataset sequence for
3085    * @param ds
3086    *          dataset alignment
3087    * @param dseqs
3088    *          vector to add new dataset sequence to
3089    */
3090   private void ensureJalviewDatasetSequence(Sequence vamsasSeq,
3091           AlignmentI ds, Vector dseqs)
3092   {
3093     // JBP TODO: Check this is called for AlCodonFrames to support recovery of
3094     // xRef Codon Maps
3095     jalview.datamodel.Sequence sq = (jalview.datamodel.Sequence) seqRefIds
3096             .get(vamsasSeq.getId());
3097     jalview.datamodel.SequenceI dsq = null;
3098     if (sq != null && sq.getDatasetSequence() != null)
3099     {
3100       dsq = (jalview.datamodel.SequenceI) sq.getDatasetSequence();
3101     }
3102
3103     String sqid = vamsasSeq.getDsseqid();
3104     if (dsq == null)
3105     {
3106       // need to create or add a new dataset sequence reference to this sequence
3107       if (sqid != null)
3108       {
3109         dsq = (jalview.datamodel.SequenceI) seqRefIds.get(sqid);
3110       }
3111       // check again
3112       if (dsq == null)
3113       {
3114         // make a new dataset sequence
3115         dsq = sq.createDatasetSequence();
3116         if (sqid == null)
3117         {
3118           // make up a new dataset reference for this sequence
3119           sqid = seqHash(dsq);
3120         }
3121         dsq.setVamsasId(uniqueSetSuffix + sqid);
3122         seqRefIds.put(sqid, dsq);
3123         if (ds == null)
3124         {
3125           if (dseqs != null)
3126           {
3127             dseqs.addElement(dsq);
3128           }
3129         }
3130         else
3131         {
3132           ds.addSequence(dsq);
3133         }
3134       }
3135       else
3136       {
3137         if (sq != dsq)
3138         { // make this dataset sequence sq's dataset sequence
3139           sq.setDatasetSequence(dsq);
3140         }
3141       }
3142     }
3143     // TODO: refactor this as a merge dataset sequence function
3144     // now check that sq (the dataset sequence) sequence really is the union of
3145     // all references to it
3146     // boolean pre = sq.getStart() < dsq.getStart();
3147     // boolean post = sq.getEnd() > dsq.getEnd();
3148     // if (pre || post)
3149     if (sq != dsq)
3150     {
3151       StringBuffer sb = new StringBuffer();
3152       String newres = jalview.analysis.AlignSeq.extractGaps(
3153               jalview.util.Comparison.GapChars, sq.getSequenceAsString());
3154       if (!newres.equalsIgnoreCase(dsq.getSequenceAsString())
3155               && newres.length() > dsq.getLength())
3156       {
3157         // Update with the longer sequence.
3158         synchronized (dsq)
3159         {
3160           /*
3161            * if (pre) { sb.insert(0, newres .substring(0, dsq.getStart() -
3162            * sq.getStart())); dsq.setStart(sq.getStart()); } if (post) {
3163            * sb.append(newres.substring(newres.length() - sq.getEnd() -
3164            * dsq.getEnd())); dsq.setEnd(sq.getEnd()); }
3165            */
3166           dsq.setSequence(sb.toString());
3167         }
3168         // TODO: merges will never happen if we 'know' we have the real dataset
3169         // sequence - this should be detected when id==dssid
3170         System.err.println("DEBUG Notice:  Merged dataset sequence"); // ("
3171         // + (pre ? "prepended" : "") + " "
3172         // + (post ? "appended" : ""));
3173       }
3174     }
3175   }
3176
3177   java.util.Hashtable datasetIds = null;
3178
3179   java.util.IdentityHashMap dataset2Ids = null;
3180
3181   private Alignment getDatasetFor(String datasetId)
3182   {
3183     if (datasetIds == null)
3184     {
3185       datasetIds = new Hashtable();
3186       return null;
3187     }
3188     if (datasetIds.containsKey(datasetId))
3189     {
3190       return (Alignment) datasetIds.get(datasetId);
3191     }
3192     return null;
3193   }
3194
3195   private void addDatasetRef(String datasetId, Alignment dataset)
3196   {
3197     if (datasetIds == null)
3198     {
3199       datasetIds = new Hashtable();
3200     }
3201     datasetIds.put(datasetId, dataset);
3202   }
3203
3204   /**
3205    * make a new dataset ID for this jalview dataset alignment
3206    *
3207    * @param dataset
3208    * @return
3209    */
3210   private String getDatasetIdRef(jalview.datamodel.Alignment dataset)
3211   {
3212     if (dataset.getDataset() != null)
3213     {
3214       warn("Serious issue!  Dataset Object passed to getDatasetIdRef is not a Jalview DATASET alignment...");
3215     }
3216     String datasetId = makeHashCode(dataset, null);
3217     if (datasetId == null)
3218     {
3219       // make a new datasetId and record it
3220       if (dataset2Ids == null)
3221       {
3222         dataset2Ids = new IdentityHashMap();
3223       }
3224       else
3225       {
3226         datasetId = (String) dataset2Ids.get(dataset);
3227       }
3228       if (datasetId == null)
3229       {
3230         datasetId = "ds" + dataset2Ids.size() + 1;
3231         dataset2Ids.put(dataset, datasetId);
3232       }
3233     }
3234     return datasetId;
3235   }
3236
3237   private void addDBRefs(SequenceI datasetSequence, Sequence sequence)
3238   {
3239     for (int d = 0; d < sequence.getDBRefCount(); d++)
3240     {
3241       DBRef dr = sequence.getDBRef(d);
3242       jalview.datamodel.DBRefEntry entry = new jalview.datamodel.DBRefEntry(
3243               sequence.getDBRef(d).getSource(), sequence.getDBRef(d)
3244                       .getVersion(), sequence.getDBRef(d).getAccessionId());
3245       if (dr.getMapping() != null)
3246       {
3247         entry.setMap(addMapping(dr.getMapping()));
3248       }
3249       datasetSequence.addDBRef(entry);
3250     }
3251   }
3252
3253   private jalview.datamodel.Mapping addMapping(Mapping m)
3254   {
3255     SequenceI dsto = null;
3256     // Mapping m = dr.getMapping();
3257     int fr[] = new int[m.getMapListFromCount() * 2];
3258     Enumeration f = m.enumerateMapListFrom();
3259     for (int _i = 0; f.hasMoreElements(); _i += 2)
3260     {
3261       MapListFrom mf = (MapListFrom) f.nextElement();
3262       fr[_i] = mf.getStart();
3263       fr[_i + 1] = mf.getEnd();
3264     }
3265     int fto[] = new int[m.getMapListToCount() * 2];
3266     f = m.enumerateMapListTo();
3267     for (int _i = 0; f.hasMoreElements(); _i += 2)
3268     {
3269       MapListTo mf = (MapListTo) f.nextElement();
3270       fto[_i] = mf.getStart();
3271       fto[_i + 1] = mf.getEnd();
3272     }
3273     jalview.datamodel.Mapping jmap = new jalview.datamodel.Mapping(dsto,
3274             fr, fto, (int) m.getMapFromUnit(), (int) m.getMapToUnit());
3275     if (m.getMappingChoice() != null)
3276     {
3277       MappingChoice mc = m.getMappingChoice();
3278       if (mc.getDseqFor() != null)
3279       {
3280         String dsfor = "" + mc.getDseqFor();
3281         if (seqRefIds.containsKey(dsfor))
3282         {
3283           /**
3284            * recover from hash
3285            */
3286           jmap.setTo((SequenceI) seqRefIds.get(dsfor));
3287         }
3288         else
3289         {
3290           frefedSequence.add(new Object[]
3291           { dsfor, jmap });
3292         }
3293       }
3294       else
3295       {
3296         /**
3297          * local sequence definition
3298          */
3299         Sequence ms = mc.getSequence();
3300         jalview.datamodel.Sequence djs = null;
3301         String sqid = ms.getDsseqid();
3302         if (sqid != null && sqid.length() > 0)
3303         {
3304           /*
3305            * recover dataset sequence
3306            */
3307           djs = (jalview.datamodel.Sequence) seqRefIds.get(sqid);
3308         }
3309         else
3310         {
3311           System.err
3312                   .println("Warning - making up dataset sequence id for DbRef sequence map reference");
3313           sqid = ((Object) ms).toString(); // make up a new hascode for
3314           // undefined dataset sequence hash
3315           // (unlikely to happen)
3316         }
3317
3318         if (djs == null)
3319         {
3320           /**
3321            * make a new dataset sequence and add it to refIds hash
3322            */
3323           djs = new jalview.datamodel.Sequence(ms.getName(), ms
3324                   .getSequence());
3325           djs.setStart(jmap.getMap().getToLowest());
3326           djs.setEnd(jmap.getMap().getToHighest());
3327           djs.setVamsasId(uniqueSetSuffix + sqid);
3328           jmap.setTo(djs);
3329           seqRefIds.put(sqid, djs);
3330
3331         }
3332         jalview.bin.Cache.log.debug("about to recurse on addDBRefs.");
3333         addDBRefs(djs, ms);
3334
3335       }
3336     }
3337     return (jmap);
3338
3339   }
3340
3341   public jalview.gui.AlignmentPanel copyAlignPanel(AlignmentPanel ap,
3342           boolean keepSeqRefs)
3343   {
3344     initSeqRefs();
3345     jalview.schemabinding.version2.JalviewModel jm = SaveState(ap, null,
3346             null);
3347
3348     if (!keepSeqRefs)
3349     {
3350       clearSeqRefs();
3351       jm.getJalviewModelSequence().getViewport(0).setSequenceSetId(null);
3352     }
3353     else
3354     {
3355       uniqueSetSuffix = "";
3356       jm.getJalviewModelSequence().getViewport(0).setId(null); // we don't
3357       // overwrite the
3358       // view we just
3359       // copied
3360     }
3361     if (this.frefedSequence == null)
3362     {
3363       frefedSequence = new Vector();
3364     }
3365
3366     viewportsAdded = new Hashtable();
3367
3368     AlignFrame af = LoadFromObject(jm, null, false, null);
3369     af.alignPanels.clear();
3370     af.closeMenuItem_actionPerformed(true);
3371
3372     /*
3373      * if(ap.av.alignment.getAlignmentAnnotation()!=null) { for(int i=0;
3374      * i<ap.av.alignment.getAlignmentAnnotation().length; i++) {
3375      * if(!ap.av.alignment.getAlignmentAnnotation()[i].autoCalculated) {
3376      * af.alignPanel.av.alignment.getAlignmentAnnotation()[i] =
3377      * ap.av.alignment.getAlignmentAnnotation()[i]; } } }
3378      */
3379
3380     return af.alignPanel;
3381   }
3382
3383   /**
3384    * flag indicating if hashtables should be cleared on finalization TODO this
3385    * flag may not be necessary
3386    */
3387   private boolean _cleartables = true;
3388
3389   private Hashtable jvids2vobj;
3390
3391   /*
3392    * (non-Javadoc)
3393    *
3394    * @see java.lang.Object#finalize()
3395    */
3396   protected void finalize() throws Throwable
3397   {
3398     // really make sure we have no buried refs left.
3399     if (_cleartables)
3400     {
3401       clearSeqRefs();
3402     }
3403     this.seqRefIds = null;
3404     this.seqsToIds = null;
3405     super.finalize();
3406   }
3407
3408   private void warn(String msg)
3409   {
3410     warn(msg, null);
3411   }
3412
3413   private void warn(String msg, Exception e)
3414   {
3415     if (Cache.log != null)
3416     {
3417       if (e != null)
3418       {
3419         Cache.log.warn(msg, e);
3420       }
3421       else
3422       {
3423         Cache.log.warn(msg);
3424       }
3425     }
3426     else
3427     {
3428       System.err.println("Warning: " + msg);
3429       if (e != null)
3430       {
3431         e.printStackTrace();
3432       }
3433     }
3434   }
3435
3436   private void debug(String string)
3437   {
3438     debug(string, null);
3439   }
3440
3441   private void debug(String msg, Exception e)
3442   {
3443     if (Cache.log != null)
3444     {
3445       if (e != null)
3446       {
3447         Cache.log.debug(msg, e);
3448       }
3449       else
3450       {
3451         Cache.log.debug(msg);
3452       }
3453     }
3454     else
3455     {
3456       System.err.println("Warning: " + msg);
3457       if (e != null)
3458       {
3459         e.printStackTrace();
3460       }
3461     }
3462   }
3463
3464   /**
3465    * set the object to ID mapping tables used to write/recover objects and XML
3466    * ID strings for the jalview project. If external tables are provided then
3467    * finalize and clearSeqRefs will not clear the tables when the Jalview2XML
3468    * object goes out of scope. - also populates the datasetIds hashtable with
3469    * alignment objects containing dataset sequences
3470    *
3471    * @param vobj2jv
3472    *          Map from ID strings to jalview datamodel
3473    * @param jv2vobj
3474    *          Map from jalview datamodel to ID strings
3475    *
3476    *
3477    */
3478   public void setObjectMappingTables(Hashtable vobj2jv,
3479           IdentityHashMap jv2vobj)
3480   {
3481     this.jv2vobj = jv2vobj;
3482     this.vobj2jv = vobj2jv;
3483     Iterator ds = jv2vobj.keySet().iterator();
3484     String id;
3485     while (ds.hasNext())
3486     {
3487       Object jvobj = ds.next();
3488       id = jv2vobj.get(jvobj).toString();
3489       if (jvobj instanceof jalview.datamodel.Alignment)
3490       {
3491         if (((jalview.datamodel.Alignment) jvobj).getDataset() == null)
3492         {
3493           addDatasetRef(id, (jalview.datamodel.Alignment) jvobj);
3494         }
3495       }
3496       else if (jvobj instanceof jalview.datamodel.Sequence)
3497       {
3498         // register sequence object so the XML parser can recover it.
3499         if (seqRefIds == null)
3500         {
3501           seqRefIds = new Hashtable();
3502         }
3503         if (seqsToIds == null)
3504         {
3505           seqsToIds = new IdentityHashMap();
3506         }
3507         seqRefIds.put(jv2vobj.get(jvobj).toString(), jvobj);
3508         seqsToIds.put(jvobj, id);
3509       }
3510       else if (jvobj instanceof jalview.datamodel.AlignmentAnnotation)
3511       {
3512         if (annotationIds == null)
3513         {
3514           annotationIds = new Hashtable();
3515         }
3516         String anid;
3517         annotationIds.put(anid = jv2vobj.get(jvobj).toString(), jvobj);
3518         jalview.datamodel.AlignmentAnnotation jvann = (jalview.datamodel.AlignmentAnnotation) jvobj;
3519         if (jvann.annotationId == null)
3520         {
3521           jvann.annotationId = anid;
3522         }
3523         if (!jvann.annotationId.equals(anid))
3524         {
3525           // TODO verify that this is the correct behaviour
3526           this.warn("Overriding Annotation ID for " + anid
3527                   + " from different id : " + jvann.annotationId);
3528           jvann.annotationId = anid;
3529         }
3530       }
3531       else if (jvobj instanceof String)
3532       {
3533         if (jvids2vobj == null)
3534         {
3535           jvids2vobj = new Hashtable();
3536           jvids2vobj.put(jvobj, jv2vobj.get(jvobj).toString());
3537         }
3538       }
3539       else
3540         Cache.log.debug("Ignoring " + jvobj.getClass() + " (ID = " + id);
3541     }
3542   }
3543
3544   /**
3545    * set the uniqueSetSuffix used to prefix/suffix object IDs for jalview
3546    * objects created from the project archive. If string is null (default for
3547    * construction) then suffix will be set automatically.
3548    *
3549    * @param string
3550    */
3551   public void setUniqueSetSuffix(String string)
3552   {
3553     uniqueSetSuffix = string;
3554
3555   }
3556
3557   /**
3558    * uses skipList2 as the skipList for skipping views on sequence sets
3559    * associated with keys in the skipList
3560    *
3561    * @param skipList2
3562    */
3563   public void setSkipList(Hashtable skipList2)
3564   {
3565     skipList = skipList2;
3566   }
3567
3568 }