/*
 * Jalview - A Sequence Alignment Editor and Viewer
 * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
package jalview.gui;


import jalview.schemes.*;

import jalview.gui.*;

import java.io.*;

import java.net.*;

import java.util.*;

import java.util.jar.*;

import javax.swing.*;

import org.exolab.castor.xml.*;

import jalview.schemabinding.version2.*;




/**
 * DOCUMENT ME!
 *
 * @author $author$
 * @version $Revision$
 */
public class Jalview2XML
{
    // SAVES SEVERAL ALIGNEMENT WINDOWS TO SAME JARFILE
    public void SaveState(File statefile)
    {
        long creation = System.currentTimeMillis();
        JInternalFrame[] frames = Desktop.desktop.getAllFrames();

        if (frames == null)
        {
            return;
        }

        try
        {
            FileOutputStream fos = new FileOutputStream(statefile);
            JarOutputStream jout = new JarOutputStream(fos);

            //NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS
            ////////////////////////////////////////////////////
            PrintWriter out = new PrintWriter(new OutputStreamWriter(jout,
                        "UTF-8"));

            Vector shortNames = new Vector();

            //REVERSE ORDER
            for (int i = frames.length - 1; i > -1; i--)
            {
                if (frames[i] instanceof AlignFrame)
                {
                    AlignFrame af = (AlignFrame) frames[i];

                    String shortName = af.getTitle();

                    if (shortName.indexOf(File.separatorChar) > -1)
                    {
                        shortName = shortName.substring(shortName.lastIndexOf(
                                    File.separatorChar) + 1);
                    }

                    int count = 1;

                    while (shortNames.contains(shortName))
                    {
                        if (shortName.endsWith("_" + (count - 1)))
                        {
                            shortName = shortName.substring(0,
                                    shortName.lastIndexOf("_"));
                        }

                        shortName = shortName.concat("_" + count);
                        count++;
                    }

                    shortNames.addElement(shortName);

                    if (!shortName.endsWith(".xml"))
                    {
                        shortName = shortName + ".xml";
                    }

                    SaveState(af, creation, shortName, jout, out);
                }
            }

            out.close();
            jout.close();
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }

    // USE THIS METHOD TO SAVE A SINGLE ALIGNMENT WINDOW
    public void SaveAlignment(AlignFrame af, String jarFile,
        String fileName)
    {
        try
        {
            FileOutputStream fos = new FileOutputStream(jarFile);
            JarOutputStream jout = new JarOutputStream(fos);

            //NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS
            ////////////////////////////////////////////////////
            PrintWriter out = new PrintWriter(new OutputStreamWriter(jout,
                        "UTF-8"));

            SaveState(af, System.currentTimeMillis(), fileName, jout, out);
            out.close();
            jout.close();
        }
        catch (Exception ex)
        {
          ex.printStackTrace();
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param af DOCUMENT ME!
     * @param timeStamp DOCUMENT ME!
     * @param fileName DOCUMENT ME!
     * @param jout DOCUMENT ME!
     * @param out DOCUMENT ME!
     */
    public void SaveState(AlignFrame af, long timeStamp,
        String fileName, JarOutputStream jout, PrintWriter out)
    {
        Vector seqids = new Vector();
        Vector userColours = new Vector();

        AlignViewport av = af.viewport;

        JalviewModel object = new JalviewModel();
        object.setVamsasModel(new jalview.schemabinding.version2.VamsasModel());

        object.setCreationDate(new java.util.Date(timeStamp));
        object.setVersion(jalview.bin.Cache.getProperty("VERSION"));

        jalview.datamodel.AlignmentI jal = af.viewport.alignment;

        SequenceSet vamsasSet = new SequenceSet();
        Sequence vamsasSeq;
        JalviewModelSequence jms = new JalviewModelSequence();

        vamsasSet.setGapChar(jal.getGapCharacter() + "");

        JSeq jseq;

        //SAVE SEQUENCES
        int id = 0;

        for (int i = 0; i < jal.getHeight(); i++)
        {
            seqids.add(jal.getSequenceAt(i));

            vamsasSeq = new Sequence();
            vamsasSeq.setId(id + "");
            vamsasSeq.setName(jal.getSequenceAt(i).getName());
            vamsasSeq.setSequence(jal.getSequenceAt(i).getSequence());
            vamsasSeq.setDescription(jal.getSequenceAt(i).getDescription());

            jseq = new JSeq();
            jseq.setStart(jal.getSequenceAt(i).getStart());
            jseq.setEnd(jal.getSequenceAt(i).getEnd());

            jseq.setColour(jal.getSequenceAt(i).getColor().getRGB());

            jseq.setId(id);

            if(jal.getSequenceAt(i).getDatasetSequence().getSequenceFeatures()!=null)
            {
              jalview.datamodel.SequenceFeature[] sf
                  = jal.getSequenceAt(i).getDatasetSequence().getSequenceFeatures();
              int index = 0;
              while(index < sf.length)
              {
                Features features = new Features();

                features.setBegin(sf[index].getBegin());
                features.setEnd(sf[index].getEnd());
                features.setDescription(sf[index].getDescription());
                features.setType(sf[index].getType());
                features.setFeatureGroup(sf[index].getFeatureGroup());
                jseq.addFeatures(features);
                index ++;
              }
            }

            if(jal.getSequenceAt(i).getDatasetSequence().getPDBId()!=null)
            {
              Enumeration en = jal.getSequenceAt(i).getDatasetSequence().getPDBId().elements();
              while(en.hasMoreElements())
              {
                Pdbids pdb = new Pdbids();
                jalview.datamodel.PDBEntry entry
                   = (jalview.datamodel.PDBEntry)en.nextElement();

                pdb.setId(entry.getId());
                pdb.setType(entry.getType());

                if(entry.getProperty()!=null)
                {
                  PdbentryItem item = new PdbentryItem();
                  Hashtable properties = entry.getProperty();
                  Enumeration en2 = properties.keys();
                  while(en2.hasMoreElements())
                  {
                    Property prop = new Property();
                    String key = en2.nextElement().toString();
                    prop.setName(key);
                    prop.setValue( properties.get(key).toString() );
                    item.addProperty(prop);
                  }
                  pdb.addPdbentryItem(item);
                }

                jseq.addPdbids(pdb);
              }
            }

            jms.addJSeq(jseq);
            vamsasSet.addSequence(vamsasSeq);
            id++;
        }

        //SAVE TREES
        ///////////////////////////////////
        if (af.viewport.currentTree != null)
        {
          // FIND ANY ASSOCIATED TREES
          // NOT IMPLEMENTED FOR HEADLESS STATE AT PRESENT
          if (Desktop.desktop != null)
          {
            JInternalFrame[] frames = Desktop.desktop.getAllFrames();

            for (int t = 0; t < frames.length; t++)
            {
              if (frames[t] instanceof TreePanel)
              {
                TreePanel tp = (TreePanel) frames[t];

                if (tp.treeCanvas.av.alignment == jal)
                {
                  Tree tree = new Tree();
                  tree.setTitle(tp.getTitle());
                  tree.setCurrentTree( (af.viewport.currentTree == tp.getTree()));
                  tree.setNewick(tp.getTree().toString());
                  tree.setThreshold(tp.treeCanvas.threshold);

                  tree.setFitToWindow(tp.fitToWindow.getState());
                  tree.setFontName(tp.getTreeFont().getName());
                  tree.setFontSize(tp.getTreeFont().getSize());
                  tree.setFontStyle(tp.getTreeFont().getStyle());
                  tree.setMarkUnlinked(tp.placeholdersMenu.getState());

                  tree.setShowBootstrap(tp.bootstrapMenu.getState());
                  tree.setShowDistances(tp.distanceMenu.getState());

                  tree.setHeight(tp.getHeight());
                  tree.setWidth(tp.getWidth());
                  tree.setXpos(tp.getX());
                  tree.setYpos(tp.getY());

                  jms.addTree(tree);
                }
              }
            }
          }
        }

        //SAVE ANNOTATIONS
        if (jal.getAlignmentAnnotation() != null)
        {
            jalview.datamodel.AlignmentAnnotation[] aa = jal.getAlignmentAnnotation();

            for (int i = 0; i < aa.length; i++)
            {
                Annotation an = new Annotation();

                if (aa[i].label.equals("Quality") ||
                        aa[i].label.equals("Conservation") ||
                        aa[i].label.equals("Consensus"))
                {
                    an.setLabel(aa[i].label);
                    an.setGraph(true);
                    vamsasSet.addAnnotation(an);
                    continue;
                }


                an.setDescription(aa[i].description);

                if(aa[i].sequenceRef!=null)
                 {
                   an.setSequenceRef(aa[i].sequenceRef.getName());
                 }

                if(aa[i].graph>0)
                {
                  an.setGraph(true);
                  an.setGraphType(aa[i].graph);
                  an.setGraphGroup(aa[i].graphGroup);
                  if(aa[i].getThreshold()!=null)
                  {
                    ThresholdLine line = new ThresholdLine();
                    line.setLabel(aa[i].getThreshold().label);
                    line.setValue(aa[i].getThreshold().value);
                    line.setColour(aa[i].getThreshold().colour.getRGB());
                    an.setThresholdLine(line);
                  }
                }
                else
                  an.setGraph(false);

                an.setLabel(aa[i].label);

                AnnotationElement ae;

                for (int a = 0; a < aa[i].annotations.length; a++)
                {
                    if ((aa[i] == null) || (aa[i].annotations[a] == null))
                    {
                        continue;
                    }

                    ae = new AnnotationElement();
                    ae.setDescription(aa[i].annotations[a].description);
                    ae.setDisplayCharacter(aa[i].annotations[a].displayCharacter);
                    ae.setValue(aa[i].annotations[a].value);
                    ae.setPosition(a);
                    ae.setSecondaryStructure(aa[i].annotations[a].secondaryStructure +
                        "");

                    if(aa[i].annotations[a].colour!=java.awt.Color.black)
                      ae.setColour(aa[i].annotations[a].colour.getRGB());

                    an.addAnnotationElement(ae);
                }

                vamsasSet.addAnnotation(an);
            }
        }

        //SAVE GROUPS
        if (jal.getGroups() != null)
        {
            JGroup[] groups = new JGroup[jal.getGroups().size()];

            for (int i = 0; i < groups.length; i++)
            {
                groups[i] = new JGroup();

                jalview.datamodel.SequenceGroup sg = (jalview.datamodel.SequenceGroup) jal.getGroups()
                                                                                          .elementAt(i);
                groups[i].setStart(sg.getStartRes());
                groups[i].setEnd(sg.getEndRes());
                groups[i].setName(sg.getName());
                if(sg.cs!=null)
                {
                  if (sg.cs.conservationApplied())
                  {
                    groups[i].setConsThreshold(sg.cs.getConservationInc());

                    if (sg.cs instanceof jalview.schemes.UserColourScheme)
                    {
                      groups[i].setColour(SetUserColourScheme(sg.cs,
                          userColours,
                          jms));
                    }
                    else
                    {
                      groups[i].setColour(ColourSchemeProperty.getColourName(sg.
                          cs));
                    }
                  }
                  else if(sg.cs instanceof jalview.schemes.AnnotationColourGradient)
                  {
                    groups[i].setColour(
                        ColourSchemeProperty.getColourName(
                      ( (jalview.schemes.AnnotationColourGradient) sg.cs).getBaseColour()));
                  }
                  else if (sg.cs instanceof jalview.schemes.UserColourScheme)
                  {
                    groups[i].setColour(SetUserColourScheme(sg.cs, userColours,
                        jms));
                  }
                  else
                  {
                    groups[i].setColour(ColourSchemeProperty.getColourName(
                        sg.cs));
                  }

                  groups[i].setPidThreshold(sg.cs.getThreshold());
                }

                groups[i].setOutlineColour(sg.getOutlineColour().getRGB());
                groups[i].setDisplayBoxes(sg.getDisplayBoxes());
                groups[i].setDisplayText(sg.getDisplayText());
                groups[i].setColourText(sg.getColourText());

                for (int s = 0; s < sg.getSize(false); s++)
                {
                    jalview.datamodel.Sequence seq = (jalview.datamodel.Sequence) sg.getSequenceAt(s);
                    int index = seqids.indexOf(seq);
                    groups[i].addSeq(index);
                }
            }

            jms.setJGroup(groups);
        }


        ///////////SAVE VIEWPORT
        Viewport view = new Viewport();
        view.setTitle(af.getTitle());
        view.setXpos(af.getX());
        view.setYpos(af.getY());
        view.setWidth(af.getWidth());
        view.setHeight(af.getHeight());
        view.setStartRes(av.startRes);
        view.setStartSeq(av.startSeq);

        if (av.getGlobalColourScheme() instanceof jalview.schemes.UserColourScheme)
        {
            view.setBgColour(SetUserColourScheme(av.getGlobalColourScheme(),
                    userColours, jms));
        }
        else if(av.getGlobalColourScheme() instanceof jalview.schemes.AnnotationColourGradient)
        {
           jalview.schemes.AnnotationColourGradient acg
              = (jalview.schemes.AnnotationColourGradient)av.getGlobalColourScheme();

            AnnotationColours ac = new AnnotationColours();
            ac.setAboveThreshold(acg.getAboveThreshold());
            ac.setThreshold(acg.getAnnotationThreshold());
            ac.setAnnotation(acg.getAnnotation());
            if(acg.getBaseColour() instanceof jalview.schemes.UserColourScheme)
              ac.setColourScheme(SetUserColourScheme(acg.getBaseColour(),
                    userColours, jms));
            else
              ac.setColourScheme(ColourSchemeProperty.getColourName(acg.getBaseColour()));

            ac.setMaxColour(acg.getMaxColour().getRGB());
            ac.setMinColour(acg.getMinColour().getRGB());
            view.setAnnotationColours(ac);
            view.setBgColour("AnnotationColourGradient");
        }
        else
        {
            view.setBgColour(ColourSchemeProperty.getColourName(
                    av.getGlobalColourScheme()));
        }

        ColourSchemeI cs = av.getGlobalColourScheme();

        if(cs!=null)
        {
          if (cs.conservationApplied())
          {
            view.setConsThreshold(cs.getConservationInc());
            if (cs instanceof jalview.schemes.UserColourScheme)
              view.setBgColour(SetUserColourScheme(cs, userColours, jms));
          }

          if (cs instanceof ResidueColourScheme)
          {
            view.setPidThreshold(cs.getThreshold());
          }
        }

        view.setConservationSelected(av.getConservationSelected());
        view.setPidSelected(av.getAbovePIDThreshold());
        view.setFontName(av.font.getName());
        view.setFontSize(av.font.getSize());
        view.setFontStyle(av.font.getStyle());
        view.setRenderGaps(av.renderGaps);
        view.setShowAnnotation(av.getShowAnnotation());
        view.setShowBoxes(av.getShowBoxes());
        view.setShowColourText(av.getColourText());
        view.setShowConservation(av.showConservation);
        view.setShowFullId(av.getShowJVSuffix());
        view.setShowIdentity(av.showIdentity);
        view.setShowQuality(av.showQuality);
        view.setShowSequenceFeatures(av.showSequenceFeatures);
        view.setShowText(av.getShowText());
        view.setWrapAlignment(av.getWrapAlignment());

        if(av.featuresDisplayed!=null)
        {
          jalview.schemabinding.version2.FeatureSettings fs
              = new jalview.schemabinding.version2.FeatureSettings();

          String [] renderOrder =
              af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().renderOrder;
          for(int ro=0; ro<renderOrder.length; ro++)
          {
            Setting setting = new Setting();
            setting.setType(renderOrder[ro]);
            setting.setColour(
                af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().getColour(renderOrder[ro]).getRGB()
                );

            setting.setDisplay(
                av.featuresDisplayed.containsKey(renderOrder[ro])
                );

            fs.addSetting(setting);

          }
          jms.setFeatureSettings(fs);

        }

        jms.addViewport(view);


        object.setJalviewModelSequence(jms);
        object.getVamsasModel().addSequenceSet(vamsasSet);

        try
        {
            if (!fileName.endsWith(".xml"))
            {
                fileName = fileName + ".xml";
            }

            JarEntry entry = new JarEntry(fileName);
            jout.putNextEntry(entry);

            object.marshal(out);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }

    String SetUserColourScheme(jalview.schemes.ColourSchemeI cs,
        Vector userColours, JalviewModelSequence jms)
    {
        String id = null;
        jalview.schemes.UserColourScheme ucs = (jalview.schemes.UserColourScheme) cs;

        if (!userColours.contains(ucs))
        {
            userColours.add(ucs);

            java.awt.Color[] colours = ucs.getColours();
            jalview.schemabinding.version2.UserColours uc = new jalview.schemabinding.version2.UserColours();
            jalview.schemabinding.version2.UserColourScheme jbucs = new jalview.schemabinding.version2.UserColourScheme();

            for (int i = 0; i < colours.length; i++)
            {
                jalview.schemabinding.version2.Colour col = new jalview.schemabinding.version2.Colour();
                col.setRGB(jalview.util.Format.getHexString(colours[i]));
                jbucs.addColour(col);
            }

            id = "ucs" + userColours.indexOf(ucs);
            uc.setId(id);
            uc.setUserColourScheme(jbucs);
            jms.addUserColours(uc);
        }

        return id;
    }

   jalview.schemes.UserColourScheme GetUserColourScheme(
        JalviewModelSequence jms, String id)
    {
        UserColours[] uc = jms.getUserColours();
        UserColours colours = null;

        for (int i = 0; i < uc.length; i++)
        {
            if (uc[i].getId().equals(id))
            {
                colours = uc[i];

                break;
            }
        }

        int csize = colours.getUserColourScheme().getColourCount();
        java.awt.Color[] newColours = new java.awt.Color[csize];

        for (int i = 0; i < csize; i++)
        {
            newColours[i] = new java.awt.Color(Integer.parseInt(
                        colours.getUserColourScheme().getColour(i).getRGB(), 16));
        }

        return new jalview.schemes.UserColourScheme(newColours);
    }

    /**
     * DOCUMENT ME!
     *
     * @param file DOCUMENT ME!
     */
    public AlignFrame LoadJalviewAlign(String file)
    {

        jalview.gui.AlignFrame af = null;

        try
        {
            //UNMARSHALLER SEEMS TO CLOSE JARINPUTSTREAM, MOST ANNOYING
            URL url = null;

            if (file.startsWith("http://"))
            {
                url = new URL(file);
            }

            JarInputStream jin = null;
            JarEntry jarentry = null;
            int entryCount = 1;

            do
            {
                if (url != null)
                {
                    jin = new JarInputStream(url.openStream());
                }
                else
                {
                    jin = new JarInputStream(new FileInputStream(file));
                }

                for (int i = 0; i < entryCount; i++)
                {
                    jarentry = jin.getNextJarEntry();

                  }


                  class NoDescIDResolver implements IDResolver
                  {
                    public Object resolve(String idref)
                    {
                      System.out.println(idref+" used");
                      return null;
                    }
                  }


                if (jarentry != null)
                {
                    InputStreamReader in = new InputStreamReader(jin, "UTF-8");
                    JalviewModel object = new JalviewModel();

                    Unmarshaller unmar = new Unmarshaller(object);
                    unmar.setValidation(false);
                    object = (JalviewModel) unmar.unmarshal( in );

                    af = LoadFromObject(object);
                    entryCount++;
                }
            }
            while (jarentry != null);
        }
        catch(java.net.UnknownHostException ex)
        {
          ex.printStackTrace();
          System.err.println("Couldn't locate Jalview XML file : " +
              ex + "\n");
           JOptionPane.showInternalMessageDialog(Desktop.desktop,
                                    "Couldn't locate " + file,
                                    "URL not found",
                                    JOptionPane.WARNING_MESSAGE);

        }
        catch (Exception ex)
        {
          //Is Version 1 Jar file?
          af =  new Jalview2XML_V1().LoadJalviewAlign(file);

          if(af!=null)
          {
            System.out.println("Successfully loaded archive file");
            return af;
          }
          ex.printStackTrace();
            System.err.println("Exception whilst loading jalview XML file : " +
                ex + "\n");
             JOptionPane.showInternalMessageDialog(Desktop.desktop,
                                      "Error loading  " + file,
                                      "Error loading Jalview file",
                                      JOptionPane.WARNING_MESSAGE);

        }

        return af;
    }

    AlignFrame LoadFromObject(JalviewModel object)
    {
        Vector seqids = new Vector();
        SequenceSet vamsasSet = object.getVamsasModel().getSequenceSet(0);
        Sequence[] vamsasSeq = vamsasSet.getSequence();

        JalviewModelSequence jms = object.getJalviewModelSequence();

        //////////////////////////////////
        //LOAD SEQUENCES
        jalview.datamodel.Sequence[] jseqs = new jalview.datamodel.Sequence[vamsasSeq.length];
        JSeq[] JSEQ = object.getJalviewModelSequence().getJSeq();
        for (int i = 0; i < vamsasSeq.length; i++)
        {
            jseqs[i] = new jalview.datamodel.Sequence(vamsasSeq[i].getName(),
                    vamsasSeq[i].getSequence());
            jseqs[i].setDescription( vamsasSeq[i].getDescription() );

            jseqs[i].setStart(JSEQ[i].getStart());
            jseqs[i].setEnd(JSEQ[i].getEnd());
            jseqs[i].setColor(new java.awt.Color(JSEQ[i].getColour()));
            seqids.add(jseqs[i]);
        }

        ///SequenceFeatures are added to the DatasetSequence,
        // so we must create the dataset before loading features
        /////////////////////////////////
        jalview.datamodel.Alignment al = new jalview.datamodel.Alignment(jseqs);
        al.setDataset(null);
        /////////////////////////////////

        for (int i = 0; i < vamsasSeq.length; i++)
        {
          if (JSEQ[i].getFeaturesCount() > 0)
          {
            Features[] features = JSEQ[i].getFeatures();
            for (int f = 0; f < features.length; f++)
            {
              jalview.datamodel.SequenceFeature sf
                  = new jalview.datamodel.SequenceFeature(features[f].getType(),
                  features[f].getDescription(), features[f].getStatus(),
                  features[f].getBegin(), features[f].getEnd(),
                  features[f].getFeatureGroup());

              al.getSequenceAt(i).getDatasetSequence().addSequenceFeature(sf);
            }
          }
          if (JSEQ[i].getPdbidsCount() > 0)
          {
            Pdbids[] ids = JSEQ[i].getPdbids();
            for (int p = 0; p < ids.length; p++)
            {
              jalview.datamodel.PDBEntry entry = new jalview.datamodel.PDBEntry();
              entry.setId(ids[p].getId());
              entry.setType(ids[p].getType());
              al.getSequenceAt(i).getDatasetSequence().addPDBId(entry);
            }

          }
        }


         /////////////////////////////////
        //////////////////////////////////
        //LOAD ANNOTATIONS
        boolean hideQuality = true,
            hideConservation = true,
            hideConsensus = true;

        if (vamsasSet.getAnnotation() != null)
        {
            Annotation[] an = vamsasSet.getAnnotation();

            for (int i = 0; i < an.length; i++)
            {
               if (an[i].getLabel().equals("Quality"))
                {
                 hideQuality = false;
                 continue;
                }
               else if(an[i].getLabel().equals("Conservation"))
               {
                 hideConservation = false;
                 continue;
               }
               else if(an[i].getLabel().equals("Consensus"))
               {
                 hideConsensus = false;
                 continue;
               }

                AnnotationElement[] ae = an[i].getAnnotationElement();
                jalview.datamodel.Annotation[] anot = new jalview.datamodel.Annotation[al.getWidth()];

                for (int aa = 0; aa < ae.length; aa++)
                {
                    anot[ae[aa].getPosition()] = new jalview.datamodel.Annotation(ae[aa].getDisplayCharacter(),
                            ae[aa].getDescription(),
                            ae[aa].getSecondaryStructure().length()==0?' ':ae[aa].getSecondaryStructure().charAt(0),
                            ae[aa].getValue());
                    anot[ae[aa].getPosition()].colour = new java.awt.Color( ae[aa].getColour() );
                }

                jalview.datamodel.AlignmentAnnotation jaa = null;

                if (an[i].getGraph())
                {
                  jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(),
                      an[i].getDescription(), anot, 0, 0,
                      an[i].getGraphType());

                  jaa.graphGroup = an[i].getGraphGroup();

                  if (an[i].getThresholdLine() != null)
                  {
                    jaa.setThreshold(new jalview.datamodel.GraphLine(
                                  an[i].getThresholdLine().getValue(),
                                  an[i].getThresholdLine().getLabel(),
                                new java.awt.Color(an[i].getThresholdLine().getColour()))
                             );

                  }

                }
                else
                {
                    jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(),
                            an[i].getDescription(), anot);
                }

                if(an[i].getSequenceRef()!=null)
                {
                  jaa.createSequenceMapping(
                      al.findName(an[i].getSequenceRef()), 1
                      );
                  al.findName(an[i].getSequenceRef()).addAlignmentAnnotation(jaa);
                }

                al.addAnnotation(jaa);
            }
        }


        //  af.changeColour() );
        /////////////////////////
        //LOAD GROUPS
        if (jms.getJGroupCount() > 0)
        {
            JGroup[] groups = jms.getJGroup();

            for (int i = 0; i < groups.length; i++)
            {
                ColourSchemeI cs = null;

                if (groups[i].getColour() != null)
                {
                    if (groups[i].getColour().startsWith("ucs"))
                    {
                        cs = GetUserColourScheme(jms, groups[i].getColour());
                    }
                    else
                    {
                        cs = ColourSchemeProperty.getColour(al,
                                groups[i].getColour());
                    }

                    if(cs!=null)
                      cs.setThreshold(groups[i].getPidThreshold(), true);
                }

                Vector seqs = new Vector();
                int[] ids = groups[i].getSeq();

                for (int s = 0; s < ids.length; s++)
                {
                    seqs.addElement((jalview.datamodel.SequenceI) seqids.elementAt(
                            ids[s]));
                }

                jalview.datamodel.SequenceGroup sg = new jalview.datamodel.SequenceGroup(seqs,
                        groups[i].getName(), cs, groups[i].getDisplayBoxes(),
                        groups[i].getDisplayText(), groups[i].getColourText(),
                        groups[i].getStart(), groups[i].getEnd());

                sg.setOutlineColour(new java.awt.Color(
                        groups[i].getOutlineColour()));

                if (groups[i].getConsThreshold() != 0)
                {
                    jalview.analysis.Conservation c = new jalview.analysis.Conservation("All",
                            ResidueProperties.propHash, 3, sg.getSequences(false), 0,
                            sg.getWidth() - 1);
                    c.calculate();
                    c.verdict(false, 25);
                    sg.cs.setConservation(c);
                }

                al.addGroup(sg);
            }
        }


        /////////////////////////////////
        // LOAD VIEWPORT
        Viewport[] views = jms.getViewport();
        Viewport view = views[0]; // DEAL WITH MULTIPLE VIEWPORTS LATER

        AlignFrame af = new AlignFrame(al);
        if(hideConsensus || hideQuality || hideConservation)
        {
          int hSize = al.getAlignmentAnnotation().length;
          for (int h = 0; h < hSize; h++)
          {
            if (
                (hideConsensus &&
                 al.getAlignmentAnnotation()[h].label.equals("Consensus"))
                ||
                (hideQuality &&
                 al.getAlignmentAnnotation()[h].label.equals("Quality"))
                ||
                (hideConservation &&
                 al.getAlignmentAnnotation()[h].label.equals("Conservation")))
            {
              al.deleteAnnotation(al.getAlignmentAnnotation()[h]);
              hSize--;
              h--;
            }
          }
          af.alignPanel.adjustAnnotationHeight();
        }

        af.setBounds(view.getXpos(), view.getYpos(), view.getWidth(),
            view.getHeight());
        af.viewport.setStartRes(view.getStartRes());
        af.viewport.setStartSeq(view.getStartSeq());
        af.viewport.setShowAnnotation(view.getShowAnnotation());
        af.viewport.showConservation = view.getShowConservation();
        af.viewport.showQuality = view.getShowQuality();
        af.viewport.showIdentity = view.getShowIdentity();
        af.viewport.setAbovePIDThreshold(view.getPidSelected());
        af.abovePIDThreshold.setSelected(view.getPidSelected());
        af.viewport.setColourText(view.getShowColourText());
        af.colourTextMenuItem.setSelected(view.getShowColourText());
        af.viewport.setConservationSelected(view.getConservationSelected());
        af.conservationMenuItem.setSelected(view.getConservationSelected());

        af.viewport.setShowJVSuffix(view.getShowFullId());
        af.seqLimits.setSelected(view.getShowFullId());

        af.viewport.setFont(new java.awt.Font(view.getFontName(),
                view.getFontStyle(), view.getFontSize()));
        af.alignPanel.fontChanged();

        af.viewport.setRenderGaps(view.getRenderGaps());
        af.renderGapsMenuItem.setSelected(view.getRenderGaps());

        af.viewport.setWrapAlignment(view.getWrapAlignment());
        af.wrapMenuItem.setSelected(view.getWrapAlignment());

        if (view.getWrapAlignment())
        {
            af.alignPanel.setWrapAlignment(view.getWrapAlignment());
        }
        else
        {
            af.annotationPanelMenuItem.setState(view.getShowAnnotation());
            af.viewport.setShowAnnotation(view.getShowAnnotation());
            af.alignPanel.setAnnotationVisible(view.getShowAnnotation());
        }

        af.viewport.setShowBoxes(view.getShowBoxes());
        af.viewBoxesMenuItem.setSelected(view.getShowBoxes());
        af.viewport.setShowText(view.getShowText());
        af.viewTextMenuItem.setSelected(view.getShowText());

        ColourSchemeI cs = null;

        if (view.getBgColour() != null)
        {
            if (view.getBgColour().startsWith("ucs"))
            {
                cs = GetUserColourScheme(jms, view.getBgColour());
            }
            else if(view.getBgColour().startsWith("Annotation"))
            {
              //int find annotation
              for (int i = 0; i < af.viewport.alignment.getAlignmentAnnotation().length; i++)
              {
                if (af.viewport.alignment.getAlignmentAnnotation()[i].label.
                    equals(view.getAnnotationColours().getAnnotation()))
                {
                  if (af.viewport.alignment.getAlignmentAnnotation()[i].
                      getThreshold() == null)
                  {
                    af.viewport.alignment.getAlignmentAnnotation()[i].
                        setThreshold(
                            new jalview.datamodel.GraphLine(
                                view.getAnnotationColours().getThreshold(),
                                "Threshold", java.awt.Color.black)

                        );
                  }


                  if (view.getAnnotationColours().getColourScheme().equals(
                      "None"))
                  {
                    cs = new AnnotationColourGradient(
                        af.viewport.alignment.getAlignmentAnnotation()[i],
                        new java.awt.Color(view.getAnnotationColours().
                                           getMinColour()),
                        new java.awt.Color(view.getAnnotationColours().
                                           getMaxColour()),
                        view.getAnnotationColours().getAboveThreshold());
                  }
                  else if (view.getAnnotationColours().getColourScheme().
                           startsWith("ucs"))
                  {
                     cs = new AnnotationColourGradient(
                         af.viewport.alignment.getAlignmentAnnotation()[i],
                         GetUserColourScheme(jms, view.getAnnotationColours().
                                                        getColourScheme()),
                         view.getAnnotationColours().getAboveThreshold()
                         );
                   }
                   else
                   {
                     cs = new AnnotationColourGradient(
                         af.viewport.alignment.getAlignmentAnnotation()[i],
                         ColourSchemeProperty.getColour(al,
                         view.getAnnotationColours().getColourScheme()),
                         view.getAnnotationColours().getAboveThreshold()
                         );
                   }

                  // Also use these settings for all the groups
                  if (al.getGroups() != null)
                    for (int g = 0; g < al.getGroups().size(); g++)
                    {
                      jalview.datamodel.SequenceGroup sg
                          = (jalview.datamodel.SequenceGroup)al.getGroups().elementAt(g);

                      if(sg.cs == null)
                        continue;


                  /*    if (view.getAnnotationColours().getColourScheme().equals("None"))
                      {
                        sg.cs = new AnnotationColourGradient(
                            af.viewport.alignment.getAlignmentAnnotation()[i],
                            new java.awt.Color(view.getAnnotationColours().
                                               getMinColour()),
                            new java.awt.Color(view.getAnnotationColours().
                                               getMaxColour()),
                            view.getAnnotationColours().getAboveThreshold());
                      }
                      else*/
                      {
                        sg.cs = new AnnotationColourGradient(
                            af.viewport.alignment.getAlignmentAnnotation()[i],
                            sg.cs,
                            view.getAnnotationColours().getAboveThreshold()
                            );
                      }

                    }


                  break;
                }

              }
            }
            else
            {
                cs = ColourSchemeProperty.getColour(al, view.getBgColour());
            }

            if(cs!=null)
            {
              cs.setThreshold(view.getPidThreshold(), true);
              cs.setConsensus(af.viewport.vconsensus);
            }
        }

        af.setColourSelected(view.getBgColour());
        af.viewport.setGlobalColourScheme(cs);
        af.viewport.setColourAppliesToAllGroups(false);
        af.changeColour(cs);
        if (view.getConservationSelected() && cs!=null)
        {
          cs.setConservationInc(view.getConsThreshold());
        }

        af.viewport.setColourAppliesToAllGroups(true);

        if (view.getShowSequenceFeatures())
        {
           af.viewport.showSequenceFeatures = true;
           af.showSeqFeatures.setSelected(true);
        }

        if(jms.getFeatureSettings()!=null)
        {
          af.viewport.featuresDisplayed = new Hashtable();
          String [] renderOrder = new String[jms.getFeatureSettings().getSettingCount()];
         for(int fs=0; fs<jms.getFeatureSettings().getSettingCount(); fs++)
         {
           Setting setting = jms.getFeatureSettings().getSetting(fs);

           af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setColour(setting.getType(),
               new java.awt.Color(setting.getColour()));

           renderOrder[fs] = setting.getType();

           if(setting.getDisplay())
             af.viewport.featuresDisplayed.put(
                 setting.getType(), new Integer(setting.getColour()));
         }
         af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().renderOrder = renderOrder;
        }


        Desktop.addInternalFrame(af, view.getTitle(),
             view.getWidth(), view.getHeight());

        //LOAD TREES
        ///////////////////////////////////////
        if (jms.getTreeCount() > 0)
        {
            try
            {
                for (int t = 0; t < jms.getTreeCount(); t++)
                {

                    Tree tree = jms.getTree(t);

                    TreePanel tp = af.ShowNewickTree(new jalview.io.NewickFile(
                                tree.getNewick()), tree.getTitle(),
                                tree.getWidth(), tree.getHeight(),
                                tree.getXpos(), tree.getYpos());

                    tp.fitToWindow.setState(tree.getFitToWindow());
                    tp.fitToWindow_actionPerformed(null);

                    if(tree.getFontName()!=null)
                      tp.setTreeFont(new java.awt.Font(tree.getFontName(),
                                          tree.getFontStyle(),
                                          tree.getFontSize()));
                    else
                      tp.setTreeFont(new java.awt.Font(view.getFontName(),
                                            view.getFontStyle(),
                                            tree.getFontSize()));

                    tp.showPlaceholders(tree.getMarkUnlinked());
                    tp.showBootstrap(tree.getShowBootstrap());
                    tp.showDistances(tree.getShowDistances());

                    tp.treeCanvas.threshold = tree.getThreshold();

                    if (tree.getCurrentTree())
                      af.viewport.setCurrentTree(tp.getTree());
                }

            }
            catch (Exception ex)
            {
                ex.printStackTrace();
            }

        }

        return af;
    }
}