src/jalview/gui/Jalview2XML.java

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