src/jalview/gui/Jalview2XML.java

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