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