src/jalview/gui/Jalview2XML.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.4)
   3  * Copyright (C) 2008 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18  */
  19 package jalview.gui;
  20
  21 import java.io.*;
  22 import java.net.*;
  23 import java.util.*;
  24 import java.util.jar.*;
  25
  26 import javax.swing.*;
  27
  28 import org.exolab.castor.xml.*;
  29
  30 import uk.ac.vamsas.objects.utils.MapList;
  31 import jalview.datamodel.Alignment;
  32 import jalview.datamodel.AlignmentI;
  33 import jalview.datamodel.SequenceI;
  34 import jalview.schemabinding.version2.*;
  35 import jalview.schemes.*;
  36 import jalview.structure.StructureSelectionManager;
  37
  38 /**
  39  * Write out the current jalview desktop state as a Jalview XML stream.
  40  *
  41  * Note: the vamsas objects referred to here are primitive versions of the
  42  * VAMSAS project schema elements - they are not the same and most likely never
  43  * will be :)
  44  *
  45  * @author $author$
  46  * @version $Revision$
  47  */
  48 public class Jalview2XML
  49 {
  50   /**
  51    * create/return unique hash string for sq
  52    *
  53    * @param sq
  54    * @return new or existing unique string for sq
  55    */
  56   String seqHash(SequenceI sq)
  57   {
  58     if (seqsToIds == null)
  59     {
  60       initSeqRefs();
  61     }
  62     if (seqsToIds.containsKey(sq))
  63     {
  64       return (String) seqsToIds.get(sq);
  65     }
  66     else
  67     {
  68       // create sequential key
  69       String key = "sq" + (seqsToIds.size() + 1);
  70       seqsToIds.put(sq, key);
  71       return key;
  72     }
  73   }
  74
  75   void clearSeqRefs()
  76   {
  77     seqRefIds.clear();
  78     seqsToIds.clear();
  79   }
  80
  81   void initSeqRefs()
  82   {
  83     if (seqsToIds == null)
  84     {
  85       seqsToIds = new IdentityHashMap();
  86     }
  87     if (seqRefIds == null)
  88     {
  89       seqRefIds = new Hashtable();
  90     }
  91   }
  92
  93   java.util.IdentityHashMap seqsToIds = null; // SequenceI->key resolution
  94
  95   java.util.Hashtable seqRefIds = null; // key->SequenceI resolution
  96
  97   Vector frefedSequence = null;
  98
  99   boolean raiseGUI = true; // whether errors are raised in dialog boxes or not
 100
 101   public Jalview2XML()
 102   {
 103   }
 104
 105   public Jalview2XML(boolean raiseGUI)
 106   {
 107     this.raiseGUI = raiseGUI;
 108   }
 109
 110   public void resolveFrefedSequences()
 111   {
 112     if (frefedSequence.size() > 0)
 113     {
 114       int r = 0, rSize = frefedSequence.size();
 115       while (r < rSize)
 116       {
 117         Object[] ref = (Object[]) frefedSequence.elementAt(r);
 118         if (ref != null)
 119         {
 120           String sref = (String) ref[0];
 121           if (seqRefIds.containsKey(sref))
 122           {
 123             if (ref[1] instanceof jalview.datamodel.Mapping)
 124             {
 125               SequenceI seq = (SequenceI) seqRefIds.get(sref);
 126               while (seq.getDatasetSequence() != null)
 127               {
 128                 seq = seq.getDatasetSequence();
 129               }
 130               ((jalview.datamodel.Mapping) ref[1]).setTo(seq);
 131             }
 132             else
 133             {
 134               if (ref[1] instanceof jalview.datamodel.AlignedCodonFrame)
 135               {
 136                 SequenceI seq = (SequenceI) seqRefIds.get(sref);
 137                 while (seq.getDatasetSequence() != null)
 138                 {
 139                   seq = seq.getDatasetSequence();
 140                 }
 141                 if (ref[2] != null
 142                         && ref[2] instanceof jalview.datamodel.Mapping)
 143                 {
 144                   jalview.datamodel.Mapping mp = (jalview.datamodel.Mapping) ref[2];
 145                   ((jalview.datamodel.AlignedCodonFrame) ref[1]).addMap(
 146                           seq, mp.getTo(), mp.getMap());
 147                 }
 148                 else
 149                 {
 150                   System.err
 151                           .println("IMPLEMENTATION ERROR: Unimplemented forward sequence references for AlcodonFrames involving "
 152                                   + ref[2].getClass() + " type objects.");
 153                 }
 154               }
 155               else
 156               {
 157                 System.err
 158                         .println("IMPLEMENTATION ERROR: Unimplemented forward sequence references for "
 159                                 + ref[1].getClass() + " type objects.");
 160               }
 161               frefedSequence.remove(r);
 162               rSize--;
 163             }
 164           }
 165           else
 166           {
 167             System.err
 168                     .println("IMPLEMENTATION WARNING: Unresolved forward reference for hash string "
 169                             + ref[0]
 170                             + " with objecttype "
 171                             + ref[1].getClass());
 172             r++;
 173           }
 174         }
 175         else
 176         {
 177           frefedSequence.remove(r);
 178           rSize--;
 179         }
 180       }
 181     }
 182   }
 183
 184   /**
 185    * This maintains a list of viewports, the key being the seqSetId. Important
 186    * to set historyItem and redoList for multiple views
 187    */
 188   Hashtable viewportsAdded;
 189
 190   Hashtable annotationIds = new Hashtable();
 191
 192   String uniqueSetSuffix = "";
 193
 194   /**
 195    * List of pdbfiles added to Jar
 196    */
 197   Vector pdbfiles = null;
 198
 199   // SAVES SEVERAL ALIGNMENT WINDOWS TO SAME JARFILE
 200   public void SaveState(File statefile)
 201   {
 202     JInternalFrame[] frames = Desktop.desktop.getAllFrames();
 203
 204     if (frames == null)
 205     {
 206       return;
 207     }
 208
 209     try
 210     {
 211       FileOutputStream fos = new FileOutputStream(statefile);
 212       JarOutputStream jout = new JarOutputStream(fos);
 213
 214       // NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS
 215       // //////////////////////////////////////////////////
 216       // NOTE ALSO new PrintWriter must be used for each new JarEntry
 217       PrintWriter out = null;
 218
 219       Vector shortNames = new Vector();
 220
 221       // REVERSE ORDER
 222       for (int i = frames.length - 1; i > -1; i--)
 223       {
 224         if (frames[i] instanceof AlignFrame)
 225         {
 226           AlignFrame af = (AlignFrame) frames[i];
 227
 228           String shortName = af.getTitle();
 229
 230           if (shortName.indexOf(File.separatorChar) > -1)
 231           {
 232             shortName = shortName.substring(shortName
 233                     .lastIndexOf(File.separatorChar) + 1);
 234           }
 235
 236           int count = 1;
 237
 238           while (shortNames.contains(shortName))
 239           {
 240             if (shortName.endsWith("_" + (count - 1)))
 241             {
 242               shortName = shortName
 243                       .substring(0, shortName.lastIndexOf("_"));
 244             }
 245
 246             shortName = shortName.concat("_" + count);
 247             count++;
 248           }
 249
 250           shortNames.addElement(shortName);
 251
 252           if (!shortName.endsWith(".xml"))
 253           {
 254             shortName = shortName + ".xml";
 255           }
 256
 257           int ap, apSize = af.alignPanels.size();
 258           for (ap = 0; ap < apSize; ap++)
 259           {
 260             AlignmentPanel apanel = (AlignmentPanel) af.alignPanels
 261                     .elementAt(ap);
 262             String fileName = apSize == 1 ? shortName : ap + shortName;
 263             if (!fileName.endsWith(".xml"))
 264             {
 265               fileName = fileName + ".xml";
 266             }
 267
 268             SaveState(apanel, fileName, jout);
 269           }
 270         }
 271       }
 272       try
 273       {
 274         jout.flush();
 275       } catch (Exception foo)
 276       {
 277       }
 278       ;
 279       jout.close();
 280     } catch (Exception ex)
 281     {
 282       // TODO: inform user of the problem - they need to know if their data was
 283       // not saved !
 284       ex.printStackTrace();
 285     }
 286   }
 287
 288   // USE THIS METHOD TO SAVE A SINGLE ALIGNMENT WINDOW
 289   public boolean SaveAlignment(AlignFrame af, String jarFile,
 290           String fileName)
 291   {
 292     try
 293     {
 294       int ap, apSize = af.alignPanels.size();
 295       FileOutputStream fos = new FileOutputStream(jarFile);
 296       JarOutputStream jout = new JarOutputStream(fos);
 297       for (ap = 0; ap < apSize; ap++)
 298       {
 299         AlignmentPanel apanel = (AlignmentPanel) af.alignPanels
 300                 .elementAt(ap);
 301         String jfileName = apSize == 1 ? fileName : fileName + ap;
 302         if (!jfileName.endsWith(".xml"))
 303         {
 304           jfileName = jfileName + ".xml";
 305         }
 306         SaveState(apanel, jfileName, jout);
 307       }
 308
 309       try
 310       {
 311         jout.flush();
 312       } catch (Exception foo)
 313       {
 314       }
 315       ;
 316       jout.close();
 317       return true;
 318     } catch (Exception ex)
 319     {
 320       ex.printStackTrace();
 321       return false;
 322     }
 323   }
 324
 325   /**
 326    * create a JalviewModel from an algnment view and marshall it to a
 327    * JarOutputStream
 328    *
 329    * @param ap
 330    *                panel to create jalview model for
 331    * @param fileName
 332    *                name of alignment panel written to output stream
 333    * @param jout
 334    *                jar output stream
 335    * @param out
 336    *                jar entry name
 337    */
 338   public JalviewModel SaveState(AlignmentPanel ap, String fileName,
 339           JarOutputStream jout)
 340   {
 341     initSeqRefs();
 342
 343     Vector userColours = new Vector();
 344
 345     AlignViewport av = ap.av;
 346
 347     JalviewModel object = new JalviewModel();
 348     object.setVamsasModel(new jalview.schemabinding.version2.VamsasModel());
 349
 350     object.setCreationDate(new java.util.Date(System.currentTimeMillis()));
 351     object.setVersion(jalview.bin.Cache.getProperty("VERSION"));
 352
 353     jalview.datamodel.AlignmentI jal = av.alignment;
 354
 355     if (av.hasHiddenRows)
 356     {
 357       jal = jal.getHiddenSequences().getFullAlignment();
 358     }
 359
 360     SequenceSet vamsasSet = new SequenceSet();
 361     Sequence vamsasSeq;
 362     JalviewModelSequence jms = new JalviewModelSequence();
 363
 364     vamsasSet.setGapChar(jal.getGapCharacter() + "");
 365
 366     if (jal.getDataset() != null)
 367     {
 368       // dataset id is the dataset's hashcode
 369       vamsasSet.setDatasetId(jal.getDataset().hashCode() + "");
 370     }
 371     if (jal.getProperties() != null)
 372     {
 373       Enumeration en = jal.getProperties().keys();
 374       while (en.hasMoreElements())
 375       {
 376         String key = en.nextElement().toString();
 377         SequenceSetProperties ssp = new SequenceSetProperties();
 378         ssp.setKey(key);
 379         ssp.setValue(jal.getProperties().get(key).toString());
 380         vamsasSet.addSequenceSetProperties(ssp);
 381       }
 382     }
 383
 384     JSeq jseq;
 385
 386     // SAVE SEQUENCES
 387     String id = "";
 388     jalview.datamodel.SequenceI jds;
 389     for (int i = 0; i < jal.getHeight(); i++)
 390     {
 391       jds = jal.getSequenceAt(i);
 392       id = seqHash(jds);
 393
 394       if (seqRefIds.get(id) != null)
 395       {
 396         // This happens for two reasons: 1. multiple views are being serialised.
 397         // 2. the hashCode has collided with another sequence's code. This DOES
 398         // HAPPEN! (PF00072.15.stk does this)
 399         // JBPNote: Uncomment to debug writing out of files that do not read
 400         // back in due to ArrayOutOfBoundExceptions.
 401         // System.err.println("vamsasSeq backref: "+id+"");
 402         // System.err.println(jds.getName()+"
 403         // "+jds.getStart()+"-"+jds.getEnd()+" "+jds.getSequenceAsString());
 404         // System.err.println("Hashcode: "+seqHash(jds));
 405         // SequenceI rsq = (SequenceI) seqRefIds.get(id + "");
 406         // System.err.println(rsq.getName()+"
 407         // "+rsq.getStart()+"-"+rsq.getEnd()+" "+rsq.getSequenceAsString());
 408         // System.err.println("Hashcode: "+seqHash(rsq));
 409       }
 410       else
 411       {
 412         vamsasSeq = createVamsasSequence(id, jds);
 413         vamsasSet.addSequence(vamsasSeq);
 414         seqRefIds.put(id, jds);
 415       }
 416
 417       jseq = new JSeq();
 418       jseq.setStart(jds.getStart());
 419       jseq.setEnd(jds.getEnd());
 420       jseq.setColour(av.getSequenceColour(jds).getRGB());
 421
 422       jseq.setId(id); // jseq id should be a string not a number
 423
 424       if (av.hasHiddenRows)
 425       {
 426         jseq.setHidden(av.alignment.getHiddenSequences().isHidden(jds));
 427
 428         if (av.hiddenRepSequences != null
 429                 && av.hiddenRepSequences.containsKey(jal.getSequenceAt(i)))
 430         {
 431           jalview.datamodel.SequenceI[] reps = ((jalview.datamodel.SequenceGroup) av.hiddenRepSequences
 432                   .get(jal.getSequenceAt(i))).getSequencesInOrder(jal);
 433
 434           for (int h = 0; h < reps.length; h++)
 435           {
 436             if (reps[h] != jal.getSequenceAt(i))
 437             {
 438               jseq.addHiddenSequences(jal.findIndex(reps[h]));
 439             }
 440           }
 441         }
 442       }
 443
 444       if (jds.getDatasetSequence().getSequenceFeatures() != null)
 445       {
 446         jalview.datamodel.SequenceFeature[] sf = jds.getDatasetSequence()
 447                 .getSequenceFeatures();
 448         int index = 0;
 449         while (index < sf.length)
 450         {
 451           Features features = new Features();
 452
 453           features.setBegin(sf[index].getBegin());
 454           features.setEnd(sf[index].getEnd());
 455           features.setDescription(sf[index].getDescription());
 456           features.setType(sf[index].getType());
 457           features.setFeatureGroup(sf[index].getFeatureGroup());
 458           features.setScore(sf[index].getScore());
 459           if (sf[index].links != null)
 460           {
 461             for (int l = 0; l < sf[index].links.size(); l++)
 462             {
 463               OtherData keyValue = new OtherData();
 464               keyValue.setKey("LINK_" + l);
 465               keyValue.setValue(sf[index].links.elementAt(l).toString());
 466               features.addOtherData(keyValue);
 467             }
 468           }
 469           if (sf[index].otherDetails != null)
 470           {
 471             String key;
 472             Enumeration keys = sf[index].otherDetails.keys();
 473             while (keys.hasMoreElements())
 474             {
 475               key = keys.nextElement().toString();
 476               OtherData keyValue = new OtherData();
 477               keyValue.setKey(key);
 478               keyValue.setValue(sf[index].otherDetails.get(key).toString());
 479               features.addOtherData(keyValue);
 480             }
 481           }
 482
 483           jseq.addFeatures(features);
 484           index++;
 485         }
 486       }
 487
 488       if (jds.getDatasetSequence().getPDBId() != null)
 489       {
 490         Enumeration en = jds.getDatasetSequence().getPDBId().elements();
 491         while (en.hasMoreElements())
 492         {
 493           Pdbids pdb = new Pdbids();
 494           jalview.datamodel.PDBEntry entry = (jalview.datamodel.PDBEntry) en
 495                   .nextElement();
 496
 497           pdb.setId(entry.getId());
 498           pdb.setType(entry.getType());
 499
 500           AppJmol jmol;
 501           // This must have been loaded, is it still visible?
 502           JInternalFrame[] frames = Desktop.desktop.getAllFrames();
 503           for (int f = frames.length - 1; f > -1; f--)
 504           {
 505             if (frames[f] instanceof AppJmol)
 506             {
 507               jmol = (AppJmol) frames[f];
 508               if (!jmol.pdbentry.getId().equals(entry.getId()))
 509                 continue;
 510
 511               StructureState state = new StructureState();
 512               state.setVisible(true);
 513               state.setXpos(jmol.getX());
 514               state.setYpos(jmol.getY());
 515               state.setWidth(jmol.getWidth());
 516               state.setHeight(jmol.getHeight());
 517
 518               String statestring = jmol.viewer.getStateInfo();
 519               if (state != null)
 520               {
 521                 state.setContent(statestring.replaceAll("\n", ""));
 522               }
 523               for (int s = 0; s < jmol.sequence.length; s++)
 524               {
 525                 if (jal.findIndex(jmol.sequence[s]) > -1)
 526                 {
 527                   pdb.addStructureState(state);
 528                 }
 529               }
 530             }
 531           }
 532
 533           if (entry.getFile() != null)
 534           {
 535             pdb.setFile(entry.getFile());
 536             if (pdbfiles == null)
 537             {
 538               pdbfiles = new Vector();
 539             }
 540
 541             if (!pdbfiles.contains(entry.getId()))
 542             {
 543               pdbfiles.addElement(entry.getId());
 544               try
 545               {
 546                 File file = new File(entry.getFile());
 547                 if (file.exists() && jout != null)
 548                 {
 549                   byte[] data = new byte[(int) file.length()];
 550                   jout.putNextEntry(new JarEntry(entry.getId()));
 551                   DataInputStream dis = new DataInputStream(
 552                           new FileInputStream(file));
 553                   dis.readFully(data);
 554
 555                   DataOutputStream dout = new DataOutputStream(jout);
 556                   dout.write(data, 0, data.length);
 557                   dout.flush();
 558                   jout.closeEntry();
 559                 }
 560               } catch (Exception ex)
 561               {
 562                 ex.printStackTrace();
 563               }
 564
 565             }
 566           }
 567
 568           if (entry.getProperty() != null)
 569           {
 570             PdbentryItem item = new PdbentryItem();
 571             Hashtable properties = entry.getProperty();
 572             Enumeration en2 = properties.keys();
 573             while (en2.hasMoreElements())
 574             {
 575               Property prop = new Property();
 576               String key = en2.nextElement().toString();
 577               prop.setName(key);
 578               prop.setValue(properties.get(key).toString());
 579               item.addProperty(prop);
 580             }
 581             pdb.addPdbentryItem(item);
 582           }
 583
 584           jseq.addPdbids(pdb);
 585         }
 586       }
 587
 588       jms.addJSeq(jseq);
 589     }
 590
 591     if (av.hasHiddenRows)
 592     {
 593       jal = av.alignment;
 594     }
 595     // SAVE MAPPINGS
 596     if (jal.getCodonFrames() != null && jal.getCodonFrames().length > 0)
 597     {
 598       jalview.datamodel.AlignedCodonFrame[] jac = jal.getCodonFrames();
 599       for (int i = 0; i < jac.length; i++)
 600       {
 601         AlcodonFrame alc = new AlcodonFrame();
 602         vamsasSet.addAlcodonFrame(alc);
 603         for (int p = 0; p < jac[i].aaWidth; p++)
 604         {
 605           Alcodon cmap = new Alcodon();
 606           cmap.setPos1(jac[i].codons[p][0]);
 607           cmap.setPos2(jac[i].codons[p][1]);
 608           cmap.setPos3(jac[i].codons[p][2]);
 609           alc.addAlcodon(cmap);
 610         }
 611         if (jac[i].getProtMappings() != null
 612                 && jac[i].getProtMappings().length > 0)
 613         {
 614           SequenceI[] dnas = jac[i].getdnaSeqs();
 615           jalview.datamodel.Mapping[] pmaps = jac[i].getProtMappings();
 616           for (int m = 0; m < pmaps.length; m++)
 617           {
 618             AlcodMap alcmap = new AlcodMap();
 619             alcmap.setDnasq("" + dnas[m].hashCode());
 620             alcmap.setMapping(createVamsasMapping(pmaps[m], dnas[m], null,
 621                     false));
 622             alc.addAlcodMap(alcmap);
 623           }
 624         }
 625       }
 626     }
 627
 628     // SAVE TREES
 629     // /////////////////////////////////
 630     if (av.currentTree != null)
 631     {
 632       // FIND ANY ASSOCIATED TREES
 633       // NOT IMPLEMENTED FOR HEADLESS STATE AT PRESENT
 634       if (Desktop.desktop != null)
 635       {
 636         JInternalFrame[] frames = Desktop.desktop.getAllFrames();
 637
 638         for (int t = 0; t < frames.length; t++)
 639         {
 640           if (frames[t] instanceof TreePanel)
 641           {
 642             TreePanel tp = (TreePanel) frames[t];
 643
 644             if (tp.treeCanvas.av.alignment == jal)
 645             {
 646               Tree tree = new Tree();
 647               tree.setTitle(tp.getTitle());
 648               tree.setCurrentTree((av.currentTree == tp.getTree()));
 649               tree.setNewick(tp.getTree().toString());
 650               tree.setThreshold(tp.treeCanvas.threshold);
 651
 652               tree.setFitToWindow(tp.fitToWindow.getState());
 653               tree.setFontName(tp.getTreeFont().getName());
 654               tree.setFontSize(tp.getTreeFont().getSize());
 655               tree.setFontStyle(tp.getTreeFont().getStyle());
 656               tree.setMarkUnlinked(tp.placeholdersMenu.getState());
 657
 658               tree.setShowBootstrap(tp.bootstrapMenu.getState());
 659               tree.setShowDistances(tp.distanceMenu.getState());
 660
 661               tree.setHeight(tp.getHeight());
 662               tree.setWidth(tp.getWidth());
 663               tree.setXpos(tp.getX());
 664               tree.setYpos(tp.getY());
 665
 666               jms.addTree(tree);
 667             }
 668           }
 669         }
 670       }
 671     }
 672
 673     // SAVE ANNOTATIONS
 674     if (jal.getAlignmentAnnotation() != null)
 675     {
 676       jalview.datamodel.AlignmentAnnotation[] aa = jal
 677               .getAlignmentAnnotation();
 678
 679       for (int i = 0; i < aa.length; i++)
 680       {
 681         Annotation an = new Annotation();
 682
 683         if (aa[i].annotationId != null)
 684         {
 685           annotationIds.put(aa[i].annotationId, aa[i]);
 686         }
 687
 688         an.setId(aa[i].annotationId);
 689
 690         if (aa[i] == av.quality || aa[i] == av.conservation
 691                 || aa[i] == av.consensus)
 692         {
 693           an.setLabel(aa[i].label);
 694           an.setGraph(true);
 695           vamsasSet.addAnnotation(an);
 696           continue;
 697         }
 698
 699         an.setVisible(aa[i].visible);
 700
 701         an.setDescription(aa[i].description);
 702
 703         if (aa[i].sequenceRef != null)
 704         {
 705           an.setSequenceRef(aa[i].sequenceRef.getName());
 706         }
 707
 708         if (aa[i].graph > 0)
 709         {
 710           an.setGraph(true);
 711           an.setGraphType(aa[i].graph);
 712           an.setGraphGroup(aa[i].graphGroup);
 713           if (aa[i].getThreshold() != null)
 714           {
 715             ThresholdLine line = new ThresholdLine();
 716             line.setLabel(aa[i].getThreshold().label);
 717             line.setValue(aa[i].getThreshold().value);
 718             line.setColour(aa[i].getThreshold().colour.getRGB());
 719             an.setThresholdLine(line);
 720           }
 721         }
 722         else
 723         {
 724           an.setGraph(false);
 725         }
 726
 727         an.setLabel(aa[i].label);
 728         if (aa[i].hasScore())
 729         {
 730           an.setScore(aa[i].getScore());
 731         }
 732         AnnotationElement ae;
 733         if (aa[i].annotations != null)
 734         {
 735           an.setScoreOnly(false);
 736           for (int a = 0; a < aa[i].annotations.length; a++)
 737           {
 738             if ((aa[i] == null) || (aa[i].annotations[a] == null))
 739             {
 740               continue;
 741             }
 742
 743             ae = new AnnotationElement();
 744             if (aa[i].annotations[a].description != null)
 745               ae.setDescription(aa[i].annotations[a].description);
 746             if (aa[i].annotations[a].displayCharacter != null)
 747               ae.setDisplayCharacter(aa[i].annotations[a].displayCharacter);
 748
 749             if (!Float.isNaN(aa[i].annotations[a].value))
 750               ae.setValue(aa[i].annotations[a].value);
 751
 752             ae.setPosition(a);
 753             if (aa[i].annotations[a].secondaryStructure != ' '
 754                     && aa[i].annotations[a].secondaryStructure != '\0')
 755               ae
 756                       .setSecondaryStructure(aa[i].annotations[a].secondaryStructure
 757                               + "");
 758
 759             if (aa[i].annotations[a].colour != null
 760                     && aa[i].annotations[a].colour != java.awt.Color.black)
 761             {
 762               ae.setColour(aa[i].annotations[a].colour.getRGB());
 763             }
 764
 765             an.addAnnotationElement(ae);
 766           }
 767         }
 768         else
 769         {
 770           an.setScoreOnly(true);
 771         }
 772         vamsasSet.addAnnotation(an);
 773       }
 774     }
 775
 776     // SAVE GROUPS
 777     if (jal.getGroups() != null)
 778     {
 779       JGroup[] groups = new JGroup[jal.getGroups().size()];
 780
 781       for (int i = 0; i < groups.length; i++)
 782       {
 783         groups[i] = new JGroup();
 784
 785         jalview.datamodel.SequenceGroup sg = (jalview.datamodel.SequenceGroup) jal
 786                 .getGroups().elementAt(i);
 787         groups[i].setStart(sg.getStartRes());
 788         groups[i].setEnd(sg.getEndRes());
 789         groups[i].setName(sg.getName());
 790         if (sg.cs != null)
 791         {
 792           if (sg.cs.conservationApplied())
 793           {
 794             groups[i].setConsThreshold(sg.cs.getConservationInc());
 795
 796             if (sg.cs instanceof jalview.schemes.UserColourScheme)
 797             {
 798               groups[i].setColour(SetUserColourScheme(sg.cs, userColours,
 799                       jms));
 800             }
 801             else
 802             {
 803               groups[i]
 804                       .setColour(ColourSchemeProperty.getColourName(sg.cs));
 805             }
 806           }
 807           else if (sg.cs instanceof jalview.schemes.AnnotationColourGradient)
 808           {
 809             groups[i]
 810                     .setColour(ColourSchemeProperty
 811                             .getColourName(((jalview.schemes.AnnotationColourGradient) sg.cs)
 812                                     .getBaseColour()));
 813           }
 814           else if (sg.cs instanceof jalview.schemes.UserColourScheme)
 815           {
 816             groups[i]
 817                     .setColour(SetUserColourScheme(sg.cs, userColours, jms));
 818           }
 819           else
 820           {
 821             groups[i].setColour(ColourSchemeProperty.getColourName(sg.cs));
 822           }
 823
 824           groups[i].setPidThreshold(sg.cs.getThreshold());
 825         }
 826
 827         groups[i].setOutlineColour(sg.getOutlineColour().getRGB());
 828         groups[i].setDisplayBoxes(sg.getDisplayBoxes());
 829         groups[i].setDisplayText(sg.getDisplayText());
 830         groups[i].setColourText(sg.getColourText());
 831         groups[i].setTextCol1(sg.textColour.getRGB());
 832         groups[i].setTextCol2(sg.textColour2.getRGB());
 833         groups[i].setTextColThreshold(sg.thresholdTextColour);
 834
 835         for (int s = 0; s < sg.getSize(); s++)
 836         {
 837           jalview.datamodel.Sequence seq = (jalview.datamodel.Sequence) sg
 838                   .getSequenceAt(s);
 839           groups[i].addSeq(seqHash(seq));
 840         }
 841       }
 842
 843       jms.setJGroup(groups);
 844     }
 845
 846     // /////////SAVE VIEWPORT
 847     Viewport view = new Viewport();
 848     view.setTitle(ap.alignFrame.getTitle());
 849     view.setSequenceSetId(av.getSequenceSetId());
 850     view.setViewName(av.viewName);
 851     view.setGatheredViews(av.gatherViewsHere);
 852
 853     if (ap.av.explodedPosition != null)
 854     {
 855       view.setXpos(av.explodedPosition.x);
 856       view.setYpos(av.explodedPosition.y);
 857       view.setWidth(av.explodedPosition.width);
 858       view.setHeight(av.explodedPosition.height);
 859     }
 860     else
 861     {
 862       view.setXpos(ap.alignFrame.getBounds().x);
 863       view.setYpos(ap.alignFrame.getBounds().y);
 864       view.setWidth(ap.alignFrame.getBounds().width);
 865       view.setHeight(ap.alignFrame.getBounds().height);
 866     }
 867
 868     view.setStartRes(av.startRes);
 869     view.setStartSeq(av.startSeq);
 870
 871     if (av.getGlobalColourScheme() instanceof jalview.schemes.UserColourScheme)
 872     {
 873       view.setBgColour(SetUserColourScheme(av.getGlobalColourScheme(),
 874               userColours, jms));
 875     }
 876     else if (av.getGlobalColourScheme() instanceof jalview.schemes.AnnotationColourGradient)
 877     {
 878       jalview.schemes.AnnotationColourGradient acg = (jalview.schemes.AnnotationColourGradient) av
 879               .getGlobalColourScheme();
 880
 881       AnnotationColours ac = new AnnotationColours();
 882       ac.setAboveThreshold(acg.getAboveThreshold());
 883       ac.setThreshold(acg.getAnnotationThreshold());
 884       ac.setAnnotation(acg.getAnnotation());
 885       if (acg.getBaseColour() instanceof jalview.schemes.UserColourScheme)
 886       {
 887         ac.setColourScheme(SetUserColourScheme(acg.getBaseColour(),
 888                 userColours, jms));
 889       }
 890       else
 891       {
 892         ac.setColourScheme(ColourSchemeProperty.getColourName(acg
 893                 .getBaseColour()));
 894       }
 895
 896       ac.setMaxColour(acg.getMaxColour().getRGB());
 897       ac.setMinColour(acg.getMinColour().getRGB());
 898       view.setAnnotationColours(ac);
 899       view.setBgColour("AnnotationColourGradient");
 900     }
 901     else
 902     {
 903       view.setBgColour(ColourSchemeProperty.getColourName(av
 904               .getGlobalColourScheme()));
 905     }
 906
 907     ColourSchemeI cs = av.getGlobalColourScheme();
 908
 909     if (cs != null)
 910     {
 911       if (cs.conservationApplied())
 912       {
 913         view.setConsThreshold(cs.getConservationInc());
 914         if (cs instanceof jalview.schemes.UserColourScheme)
 915         {
 916           view.setBgColour(SetUserColourScheme(cs, userColours, jms));
 917         }
 918       }
 919
 920       if (cs instanceof ResidueColourScheme)
 921       {
 922         view.setPidThreshold(cs.getThreshold());
 923       }
 924     }
 925
 926     view.setConservationSelected(av.getConservationSelected());
 927     view.setPidSelected(av.getAbovePIDThreshold());
 928     view.setFontName(av.font.getName());
 929     view.setFontSize(av.font.getSize());
 930     view.setFontStyle(av.font.getStyle());
 931     view.setRenderGaps(av.renderGaps);
 932     view.setShowAnnotation(av.getShowAnnotation());
 933     view.setShowBoxes(av.getShowBoxes());
 934     view.setShowColourText(av.getColourText());
 935     view.setShowFullId(av.getShowJVSuffix());
 936     view.setRightAlignIds(av.rightAlignIds);
 937     view.setShowSequenceFeatures(av.showSequenceFeatures);
 938     view.setShowText(av.getShowText());
 939     view.setWrapAlignment(av.getWrapAlignment());
 940     view.setTextCol1(av.textColour.getRGB());
 941     view.setTextCol2(av.textColour2.getRGB());
 942     view.setTextColThreshold(av.thresholdTextColour);
 943
 944     if (av.featuresDisplayed != null)
 945     {
 946       jalview.schemabinding.version2.FeatureSettings fs = new jalview.schemabinding.version2.FeatureSettings();
 947
 948       String[] renderOrder = ap.seqPanel.seqCanvas.getFeatureRenderer().renderOrder;
 949
 950       Vector settingsAdded = new Vector();
 951       for (int ro = 0; ro < renderOrder.length; ro++)
 952       {
 953         Setting setting = new Setting();
 954         setting.setType(renderOrder[ro]);
 955         setting.setColour(ap.seqPanel.seqCanvas.getFeatureRenderer()
 956                 .getColour(renderOrder[ro]).getRGB());
 957
 958         setting.setDisplay(av.featuresDisplayed
 959                 .containsKey(renderOrder[ro]));
 960         float rorder = ap.seqPanel.seqCanvas.getFeatureRenderer().getOrder(
 961                 renderOrder[ro]);
 962         if (rorder > -1)
 963         {
 964           setting.setOrder(rorder);
 965         }
 966         fs.addSetting(setting);
 967         settingsAdded.addElement(renderOrder[ro]);
 968       }
 969
 970       // Make sure we save none displayed feature settings
 971       Enumeration en = ap.seqPanel.seqCanvas.getFeatureRenderer().featureColours
 972               .keys();
 973       while (en.hasMoreElements())
 974       {
 975         String key = en.nextElement().toString();
 976         if (settingsAdded.contains(key))
 977         {
 978           continue;
 979         }
 980
 981         Setting setting = new Setting();
 982         setting.setType(key);
 983         setting.setColour(ap.seqPanel.seqCanvas.getFeatureRenderer()
 984                 .getColour(key).getRGB());
 985
 986         setting.setDisplay(false);
 987         float rorder = ap.seqPanel.seqCanvas.getFeatureRenderer().getOrder(
 988                 key);
 989         if (rorder > -1)
 990         {
 991           setting.setOrder(rorder);
 992         }
 993         fs.addSetting(setting);
 994         settingsAdded.addElement(key);
 995       }
 996       en = ap.seqPanel.seqCanvas.getFeatureRenderer().featureGroups.keys();
 997       Vector groupsAdded = new Vector();
 998       while (en.hasMoreElements())
 999       {
1000         String grp = en.nextElement().toString();
1001         if (groupsAdded.contains(grp))
1002         {
1003           continue;
1004         }
1005         Group g = new Group();
1006         g.setName(grp);
1007         g
1008                 .setDisplay(((Boolean) ap.seqPanel.seqCanvas
1009                         .getFeatureRenderer().featureGroups.get(grp))
1010                         .booleanValue());
1011         fs.addGroup(g);
1012         groupsAdded.addElement(grp);
1013       }
1014       jms.setFeatureSettings(fs);
1015
1016     }
1017
1018     if (av.hasHiddenColumns)
1019     {
1020       for (int c = 0; c < av.getColumnSelection().getHiddenColumns().size(); c++)
1021       {
1022         int[] region = (int[]) av.getColumnSelection().getHiddenColumns()
1023                 .elementAt(c);
1024         HiddenColumns hc = new HiddenColumns();
1025         hc.setStart(region[0]);
1026         hc.setEnd(region[1]);
1027         view.addHiddenColumns(hc);
1028       }
1029     }
1030
1031     jms.addViewport(view);
1032
1033     object.setJalviewModelSequence(jms);
1034     object.getVamsasModel().addSequenceSet(vamsasSet);
1035
1036     if (jout != null && fileName != null)
1037     {
1038       // We may not want to write the object to disk,
1039       // eg we can copy the alignViewport to a new view object
1040       // using save and then load
1041       try
1042       {
1043         JarEntry entry = new JarEntry(fileName);
1044         jout.putNextEntry(entry);
1045         PrintWriter pout = new PrintWriter(new OutputStreamWriter(jout,
1046                 "UTF-8"));
1047         org.exolab.castor.xml.Marshaller marshaller = new org.exolab.castor.xml.Marshaller(
1048                 pout);
1049         marshaller.marshal(object);
1050         pout.flush();
1051         jout.closeEntry();
1052       } catch (Exception ex)
1053       {
1054         // TODO: raise error in GUI if marshalling failed.
1055         ex.printStackTrace();
1056       }
1057     }
1058     return object;
1059   }
1060
1061   private Sequence createVamsasSequence(String id, SequenceI jds)
1062   {
1063     return createVamsasSequence(true, id, jds, null);
1064   }
1065
1066   private Sequence createVamsasSequence(boolean recurse, String id,
1067           SequenceI jds, SequenceI parentseq)
1068   {
1069     Sequence vamsasSeq = new Sequence();
1070     vamsasSeq.setId(id);
1071     vamsasSeq.setName(jds.getName());
1072     vamsasSeq.setSequence(jds.getSequenceAsString());
1073     vamsasSeq.setDescription(jds.getDescription());
1074     jalview.datamodel.DBRefEntry[] dbrefs = null;
1075     if (jds.getDatasetSequence() != null)
1076     {
1077       vamsasSeq.setDsseqid(seqHash(jds.getDatasetSequence()));
1078       if (jds.getDatasetSequence().getDBRef() != null)
1079       {
1080         dbrefs = jds.getDatasetSequence().getDBRef();
1081       }
1082     }
1083     else
1084     {
1085       vamsasSeq.setDsseqid(id); // so we can tell which sequences really are
1086                                 // dataset sequences only
1087       dbrefs = jds.getDBRef();
1088     }
1089     if (dbrefs != null)
1090     {
1091       for (int d = 0; d < dbrefs.length; d++)
1092       {
1093         DBRef dbref = new DBRef();
1094         dbref.setSource(dbrefs[d].getSource());
1095         dbref.setVersion(dbrefs[d].getVersion());
1096         dbref.setAccessionId(dbrefs[d].getAccessionId());
1097         if (dbrefs[d].hasMap())
1098         {
1099           Mapping mp = createVamsasMapping(dbrefs[d].getMap(), parentseq,
1100                   jds, recurse);
1101           dbref.setMapping(mp);
1102         }
1103         vamsasSeq.addDBRef(dbref);
1104       }
1105     }
1106     return vamsasSeq;
1107   }
1108
1109   private Mapping createVamsasMapping(jalview.datamodel.Mapping jmp,
1110           SequenceI parentseq, SequenceI jds, boolean recurse)
1111   {
1112     Mapping mp = null;
1113     if (jmp.getMap() != null)
1114     {
1115       mp = new Mapping();
1116
1117       jalview.util.MapList mlst = jmp.getMap();
1118       int r[] = mlst.getFromRanges();
1119       for (int s = 0; s < r.length; s += 2)
1120       {
1121         MapListFrom mfrom = new MapListFrom();
1122         mfrom.setStart(r[s]);
1123         mfrom.setEnd(r[s + 1]);
1124         mp.addMapListFrom(mfrom);
1125       }
1126       r = mlst.getToRanges();
1127       for (int s = 0; s < r.length; s += 2)
1128       {
1129         MapListTo mto = new MapListTo();
1130         mto.setStart(r[s]);
1131         mto.setEnd(r[s + 1]);
1132         mp.addMapListTo(mto);
1133       }
1134       mp.setMapFromUnit(mlst.getFromRatio());
1135       mp.setMapToUnit(mlst.getToRatio());
1136       if (jmp.getTo() != null)
1137       {
1138         MappingChoice mpc = new MappingChoice();
1139         if (recurse
1140                 && (parentseq != jmp.getTo() || parentseq
1141                         .getDatasetSequence() != jmp.getTo()))
1142         {
1143           mpc.setSequence(createVamsasSequence(false, seqHash(jmp.getTo()),
1144                   jmp.getTo(), jds));
1145         }
1146         else
1147         {
1148           String jmpid = "";
1149           SequenceI ps = null;
1150           if (parentseq != jmp.getTo()
1151                   && parentseq.getDatasetSequence() != jmp.getTo())
1152           {
1153             // chaining dbref rather than a handshaking one
1154             jmpid = seqHash(ps = jmp.getTo());
1155           }
1156           else
1157           {
1158             jmpid = seqHash(ps = parentseq);
1159           }
1160           mpc.setDseqFor(jmpid);
1161           if (!seqRefIds.containsKey(mpc.getDseqFor()))
1162           {
1163             jalview.bin.Cache.log.debug("creatign new DseqFor ID");
1164             seqRefIds.put(mpc.getDseqFor(), ps);
1165           }
1166           else
1167           {
1168             jalview.bin.Cache.log.debug("reusing DseqFor ID");
1169           }
1170         }
1171         mp.setMappingChoice(mpc);
1172       }
1173     }
1174     return mp;
1175   }
1176
1177   String SetUserColourScheme(jalview.schemes.ColourSchemeI cs,
1178           Vector userColours, JalviewModelSequence jms)
1179   {
1180     String id = null;
1181     jalview.schemes.UserColourScheme ucs = (jalview.schemes.UserColourScheme) cs;
1182
1183     if (!userColours.contains(ucs))
1184     {
1185       userColours.add(ucs);
1186
1187       java.awt.Color[] colours = ucs.getColours();
1188       jalview.schemabinding.version2.UserColours uc = new jalview.schemabinding.version2.UserColours();
1189       jalview.schemabinding.version2.UserColourScheme jbucs = new jalview.schemabinding.version2.UserColourScheme();
1190
1191       for (int i = 0; i < colours.length; i++)
1192       {
1193         jalview.schemabinding.version2.Colour col = new jalview.schemabinding.version2.Colour();
1194         col.setName(ResidueProperties.aa[i]);
1195         col.setRGB(jalview.util.Format.getHexString(colours[i]));
1196         jbucs.addColour(col);
1197       }
1198       if (ucs.getLowerCaseColours() != null)
1199       {
1200         colours = ucs.getLowerCaseColours();
1201         for (int i = 0; i < colours.length; i++)
1202         {
1203           jalview.schemabinding.version2.Colour col = new jalview.schemabinding.version2.Colour();
1204           col.setName(ResidueProperties.aa[i].toLowerCase());
1205           col.setRGB(jalview.util.Format.getHexString(colours[i]));
1206           jbucs.addColour(col);
1207         }
1208       }
1209
1210       id = "ucs" + userColours.indexOf(ucs);
1211       uc.setId(id);
1212       uc.setUserColourScheme(jbucs);
1213       jms.addUserColours(uc);
1214     }
1215
1216     return id;
1217   }
1218
1219   jalview.schemes.UserColourScheme GetUserColourScheme(
1220           JalviewModelSequence jms, String id)
1221   {
1222     UserColours[] uc = jms.getUserColours();
1223     UserColours colours = null;
1224
1225     for (int i = 0; i < uc.length; i++)
1226     {
1227       if (uc[i].getId().equals(id))
1228       {
1229         colours = uc[i];
1230
1231         break;
1232       }
1233     }
1234
1235     java.awt.Color[] newColours = new java.awt.Color[24];
1236
1237     for (int i = 0; i < 24; i++)
1238     {
1239       newColours[i] = new java.awt.Color(Integer.parseInt(colours
1240               .getUserColourScheme().getColour(i).getRGB(), 16));
1241     }
1242
1243     jalview.schemes.UserColourScheme ucs = new jalview.schemes.UserColourScheme(
1244             newColours);
1245
1246     if (colours.getUserColourScheme().getColourCount() > 24)
1247     {
1248       newColours = new java.awt.Color[23];
1249       for (int i = 0; i < 23; i++)
1250       {
1251         newColours[i] = new java.awt.Color(Integer.parseInt(colours
1252                 .getUserColourScheme().getColour(i + 24).getRGB(), 16));
1253       }
1254       ucs.setLowerCaseColours(newColours);
1255     }
1256
1257     return ucs;
1258   }
1259
1260   /**
1261    * DOCUMENT ME!
1262    *
1263    * @param file
1264    *                DOCUMENT ME!
1265    */
1266   public AlignFrame LoadJalviewAlign(final String file)
1267   {
1268     uniqueSetSuffix = System.currentTimeMillis() % 100000 + "";
1269
1270     jalview.gui.AlignFrame af = null;
1271
1272     seqRefIds = new Hashtable();
1273     viewportsAdded = new Hashtable();
1274     frefedSequence = new Vector();
1275     Hashtable gatherToThisFrame = new Hashtable();
1276
1277     String errorMessage = null;
1278
1279     try
1280     {
1281       // UNMARSHALLER SEEMS TO CLOSE JARINPUTSTREAM, MOST ANNOYING
1282       URL url = null;
1283
1284       if (file.startsWith("http://"))
1285       {
1286         url = new URL(file);
1287       }
1288
1289       JarInputStream jin = null;
1290       JarEntry jarentry = null;
1291       int entryCount = 1;
1292
1293       do
1294       {
1295         if (url != null)
1296         {
1297           jin = new JarInputStream(url.openStream());
1298         }
1299         else
1300         {
1301           jin = new JarInputStream(new FileInputStream(file));
1302         }
1303
1304         for (int i = 0; i < entryCount; i++)
1305         {
1306           jarentry = jin.getNextJarEntry();
1307         }
1308
1309         if (jarentry != null && jarentry.getName().endsWith(".xml"))
1310         {
1311           InputStreamReader in = new InputStreamReader(jin, "UTF-8");
1312           JalviewModel object = new JalviewModel();
1313
1314           Unmarshaller unmar = new Unmarshaller(object);
1315           unmar.setValidation(false);
1316           object = (JalviewModel) unmar.unmarshal(in);
1317
1318           af = LoadFromObject(object, file, true);
1319           if (af.viewport.gatherViewsHere)
1320           {
1321             gatherToThisFrame.put(af.viewport.getSequenceSetId(), af);
1322           }
1323           entryCount++;
1324         }
1325         else if (jarentry != null)
1326         {
1327           // Some other file here.
1328           entryCount++;
1329         }
1330       } while (jarentry != null);
1331       resolveFrefedSequences();
1332     } catch (java.io.FileNotFoundException ex)
1333     {
1334       ex.printStackTrace();
1335       errorMessage = "Couldn't locate Jalview XML file : " + file;
1336       System.err.println("Exception whilst loading jalview XML file : "
1337               + ex + "\n");
1338     } catch (java.net.UnknownHostException ex)
1339     {
1340       ex.printStackTrace();
1341       errorMessage = "Couldn't locate Jalview XML file : " + file;
1342       System.err.println("Exception whilst loading jalview XML file : "
1343               + ex + "\n");
1344     } catch (Exception ex)
1345     {
1346       System.err.println("Parsing as Jalview Version 2 file failed.");
1347       ex.printStackTrace(System.err);
1348
1349       // Is Version 1 Jar file?
1350       try
1351       {
1352         af = new Jalview2XML_V1(raiseGUI).LoadJalviewAlign(file);
1353       } catch (Exception ex2)
1354       {
1355         System.err.println("Exception whilst loading as jalviewXMLV1:");
1356         ex2.printStackTrace();
1357         af = null;
1358       }
1359
1360       if (Desktop.instance != null)
1361       {
1362         Desktop.instance.stopLoading();
1363       }
1364       if (af != null)
1365       {
1366         System.out.println("Successfully loaded archive file");
1367         return af;
1368       }
1369       ex.printStackTrace();
1370
1371       System.err.println("Exception whilst loading jalview XML file : "
1372               + ex + "\n");
1373     }
1374
1375     if (Desktop.instance != null)
1376     {
1377       Desktop.instance.stopLoading();
1378     }
1379
1380     Enumeration en = gatherToThisFrame.elements();
1381     while (en.hasMoreElements())
1382     {
1383       Desktop.instance.gatherViews((AlignFrame) en.nextElement());
1384     }
1385
1386     if (errorMessage != null)
1387     {
1388       final String finalErrorMessage = errorMessage;
1389       if (raiseGUI)
1390       {
1391         javax.swing.SwingUtilities.invokeLater(new Runnable()
1392         {
1393           public void run()
1394           {
1395             JOptionPane.showInternalMessageDialog(Desktop.desktop,
1396                     finalErrorMessage, "Error loading Jalview file",
1397                     JOptionPane.WARNING_MESSAGE);
1398           }
1399         });
1400       }
1401       else
1402       {
1403         System.err.println("Problem loading Jalview file: " + errorMessage);
1404       }
1405     }
1406
1407     return af;
1408   }
1409
1410   Hashtable alreadyLoadedPDB;
1411
1412   String loadPDBFile(String file, String pdbId)
1413   {
1414     if (alreadyLoadedPDB == null)
1415       alreadyLoadedPDB = new Hashtable();
1416
1417     if (alreadyLoadedPDB.containsKey(pdbId))
1418       return alreadyLoadedPDB.get(pdbId).toString();
1419
1420     try
1421     {
1422       JarInputStream jin = null;
1423
1424       if (file.startsWith("http://"))
1425       {
1426         jin = new JarInputStream(new URL(file).openStream());
1427       }
1428       else
1429       {
1430         jin = new JarInputStream(new FileInputStream(file));
1431       }
1432
1433       JarEntry entry = null;
1434       do
1435       {
1436         entry = jin.getNextJarEntry();
1437       } while (!entry.getName().equals(pdbId));
1438
1439       BufferedReader in = new BufferedReader(new InputStreamReader(jin));
1440       File outFile = File.createTempFile("jalview_pdb", ".txt");
1441       outFile.deleteOnExit();
1442       PrintWriter out = new PrintWriter(new FileOutputStream(outFile));
1443       String data;
1444
1445       while ((data = in.readLine()) != null)
1446       {
1447         out.println(data);
1448       }
1449       try
1450       {
1451         out.flush();
1452       } catch (Exception foo)
1453       {
1454       }
1455       ;
1456       out.close();
1457
1458       alreadyLoadedPDB.put(pdbId, outFile.getAbsolutePath());
1459       return outFile.getAbsolutePath();
1460
1461     } catch (Exception ex)
1462     {
1463       ex.printStackTrace();
1464     }
1465
1466     return null;
1467   }
1468
1469   AlignFrame LoadFromObject(JalviewModel object, String file,
1470           boolean loadTreesAndStructures)
1471   {
1472     SequenceSet vamsasSet = object.getVamsasModel().getSequenceSet(0);
1473     Sequence[] vamsasSeq = vamsasSet.getSequence();
1474
1475     JalviewModelSequence jms = object.getJalviewModelSequence();
1476
1477     Viewport view = jms.getViewport(0);
1478
1479     // ////////////////////////////////
1480     // LOAD SEQUENCES
1481
1482     Vector hiddenSeqs = null;
1483     jalview.datamodel.Sequence jseq;
1484
1485     ArrayList tmpseqs = new ArrayList();
1486
1487     boolean multipleView = false;
1488
1489     JSeq[] JSEQ = object.getJalviewModelSequence().getJSeq();
1490     int vi = 0; // counter in vamsasSeq array
1491     for (int i = 0; i < JSEQ.length; i++)
1492     {
1493       String seqId = JSEQ[i].getId() + "";
1494
1495       if (seqRefIds.get(seqId) != null)
1496       {
1497         tmpseqs.add((jalview.datamodel.Sequence) seqRefIds.get(seqId));
1498         multipleView = true;
1499       }
1500       else
1501       {
1502         jseq = new jalview.datamodel.Sequence(vamsasSeq[vi].getName(),
1503                 vamsasSeq[vi].getSequence());
1504         jseq.setDescription(vamsasSeq[vi].getDescription());
1505         jseq.setStart(JSEQ[i].getStart());
1506         jseq.setEnd(JSEQ[i].getEnd());
1507         jseq.setVamsasId(uniqueSetSuffix + seqId);
1508         seqRefIds.put(vamsasSeq[vi].getId() + "", jseq);
1509         tmpseqs.add(jseq);
1510         vi++;
1511       }
1512
1513       if (JSEQ[i].getHidden())
1514       {
1515         if (hiddenSeqs == null)
1516         {
1517           hiddenSeqs = new Vector();
1518         }
1519
1520         hiddenSeqs.addElement((jalview.datamodel.Sequence) seqRefIds
1521                 .get(seqId));
1522       }
1523
1524     }
1525
1526     // /
1527     // Create the alignment object from the sequence set
1528     // ///////////////////////////////
1529     jalview.datamodel.Sequence[] orderedSeqs = new jalview.datamodel.Sequence[tmpseqs
1530             .size()];
1531
1532     tmpseqs.toArray(orderedSeqs);
1533
1534     jalview.datamodel.Alignment al = new jalview.datamodel.Alignment(
1535             orderedSeqs);
1536
1537     // / Add the alignment properties
1538     for (int i = 0; i < vamsasSet.getSequenceSetPropertiesCount(); i++)
1539     {
1540       SequenceSetProperties ssp = vamsasSet.getSequenceSetProperties(i);
1541       al.setProperty(ssp.getKey(), ssp.getValue());
1542     }
1543
1544     // /
1545     // SequenceFeatures are added to the DatasetSequence,
1546     // so we must create or recover the dataset before loading features
1547     // ///////////////////////////////
1548     if (vamsasSet.getDatasetId() == null || vamsasSet.getDatasetId() == "")
1549     {
1550       // older jalview projects do not have a dataset id.
1551       al.setDataset(null);
1552     }
1553     else
1554     {
1555       recoverDatasetFor(vamsasSet, al);
1556     }
1557     // ///////////////////////////////
1558
1559     Hashtable pdbloaded = new Hashtable();
1560     if (!multipleView)
1561     {
1562       for (int i = 0; i < vamsasSeq.length; i++)
1563       {
1564         if (JSEQ[i].getFeaturesCount() > 0)
1565         {
1566           Features[] features = JSEQ[i].getFeatures();
1567           for (int f = 0; f < features.length; f++)
1568           {
1569             jalview.datamodel.SequenceFeature sf = new jalview.datamodel.SequenceFeature(
1570                     features[f].getType(), features[f].getDescription(),
1571                     features[f].getStatus(), features[f].getBegin(),
1572                     features[f].getEnd(), features[f].getFeatureGroup());
1573
1574             sf.setScore(features[f].getScore());
1575             for (int od = 0; od < features[f].getOtherDataCount(); od++)
1576             {
1577               OtherData keyValue = features[f].getOtherData(od);
1578               if (keyValue.getKey().startsWith("LINK"))
1579               {
1580                 sf.addLink(keyValue.getValue());
1581               }
1582               else
1583               {
1584                 sf.setValue(keyValue.getKey(), keyValue.getValue());
1585               }
1586
1587             }
1588
1589             al.getSequenceAt(i).getDatasetSequence().addSequenceFeature(sf);
1590           }
1591         }
1592         if (vamsasSeq[i].getDBRefCount() > 0)
1593         {
1594           addDBRefs(al.getSequenceAt(i).getDatasetSequence(), vamsasSeq[i]);
1595         }
1596         if (JSEQ[i].getPdbidsCount() > 0)
1597         {
1598           Pdbids[] ids = JSEQ[i].getPdbids();
1599           for (int p = 0; p < ids.length; p++)
1600           {
1601             jalview.datamodel.PDBEntry entry = new jalview.datamodel.PDBEntry();
1602             entry.setId(ids[p].getId());
1603             entry.setType(ids[p].getType());
1604             if (ids[p].getFile() != null)
1605             {
1606               if (!pdbloaded.containsKey(ids[p].getFile()))
1607               {
1608                 entry.setFile(loadPDBFile(file, ids[p].getId()));
1609               }
1610               else
1611               {
1612                 entry.setFile(pdbloaded.get(ids[p].getId()).toString());
1613               }
1614             }
1615
1616             al.getSequenceAt(i).getDatasetSequence().addPDBId(entry);
1617           }
1618         }
1619       }
1620     }
1621
1622     // ///////////////////////////////
1623     // LOAD SEQUENCE MAPPINGS
1624     if (vamsasSet.getAlcodonFrameCount() > 0)
1625     {
1626       AlcodonFrame[] alc = vamsasSet.getAlcodonFrame();
1627       for (int i = 0; i < alc.length; i++)
1628       {
1629         jalview.datamodel.AlignedCodonFrame cf = new jalview.datamodel.AlignedCodonFrame(
1630                 alc[i].getAlcodonCount());
1631         if (alc[i].getAlcodonCount() > 0)
1632         {
1633           Alcodon[] alcods = alc[i].getAlcodon();
1634           for (int p = 0; p < cf.codons.length; p++)
1635           {
1636             cf.codons[p] = new int[3];
1637             cf.codons[p][0] = (int) alcods[p].getPos1();
1638             cf.codons[p][1] = (int) alcods[p].getPos2();
1639             cf.codons[p][2] = (int) alcods[p].getPos3();
1640           }
1641         }
1642         if (alc[i].getAlcodMapCount() > 0)
1643         {
1644           AlcodMap[] maps = alc[i].getAlcodMap();
1645           for (int m = 0; m < maps.length; m++)
1646           {
1647             SequenceI dnaseq = (SequenceI) seqRefIds
1648                     .get(maps[m].getDnasq());
1649             // Load Mapping
1650             jalview.datamodel.Mapping mapping = null;
1651             // attach to dna sequence reference.
1652             if (maps[m].getMapping() != null)
1653             {
1654               mapping = addMapping(maps[m].getMapping());
1655             }
1656             if (dnaseq != null)
1657             {
1658               cf.addMap(dnaseq, mapping.getTo(), mapping.getMap());
1659             }
1660             else
1661             {
1662               // defer to later
1663               frefedSequence.add(new Object[]
1664               { maps[m].getDnasq(), cf, mapping });
1665             }
1666           }
1667         }
1668         al.addCodonFrame(cf);
1669       }
1670
1671     }
1672
1673     // ////////////////////////////////
1674     // LOAD ANNOTATIONS
1675     boolean hideQuality = true, hideConservation = true, hideConsensus = true;
1676
1677     if (vamsasSet.getAnnotationCount() > 0)
1678     {
1679       Annotation[] an = vamsasSet.getAnnotation();
1680
1681       for (int i = 0; i < an.length; i++)
1682       {
1683         if (an[i].getLabel().equals("Quality"))
1684         {
1685           hideQuality = false;
1686           continue;
1687         }
1688         else if (an[i].getLabel().equals("Conservation"))
1689         {
1690           hideConservation = false;
1691           continue;
1692         }
1693         else if (an[i].getLabel().equals("Consensus"))
1694         {
1695           hideConsensus = false;
1696           continue;
1697         }
1698
1699         if (an[i].getId() != null
1700                 && annotationIds.containsKey(an[i].getId()))
1701         {
1702           jalview.datamodel.AlignmentAnnotation jda = (jalview.datamodel.AlignmentAnnotation) annotationIds
1703                   .get(an[i].getId());
1704           if (an[i].hasVisible())
1705             jda.visible = an[i].getVisible();
1706
1707           al.addAnnotation(jda);
1708
1709           continue;
1710         }
1711
1712         AnnotationElement[] ae = an[i].getAnnotationElement();
1713         jalview.datamodel.Annotation[] anot = null;
1714
1715         if (!an[i].getScoreOnly())
1716         {
1717           anot = new jalview.datamodel.Annotation[al.getWidth()];
1718
1719           for (int aa = 0; aa < ae.length && aa < anot.length; aa++)
1720           {
1721             if (ae[aa].getPosition() >= anot.length)
1722               continue;
1723
1724             anot[ae[aa].getPosition()] = new jalview.datamodel.Annotation(
1725
1726             ae[aa].getDisplayCharacter(), ae[aa].getDescription(), (ae[aa]
1727                     .getSecondaryStructure() == null || ae[aa]
1728                     .getSecondaryStructure().length() == 0) ? ' ' : ae[aa]
1729                     .getSecondaryStructure().charAt(0), ae[aa].getValue()
1730
1731             );
1732             // JBPNote: Consider verifying dataflow for IO of secondary
1733             // structure annotation read from Stockholm files
1734             // this was added to try to ensure that
1735             // if (anot[ae[aa].getPosition()].secondaryStructure>' ')
1736             // {
1737             // anot[ae[aa].getPosition()].displayCharacter = "";
1738             // }
1739             anot[ae[aa].getPosition()].colour = new java.awt.Color(ae[aa]
1740                     .getColour());
1741           }
1742         }
1743         jalview.datamodel.AlignmentAnnotation jaa = null;
1744
1745         if (an[i].getGraph())
1746         {
1747           jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(),
1748                   an[i].getDescription(), anot, 0, 0, an[i].getGraphType());
1749
1750           jaa.graphGroup = an[i].getGraphGroup();
1751
1752           if (an[i].getThresholdLine() != null)
1753           {
1754             jaa.setThreshold(new jalview.datamodel.GraphLine(an[i]
1755                     .getThresholdLine().getValue(), an[i]
1756                     .getThresholdLine().getLabel(), new java.awt.Color(
1757                     an[i].getThresholdLine().getColour())));
1758
1759           }
1760
1761         }
1762         else
1763         {
1764           jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(),
1765                   an[i].getDescription(), anot);
1766         }
1767
1768         if (an[i].getId() != null)
1769         {
1770           annotationIds.put(an[i].getId(), jaa);
1771           jaa.annotationId = an[i].getId();
1772         }
1773
1774         if (an[i].getSequenceRef() != null)
1775         {
1776           if (al.findName(an[i].getSequenceRef()) != null)
1777           {
1778             jaa.createSequenceMapping(al.findName(an[i].getSequenceRef()),
1779                     1, true);
1780             al.findName(an[i].getSequenceRef()).addAlignmentAnnotation(jaa);
1781           }
1782         }
1783         if (an[i].hasScore())
1784         {
1785           jaa.setScore(an[i].getScore());
1786         }
1787
1788         if (an[i].hasVisible())
1789           jaa.visible = an[i].getVisible();
1790
1791         al.addAnnotation(jaa);
1792       }
1793     }
1794
1795     // ///////////////////////
1796     // LOAD GROUPS
1797     if (jms.getJGroupCount() > 0)
1798     {
1799       JGroup[] groups = jms.getJGroup();
1800
1801       for (int i = 0; i < groups.length; i++)
1802       {
1803         ColourSchemeI cs = null;
1804
1805         if (groups[i].getColour() != null)
1806         {
1807           if (groups[i].getColour().startsWith("ucs"))
1808           {
1809             cs = GetUserColourScheme(jms, groups[i].getColour());
1810           }
1811           else
1812           {
1813             cs = ColourSchemeProperty.getColour(al, groups[i].getColour());
1814           }
1815
1816           if (cs != null)
1817           {
1818             cs.setThreshold(groups[i].getPidThreshold(), true);
1819           }
1820         }
1821
1822         Vector seqs = new Vector();
1823
1824         for (int s = 0; s < groups[i].getSeqCount(); s++)
1825         {
1826           String seqId = groups[i].getSeq(s) + "";
1827           jalview.datamodel.SequenceI ts = (jalview.datamodel.SequenceI) seqRefIds
1828                   .get(seqId);
1829
1830           if (ts != null)
1831           {
1832             seqs.addElement(ts);
1833           }
1834         }
1835
1836         if (seqs.size() < 1)
1837         {
1838           continue;
1839         }
1840
1841         jalview.datamodel.SequenceGroup sg = new jalview.datamodel.SequenceGroup(
1842                 seqs, groups[i].getName(), cs, groups[i].getDisplayBoxes(),
1843                 groups[i].getDisplayText(), groups[i].getColourText(),
1844                 groups[i].getStart(), groups[i].getEnd());
1845
1846         sg
1847                 .setOutlineColour(new java.awt.Color(groups[i]
1848                         .getOutlineColour()));
1849
1850         sg.textColour = new java.awt.Color(groups[i].getTextCol1());
1851         sg.textColour2 = new java.awt.Color(groups[i].getTextCol2());
1852         sg.thresholdTextColour = groups[i].getTextColThreshold();
1853
1854         if (groups[i].getConsThreshold() != 0)
1855         {
1856           jalview.analysis.Conservation c = new jalview.analysis.Conservation(
1857                   "All", ResidueProperties.propHash, 3, sg
1858                           .getSequences(null), 0, sg.getWidth() - 1);
1859           c.calculate();
1860           c.verdict(false, 25);
1861           sg.cs.setConservation(c);
1862         }
1863
1864         al.addGroup(sg);
1865       }
1866     }
1867
1868     // ///////////////////////////////
1869     // LOAD VIEWPORT
1870
1871     AlignFrame af = new AlignFrame(al, view.getWidth(), view.getHeight());
1872
1873     af.setFileName(file, "Jalview");
1874
1875     for (int i = 0; i < JSEQ.length; i++)
1876     {
1877       af.viewport.setSequenceColour(af.viewport.alignment.getSequenceAt(i),
1878               new java.awt.Color(JSEQ[i].getColour()));
1879     }
1880
1881     // If we just load in the same jar file again, the sequenceSetId
1882     // will be the same, and we end up with multiple references
1883     // to the same sequenceSet. We must modify this id on load
1884     // so that each load of the file gives a unique id
1885     String uniqueSeqSetId = view.getSequenceSetId() + uniqueSetSuffix;
1886
1887     af.viewport.gatherViewsHere = view.getGatheredViews();
1888
1889     if (view.getSequenceSetId() != null)
1890     {
1891       jalview.gui.AlignViewport av = (jalview.gui.AlignViewport) viewportsAdded
1892               .get(uniqueSeqSetId);
1893
1894       af.viewport.sequenceSetID = uniqueSeqSetId;
1895       if (av != null)
1896       {
1897
1898         af.viewport.historyList = av.historyList;
1899         af.viewport.redoList = av.redoList;
1900       }
1901       else
1902       {
1903         viewportsAdded.put(uniqueSeqSetId, af.viewport);
1904       }
1905
1906       PaintRefresher.Register(af.alignPanel, uniqueSeqSetId);
1907     }
1908     if (hiddenSeqs != null)
1909     {
1910       for (int s = 0; s < JSEQ.length; s++)
1911       {
1912         jalview.datamodel.SequenceGroup hidden = new jalview.datamodel.SequenceGroup();
1913
1914         for (int r = 0; r < JSEQ[s].getHiddenSequencesCount(); r++)
1915         {
1916           hidden.addSequence(al
1917                   .getSequenceAt(JSEQ[s].getHiddenSequences(r)), false);
1918         }
1919         af.viewport.hideRepSequences(al.getSequenceAt(s), hidden);
1920       }
1921
1922       jalview.datamodel.SequenceI[] hseqs = new jalview.datamodel.SequenceI[hiddenSeqs
1923               .size()];
1924
1925       for (int s = 0; s < hiddenSeqs.size(); s++)
1926       {
1927         hseqs[s] = (jalview.datamodel.SequenceI) hiddenSeqs.elementAt(s);
1928       }
1929
1930       af.viewport.hideSequence(hseqs);
1931
1932     }
1933
1934     if ((hideConsensus || hideQuality || hideConservation)
1935             && al.getAlignmentAnnotation() != null)
1936     {
1937       int hSize = al.getAlignmentAnnotation().length;
1938       for (int h = 0; h < hSize; h++)
1939       {
1940         if ((hideConsensus && al.getAlignmentAnnotation()[h].label
1941                 .equals("Consensus"))
1942                 || (hideQuality && al.getAlignmentAnnotation()[h].label
1943                         .equals("Quality"))
1944                 || (hideConservation && al.getAlignmentAnnotation()[h].label
1945                         .equals("Conservation")))
1946         {
1947           al.deleteAnnotation(al.getAlignmentAnnotation()[h]);
1948           hSize--;
1949           h--;
1950         }
1951       }
1952       af.alignPanel.adjustAnnotationHeight();
1953     }
1954
1955     if (view.getViewName() != null)
1956     {
1957       af.viewport.viewName = view.getViewName();
1958       af.setInitialTabVisible();
1959     }
1960     af.setBounds(view.getXpos(), view.getYpos(), view.getWidth(), view
1961             .getHeight());
1962
1963     af.viewport.setShowAnnotation(view.getShowAnnotation());
1964     af.viewport.setAbovePIDThreshold(view.getPidSelected());
1965
1966     af.viewport.setColourText(view.getShowColourText());
1967
1968     af.viewport.setConservationSelected(view.getConservationSelected());
1969     af.viewport.setShowJVSuffix(view.getShowFullId());
1970     af.viewport.rightAlignIds = view.getRightAlignIds();
1971     af.viewport.setFont(new java.awt.Font(view.getFontName(), view
1972             .getFontStyle(), view.getFontSize()));
1973     af.alignPanel.fontChanged();
1974     af.viewport.setRenderGaps(view.getRenderGaps());
1975     af.viewport.setWrapAlignment(view.getWrapAlignment());
1976     af.alignPanel.setWrapAlignment(view.getWrapAlignment());
1977     af.viewport.setShowAnnotation(view.getShowAnnotation());
1978     af.alignPanel.setAnnotationVisible(view.getShowAnnotation());
1979
1980     af.viewport.setShowBoxes(view.getShowBoxes());
1981
1982     af.viewport.setShowText(view.getShowText());
1983
1984     af.viewport.textColour = new java.awt.Color(view.getTextCol1());
1985     af.viewport.textColour2 = new java.awt.Color(view.getTextCol2());
1986     af.viewport.thresholdTextColour = view.getTextColThreshold();
1987
1988     af.viewport.setStartRes(view.getStartRes());
1989     af.viewport.setStartSeq(view.getStartSeq());
1990
1991     ColourSchemeI cs = null;
1992
1993     if (view.getBgColour() != null)
1994     {
1995       if (view.getBgColour().startsWith("ucs"))
1996       {
1997         cs = GetUserColourScheme(jms, view.getBgColour());
1998       }
1999       else if (view.getBgColour().startsWith("Annotation"))
2000       {
2001         // int find annotation
2002         for (int i = 0; i < af.viewport.alignment.getAlignmentAnnotation().length; i++)
2003         {
2004           if (af.viewport.alignment.getAlignmentAnnotation()[i].label
2005                   .equals(view.getAnnotationColours().getAnnotation()))
2006           {
2007             if (af.viewport.alignment.getAlignmentAnnotation()[i]
2008                     .getThreshold() == null)
2009             {
2010               af.viewport.alignment.getAlignmentAnnotation()[i]
2011                       .setThreshold(new jalview.datamodel.GraphLine(view
2012                               .getAnnotationColours().getThreshold(),
2013                               "Threshold", java.awt.Color.black)
2014
2015                       );
2016             }
2017
2018             if (view.getAnnotationColours().getColourScheme()
2019                     .equals("None"))
2020             {
2021               cs = new AnnotationColourGradient(af.viewport.alignment
2022                       .getAlignmentAnnotation()[i], new java.awt.Color(view
2023                       .getAnnotationColours().getMinColour()),
2024                       new java.awt.Color(view.getAnnotationColours()
2025                               .getMaxColour()), view.getAnnotationColours()
2026                               .getAboveThreshold());
2027             }
2028             else if (view.getAnnotationColours().getColourScheme()
2029                     .startsWith("ucs"))
2030             {
2031               cs = new AnnotationColourGradient(af.viewport.alignment
2032                       .getAlignmentAnnotation()[i], GetUserColourScheme(
2033                       jms, view.getAnnotationColours().getColourScheme()),
2034                       view.getAnnotationColours().getAboveThreshold());
2035             }
2036             else
2037             {
2038               cs = new AnnotationColourGradient(af.viewport.alignment
2039                       .getAlignmentAnnotation()[i], ColourSchemeProperty
2040                       .getColour(al, view.getAnnotationColours()
2041                               .getColourScheme()), view
2042                       .getAnnotationColours().getAboveThreshold());
2043             }
2044
2045             // Also use these settings for all the groups
2046             if (al.getGroups() != null)
2047             {
2048               for (int g = 0; g < al.getGroups().size(); g++)
2049               {
2050                 jalview.datamodel.SequenceGroup sg = (jalview.datamodel.SequenceGroup) al
2051                         .getGroups().elementAt(g);
2052
2053                 if (sg.cs == null)
2054                 {
2055                   continue;
2056                 }
2057
2058                 /*
2059                  * if
2060                  * (view.getAnnotationColours().getColourScheme().equals("None")) {
2061                  * sg.cs = new AnnotationColourGradient(
2062                  * af.viewport.alignment.getAlignmentAnnotation()[i], new
2063                  * java.awt.Color(view.getAnnotationColours(). getMinColour()),
2064                  * new java.awt.Color(view.getAnnotationColours().
2065                  * getMaxColour()),
2066                  * view.getAnnotationColours().getAboveThreshold()); } else
2067                  */
2068                 {
2069                   sg.cs = new AnnotationColourGradient(
2070                           af.viewport.alignment.getAlignmentAnnotation()[i],
2071                           sg.cs, view.getAnnotationColours()
2072                                   .getAboveThreshold());
2073                 }
2074
2075               }
2076             }
2077
2078             break;
2079           }
2080
2081         }
2082       }
2083       else
2084       {
2085         cs = ColourSchemeProperty.getColour(al, view.getBgColour());
2086       }
2087
2088       if (cs != null)
2089       {
2090         cs.setThreshold(view.getPidThreshold(), true);
2091         cs.setConsensus(af.viewport.hconsensus);
2092       }
2093     }
2094
2095     af.viewport.setGlobalColourScheme(cs);
2096     af.viewport.setColourAppliesToAllGroups(false);
2097
2098     if (view.getConservationSelected() && cs != null)
2099     {
2100       cs.setConservationInc(view.getConsThreshold());
2101     }
2102
2103     af.changeColour(cs);
2104
2105     af.viewport.setColourAppliesToAllGroups(true);
2106
2107     if (view.getShowSequenceFeatures())
2108     {
2109       af.viewport.showSequenceFeatures = true;
2110     }
2111
2112     if (jms.getFeatureSettings() != null)
2113     {
2114       af.viewport.featuresDisplayed = new Hashtable();
2115       String[] renderOrder = new String[jms.getFeatureSettings()
2116               .getSettingCount()];
2117       for (int fs = 0; fs < jms.getFeatureSettings().getSettingCount(); fs++)
2118       {
2119         Setting setting = jms.getFeatureSettings().getSetting(fs);
2120
2121         af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setColour(
2122                 setting.getType(), new java.awt.Color(setting.getColour()));
2123         renderOrder[fs] = setting.getType();
2124         if (setting.hasOrder())
2125           af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setOrder(
2126                   setting.getType(), setting.getOrder());
2127         else
2128           af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setOrder(
2129                   setting.getType(),
2130                   fs / jms.getFeatureSettings().getSettingCount());
2131         if (setting.getDisplay())
2132         {
2133           af.viewport.featuresDisplayed.put(setting.getType(), new Integer(
2134                   setting.getColour()));
2135         }
2136       }
2137       af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().renderOrder = renderOrder;
2138       Hashtable fgtable;
2139       af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().featureGroups = fgtable = new Hashtable();
2140       for (int gs = 0; gs < jms.getFeatureSettings().getGroupCount(); gs++)
2141       {
2142         Group grp = jms.getFeatureSettings().getGroup(gs);
2143         fgtable.put(grp.getName(), new Boolean(grp.getDisplay()));
2144       }
2145     }
2146
2147     if (view.getHiddenColumnsCount() > 0)
2148     {
2149       for (int c = 0; c < view.getHiddenColumnsCount(); c++)
2150       {
2151         af.viewport.hideColumns(view.getHiddenColumns(c).getStart(), view
2152                 .getHiddenColumns(c).getEnd() // +1
2153                 );
2154       }
2155     }
2156
2157     af.setMenusFromViewport(af.viewport);
2158
2159     Desktop.addInternalFrame(af, view.getTitle(), view.getWidth(), view
2160             .getHeight());
2161
2162     // LOAD TREES
2163     // /////////////////////////////////////
2164     if (loadTreesAndStructures && jms.getTreeCount() > 0)
2165     {
2166       try
2167       {
2168         for (int t = 0; t < jms.getTreeCount(); t++)
2169         {
2170
2171           Tree tree = jms.getTree(t);
2172
2173           TreePanel tp = af.ShowNewickTree(new jalview.io.NewickFile(tree
2174                   .getNewick()), tree.getTitle(), tree.getWidth(), tree
2175                   .getHeight(), tree.getXpos(), tree.getYpos());
2176
2177           tp.fitToWindow.setState(tree.getFitToWindow());
2178           tp.fitToWindow_actionPerformed(null);
2179
2180           if (tree.getFontName() != null)
2181           {
2182             tp.setTreeFont(new java.awt.Font(tree.getFontName(), tree
2183                     .getFontStyle(), tree.getFontSize()));
2184           }
2185           else
2186           {
2187             tp.setTreeFont(new java.awt.Font(view.getFontName(), view
2188                     .getFontStyle(), tree.getFontSize()));
2189           }
2190
2191           tp.showPlaceholders(tree.getMarkUnlinked());
2192           tp.showBootstrap(tree.getShowBootstrap());
2193           tp.showDistances(tree.getShowDistances());
2194
2195           tp.treeCanvas.threshold = tree.getThreshold();
2196
2197           if (tree.getCurrentTree())
2198           {
2199             af.viewport.setCurrentTree(tp.getTree());
2200           }
2201         }
2202
2203       } catch (Exception ex)
2204       {
2205         ex.printStackTrace();
2206       }
2207     }
2208
2209     // //LOAD STRUCTURES
2210     if (loadTreesAndStructures)
2211     {
2212       for (int i = 0; i < JSEQ.length; i++)
2213       {
2214         if (JSEQ[i].getPdbidsCount() > 0)
2215         {
2216           Pdbids[] ids = JSEQ[i].getPdbids();
2217           for (int p = 0; p < ids.length; p++)
2218           {
2219             for (int s = 0; s < ids[p].getStructureStateCount(); s++)
2220             {
2221               jalview.datamodel.PDBEntry jpdb = new jalview.datamodel.PDBEntry();
2222
2223               jpdb.setFile(loadPDBFile(ids[p].getFile(), ids[p].getId()));
2224               jpdb.setId(ids[p].getId());
2225
2226               int x = ids[p].getStructureState(s).getXpos();
2227               int y = ids[p].getStructureState(s).getYpos();
2228               int width = ids[p].getStructureState(s).getWidth();
2229               int height = ids[p].getStructureState(s).getHeight();
2230
2231               java.awt.Component comp = null;
2232
2233               JInternalFrame[] frames = null;
2234               do
2235               {
2236                 try
2237                 {
2238                   frames = Desktop.desktop.getAllFrames();
2239                 } catch (ArrayIndexOutOfBoundsException e)
2240                 {
2241                   // occasional No such child exceptions are thrown here...
2242                   frames = null;
2243                   try
2244                   {
2245                     Thread.sleep(10);
2246                   } catch (Exception f)
2247                   {
2248                   }
2249                   ;
2250                 }
2251               } while (frames == null);
2252               for (int f = 0; f < frames.length; f++)
2253               {
2254                 if (frames[f] instanceof AppJmol)
2255                 {
2256                   if (frames[f].getX() == x && frames[f].getY() == y
2257                           && frames[f].getHeight() == height
2258                           && frames[f].getWidth() == width)
2259                   {
2260                     comp = frames[f];
2261                     break;
2262                   }
2263                 }
2264               }
2265
2266               Desktop.desktop.getComponentAt(x, y);
2267
2268               String pdbFile = loadPDBFile(file, ids[p].getId());
2269
2270               jalview.datamodel.SequenceI[] seq = new jalview.datamodel.SequenceI[]
2271               { (jalview.datamodel.SequenceI) seqRefIds.get(JSEQ[i].getId()
2272                       + "") };
2273
2274               if (comp == null)
2275               {
2276                 String state = ids[p].getStructureState(s).getContent();
2277
2278                 StringBuffer newFileLoc = new StringBuffer(state.substring(
2279                         0, state.indexOf("\"", state.indexOf("load")) + 1));
2280
2281                 newFileLoc.append(jpdb.getFile());
2282                 newFileLoc.append(state.substring(state.indexOf("\"", state
2283                         .indexOf("load \"") + 6)));
2284
2285                 new AppJmol(pdbFile, ids[p].getId(), seq, af.alignPanel,
2286                         newFileLoc.toString(), new java.awt.Rectangle(x, y,
2287                                 width, height));
2288
2289               }
2290               else if (comp != null)
2291               {
2292                 StructureSelectionManager.getStructureSelectionManager()
2293                         .setMapping(seq, null, pdbFile,
2294                                 jalview.io.AppletFormatAdapter.FILE);
2295
2296                 ((AppJmol) comp).addSequence(seq);
2297               }
2298             }
2299           }
2300         }
2301       }
2302     }
2303
2304     return af;
2305   }
2306
2307   private void recoverDatasetFor(SequenceSet vamsasSet, Alignment al)
2308   {
2309     jalview.datamodel.Alignment ds = getDatasetFor(vamsasSet.getDatasetId());
2310     Vector dseqs = null;
2311     if (ds == null)
2312     {
2313       // create a list of new dataset sequences
2314       dseqs = new Vector();
2315     }
2316     for (int i = 0, iSize = vamsasSet.getSequenceCount(); i < iSize; i++)
2317     {
2318       Sequence vamsasSeq = vamsasSet.getSequence(i);
2319       ensureJalviewDatasetSequence(vamsasSeq, ds, dseqs);
2320     }
2321     // create a new dataset
2322     if (ds == null)
2323     {
2324       SequenceI[] dsseqs = new SequenceI[dseqs.size()];
2325       dseqs.copyInto(dsseqs);
2326       ds = new jalview.datamodel.Alignment(dsseqs);
2327       addDatasetRef(vamsasSet.getDatasetId(), ds);
2328     }
2329     // set the dataset for the newly imported alignment.
2330     if (al.getDataset() == null)
2331     {
2332       al.setDataset(ds);
2333     }
2334   }
2335
2336   /**
2337    *
2338    * @param vamsasSeq
2339    *                sequence definition to create/merge dataset sequence for
2340    * @param ds
2341    *                dataset alignment
2342    * @param dseqs
2343    *                vector to add new dataset sequence to
2344    */
2345   private void ensureJalviewDatasetSequence(Sequence vamsasSeq,
2346           AlignmentI ds, Vector dseqs)
2347   {
2348     // JBP TODO: Check this is called for AlCodonFrames to support recovery of
2349     // xRef Codon Maps
2350     jalview.datamodel.Sequence sq = (jalview.datamodel.Sequence) seqRefIds
2351             .get(vamsasSeq.getId());
2352     jalview.datamodel.SequenceI dsq = null;
2353     if (sq != null && sq.getDatasetSequence() != null)
2354     {
2355       dsq = (jalview.datamodel.SequenceI) sq.getDatasetSequence();
2356     }
2357
2358     String sqid = vamsasSeq.getDsseqid();
2359     if (dsq == null)
2360     {
2361       // need to create or add a new dataset sequence reference to this sequence
2362       if (sqid != null)
2363       {
2364         dsq = (jalview.datamodel.SequenceI) seqRefIds.get(sqid);
2365       }
2366       // check again
2367       if (dsq == null)
2368       {
2369         // make a new dataset sequence
2370         dsq = sq.createDatasetSequence();
2371         if (sqid == null)
2372         {
2373           // make up a new dataset reference for this sequence
2374           sqid = seqHash(dsq);
2375         }
2376         dsq.setVamsasId(uniqueSetSuffix + sqid);
2377         seqRefIds.put(sqid, dsq);
2378         if (ds == null)
2379         {
2380           if (dseqs != null)
2381           {
2382             dseqs.addElement(dsq);
2383           }
2384         }
2385         else
2386         {
2387           ds.addSequence(dsq);
2388         }
2389       }
2390       else
2391       {
2392         if (sq != dsq)
2393         { // make this dataset sequence sq's dataset sequence
2394           sq.setDatasetSequence(dsq);
2395         }
2396       }
2397     }
2398     // TODO: refactor this as a merge dataset sequence function
2399     // now check that sq (the dataset sequence) sequence really is the union of
2400     // all references to it
2401     // boolean pre = sq.getStart() < dsq.getStart();
2402     // boolean post = sq.getEnd() > dsq.getEnd();
2403     // if (pre || post)
2404     if (sq != dsq)
2405     {
2406       StringBuffer sb = new StringBuffer();
2407       String newres = jalview.analysis.AlignSeq.extractGaps(
2408               jalview.util.Comparison.GapChars, sq.getSequenceAsString());
2409       if (!newres.equalsIgnoreCase(dsq.getSequenceAsString())
2410               && newres.length() > dsq.getLength())
2411       {
2412         // Update with the longer sequence.
2413         synchronized (dsq)
2414         {
2415           /*
2416            * if (pre) { sb.insert(0, newres .substring(0, dsq.getStart() -
2417            * sq.getStart())); dsq.setStart(sq.getStart()); } if (post) {
2418            * sb.append(newres.substring(newres.length() - sq.getEnd() -
2419            * dsq.getEnd())); dsq.setEnd(sq.getEnd()); }
2420            */
2421           dsq.setSequence(sb.toString());
2422         }
2423         // TODO: merges will never happen if we 'know' we have the real dataset
2424         // sequence - this should be detected when id==dssid
2425         System.err.println("DEBUG Notice:  Merged dataset sequence"); // ("
2426         // + (pre ? "prepended" : "") + " "
2427         // + (post ? "appended" : ""));
2428       }
2429     }
2430   }
2431
2432   java.util.Hashtable datasetIds = null;
2433
2434   private Alignment getDatasetFor(String datasetId)
2435   {
2436     if (datasetIds == null)
2437     {
2438       datasetIds = new Hashtable();
2439       return null;
2440     }
2441     if (datasetIds.containsKey(datasetId))
2442     {
2443       return (Alignment) datasetIds.get(datasetId);
2444     }
2445     return null;
2446   }
2447
2448   private void addDatasetRef(String datasetId, Alignment dataset)
2449   {
2450     if (datasetIds == null)
2451     {
2452       datasetIds = new Hashtable();
2453     }
2454     datasetIds.put(datasetId, dataset);
2455   }
2456
2457   private void addDBRefs(SequenceI datasetSequence, Sequence sequence)
2458   {
2459     for (int d = 0; d < sequence.getDBRefCount(); d++)
2460     {
2461       DBRef dr = sequence.getDBRef(d);
2462       jalview.datamodel.DBRefEntry entry = new jalview.datamodel.DBRefEntry(
2463               sequence.getDBRef(d).getSource(), sequence.getDBRef(d)
2464                       .getVersion(), sequence.getDBRef(d).getAccessionId());
2465       if (dr.getMapping() != null)
2466       {
2467         entry.setMap(addMapping(dr.getMapping()));
2468       }
2469       datasetSequence.addDBRef(entry);
2470     }
2471   }
2472
2473   private jalview.datamodel.Mapping addMapping(Mapping m)
2474   {
2475     SequenceI dsto = null;
2476     // Mapping m = dr.getMapping();
2477     int fr[] = new int[m.getMapListFromCount() * 2];
2478     Enumeration f = m.enumerateMapListFrom();
2479     for (int _i = 0; f.hasMoreElements(); _i += 2)
2480     {
2481       MapListFrom mf = (MapListFrom) f.nextElement();
2482       fr[_i] = mf.getStart();
2483       fr[_i + 1] = mf.getEnd();
2484     }
2485     int fto[] = new int[m.getMapListToCount() * 2];
2486     f = m.enumerateMapListTo();
2487     for (int _i = 0; f.hasMoreElements(); _i += 2)
2488     {
2489       MapListTo mf = (MapListTo) f.nextElement();
2490       fto[_i] = mf.getStart();
2491       fto[_i + 1] = mf.getEnd();
2492     }
2493     jalview.datamodel.Mapping jmap = new jalview.datamodel.Mapping(dsto,
2494             fr, fto, (int) m.getMapFromUnit(), (int) m.getMapToUnit());
2495     if (m.getMappingChoice() != null)
2496     {
2497       MappingChoice mc = m.getMappingChoice();
2498       if (mc.getDseqFor() != null)
2499       {
2500         if (seqRefIds.containsKey(mc.getDseqFor()))
2501         {
2502           /**
2503            * recover from hash
2504            */
2505           jmap.setTo((SequenceI) seqRefIds.get(mc.getDseqFor()));
2506         }
2507         else
2508         {
2509           frefedSequence.add(new Object[]
2510           { mc.getDseqFor(), jmap });
2511         }
2512       }
2513       else
2514       {
2515         /**
2516          * local sequence definition
2517          */
2518         Sequence ms = mc.getSequence();
2519         jalview.datamodel.Sequence djs = null;
2520         String sqid = ms.getDsseqid();
2521         if (sqid != null && sqid.length() > 0)
2522         {
2523           /*
2524            * recover dataset sequence
2525            */
2526           djs = (jalview.datamodel.Sequence) seqRefIds.get(sqid);
2527         }
2528         else
2529         {
2530           System.err
2531                   .println("Warning - making up dataset sequence id for DbRef sequence map reference");
2532           sqid = ((Object) ms).toString(); // make up a new hascode for
2533                                             // undefined dataset sequence hash
2534                                             // (unlikely to happen)
2535         }
2536
2537         if (djs == null)
2538         {
2539           /**
2540            * make a new dataset sequence and add it to refIds hash
2541            */
2542           djs = new jalview.datamodel.Sequence(ms.getName(), ms
2543                   .getSequence());
2544           djs.setStart(jmap.getMap().getToLowest());
2545           djs.setEnd(jmap.getMap().getToHighest());
2546           djs.setVamsasId(uniqueSetSuffix + sqid);
2547           jmap.setTo(djs);
2548           seqRefIds.put(sqid, djs);
2549
2550         }
2551         jalview.bin.Cache.log.debug("about to recurse on addDBRefs.");
2552         addDBRefs(djs, ms);
2553
2554       }
2555     }
2556     return (jmap);
2557
2558   }
2559
2560   public jalview.gui.AlignmentPanel copyAlignPanel(AlignmentPanel ap,
2561           boolean keepSeqRefs)
2562   {
2563     jalview.schemabinding.version2.JalviewModel jm = SaveState(ap, null,
2564             null);
2565
2566     if (!keepSeqRefs)
2567     {
2568       clearSeqRefs();
2569       jm.getJalviewModelSequence().getViewport(0).setSequenceSetId(null);
2570     }
2571     else
2572     {
2573       uniqueSetSuffix = "";
2574     }
2575
2576     viewportsAdded = new Hashtable();
2577
2578     AlignFrame af = LoadFromObject(jm, null, false);
2579     af.alignPanels.clear();
2580     af.closeMenuItem_actionPerformed(true);
2581
2582     /*
2583      * if(ap.av.alignment.getAlignmentAnnotation()!=null) { for(int i=0; i<ap.av.alignment.getAlignmentAnnotation().length;
2584      * i++) { if(!ap.av.alignment.getAlignmentAnnotation()[i].autoCalculated) {
2585      * af.alignPanel.av.alignment.getAlignmentAnnotation()[i] =
2586      * ap.av.alignment.getAlignmentAnnotation()[i]; } } }
2587      */
2588
2589     return af.alignPanel;
2590   }
2591
2592   /*
2593    * (non-Javadoc)
2594    *
2595    * @see java.lang.Object#finalize()
2596    */
2597   protected void finalize() throws Throwable
2598   {
2599     // really make sure we have no buried refs left.
2600     clearSeqRefs();
2601     this.seqRefIds = null;
2602     this.seqsToIds = null;
2603     super.finalize();
2604   }
2605
2606 }