src/jalview/gui/Jalview2XML.java

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