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