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 import jalview.schemabinding.version2.*;
  30 import jalview.schemes.*;
  31 import jalview.structure.StructureSelectionManager;
  32
  33 /**
  34  * DOCUMENT ME!
  35  *
  36  * @author $author$
  37  * @version $Revision$
  38  */
  39 public class Jalview2XML
  40 {
  41
  42   Hashtable seqRefIds;
  43
  44   /**
  45    * This maintains a list of viewports, the key being the
  46    * seqSetId. Important to set historyItem and redoList
  47    * for multiple views
  48    */
  49   Hashtable viewportsAdded;
  50
  51   Hashtable annotationIds = new Hashtable();
  52
  53   String uniqueSetSuffix = "";
  54   /**
  55    * List of pdbfiles added to Jar
  56    */
  57   Vector pdbfiles = null;
  58
  59   // SAVES SEVERAL ALIGNMENT WINDOWS TO SAME JARFILE
  60   public void SaveState(File statefile)
  61   {
  62     JInternalFrame[] frames = Desktop.desktop.getAllFrames();
  63
  64     if (frames == null)
  65     {
  66       return;
  67     }
  68
  69     try
  70     {
  71       FileOutputStream fos = new FileOutputStream(statefile);
  72       JarOutputStream jout = new JarOutputStream(fos);
  73
  74       //NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS
  75       ////////////////////////////////////////////////////
  76       PrintWriter out = new PrintWriter(new OutputStreamWriter(jout,
  77           "UTF-8"));
  78
  79       Vector shortNames = new Vector();
  80
  81       //REVERSE ORDER
  82       for (int i = frames.length - 1; i > -1; i--)
  83       {
  84         if (frames[i] instanceof AlignFrame)
  85         {
  86           AlignFrame af = (AlignFrame) frames[i];
  87
  88           String shortName = af.getTitle();
  89
  90           if (shortName.indexOf(File.separatorChar) > -1)
  91           {
  92             shortName = shortName.substring(shortName.lastIndexOf(
  93                 File.separatorChar) + 1);
  94           }
  95
  96           int count = 1;
  97
  98           while (shortNames.contains(shortName))
  99           {
 100             if (shortName.endsWith("_" + (count - 1)))
 101             {
 102               shortName = shortName.substring(0,
 103                                               shortName.lastIndexOf("_"));
 104             }
 105
 106             shortName = shortName.concat("_" + count);
 107             count++;
 108           }
 109
 110           shortNames.addElement(shortName);
 111
 112           if (!shortName.endsWith(".xml"))
 113           {
 114             shortName = shortName + ".xml";
 115           }
 116
 117           int ap, apSize = af.alignPanels.size();
 118           for (ap = 0; ap < apSize; ap++)
 119           {
 120             AlignmentPanel apanel = (AlignmentPanel) af.alignPanels.
 121                 elementAt(ap);
 122
 123             SaveState(apanel,
 124                       apSize == 1 ? shortName : ap + shortName,
 125                       jout, out);
 126           }
 127         }
 128       }
 129
 130       out.close();
 131       jout.close();
 132     }
 133     catch (Exception ex)
 134     {
 135       ex.printStackTrace();
 136     }
 137   }
 138
 139   // USE THIS METHOD TO SAVE A SINGLE ALIGNMENT WINDOW
 140   public boolean SaveAlignment(AlignFrame af, String jarFile,
 141                                String fileName)
 142   {
 143     try
 144     {
 145       int ap, apSize = af.alignPanels.size();
 146       FileOutputStream fos = new FileOutputStream(jarFile);
 147       JarOutputStream jout = new JarOutputStream(fos);
 148       PrintWriter out = new PrintWriter(new OutputStreamWriter(jout,
 149           "UTF-8"));
 150       for (ap = 0; ap < apSize; ap++)
 151       {
 152         AlignmentPanel apanel = (AlignmentPanel) af.alignPanels.elementAt(ap);
 153
 154         SaveState(apanel,
 155                   apSize == 1 ? fileName : fileName + ap,
 156                   jout, out);
 157       }
 158
 159       out.close();
 160       jout.close();
 161       return true;
 162     }
 163     catch (Exception ex)
 164     {
 165       ex.printStackTrace();
 166       return false;
 167     }
 168   }
 169
 170   /**
 171    * DOCUMENT ME!
 172    *
 173    * @param af DOCUMENT ME!
 174    * @param timeStamp DOCUMENT ME!
 175    * @param fileName DOCUMENT ME!
 176    * @param jout DOCUMENT ME!
 177    * @param out DOCUMENT ME!
 178    */
 179   public JalviewModel SaveState(AlignmentPanel ap,
 180                                 String fileName,
 181                                 JarOutputStream jout,
 182                                 PrintWriter out)
 183   {
 184     if (seqRefIds == null)
 185     {
 186       seqRefIds = new Hashtable();
 187     }
 188
 189     Vector userColours = new Vector();
 190
 191     AlignViewport av = ap.av;
 192
 193     JalviewModel object = new JalviewModel();
 194     object.setVamsasModel(new jalview.schemabinding.version2.VamsasModel());
 195
 196     object.setCreationDate(new java.util.Date(System.currentTimeMillis()));
 197     object.setVersion(jalview.bin.Cache.getProperty("VERSION"));
 198
 199     jalview.datamodel.AlignmentI jal = av.alignment;
 200
 201     if (av.hasHiddenRows)
 202     {
 203       jal = jal.getHiddenSequences().getFullAlignment();
 204     }
 205
 206     SequenceSet vamsasSet = new SequenceSet();
 207     Sequence vamsasSeq;
 208     JalviewModelSequence jms = new JalviewModelSequence();
 209
 210     vamsasSet.setGapChar(jal.getGapCharacter() + "");
 211
 212     JSeq jseq;
 213
 214     //SAVE SEQUENCES
 215     int id = 0;
 216     jalview.datamodel.SequenceI jds;
 217     for (int i = 0; i < jal.getHeight(); i++)
 218     {
 219       jds = jal.getSequenceAt(i);
 220       id = jds.hashCode();
 221
 222       if (seqRefIds.get(id + "") != null)
 223       {
 224
 225       }
 226       else
 227       {
 228         vamsasSeq = new Sequence();
 229         vamsasSeq.setId(id + "");
 230         vamsasSeq.setName(jds.getName());
 231         vamsasSeq.setSequence(jds.getSequenceAsString());
 232         vamsasSeq.setDescription(jds.getDescription());
 233
 234         if (jds.getDatasetSequence().getDBRef() != null)
 235         {
 236           jalview.datamodel.DBRefEntry[] dbrefs =
 237               jds.getDatasetSequence().getDBRef();
 238
 239           for (int d = 0; d < dbrefs.length; d++)
 240           {
 241             DBRef dbref = new DBRef();
 242             dbref.setSource(dbrefs[d].getSource());
 243             dbref.setVersion(dbrefs[d].getVersion());
 244             dbref.setAccessionId(dbrefs[d].getAccessionId());
 245             vamsasSeq.addDBRef(dbref);
 246           }
 247         }
 248
 249         vamsasSet.addSequence(vamsasSeq);
 250         seqRefIds.put(id + "", jal.getSequenceAt(i));
 251       }
 252
 253       jseq = new JSeq();
 254       jseq.setStart(jds.getStart());
 255       jseq.setEnd(jds.getEnd());
 256       jseq.setColour(av.getSequenceColour(jds).getRGB());
 257
 258       jseq.setId(id);
 259
 260       if (av.hasHiddenRows)
 261       {
 262         jseq.setHidden(av.alignment.getHiddenSequences().isHidden(jds));
 263
 264         if (av.hiddenRepSequences != null
 265             && av.hiddenRepSequences.containsKey(jal.getSequenceAt(i)))
 266         {
 267           jalview.datamodel.SequenceI[] reps =
 268               ( (jalview.datamodel.SequenceGroup)
 269                av.hiddenRepSequences.get(
 270                    jal.getSequenceAt(i))).getSequencesInOrder(jal);
 271
 272           for (int h = 0; h < reps.length; h++)
 273           {
 274             if (reps[h] != jal.getSequenceAt(i))
 275             {
 276               jseq.addHiddenSequences(
 277                   jal.findIndex(reps[h])
 278                   );
 279             }
 280           }
 281         }
 282       }
 283
 284       if (jds.getDatasetSequence().getSequenceFeatures() != null)
 285       {
 286         jalview.datamodel.SequenceFeature[] sf
 287             = jds.getDatasetSequence().getSequenceFeatures();
 288         int index = 0;
 289         while (index < sf.length)
 290         {
 291           Features features = new Features();
 292
 293           features.setBegin(sf[index].getBegin());
 294           features.setEnd(sf[index].getEnd());
 295           features.setDescription(sf[index].getDescription());
 296           features.setType(sf[index].getType());
 297           features.setFeatureGroup(sf[index].getFeatureGroup());
 298           features.setScore(sf[index].getScore());
 299           if (sf[index].links != null)
 300           {
 301             for (int l = 0; l < sf[index].links.size(); l++)
 302             {
 303               OtherData keyValue = new OtherData();
 304               keyValue.setKey("LINK_" + l);
 305               keyValue.setValue(sf[index].links.elementAt(l).toString());
 306               features.addOtherData(keyValue);
 307             }
 308           }
 309           if (sf[index].otherDetails != null)
 310           {
 311             String key;
 312             Enumeration keys = sf[index].otherDetails.keys();
 313             while (keys.hasMoreElements())
 314             {
 315               key = keys.nextElement().toString();
 316               OtherData keyValue = new OtherData();
 317               keyValue.setKey(key);
 318               keyValue.setValue(
 319                   sf[index].otherDetails.get(key).toString());
 320               features.addOtherData(keyValue);
 321             }
 322           }
 323
 324           jseq.addFeatures(features);
 325           index++;
 326         }
 327       }
 328
 329       if (jds.getDatasetSequence().getPDBId() != null)
 330       {
 331         Enumeration en = jds.getDatasetSequence().getPDBId().elements();
 332         while (en.hasMoreElements())
 333         {
 334           Pdbids pdb = new Pdbids();
 335           jalview.datamodel.PDBEntry entry
 336               = (jalview.datamodel.PDBEntry) en.nextElement();
 337
 338           pdb.setId(entry.getId());
 339           pdb.setType(entry.getType());
 340
 341           AppJMol jmol;
 342           //This must have been loaded, is it still visible?
 343           JInternalFrame[] frames = Desktop.desktop.getAllFrames();
 344           for (int f = frames.length - 1; f > -1; f--)
 345           {
 346             if (frames[f] instanceof AppJMol)
 347             {
 348               jmol = (AppJMol) frames[f];
 349               if (!jmol.pdbentry.getId().equals(entry.getId()))
 350                 continue;
 351
 352               StructureState state = new StructureState();
 353               state.setVisible(true);
 354               state.setXpos(jmol.getX());
 355               state.setYpos(jmol.getY());
 356               state.setWidth(jmol.getWidth());
 357               state.setHeight(jmol.getHeight());
 358
 359               state.setContent(jmol.viewer.getStateInfo().replaceAll("\n", ""));
 360
 361               for (int s = 0; s < jmol.sequence.length; s++)
 362               {
 363                 if (jal.findIndex(jmol.sequence[s]) > -1)
 364                 {
 365                   pdb.addStructureState(state);
 366                 }
 367               }
 368             }
 369           }
 370
 371
 372           if (entry.getFile() != null)
 373           {
 374             pdb.setFile(entry.getFile());
 375             if (pdbfiles == null)
 376             {
 377               pdbfiles = new Vector();
 378             }
 379
 380             if (!pdbfiles.contains(entry.getId()))
 381             {
 382               pdbfiles.addElement(entry.getId());
 383               try
 384               {
 385                 File file = new File(entry.getFile());
 386                 if (file.exists() && jout != null)
 387                 {
 388                   byte[] data = new byte[ (int) file.length()];
 389                   jout.putNextEntry(new JarEntry(entry.getId()));
 390                   DataInputStream dis = new DataInputStream(new
 391                       FileInputStream(file));
 392                   dis.readFully(data);
 393
 394                   DataOutputStream dout = new DataOutputStream(jout);
 395                   dout.write(data, 0, data.length);
 396                   jout.closeEntry();
 397                 }
 398               }
 399               catch (Exception ex)
 400               {
 401                   ex.printStackTrace();
 402               }
 403
 404             }
 405           }
 406
 407           if (entry.getProperty() != null)
 408           {
 409             PdbentryItem item = new PdbentryItem();
 410             Hashtable properties = entry.getProperty();
 411             Enumeration en2 = properties.keys();
 412             while (en2.hasMoreElements())
 413             {
 414               Property prop = new Property();
 415               String key = en2.nextElement().toString();
 416               prop.setName(key);
 417               prop.setValue(properties.get(key).toString());
 418               item.addProperty(prop);
 419             }
 420             pdb.addPdbentryItem(item);
 421           }
 422
 423           jseq.addPdbids(pdb);
 424         }
 425       }
 426
 427       jms.addJSeq(jseq);
 428     }
 429
 430     if (av.hasHiddenRows)
 431     {
 432       jal = av.alignment;
 433     }
 434
 435     //SAVE TREES
 436     ///////////////////////////////////
 437     if (av.currentTree != null)
 438     {
 439       // FIND ANY ASSOCIATED TREES
 440       // NOT IMPLEMENTED FOR HEADLESS STATE AT PRESENT
 441       if (Desktop.desktop != null)
 442       {
 443         JInternalFrame[] frames = Desktop.desktop.getAllFrames();
 444
 445         for (int t = 0; t < frames.length; t++)
 446         {
 447           if (frames[t] instanceof TreePanel)
 448           {
 449             TreePanel tp = (TreePanel) frames[t];
 450
 451             if (tp.treeCanvas.av.alignment == jal)
 452             {
 453               Tree tree = new Tree();
 454               tree.setTitle(tp.getTitle());
 455               tree.setCurrentTree( (av.currentTree == tp.getTree()));
 456               tree.setNewick(tp.getTree().toString());
 457               tree.setThreshold(tp.treeCanvas.threshold);
 458
 459               tree.setFitToWindow(tp.fitToWindow.getState());
 460               tree.setFontName(tp.getTreeFont().getName());
 461               tree.setFontSize(tp.getTreeFont().getSize());
 462               tree.setFontStyle(tp.getTreeFont().getStyle());
 463               tree.setMarkUnlinked(tp.placeholdersMenu.getState());
 464
 465               tree.setShowBootstrap(tp.bootstrapMenu.getState());
 466               tree.setShowDistances(tp.distanceMenu.getState());
 467
 468               tree.setHeight(tp.getHeight());
 469               tree.setWidth(tp.getWidth());
 470               tree.setXpos(tp.getX());
 471               tree.setYpos(tp.getY());
 472
 473               jms.addTree(tree);
 474             }
 475           }
 476         }
 477       }
 478     }
 479
 480     //SAVE ANNOTATIONS
 481     if (jal.getAlignmentAnnotation() != null)
 482     {
 483       jalview.datamodel.AlignmentAnnotation[] aa = jal.getAlignmentAnnotation();
 484
 485       for (int i = 0; i < aa.length; i++)
 486       {
 487         Annotation an = new Annotation();
 488
 489         if (aa[i].annotationId != null)
 490         {
 491           annotationIds.put(aa[i].annotationId, aa[i]);
 492         }
 493
 494         an.setId(aa[i].annotationId);
 495
 496         if (aa[i] == av.quality ||
 497             aa[i] == av.conservation ||
 498             aa[i] == av.consensus)
 499         {
 500           an.setLabel(aa[i].label);
 501           an.setGraph(true);
 502           vamsasSet.addAnnotation(an);
 503           continue;
 504         }
 505
 506         an.setDescription(aa[i].description);
 507
 508         if (aa[i].sequenceRef != null)
 509         {
 510           an.setSequenceRef(aa[i].sequenceRef.getName());
 511         }
 512
 513         if (aa[i].graph > 0)
 514         {
 515           an.setGraph(true);
 516           an.setGraphType(aa[i].graph);
 517           an.setGraphGroup(aa[i].graphGroup);
 518           if (aa[i].getThreshold() != null)
 519           {
 520             ThresholdLine line = new ThresholdLine();
 521             line.setLabel(aa[i].getThreshold().label);
 522             line.setValue(aa[i].getThreshold().value);
 523             line.setColour(aa[i].getThreshold().colour.getRGB());
 524             an.setThresholdLine(line);
 525           }
 526         }
 527         else
 528         {
 529           an.setGraph(false);
 530         }
 531
 532         an.setLabel(aa[i].label);
 533         if (aa[i].hasScore())
 534         {
 535           an.setScore(aa[i].getScore());
 536         }
 537         AnnotationElement ae;
 538         if (aa[i].annotations!=null)
 539         {
 540           an.setScoreOnly(false);
 541           for (int a = 0; a < aa[i].annotations.length; a++)
 542           {
 543             if ((aa[i] == null) || (aa[i].annotations[a] == null))
 544             {
 545               continue;
 546             }
 547
 548             ae = new AnnotationElement();
 549             ae.setDescription(aa[i].annotations[a].description);
 550             ae.setDisplayCharacter(aa[i].annotations[a].displayCharacter);
 551             ae.setValue(aa[i].annotations[a].value);
 552             ae.setPosition(a);
 553             ae
 554                     .setSecondaryStructure(aa[i].annotations[a].secondaryStructure
 555                             + "");
 556
 557             if (aa[i].annotations[a].colour != java.awt.Color.black)
 558             {
 559               ae.setColour(aa[i].annotations[a].colour.getRGB());
 560             }
 561
 562             an.addAnnotationElement(ae);
 563           }
 564         } else {
 565           an.setScoreOnly(true);
 566         }
 567         vamsasSet.addAnnotation(an);
 568       }
 569     }
 570
 571     //SAVE GROUPS
 572     if (jal.getGroups() != null)
 573     {
 574       JGroup[] groups = new JGroup[jal.getGroups().size()];
 575
 576       for (int i = 0; i < groups.length; i++)
 577       {
 578         groups[i] = new JGroup();
 579
 580         jalview.datamodel.SequenceGroup sg = (jalview.datamodel.SequenceGroup)
 581             jal.getGroups()
 582             .elementAt(i);
 583         groups[i].setStart(sg.getStartRes());
 584         groups[i].setEnd(sg.getEndRes());
 585         groups[i].setName(sg.getName());
 586         if (sg.cs != null)
 587         {
 588           if (sg.cs.conservationApplied())
 589           {
 590             groups[i].setConsThreshold(sg.cs.getConservationInc());
 591
 592             if (sg.cs instanceof jalview.schemes.UserColourScheme)
 593             {
 594               groups[i].setColour(SetUserColourScheme(sg.cs,
 595                   userColours,
 596                   jms));
 597             }
 598             else
 599             {
 600               groups[i].setColour(ColourSchemeProperty.getColourName(sg.
 601                   cs));
 602             }
 603           }
 604           else if (sg.cs instanceof jalview.schemes.AnnotationColourGradient)
 605           {
 606             groups[i].setColour(
 607                 ColourSchemeProperty.getColourName(
 608                     ( (jalview.schemes.AnnotationColourGradient) sg.cs).
 609                     getBaseColour()));
 610           }
 611           else if (sg.cs instanceof jalview.schemes.UserColourScheme)
 612           {
 613             groups[i].setColour(SetUserColourScheme(sg.cs, userColours,
 614                 jms));
 615           }
 616           else
 617           {
 618             groups[i].setColour(ColourSchemeProperty.getColourName(
 619                 sg.cs));
 620           }
 621
 622           groups[i].setPidThreshold(sg.cs.getThreshold());
 623         }
 624
 625         groups[i].setOutlineColour(sg.getOutlineColour().getRGB());
 626         groups[i].setDisplayBoxes(sg.getDisplayBoxes());
 627         groups[i].setDisplayText(sg.getDisplayText());
 628         groups[i].setColourText(sg.getColourText());
 629         groups[i].setTextCol1(sg.textColour.getRGB());
 630         groups[i].setTextCol2(sg.textColour2.getRGB());
 631         groups[i].setTextColThreshold(sg.thresholdTextColour);
 632
 633         for (int s = 0; s < sg.getSize(); s++)
 634         {
 635           jalview.datamodel.Sequence seq =
 636               (jalview.datamodel.Sequence) sg.getSequenceAt(s);
 637           groups[i].addSeq(seq.hashCode());
 638         }
 639       }
 640
 641       jms.setJGroup(groups);
 642     }
 643
 644     ///////////SAVE VIEWPORT
 645     Viewport view = new Viewport();
 646     view.setTitle(ap.alignFrame.getTitle());
 647     view.setSequenceSetId(av.getSequenceSetId());
 648     view.setViewName(av.viewName);
 649     view.setGatheredViews(av.gatherViewsHere);
 650
 651
 652
 653     if (ap.av.explodedPosition != null)
 654     {
 655       view.setXpos(av.explodedPosition.x);
 656       view.setYpos(av.explodedPosition.y);
 657       view.setWidth(av.explodedPosition.width);
 658       view.setHeight(av.explodedPosition.height);
 659     }
 660     else
 661     {
 662       view.setXpos(ap.alignFrame.getBounds().x);
 663       view.setYpos(ap.alignFrame.getBounds().y);
 664       view.setWidth(ap.alignFrame.getBounds().width);
 665       view.setHeight(ap.alignFrame.getBounds().height);
 666     }
 667
 668     view.setStartRes(av.startRes);
 669     view.setStartSeq(av.startSeq);
 670
 671     if (av.getGlobalColourScheme() instanceof jalview.schemes.UserColourScheme)
 672     {
 673       view.setBgColour(SetUserColourScheme(av.getGlobalColourScheme(),
 674                                            userColours, jms));
 675     }
 676     else if (av.getGlobalColourScheme() instanceof jalview.schemes.
 677              AnnotationColourGradient)
 678     {
 679       jalview.schemes.AnnotationColourGradient acg
 680           = (jalview.schemes.AnnotationColourGradient) av.getGlobalColourScheme();
 681
 682       AnnotationColours ac = new AnnotationColours();
 683       ac.setAboveThreshold(acg.getAboveThreshold());
 684       ac.setThreshold(acg.getAnnotationThreshold());
 685       ac.setAnnotation(acg.getAnnotation());
 686       if (acg.getBaseColour() instanceof jalview.schemes.UserColourScheme)
 687       {
 688         ac.setColourScheme(SetUserColourScheme(acg.getBaseColour(),
 689                                                userColours, jms));
 690       }
 691       else
 692       {
 693         ac.setColourScheme(ColourSchemeProperty.getColourName(acg.getBaseColour()));
 694       }
 695
 696       ac.setMaxColour(acg.getMaxColour().getRGB());
 697       ac.setMinColour(acg.getMinColour().getRGB());
 698       view.setAnnotationColours(ac);
 699       view.setBgColour("AnnotationColourGradient");
 700     }
 701     else
 702     {
 703       view.setBgColour(ColourSchemeProperty.getColourName(
 704           av.getGlobalColourScheme()));
 705     }
 706
 707     ColourSchemeI cs = av.getGlobalColourScheme();
 708
 709     if (cs != null)
 710     {
 711       if (cs.conservationApplied())
 712       {
 713         view.setConsThreshold(cs.getConservationInc());
 714         if (cs instanceof jalview.schemes.UserColourScheme)
 715         {
 716           view.setBgColour(SetUserColourScheme(cs, userColours, jms));
 717         }
 718       }
 719
 720       if (cs instanceof ResidueColourScheme)
 721       {
 722         view.setPidThreshold(cs.getThreshold());
 723       }
 724     }
 725
 726     view.setConservationSelected(av.getConservationSelected());
 727     view.setPidSelected(av.getAbovePIDThreshold());
 728     view.setFontName(av.font.getName());
 729     view.setFontSize(av.font.getSize());
 730     view.setFontStyle(av.font.getStyle());
 731     view.setRenderGaps(av.renderGaps);
 732     view.setShowAnnotation(av.getShowAnnotation());
 733     view.setShowBoxes(av.getShowBoxes());
 734     view.setShowColourText(av.getColourText());
 735     view.setShowFullId(av.getShowJVSuffix());
 736     view.setRightAlignIds(av.rightAlignIds);
 737     view.setShowSequenceFeatures(av.showSequenceFeatures);
 738     view.setShowText(av.getShowText());
 739     view.setWrapAlignment(av.getWrapAlignment());
 740     view.setTextCol1(av.textColour.getRGB());
 741     view.setTextCol2(av.textColour2.getRGB());
 742     view.setTextColThreshold(av.thresholdTextColour);
 743
 744     if (av.featuresDisplayed != null)
 745     {
 746       jalview.schemabinding.version2.FeatureSettings fs
 747           = new jalview.schemabinding.version2.FeatureSettings();
 748
 749       String[] renderOrder =
 750           ap.seqPanel.seqCanvas.getFeatureRenderer().renderOrder;
 751
 752       Vector settingsAdded = new Vector();
 753       for (int ro = 0; ro < renderOrder.length; ro++)
 754       {
 755         Setting setting = new Setting();
 756         setting.setType(renderOrder[ro]);
 757         setting.setColour(
 758             ap.seqPanel.seqCanvas.getFeatureRenderer().getColour(renderOrder[ro]).
 759             getRGB()
 760             );
 761
 762         setting.setDisplay(
 763             av.featuresDisplayed.containsKey(renderOrder[ro])
 764             );
 765         float rorder=ap.seqPanel.seqCanvas.getFeatureRenderer().getOrder(renderOrder[ro]);
 766         if (rorder>-1) {
 767           setting.setOrder(rorder);
 768         }
 769         fs.addSetting(setting);
 770         settingsAdded.addElement(renderOrder[ro]);
 771       }
 772
 773       //Make sure we save none displayed feature settings
 774       Enumeration en =
 775           ap.seqPanel.seqCanvas.getFeatureRenderer().featureColours.keys();
 776       while (en.hasMoreElements())
 777       {
 778         String key = en.nextElement().toString();
 779         if (settingsAdded.contains(key))
 780         {
 781           continue;
 782         }
 783
 784         Setting setting = new Setting();
 785         setting.setType(key);
 786         setting.setColour(
 787             ap.seqPanel.seqCanvas.getFeatureRenderer().getColour(key).getRGB()
 788             );
 789
 790         setting.setDisplay(false);
 791         float rorder = ap.seqPanel.seqCanvas.getFeatureRenderer().getOrder(key);
 792         if (rorder>-1)
 793         {
 794           setting.setOrder(rorder);
 795         }
 796         fs.addSetting(setting);
 797         settingsAdded.addElement(key);
 798       }
 799       en = ap.seqPanel.seqCanvas.getFeatureRenderer().featureGroups.keys();
 800       Vector groupsAdded=new Vector();
 801       while (en.hasMoreElements())
 802       {
 803         String grp = en.nextElement().toString();
 804         if (groupsAdded.contains(grp))
 805         {
 806           continue;
 807         }
 808         Group g = new Group();
 809         g.setName(grp);
 810         g.setDisplay(((Boolean)ap.seqPanel.seqCanvas.getFeatureRenderer().featureGroups.get(grp)).booleanValue());
 811         fs.addGroup(g);
 812         groupsAdded.addElement(grp);
 813       }
 814       jms.setFeatureSettings(fs);
 815
 816     }
 817
 818     if (av.hasHiddenColumns)
 819     {
 820       for (int c = 0; c < av.getColumnSelection().getHiddenColumns().size(); c++)
 821       {
 822         int[] region = (int[]) av.getColumnSelection().getHiddenColumns().
 823             elementAt(c);
 824         HiddenColumns hc = new HiddenColumns();
 825         hc.setStart(region[0]);
 826         hc.setEnd(region[1]);
 827         view.addHiddenColumns(hc);
 828       }
 829     }
 830
 831     jms.addViewport(view);
 832
 833     object.setJalviewModelSequence(jms);
 834     object.getVamsasModel().addSequenceSet(vamsasSet);
 835
 836     if (out != null)
 837     {
 838       //We may not want to right the object to disk,
 839       //eg we can copy the alignViewport to a new view object
 840       //using save and then load
 841       try
 842       {
 843         if (!fileName.endsWith(".xml"))
 844         {
 845           fileName = fileName + ".xml";
 846         }
 847
 848         JarEntry entry = new JarEntry(fileName);
 849         jout.putNextEntry(entry);
 850
 851         object.marshal(out);
 852       }
 853       catch (Exception ex)
 854       {
 855         ex.printStackTrace();
 856       }
 857     }
 858     return object;
 859   }
 860
 861   String SetUserColourScheme(jalview.schemes.ColourSchemeI cs,
 862                              Vector userColours, JalviewModelSequence jms)
 863   {
 864     String id = null;
 865     jalview.schemes.UserColourScheme ucs = (jalview.schemes.UserColourScheme)
 866         cs;
 867
 868     if (!userColours.contains(ucs))
 869     {
 870       userColours.add(ucs);
 871
 872       java.awt.Color[] colours = ucs.getColours();
 873       jalview.schemabinding.version2.UserColours uc = new jalview.schemabinding.
 874           version2.UserColours();
 875       jalview.schemabinding.version2.UserColourScheme jbucs = new jalview.
 876           schemabinding.version2.UserColourScheme();
 877
 878       for (int i = 0; i < colours.length; i++)
 879       {
 880         jalview.schemabinding.version2.Colour col = new jalview.schemabinding.
 881             version2.Colour();
 882         col.setName(ResidueProperties.aa[i]);
 883         col.setRGB(jalview.util.Format.getHexString(colours[i]));
 884         jbucs.addColour(col);
 885       }
 886       if (ucs.getLowerCaseColours() != null)
 887       {
 888         colours = ucs.getLowerCaseColours();
 889         for (int i = 0; i < colours.length; i++)
 890         {
 891           jalview.schemabinding.version2.Colour col = new jalview.schemabinding.
 892               version2.Colour();
 893           col.setName(ResidueProperties.aa[i].toLowerCase());
 894           col.setRGB(jalview.util.Format.getHexString(colours[i]));
 895           jbucs.addColour(col);
 896         }
 897       }
 898
 899       id = "ucs" + userColours.indexOf(ucs);
 900       uc.setId(id);
 901       uc.setUserColourScheme(jbucs);
 902       jms.addUserColours(uc);
 903     }
 904
 905     return id;
 906   }
 907
 908   jalview.schemes.UserColourScheme GetUserColourScheme(
 909       JalviewModelSequence jms, String id)
 910   {
 911     UserColours[] uc = jms.getUserColours();
 912     UserColours colours = null;
 913
 914     for (int i = 0; i < uc.length; i++)
 915     {
 916       if (uc[i].getId().equals(id))
 917       {
 918         colours = uc[i];
 919
 920         break;
 921       }
 922     }
 923
 924     java.awt.Color[] newColours = new java.awt.Color[24];
 925
 926     for (int i = 0; i < 24; i++)
 927     {
 928       newColours[i] = new java.awt.Color(Integer.parseInt(
 929           colours.getUserColourScheme().getColour(i).getRGB(), 16));
 930     }
 931
 932     jalview.schemes.UserColourScheme ucs =
 933         new jalview.schemes.UserColourScheme(newColours);
 934
 935     if (colours.getUserColourScheme().getColourCount() > 24)
 936     {
 937       newColours = new java.awt.Color[23];
 938       for (int i = 0; i < 23; i++)
 939       {
 940         newColours[i] = new java.awt.Color(Integer.parseInt(
 941             colours.getUserColourScheme().getColour(i + 24).getRGB(), 16));
 942       }
 943       ucs.setLowerCaseColours(newColours);
 944     }
 945
 946     return ucs;
 947   }
 948
 949   /**
 950    * DOCUMENT ME!
 951    *
 952    * @param file DOCUMENT ME!
 953    */
 954   public AlignFrame LoadJalviewAlign(final String file)
 955   {
 956     uniqueSetSuffix = System.currentTimeMillis() % 100000 + "";
 957
 958     jalview.gui.AlignFrame af = null;
 959
 960     seqRefIds = new Hashtable();
 961     viewportsAdded = new Hashtable();
 962
 963     Hashtable gatherToThisFrame = new Hashtable();
 964
 965     try
 966     {
 967       //UNMARSHALLER SEEMS TO CLOSE JARINPUTSTREAM, MOST ANNOYING
 968       URL url = null;
 969
 970       if (file.startsWith("http://"))
 971       {
 972         url = new URL(file);
 973       }
 974
 975       JarInputStream jin = null;
 976       JarEntry jarentry = null;
 977       int entryCount = 1;
 978
 979       do
 980       {
 981         if (url != null)
 982         {
 983           jin = new JarInputStream(url.openStream());
 984         }
 985         else
 986         {
 987           jin = new JarInputStream(new FileInputStream(file));
 988         }
 989
 990         for (int i = 0; i < entryCount; i++)
 991         {
 992           jarentry = jin.getNextJarEntry();
 993         }
 994
 995         if (jarentry != null && jarentry.getName().endsWith(".xml"))
 996         {
 997           InputStreamReader in = new InputStreamReader(jin, "UTF-8");
 998           JalviewModel object = new JalviewModel();
 999
1000           Unmarshaller unmar = new Unmarshaller(object);
1001           unmar.setValidation(false);
1002           object = (JalviewModel) unmar.unmarshal(in);
1003
1004           af = LoadFromObject(object, file, true);
1005           if (af.viewport.gatherViewsHere)
1006           {
1007             gatherToThisFrame.put(af.viewport.getSequenceSetId(), af);
1008           }
1009           entryCount++;
1010         }
1011         else if (jarentry != null)
1012         {
1013           //Some other file here.
1014           entryCount++;
1015         }
1016       }
1017       while (jarentry != null);
1018     }
1019     catch (java.net.UnknownHostException ex)
1020     {
1021       ex.printStackTrace();
1022       System.err.println("Couldn't locate Jalview XML file : " +
1023                          ex + "\n");
1024
1025       javax.swing.SwingUtilities.invokeLater(new Runnable()
1026       {
1027         public void run()
1028         {
1029           JOptionPane.showInternalMessageDialog(Desktop.desktop,
1030                                                 "Couldn't locate " + file,
1031                                                 "URL not found",
1032                                                 JOptionPane.WARNING_MESSAGE);
1033         }
1034       });
1035     }
1036     catch (Exception ex)
1037     {
1038       //Is Version 1 Jar file?
1039       af = new Jalview2XML_V1().LoadJalviewAlign(file);
1040
1041       if (af != null)
1042       {
1043         System.out.println("Successfully loaded archive file");
1044         return af;
1045       }
1046       ex.printStackTrace();
1047
1048       System.err.println("Exception whilst loading jalview XML file : " +
1049                          ex + "\n");
1050       javax.swing.SwingUtilities.invokeLater(new Runnable()
1051       {
1052         public void run()
1053         {
1054
1055           JOptionPane.showInternalMessageDialog(Desktop.desktop,
1056                                                 "Error loading  " + file,
1057                                                 "Error loading Jalview file",
1058                                                 JOptionPane.WARNING_MESSAGE);
1059         }
1060       });
1061     }
1062
1063     if (Desktop.instance != null)
1064     {
1065       Desktop.instance.stopLoading();
1066     }
1067
1068     Enumeration en = gatherToThisFrame.elements();
1069     while(en.hasMoreElements())
1070     {
1071       Desktop.instance.gatherViews(
1072           (AlignFrame) en.nextElement());
1073     }
1074
1075     return af;
1076   }
1077
1078   Hashtable alreadyLoadedPDB;
1079   String loadPDBFile(String file, String pdbId)
1080   {
1081     if (alreadyLoadedPDB == null)
1082       alreadyLoadedPDB = new Hashtable();
1083
1084     if (alreadyLoadedPDB.containsKey(pdbId))
1085       return alreadyLoadedPDB.get(pdbId).toString();
1086
1087     try
1088     {
1089       JarInputStream jin = null;
1090
1091       if (file.startsWith("http://"))
1092       {
1093         jin = new JarInputStream(new URL(file).openStream());
1094       }
1095       else
1096       {
1097         jin = new JarInputStream(new FileInputStream(file));
1098       }
1099
1100       JarEntry entry = null;
1101       do
1102       {
1103         entry = jin.getNextJarEntry();
1104       }
1105       while (!entry.getName().equals(pdbId));
1106
1107       BufferedReader in = new BufferedReader(new InputStreamReader(jin));
1108       File outFile = File.createTempFile("jalview_pdb", ".txt");
1109       outFile.deleteOnExit();
1110       PrintWriter out = new PrintWriter(new FileOutputStream(outFile));
1111       String data;
1112
1113       while ( (data = in.readLine()) != null)
1114       {
1115         out.println(data);
1116       }
1117       out.close();
1118
1119       alreadyLoadedPDB.put(pdbId, outFile.getAbsolutePath());
1120       return outFile.getAbsolutePath();
1121
1122     }
1123     catch (Exception ex)
1124     {
1125       ex.printStackTrace();
1126     }
1127
1128     return null;
1129   }
1130
1131   AlignFrame LoadFromObject(JalviewModel object,
1132                             String file,
1133                             boolean loadTreesAndStructures)
1134   {
1135     SequenceSet vamsasSet = object.getVamsasModel().getSequenceSet(0);
1136     Sequence[] vamsasSeq = vamsasSet.getSequence();
1137
1138     JalviewModelSequence jms = object.getJalviewModelSequence();
1139
1140     Viewport view = jms.getViewport(0);
1141
1142     //////////////////////////////////
1143     //LOAD SEQUENCES
1144
1145     Vector hiddenSeqs = null;
1146     jalview.datamodel.Sequence jseq;
1147
1148     ArrayList tmpseqs = new ArrayList();
1149
1150     boolean multipleView = false;
1151
1152     JSeq[] JSEQ = object.getJalviewModelSequence().getJSeq();
1153     for (int i = 0; i < JSEQ.length; i++)
1154     {
1155       String seqId = JSEQ[i].getId() + "";
1156
1157       if (seqRefIds.get(seqId) != null)
1158       {
1159         tmpseqs.add( (jalview.datamodel.Sequence) seqRefIds.get(seqId));
1160         multipleView = true;
1161       }
1162       else
1163       {
1164         jseq = new jalview.datamodel.Sequence(vamsasSeq[i].getName(),
1165                                               vamsasSeq[i].getSequence());
1166         jseq.setDescription(vamsasSeq[i].getDescription());
1167         jseq.setStart(JSEQ[i].getStart());
1168         jseq.setEnd(JSEQ[i].getEnd());
1169         seqRefIds.put(vamsasSeq[i].getId(), jseq);
1170         tmpseqs.add(jseq);
1171       }
1172
1173       if (JSEQ[i].getHidden())
1174       {
1175         if (hiddenSeqs == null)
1176         {
1177           hiddenSeqs = new Vector();
1178         }
1179
1180         hiddenSeqs.addElement(
1181             (jalview.datamodel.Sequence) seqRefIds.get(seqId));
1182       }
1183
1184     }
1185
1186     ///SequenceFeatures are added to the DatasetSequence,
1187     // so we must create the dataset before loading features
1188     /////////////////////////////////
1189
1190
1191     jalview.datamodel.Sequence[] orderedSeqs = new jalview.datamodel.Sequence[
1192         tmpseqs.size()];
1193
1194     tmpseqs.toArray(orderedSeqs);
1195
1196     jalview.datamodel.Alignment al =
1197         new jalview.datamodel.Alignment(orderedSeqs);
1198
1199     al.setDataset(null);
1200     /////////////////////////////////
1201
1202
1203     Hashtable pdbloaded = new Hashtable();
1204
1205     if (!multipleView)
1206     {
1207       for (int i = 0; i < vamsasSeq.length; i++)
1208       {
1209         if (JSEQ[i].getFeaturesCount() > 0)
1210         {
1211           Features[] features = JSEQ[i].getFeatures();
1212           for (int f = 0; f < features.length; f++)
1213           {
1214             jalview.datamodel.SequenceFeature sf
1215                 = new jalview.datamodel.SequenceFeature(features[f].getType(),
1216                 features[f].getDescription(), features[f].getStatus(),
1217                 features[f].getBegin(), features[f].getEnd(),
1218                 features[f].getFeatureGroup());
1219
1220             sf.setScore(features[f].getScore());
1221             for (int od = 0; od < features[f].getOtherDataCount(); od++)
1222             {
1223               OtherData keyValue = features[f].getOtherData(od);
1224               if (keyValue.getKey().startsWith("LINK"))
1225               {
1226                 sf.addLink(keyValue.getValue());
1227               }
1228               else
1229               {
1230                 sf.setValue(keyValue.getKey(), keyValue.getValue());
1231               }
1232
1233             }
1234
1235             al.getSequenceAt(i).getDatasetSequence().addSequenceFeature(sf);
1236           }
1237         }
1238
1239         if (JSEQ[i].getPdbidsCount() > 0)
1240         {
1241           Pdbids[] ids = JSEQ[i].getPdbids();
1242           for (int p = 0; p < ids.length; p++)
1243           {
1244             jalview.datamodel.PDBEntry entry = new jalview.datamodel.
1245                 PDBEntry();
1246             entry.setId(ids[p].getId());
1247             entry.setType(ids[p].getType());
1248             if (ids[p].getFile() != null)
1249             {
1250               if (!pdbloaded.containsKey(ids[p].getFile()))
1251               {
1252                 entry.setFile(loadPDBFile(file, ids[p].getId()));
1253               }
1254               else
1255               {
1256                 entry.setFile(pdbloaded.get(ids[p].getId()).toString());
1257               }
1258             }
1259
1260             al.getSequenceAt(i).getDatasetSequence().addPDBId(entry);
1261           }
1262         }
1263         if (vamsasSeq[i].getDBRefCount() > 0)
1264         {
1265           for (int d = 0; d < vamsasSeq[i].getDBRefCount(); d++)
1266           {
1267             jalview.datamodel.DBRefEntry entry =
1268                 new jalview.datamodel.DBRefEntry(
1269                     vamsasSeq[i].getDBRef(d).getSource(),
1270                     vamsasSeq[i].getDBRef(d).getVersion(),
1271                     vamsasSeq[i].getDBRef(d).getAccessionId()
1272                 );
1273             al.getSequenceAt(i).getDatasetSequence().addDBRef(entry);
1274           }
1275
1276         }
1277       }
1278     }
1279
1280     /////////////////////////////////
1281     //////////////////////////////////
1282     //LOAD ANNOTATIONS
1283     boolean hideQuality = true,
1284         hideConservation = true,
1285         hideConsensus = true;
1286
1287     if (vamsasSet.getAnnotationCount() > 0)
1288     {
1289       Annotation[] an = vamsasSet.getAnnotation();
1290
1291       for (int i = 0; i < an.length; i++)
1292       {
1293         if (an[i].getLabel().equals("Quality"))
1294         {
1295           hideQuality = false;
1296           continue;
1297         }
1298         else if (an[i].getLabel().equals("Conservation"))
1299         {
1300           hideConservation = false;
1301           continue;
1302         }
1303         else if (an[i].getLabel().equals("Consensus"))
1304         {
1305           hideConsensus = false;
1306           continue;
1307         }
1308
1309         if (an[i].getId() != null
1310             && annotationIds.containsKey(an[i].getId()))
1311         {
1312           al.addAnnotation(
1313               (jalview.datamodel.AlignmentAnnotation) annotationIds.get(an[i].
1314               getId())
1315               );
1316
1317           continue;
1318         }
1319
1320         AnnotationElement[] ae = an[i].getAnnotationElement();
1321         jalview.datamodel.Annotation[] anot = null;
1322         if (!an[i].getScoreOnly())
1323         {
1324           anot = new jalview.datamodel.Annotation[
1325                     al.getWidth()];
1326
1327           for (int aa = 0; aa < ae.length && aa < anot.length; aa++)
1328           {
1329             anot[ae[aa].getPosition()] = new jalview.datamodel.Annotation(ae[aa].
1330                     getDisplayCharacter(),
1331                     ae[aa].getDescription(),
1332                     ae[aa].getSecondaryStructure().length() == 0 ? ' ' :
1333                       ae[aa].getSecondaryStructure().charAt(0),
1334                       ae[aa].getValue());
1335             anot[ae[aa].getPosition()].colour = new java.awt.Color(ae[aa].
1336                     getColour());
1337           }
1338         }
1339         jalview.datamodel.AlignmentAnnotation jaa = null;
1340
1341         if (an[i].getGraph())
1342         {
1343           jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(),
1344               an[i].getDescription(), anot, 0, 0,
1345               an[i].getGraphType());
1346
1347           jaa.graphGroup = an[i].getGraphGroup();
1348
1349           if (an[i].getThresholdLine() != null)
1350           {
1351             jaa.setThreshold(new jalview.datamodel.GraphLine(
1352                 an[i].getThresholdLine().getValue(),
1353                 an[i].getThresholdLine().getLabel(),
1354                 new java.awt.Color(an[i].getThresholdLine().getColour()))
1355                 );
1356
1357           }
1358
1359         }
1360         else
1361         {
1362           jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(),
1363               an[i].getDescription(), anot);
1364         }
1365
1366         if (an[i].getId() != null)
1367         {
1368           annotationIds.put(an[i].getId(), jaa);
1369           jaa.annotationId = an[i].getId();
1370         }
1371
1372         if (an[i].getSequenceRef() != null)
1373         {
1374           jaa.createSequenceMapping(
1375               al.findName(an[i].getSequenceRef()), 1, true
1376               );
1377           al.findName(an[i].getSequenceRef()).addAlignmentAnnotation(jaa);
1378         }
1379         if (an[i].hasScore())
1380         {
1381           jaa.setScore(an[i].getScore());
1382         }
1383         al.addAnnotation(jaa);
1384       }
1385     }
1386
1387     /////////////////////////
1388     //LOAD GROUPS
1389     if (jms.getJGroupCount() > 0)
1390     {
1391       JGroup[] groups = jms.getJGroup();
1392
1393       for (int i = 0; i < groups.length; i++)
1394       {
1395         ColourSchemeI cs = null;
1396
1397         if (groups[i].getColour() != null)
1398         {
1399           if (groups[i].getColour().startsWith("ucs"))
1400           {
1401             cs = GetUserColourScheme(jms, groups[i].getColour());
1402           }
1403           else
1404           {
1405             cs = ColourSchemeProperty.getColour(al,
1406                                                 groups[i].getColour());
1407           }
1408
1409           if (cs != null)
1410           {
1411             cs.setThreshold(groups[i].getPidThreshold(), true);
1412           }
1413         }
1414
1415         Vector seqs = new Vector();
1416
1417         for (int s = 0; s < groups[i].getSeqCount(); s++)
1418         {
1419           String seqId = groups[i].getSeq(s) + "";
1420           jalview.datamodel.SequenceI ts = (jalview.datamodel.SequenceI)
1421               seqRefIds.get(seqId);
1422
1423           if (ts != null)
1424           {
1425             seqs.addElement(ts);
1426           }
1427         }
1428
1429         if (seqs.size() < 1)
1430         {
1431           continue;
1432         }
1433
1434         jalview.datamodel.SequenceGroup sg = new jalview.datamodel.
1435             SequenceGroup(seqs,
1436                           groups[i].getName(), cs, groups[i].getDisplayBoxes(),
1437                           groups[i].getDisplayText(), groups[i].getColourText(),
1438                           groups[i].getStart(), groups[i].getEnd());
1439
1440         sg.setOutlineColour(new java.awt.Color(
1441             groups[i].getOutlineColour()));
1442
1443         sg.textColour = new java.awt.Color(groups[i].getTextCol1());
1444         sg.textColour2 = new java.awt.Color(groups[i].getTextCol2());
1445         sg.thresholdTextColour = groups[i].getTextColThreshold();
1446
1447         if (groups[i].getConsThreshold() != 0)
1448         {
1449           jalview.analysis.Conservation c = new jalview.analysis.Conservation(
1450               "All",
1451               ResidueProperties.propHash, 3, sg.getSequences(null), 0,
1452               sg.getWidth() - 1);
1453           c.calculate();
1454           c.verdict(false, 25);
1455           sg.cs.setConservation(c);
1456         }
1457
1458         al.addGroup(sg);
1459       }
1460     }
1461
1462     /////////////////////////////////
1463     // LOAD VIEWPORT
1464
1465     AlignFrame af = new AlignFrame(al,
1466                                    view.getWidth(),
1467                                    view.getHeight());
1468
1469     af.setFileName(file, "Jalview");
1470
1471     for (int i = 0; i < JSEQ.length; i++)
1472     {
1473       af.viewport.setSequenceColour(
1474           af.viewport.alignment.getSequenceAt(i),
1475           new java.awt.Color(
1476               JSEQ[i].getColour()));
1477     }
1478
1479     //If we just load in the same jar file again, the sequenceSetId
1480     //will be the same, and we end up with multiple references
1481     //to the same sequenceSet. We must modify this id on load
1482     //so that each load of the file gives a unique id
1483     String uniqueSeqSetId = view.getSequenceSetId() + uniqueSetSuffix;
1484
1485     af.viewport.gatherViewsHere = view.getGatheredViews();
1486
1487     if (view.getSequenceSetId() != null)
1488     {
1489       jalview.gui.AlignViewport av =
1490           (jalview.gui.AlignViewport)
1491           viewportsAdded.get(uniqueSeqSetId);
1492
1493       af.viewport.sequenceSetID = uniqueSeqSetId;
1494       if (av != null)
1495       {
1496
1497         af.viewport.historyList = av.historyList;
1498         af.viewport.redoList = av.redoList;
1499       }
1500       else
1501       {
1502         viewportsAdded.put(uniqueSeqSetId, af.viewport);
1503       }
1504
1505       PaintRefresher.Register(af.alignPanel, uniqueSeqSetId);
1506     }
1507     if (hiddenSeqs != null)
1508     {
1509       for (int s = 0; s < JSEQ.length; s++)
1510       {
1511         jalview.datamodel.SequenceGroup hidden =
1512             new jalview.datamodel.SequenceGroup();
1513
1514         for (int r = 0; r < JSEQ[s].getHiddenSequencesCount(); r++)
1515         {
1516           hidden.addSequence(
1517               al.getSequenceAt(JSEQ[s].getHiddenSequences(r))
1518               , false
1519               );
1520         }
1521         af.viewport.hideRepSequences(al.getSequenceAt(s), hidden);
1522       }
1523
1524       jalview.datamodel.SequenceI[] hseqs = new
1525           jalview.datamodel.SequenceI[hiddenSeqs.size()];
1526
1527       for (int s = 0; s < hiddenSeqs.size(); s++)
1528       {
1529         hseqs[s] = (jalview.datamodel.SequenceI) hiddenSeqs.elementAt(s);
1530       }
1531
1532       af.viewport.hideSequence(hseqs);
1533
1534     }
1535
1536     if ( (hideConsensus || hideQuality || hideConservation)
1537         && al.getAlignmentAnnotation() != null)
1538     {
1539       int hSize = al.getAlignmentAnnotation().length;
1540       for (int h = 0; h < hSize; h++)
1541       {
1542         if (
1543             (hideConsensus &&
1544              al.getAlignmentAnnotation()[h].label.equals("Consensus"))
1545             ||
1546             (hideQuality &&
1547              al.getAlignmentAnnotation()[h].label.equals("Quality"))
1548             ||
1549             (hideConservation &&
1550              al.getAlignmentAnnotation()[h].label.equals("Conservation")))
1551         {
1552           al.deleteAnnotation(al.getAlignmentAnnotation()[h]);
1553           hSize--;
1554           h--;
1555         }
1556       }
1557       af.alignPanel.adjustAnnotationHeight();
1558     }
1559
1560     if (view.getViewName() != null)
1561     {
1562       af.viewport.viewName = view.getViewName();
1563       af.setInitialTabVisible();
1564     }
1565     af.setBounds(view.getXpos(), view.getYpos(), view.getWidth(),
1566                  view.getHeight());
1567
1568     af.viewport.setShowAnnotation(view.getShowAnnotation());
1569     af.viewport.setAbovePIDThreshold(view.getPidSelected());
1570
1571     af.viewport.setColourText(view.getShowColourText());
1572
1573     af.viewport.setConservationSelected(view.getConservationSelected());
1574     af.viewport.setShowJVSuffix(view.getShowFullId());
1575     af.viewport.rightAlignIds = view.getRightAlignIds();
1576     af.viewport.setFont(new java.awt.Font(view.getFontName(),
1577                                           view.getFontStyle(), view.getFontSize()));
1578     af.alignPanel.fontChanged();
1579     af.viewport.setRenderGaps(view.getRenderGaps());
1580     af.viewport.setWrapAlignment(view.getWrapAlignment());
1581     af.alignPanel.setWrapAlignment(view.getWrapAlignment());
1582     af.viewport.setShowAnnotation(view.getShowAnnotation());
1583     af.alignPanel.setAnnotationVisible(view.getShowAnnotation());
1584
1585     af.viewport.setShowBoxes(view.getShowBoxes());
1586
1587     af.viewport.setShowText(view.getShowText());
1588
1589     af.viewport.textColour = new java.awt.Color(view.getTextCol1());
1590     af.viewport.textColour2 = new java.awt.Color(view.getTextCol2());
1591     af.viewport.thresholdTextColour = view.getTextColThreshold();
1592
1593     af.viewport.setStartRes(view.getStartRes());
1594     af.viewport.setStartSeq(view.getStartSeq());
1595
1596     ColourSchemeI cs = null;
1597
1598     if (view.getBgColour() != null)
1599     {
1600       if (view.getBgColour().startsWith("ucs"))
1601       {
1602         cs = GetUserColourScheme(jms, view.getBgColour());
1603       }
1604       else if (view.getBgColour().startsWith("Annotation"))
1605       {
1606         //int find annotation
1607         for (int i = 0;
1608              i < af.viewport.alignment.getAlignmentAnnotation().length; i++)
1609         {
1610           if (af.viewport.alignment.getAlignmentAnnotation()[i].label.
1611               equals(view.getAnnotationColours().getAnnotation()))
1612           {
1613             if (af.viewport.alignment.getAlignmentAnnotation()[i].
1614                 getThreshold() == null)
1615             {
1616               af.viewport.alignment.getAlignmentAnnotation()[i].
1617                   setThreshold(
1618                       new jalview.datamodel.GraphLine(
1619                           view.getAnnotationColours().getThreshold(),
1620                           "Threshold", java.awt.Color.black)
1621
1622                   );
1623             }
1624
1625             if (view.getAnnotationColours().getColourScheme().equals(
1626                 "None"))
1627             {
1628               cs = new AnnotationColourGradient(
1629                   af.viewport.alignment.getAlignmentAnnotation()[i],
1630                   new java.awt.Color(view.getAnnotationColours().
1631                                      getMinColour()),
1632                   new java.awt.Color(view.getAnnotationColours().
1633                                      getMaxColour()),
1634                   view.getAnnotationColours().getAboveThreshold());
1635             }
1636             else if (view.getAnnotationColours().getColourScheme().
1637                      startsWith("ucs"))
1638             {
1639               cs = new AnnotationColourGradient(
1640                   af.viewport.alignment.getAlignmentAnnotation()[i],
1641                   GetUserColourScheme(jms, view.getAnnotationColours().
1642                                       getColourScheme()),
1643                   view.getAnnotationColours().getAboveThreshold()
1644                   );
1645             }
1646             else
1647             {
1648               cs = new AnnotationColourGradient(
1649                   af.viewport.alignment.getAlignmentAnnotation()[i],
1650                   ColourSchemeProperty.getColour(al,
1651                                                  view.getAnnotationColours().
1652                                                  getColourScheme()),
1653                   view.getAnnotationColours().getAboveThreshold()
1654                   );
1655             }
1656
1657             // Also use these settings for all the groups
1658             if (al.getGroups() != null)
1659             {
1660               for (int g = 0; g < al.getGroups().size(); g++)
1661               {
1662                 jalview.datamodel.SequenceGroup sg
1663                     = (jalview.datamodel.SequenceGroup) al.getGroups().
1664                     elementAt(g);
1665
1666                 if (sg.cs == null)
1667                 {
1668                   continue;
1669                 }
1670
1671                 /*    if (view.getAnnotationColours().getColourScheme().equals("None"))
1672                     {
1673                       sg.cs = new AnnotationColourGradient(
1674                           af.viewport.alignment.getAlignmentAnnotation()[i],
1675                           new java.awt.Color(view.getAnnotationColours().
1676                                              getMinColour()),
1677                           new java.awt.Color(view.getAnnotationColours().
1678                                              getMaxColour()),
1679                           view.getAnnotationColours().getAboveThreshold());
1680                     }
1681                     else*/
1682                 {
1683                   sg.cs = new AnnotationColourGradient(
1684                       af.viewport.alignment.getAlignmentAnnotation()[i],
1685                       sg.cs,
1686                       view.getAnnotationColours().getAboveThreshold()
1687                       );
1688                 }
1689
1690               }
1691             }
1692
1693             break;
1694           }
1695
1696         }
1697       }
1698       else
1699       {
1700         cs = ColourSchemeProperty.getColour(al, view.getBgColour());
1701       }
1702
1703       if (cs != null)
1704       {
1705         cs.setThreshold(view.getPidThreshold(), true);
1706         cs.setConsensus(af.viewport.hconsensus);
1707       }
1708     }
1709
1710     af.viewport.setGlobalColourScheme(cs);
1711     af.viewport.setColourAppliesToAllGroups(false);
1712
1713     if (view.getConservationSelected() && cs != null)
1714     {
1715       cs.setConservationInc(view.getConsThreshold());
1716     }
1717
1718     af.changeColour(cs);
1719
1720     af.viewport.setColourAppliesToAllGroups(true);
1721
1722     if (view.getShowSequenceFeatures())
1723     {
1724       af.viewport.showSequenceFeatures = true;
1725     }
1726
1727     if (jms.getFeatureSettings() != null)
1728     {
1729       af.viewport.featuresDisplayed = new Hashtable();
1730       String[] renderOrder = new String[jms.getFeatureSettings().
1731           getSettingCount()];
1732       for (int fs = 0; fs < jms.getFeatureSettings().getSettingCount(); fs++)
1733       {
1734         Setting setting = jms.getFeatureSettings().getSetting(fs);
1735
1736         af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setColour(setting.
1737             getType(),
1738             new java.awt.Color(setting.getColour()));
1739         renderOrder[fs] = setting.getType();
1740         if (setting.hasOrder())
1741           af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setOrder(setting.getType(), setting.getOrder());
1742         else
1743           af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setOrder(setting.getType(), fs/jms.getFeatureSettings().getSettingCount());
1744         if (setting.getDisplay())
1745         {
1746           af.viewport.featuresDisplayed.put(
1747               setting.getType(), new Integer(setting.getColour()));
1748         }
1749       }
1750       af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().renderOrder =
1751           renderOrder;
1752       Hashtable fgtable;
1753       af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().featureGroups = fgtable=new Hashtable();
1754       for (int gs=0;gs<jms.getFeatureSettings().getGroupCount(); gs++)
1755       {
1756         Group grp = jms.getFeatureSettings().getGroup(gs);
1757         fgtable.put(grp.getName(), new Boolean(grp.getDisplay()));
1758       }
1759     }
1760
1761     if (view.getHiddenColumnsCount() > 0)
1762     {
1763       for (int c = 0; c < view.getHiddenColumnsCount(); c++)
1764       {
1765         af.viewport.hideColumns(
1766             view.getHiddenColumns(c).getStart(),
1767             view.getHiddenColumns(c).getEnd() //+1
1768             );
1769       }
1770     }
1771
1772     af.setMenusFromViewport(af.viewport);
1773
1774     Desktop.addInternalFrame(af, view.getTitle(),
1775                              view.getWidth(), view.getHeight());
1776
1777     //LOAD TREES
1778     ///////////////////////////////////////
1779     if (loadTreesAndStructures && jms.getTreeCount() > 0)
1780     {
1781       try
1782       {
1783         for (int t = 0; t < jms.getTreeCount(); t++)
1784         {
1785
1786           Tree tree = jms.getTree(t);
1787
1788           TreePanel tp = af.ShowNewickTree(new jalview.io.NewickFile(
1789               tree.getNewick()), tree.getTitle(),
1790                                            tree.getWidth(), tree.getHeight(),
1791                                            tree.getXpos(), tree.getYpos());
1792
1793           tp.fitToWindow.setState(tree.getFitToWindow());
1794           tp.fitToWindow_actionPerformed(null);
1795
1796           if (tree.getFontName() != null)
1797           {
1798             tp.setTreeFont(new java.awt.Font(tree.getFontName(),
1799                                              tree.getFontStyle(),
1800                                              tree.getFontSize()));
1801           }
1802           else
1803           {
1804             tp.setTreeFont(new java.awt.Font(view.getFontName(),
1805                                              view.getFontStyle(),
1806                                              tree.getFontSize()));
1807           }
1808
1809           tp.showPlaceholders(tree.getMarkUnlinked());
1810           tp.showBootstrap(tree.getShowBootstrap());
1811           tp.showDistances(tree.getShowDistances());
1812
1813           tp.treeCanvas.threshold = tree.getThreshold();
1814
1815           if (tree.getCurrentTree())
1816           {
1817             af.viewport.setCurrentTree(tp.getTree());
1818           }
1819         }
1820
1821       }
1822       catch (Exception ex)
1823       {
1824         ex.printStackTrace();
1825       }
1826     }
1827
1828     ////LOAD STRUCTURES
1829     if(loadTreesAndStructures)
1830     {
1831       for (int i = 0; i < JSEQ.length; i++)
1832       {
1833         if (JSEQ[i].getPdbidsCount() > 0)
1834         {
1835           Pdbids[] ids = JSEQ[i].getPdbids();
1836           for (int p = 0; p < ids.length; p++)
1837           {
1838             for (int s = 0; s < ids[p].getStructureStateCount(); s++)
1839             {
1840               jalview.datamodel.PDBEntry jpdb = new jalview.datamodel.PDBEntry();
1841
1842               jpdb.setFile(loadPDBFile(ids[p].getFile(), ids[p].getId()));
1843               jpdb.setId(ids[p].getId());
1844
1845               int x = ids[p].getStructureState(s).getXpos();
1846               int y = ids[p].getStructureState(s).getYpos();
1847               int width = ids[p].getStructureState(s).getWidth();
1848               int height = ids[p].getStructureState(s).getHeight();
1849
1850               java.awt.Component comp = Desktop.desktop.getComponentAt(x, y);
1851
1852               String pdbFile = loadPDBFile(file, ids[p].getId());
1853
1854               jalview.datamodel.SequenceI[] seq = new jalview.datamodel.SequenceI[]
1855                   {
1856                   al.getSequenceAt(i)};
1857
1858               if (comp == null ||
1859                   (comp.getWidth() != width && comp.getHeight() != height))
1860               {
1861                 String state = ids[p].getStructureState(s).getContent();
1862
1863                 StringBuffer newFileLoc = new StringBuffer(state.substring(0,
1864                     state.indexOf("\"", state.indexOf("load")) + 1));
1865
1866                 newFileLoc.append(jpdb.getFile());
1867                 newFileLoc.append(state.substring(
1868                     state.indexOf("\"", state.indexOf("load \"") + 6)));
1869
1870                 new AppJMol(pdbFile,
1871                             ids[p].getId(),
1872                             seq,
1873                             af.alignPanel,
1874                             newFileLoc.toString(),
1875                             new java.awt.Rectangle(x, y, width, height));
1876
1877               }
1878               else if(comp!=null)
1879               {
1880                 StructureSelectionManager.getStructureSelectionManager()
1881                     .setMapping(seq, pdbFile,
1882                                 jalview.io.AppletFormatAdapter.FILE);
1883
1884                 ( (AppJMol) comp).addSequence(seq);
1885               }
1886             }
1887           }
1888         }
1889       }
1890     }
1891
1892     return af;
1893   }
1894
1895   public jalview.gui.AlignmentPanel copyAlignPanel(AlignmentPanel ap,
1896       boolean keepSeqRefs)
1897   {
1898     jalview.schemabinding.version2.JalviewModel jm
1899         = SaveState(ap, null, null, null);
1900
1901     if (!keepSeqRefs)
1902     {
1903       seqRefIds.clear();
1904       jm.getJalviewModelSequence().getViewport(0).setSequenceSetId(null);
1905     }
1906     else
1907     {
1908       uniqueSetSuffix = "";
1909     }
1910
1911     viewportsAdded = new Hashtable();
1912
1913     AlignFrame af = LoadFromObject(jm, null, false);
1914     af.alignPanels.clear();
1915     af.closeMenuItem_actionPerformed(true);
1916
1917     /*  if(ap.av.alignment.getAlignmentAnnotation()!=null)
1918       {
1919         for(int i=0; i<ap.av.alignment.getAlignmentAnnotation().length; i++)
1920         {
1921           if(!ap.av.alignment.getAlignmentAnnotation()[i].autoCalculated)
1922           {
1923             af.alignPanel.av.alignment.getAlignmentAnnotation()[i] =
1924                 ap.av.alignment.getAlignmentAnnotation()[i];
1925           }
1926         }
1927       }   */
1928
1929     return af.alignPanel;
1930   }
1931 }