src/jalview/gui/Jalview2XML.java

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