From e33cdacd2ac2836504375c538574a0f1cafec7e3 Mon Sep 17 00:00:00 2001
From: jprocter <Jim Procter>
Date: Wed, 26 Jul 2006 13:32:37 +0000
Subject: [PATCH] Implemented CIGAR representation of an Alignment view for
 passing to analysis'.

---
 src/jalview/analysis/NJTree.java           |   81 +-
 src/jalview/appletgui/TreePanel.java       |    2 +-
 src/jalview/datamodel/Alignment.java       | 1607 ++++++++++++++--------------
 src/jalview/datamodel/AlignmentI.java      |    6 +-
 src/jalview/datamodel/ColumnSelection.java |  915 ++++++++--------
 src/jalview/gui/AlignViewport.java         |   81 ++
 src/jalview/gui/TreePanel.java             |   46 +-
 src/jalview/jbgui/GTreePanel.java          |    2 +-
 8 files changed, 1459 insertions(+), 1281 deletions(-)

diff --git a/src/jalview/analysis/NJTree.java b/src/jalview/analysis/NJTree.java
index 423e235..98916e3 100755
--- a/src/jalview/analysis/NJTree.java
+++ b/src/jalview/analysis/NJTree.java
@@ -42,7 +42,7 @@ public class NJTree
 
     //SequenceData is a string representation of what the user
     //sees. The display may contain hidden columns.
-    String [] sequenceString;
+    CigarArray seqData=null;
 
     int[] done;
     int noseqs;
@@ -69,18 +69,42 @@ public class NJTree
 
     private boolean hasRootDistance = true;
 
+    /**
+     * Create a new NJTree object with leaves associated with sequences in seqs,
+     * and original alignment data represented by Cigar strings.
+     * @param seqs SequenceI[]
+     * @param odata Cigar[]
+     * @param treefile NewickFile
+     */
+    public NJTree(SequenceI[] seqs, CigarArray odata, NewickFile treefile) {
+      this(seqs, treefile);
+      if (odata!=null)
+        seqData = odata;
+      /*
+      sequenceString = new String[odata.length];
+      char gapChar = jalview.util.Comparison.GapChars.charAt(0);
+      for (int i = 0; i < odata.length; i++)
+      {
+        SequenceI oseq_aligned = odata[i].getSeq(gapChar);
+          sequenceString[i] = oseq_aligned.getSequence();
+      } */
+    }
 
     /**
-     * Creates a new NJTree object.
+     * Creates a new NJTree object from a tree from an external source
      *
-     * @param seqs DOCUMENT ME!
-     * @param treefile DOCUMENT ME!
+     * @param seqs SequenceI which should be associated with leafs of treefile
+     * @param treefile A parsed tree
      */
     public NJTree(SequenceI[] seqs,  NewickFile treefile)
     {
         this.sequence = seqs;
         top = treefile.getTree();
 
+        /**
+         * There is no dependent alignment to be recovered from an
+         * imported tree.
+         *
         if (sequenceString == null)
         {
           sequenceString = new String[seqs.length];
@@ -89,7 +113,7 @@ public class NJTree
             sequenceString[i] = seqs[i].getSequence();
           }
         }
-
+        */
 
         hasDistances = treefile.HasDistances();
         hasBootstrap = treefile.HasBootstrap();
@@ -143,7 +167,7 @@ public class NJTree
      * @param end DOCUMENT ME!
      */
     public NJTree(SequenceI[] sequence,
-                  String [] sequenceString,
+                  CigarArray seqData,
                   String type,
                   String pwtype,
                   int start, int end)
@@ -152,18 +176,17 @@ public class NJTree
         this.node = new Vector();
         this.type = type;
         this.pwtype = pwtype;
-
-        if (sequenceString == null)
-        {
-          this.sequenceString = new String[sequence.length];
+        if (seqData!=null) {
+          this.seqData = seqData;
+        } else {
+          SeqCigar[] seqs = new SeqCigar[sequence.length];
           for(int i=0; i<sequence.length; i++)
-          {
-            this.sequenceString[i] = sequence[i].getSequence(start, end);
-          }
+            {
+              seqs[i] = new SeqCigar(sequence[i], start, end);
+            }
+            this.seqData = new CigarArray(seqs);
+            this.seqData.addOperation(CigarArray.M, end-start+1);
         }
-        else
-          this.sequenceString = sequenceString;
-
 
         if (!(type.equals("NJ")))
         {
@@ -187,7 +210,7 @@ public class NJTree
 
         noseqs = i++;
 
-        distance = findDistances();
+        distance = findDistances(this.seqData.getSequenceStrings(Comparison.GapChars.charAt(0)));
 
         makeLeaves();
 
@@ -596,7 +619,7 @@ public class NJTree
      *
      * @return DOCUMENT ME!
      */
-    public float[][] findDistances()
+    public float[][] findDistances(String[] sequenceString)
     {
         float[][] distance = new float[noseqs][noseqs];
 
@@ -982,15 +1005,31 @@ public class NJTree
 
         return top;
     }
-
+    /**
+     *
+     * @return true if original sequence data can be recovered
+     */
+    public boolean hasOriginalSequenceData() {
+      return seqData!=null;
+    }
+    /**
+     * Returns original alignment data used for calculation - or null where
+     * not available.
+     *
+     * @return null or cut'n'pasteable alignment
+     */
     public String printOriginalSequenceData()
     {
+      if (seqData==null)
+        return null;
+//      return seqData.getSequenceString(Comparison.GapChars[0]);
       StringBuffer sb = new StringBuffer();
-      for(int i=0; i<sequenceString.length; i++)
+      String[] seqdatas = seqData.getSequenceStrings(Comparison.GapChars.charAt(0));
+      for(int i=0; i<seqdatas.length; i++)
       {
         sb.append(new jalview.util.Format("%-" + 15 + "s").form(
             sequence[i].getName()));
-        sb.append(" "+sequenceString[i]+"\n");
+        sb.append(" "+seqdatas[i]+"\n");
       }
       return sb.toString();
     }
diff --git a/src/jalview/appletgui/TreePanel.java b/src/jalview/appletgui/TreePanel.java
index e770a16..19ed987 100755
--- a/src/jalview/appletgui/TreePanel.java
+++ b/src/jalview/appletgui/TreePanel.java
@@ -134,7 +134,7 @@ public class TreePanel extends Frame implements ActionListener, ItemListener
         {
           int start, end;
           SequenceI [] seqs;
-          String [] seqStrings = null;
+          CigarArray seqStrings = null;
        //   if (av.hasHiddenColumns)
           {
         //    seqStrings = av.getSelectionAsString();
diff --git a/src/jalview/datamodel/Alignment.java b/src/jalview/datamodel/Alignment.java
index 90347ca..8c320f7 100755
--- a/src/jalview/datamodel/Alignment.java
+++ b/src/jalview/datamodel/Alignment.java
@@ -1,788 +1,819 @@
-/*
- * 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.datamodel;
-
-import jalview.analysis.*;
-
-import jalview.util.*;
-
-import java.util.*;
-
-/** Data structure to hold and manipulate a multiple sequence alignment
- */
-public class Alignment implements AlignmentI
-{
-    protected Alignment dataset;
-    protected Vector sequences;
-    protected Vector groups = new Vector();
-    protected char gapCharacter = '-';
-    protected int type = NUCLEOTIDE;
-    public static final int PROTEIN = 0;
-    public static final int NUCLEOTIDE = 1;
-
-    /** DOCUMENT ME!! */
-    public AlignmentAnnotation[] annotations;
-
-    HiddenSequences hiddenSequences = new HiddenSequences(this);
-
-
-    /** Make an alignment from an array of Sequences.
-     *
-     * @param sequences
-     */
-    public Alignment(SequenceI[] seqs)
-    {
-        int i=0;
-
-        if( jalview.util.Comparison.isNucleotide(seqs))
-          type = NUCLEOTIDE;
-        else
-          type = PROTEIN;
-
-        sequences = new Vector();
-
-        for (i = 0; i < seqs.length; i++)
-        {
-            sequences.addElement(seqs[i]);
-        }
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public Vector getSequences()
-    {
-        return sequences;
-    }
-
-    public SequenceI [] getSequencesArray()
-    {
-      SequenceI [] reply = new SequenceI[sequences.size()];
-      for(int i=0; i<sequences.size(); i++)
-      {
-        reply[i] = (SequenceI)sequences.elementAt(i);
-      }
-      return reply;
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param i DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public SequenceI getSequenceAt(int i)
-    {
-        if (i < sequences.size())
-        {
-            return (SequenceI) sequences.elementAt(i);
-        }
-
-        return null;
-    }
-
-    /** Adds a sequence to the alignment.  Recalculates maxLength and size.
-     *
-     * @param snew
-     */
-    public void addSequence(SequenceI snew)
-    {
-      if(dataset!=null)
-      {
-        if(snew.getDatasetSequence()!=null)
-        {
-          System.out.println(snew.getName());
-          getDataset().addSequence(snew.getDatasetSequence());
-        }
-        else
-        {
-          Sequence ds = new Sequence(snew.getName(),
-                                     AlignSeq.extractGaps("-. ",
-              snew.getSequence()),
-                                     snew.getStart(),
-                                     snew.getEnd());
-
-          snew.setDatasetSequence(ds);
-          getDataset().addSequence(ds);
-        }
-      }
-
-      sequences.addElement(snew);
-    }
-
-
-    /** Adds a sequence to the alignment.  Recalculates maxLength and size.
-     *
-     * @param snew
-     */
-    public void setSequenceAt(int i, SequenceI snew)
-    {
-        SequenceI oldseq = getSequenceAt(i);
-        deleteSequence(oldseq);
-
-        sequences.setElementAt(snew, i);
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public Vector getGroups()
-    {
-        return groups;
-    }
-
-    /** Takes out columns consisting entirely of gaps (-,.," ")
-     */
-    public void removeGaps()
-    {
-        SequenceI[] seqs = getVisibleAndRepresentedSeqs();
-        int j, jSize = seqs.length;
-
-        int width = 0;
-        for (int i = 0; i < jSize; i++)
-        {
-          if (seqs[i].getLength() > width)
-          {
-            width = seqs[i].getLength();
-          }
-        }
-
-        int startCol = -1, endCol = -1;
-        boolean delete = true;
-        for (int i = 0; i < width; i++)
-        {
-            delete = true;
-
-            for (j = 0; j < jSize; j++)
-            {
-                if (seqs[j].getLength() > i)
-                {
-                    if (!jalview.util.Comparison.isGap(seqs[j].getCharAt(i)))
-                    {
-                        if(delete)
-                          endCol = i;
-
-                        delete = false;
-                        break;
-                    }
-                }
-
-            }
-
-            if(delete && startCol==-1)
-            {
-              startCol = i;
-            }
-
-
-            if (!delete && startCol > -1)
-            {
-              deleteColumns(seqs, startCol, endCol);
-              width -= (endCol - startCol);
-              i -= (endCol - startCol);
-              startCol = -1;
-              endCol = -1;
-            }
-        }
-
-        if (delete && startCol > -1)
-        {
-          deleteColumns(seqs, startCol, endCol);
-        }
-
-    }
-
-    /** Removes a range of columns (start to end inclusive).
-     *
-     * @param seqs Sequences to remove columns from
-     * @param start Start column in the alignment
-     * @param end End column in the alignment
-     */
-    public void deleteColumns(SequenceI [] seqs, int start, int end)
-    {
-      for(int i=0; i<seqs.length; i++)
-        seqs[i].deleteChars(start, end);
-    }
-
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param i DOCUMENT ME!
-     */
-    public void trimLeft(int i)
-    {
-        SequenceI[] seqs = getVisibleAndRepresentedSeqs();
-        int j, jSize = seqs.length;
-        for (j = 0; j < jSize; j++)
-        {
-            int newstart = seqs[j].findPosition(i);
-
-            if(i>seqs[j].getLength())
-            {
-              sequences.removeElement(seqs[j]);
-              j--;
-              jSize--;
-            }
-            else
-            {
-              seqs[j].setStart(newstart);
-              seqs[j].setSequence(seqs[j].getSequence().substring(i));
-            }
-        }
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param i DOCUMENT ME!
-     */
-    public void trimRight(int i)
-    {
-        SequenceI[] seqs = getVisibleAndRepresentedSeqs();
-        int j, jSize = seqs.length;
-        for (j = 0; j < jSize; j++)
-        {
-            int newend = seqs[j].findPosition(i);
-
-            seqs[j].setEnd(newend);
-            if(seqs[j].getLength()>i)
-              seqs[j].setSequence(seqs[j].getSequence().substring(0, i + 1));
-        }
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param s DOCUMENT ME!
-     */
-    public void deleteSequence(SequenceI s)
-    {
-        for (int i = 0; i < getHeight(); i++)
-        {
-            if (getSequenceAt(i) == s)
-            {
-                deleteSequence(i);
-            }
-        }
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param i DOCUMENT ME!
-     */
-    public void deleteSequence(int i)
-    {
-        sequences.removeElementAt(i);
-    }
-
-
-    /**    */
-    public SequenceGroup findGroup(SequenceI s)
-    {
-        for (int i = 0; i < this.groups.size(); i++)
-        {
-            SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
-
-            if (sg.getSequences(false).contains(s))
-            {
-                return sg;
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param s DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public SequenceGroup[] findAllGroups(SequenceI s)
-    {
-        Vector temp = new Vector();
-
-        int gSize = groups.size();
-        for (int i = 0; i < gSize; i++)
-        {
-            SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
-            if(sg==null || sg.getSequences(false)==null)
-            {
-              this.deleteGroup(sg);
-              gSize--;
-              continue;
-            }
-
-            if (sg.getSequences(false).contains(s))
-            {
-                temp.addElement(sg);
-            }
-        }
-
-        SequenceGroup[] ret = new SequenceGroup[temp.size()];
-
-        for (int i = 0; i < temp.size(); i++)
-        {
-            ret[i] = (SequenceGroup) temp.elementAt(i);
-        }
-
-        return ret;
-    }
-
-
-
-    /**    */
-    public void addGroup(SequenceGroup sg)
-    {
-        if (!groups.contains(sg))
-        {
-            groups.addElement(sg);
-        }
-    }
-
-    /**
-     * DOCUMENT ME!
-     */
-    public void deleteAllGroups()
-    {
-        groups.removeAllElements();
-
-        int i = 0;
-
-        while (i < sequences.size())
-        {
-            SequenceI s = getSequenceAt(i);
-            s.setColor(java.awt.Color.white);
-            i++;
-        }
-    }
-
-    /**    */
-    public void deleteGroup(SequenceGroup g)
-    {
-        if (groups.contains(g))
-        {
-            groups.removeElement(g);
-        }
-    }
-
-    /**    */
-    public SequenceI findName(String name)
-    {
-        int i = 0;
-
-        while (i < sequences.size())
-        {
-            if (getSequenceAt(i).getName().equals(name))
-            {
-                return getSequenceAt(i);
-            }
-
-            i++;
-        }
-
-        return null;
-    }
-
-
-    /**    */
-    public int findIndex(SequenceI s)
-    {
-        int i = 0;
-
-        while (i < sequences.size())
-        {
-            if (s == getSequenceAt(i))
-            {
-                return i;
-            }
-
-            i++;
-        }
-
-        return -1;
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public int getHeight()
-    {
-        return sequences.size();
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public int getWidth()
-    {
-        int maxLength = -1;
-
-        for (int i = 0; i < sequences.size(); i++)
-        {
-            if (getSequenceAt(i).getLength() > maxLength)
-            {
-                maxLength = getSequenceAt(i).getLength();
-            }
-        }
-
-        return maxLength;
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public int getMaxIdLength()
-    {
-        int max = 0;
-        int i = 0;
-
-        while (i < sequences.size())
-        {
-            SequenceI seq = getSequenceAt(i);
-            String tmp = seq.getName() + "/" + seq.getStart() + "-" +
-                seq.getEnd();
-
-            if (tmp.length() > max)
-            {
-                max = tmp.length();
-            }
-
-            i++;
-        }
-
-        return max;
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param gc DOCUMENT ME!
-     */
-    public void setGapCharacter(char gc)
-    {
-        gapCharacter = gc;
-
-        for (int i = 0; i < sequences.size(); i++)
-        {
-            Sequence seq = (Sequence) sequences.elementAt(i);
-            seq.setSequence( seq.getSequence().replace('.', gc) );
-            seq.setSequence( seq.getSequence().replace('-', gc) );
-            seq.setSequence( seq.getSequence().replace(' ', gc) );
-        }
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public char getGapCharacter()
-    {
-        return gapCharacter;
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public Vector getAAFrequency()
-    {
-        return AAFrequency.calculate(sequences, 0, getWidth());
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public boolean isAligned()
-    {
-        int width = getWidth();
-
-        for (int i = 0; i < sequences.size(); i++)
-        {
-            if (getSequenceAt(i).getLength() != width)
-            {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param aa DOCUMENT ME!
-     */
-    public void deleteAnnotation(AlignmentAnnotation aa)
-    {
-        int aSize = 1;
-
-        if (annotations != null)
-        {
-            aSize = annotations.length;
-        }
-
-        AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize - 1];
-
-        int tIndex = 0;
-
-        for (int i = 0; i < aSize; i++)
-        {
-            if (annotations[i] == aa)
-            {
-                continue;
-            }
-
-            temp[tIndex] = annotations[i];
-            tIndex++;
-        }
-
-        annotations = temp;
-    }
-
-
-    public void adjustSequenceAnnotations()
-    {
-      if(annotations!=null)
-      {
-        for (int a = 0; a < annotations.length; a++)
-        {
-          if (annotations[a].sequenceRef != null)
-          {
-            annotations[a].adjustForAlignment();
-          }
-        }
-      }
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param aa DOCUMENT ME!
-     */
-    public void addAnnotation(AlignmentAnnotation aa)
-    {
-        int aSize = 1;
-        if (annotations != null)
-        {
-            aSize = annotations.length + 1;
-        }
-
-        AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize];
-
-        temp[aSize-1] = aa;
-
-        int i = 0;
-
-        if (aSize > 1)
-        {
-            for (i = 0; i < (aSize-1); i++)
-            {
-                temp[i] = annotations[i];
-            }
-        }
-
-        annotations = temp;
-    }
-
-    public void setAnnotationIndex(AlignmentAnnotation aa, int index)
-    {
-      if(aa==null || annotations==null || annotations.length-1<index)
-        return;
-
-      int aSize = annotations.length;
-      AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize];
-
-      temp[index] = aa;
-
-      for (int i = 0; i < aSize; i++)
-      {
-        if(i==index)
-          continue;
-
-        if(i<index)
-          temp[i] = annotations[i];
-        else
-          temp[i] = annotations[i-1];
-      }
-
-        annotations = temp;
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public AlignmentAnnotation[] getAlignmentAnnotation()
-    {
-        return annotations;
-    }
-
-    public void setNucleotide(boolean b)
-    {
-      if(b)
-        type = NUCLEOTIDE;
-      else
-        type = PROTEIN;
-    }
-
-    public boolean isNucleotide()
-    {
-      if(type==NUCLEOTIDE)
-        return true;
-      else
-        return false;
-    }
-
-    public void setDataset(Alignment data)
-    {
-      if(dataset==null && data==null)
-      {
-        // Create a new dataset for this alignment.
-        // Can only be done once, if dataset is not null
-        // This will not be performed
-        Sequence[] seqs = new Sequence[getHeight()];
-        for (int i = 0; i < getHeight(); i++)
-        {
-          if(getSequenceAt(i).getDatasetSequence()!=null)
-          {
-            seqs[i] = (Sequence)getSequenceAt(i).getDatasetSequence();
-          }
-          else
-          {
-            seqs[i] = new Sequence(getSequenceAt(i).getName(),
-                                   AlignSeq.extractGaps(
-                                       jalview.util.Comparison.GapChars,
-                                       getSequenceAt(i).getSequence()
-                                   ),
-                                   getSequenceAt(i).getStart(),
-                                   getSequenceAt(i).getEnd());
-
-            getSequenceAt(i).setDatasetSequence(seqs[i]);
-          }
-        }
-
-        dataset = new Alignment(seqs);
-      }
-      else if(dataset==null && data!=null)
-      {
-        dataset = data;
-      }
-    }
-
-    public Alignment getDataset()
-    {
-      return dataset;
-    }
-
-    public boolean padGaps() {
-      boolean modified=false;
-
-      //Remove excess gaps from the end of alignment
-      int maxLength = -1;
-
-      SequenceI current;
-      for (int i = 0; i < sequences.size(); i++)
-      {
-        current = getSequenceAt(i);
-        for (int j = current.getLength(); j > maxLength; j--)
-        {
-          if (j > maxLength && !jalview.util.Comparison.isGap(
-              current.getCharAt(j)))
-          {
-            maxLength = j;
-            break;
-          }
-        }
-      }
-
-      maxLength++;
-
-      for (int i = 0; i < sequences.size();
-           i++)
-      {
-        current = getSequenceAt(i);
-
-        if (current.getLength() < maxLength)
-        {
-          current.insertCharAt(maxLength - 1, gapCharacter);
-          modified=true;
-        }
-        else if(current.getLength() > maxLength)
-        {
-          current.deleteChars(maxLength, current.getLength());
-        }
-      }
-      return modified;
-    }
-
-    public HiddenSequences getHiddenSequences()
-    {
-      return hiddenSequences;
-    }
-
-    SequenceI [] getVisibleAndRepresentedSeqs()
-    {
-      if(hiddenSequences==null || hiddenSequences.getSize()<1)
-        return getSequencesArray();
-
-      Vector seqs = new Vector();
-      SequenceI seq;
-      SequenceGroup hidden;
-      for (int i = 0; i < sequences.size(); i++)
-      {
-        seq = (SequenceI) sequences.elementAt(i);
-        seqs.addElement(seq);
-        hidden = seq.getHiddenSequences();
-        if(hidden!=null)
-        {
-          for(int j=0; j<hidden.getSize(false); j++)
-          {
-            seqs.addElement(hidden.getSequenceAt(j));
-          }
-        }
-      }
-      SequenceI [] result = new SequenceI[seqs.size()];
-      for(int i=0; i<seqs.size(); i++)
-        result[i] = (SequenceI)seqs.elementAt(i);
-
-      return result;
-
-    }
-
-}
+/*
+ * 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.datamodel;
+
+import jalview.analysis.*;
+
+import jalview.util.*;
+
+import java.util.*;
+
+/** Data structure to hold and manipulate a multiple sequence alignment
+ */
+public class Alignment implements AlignmentI
+{
+    protected Alignment dataset;
+    protected Vector sequences;
+    protected Vector groups = new Vector();
+    protected char gapCharacter = '-';
+    protected int type = NUCLEOTIDE;
+    public static final int PROTEIN = 0;
+    public static final int NUCLEOTIDE = 1;
+
+    /** DOCUMENT ME!! */
+    public AlignmentAnnotation[] annotations;
+
+    HiddenSequences hiddenSequences = new HiddenSequences(this);
+
+    private void initAlignment(SequenceI[] seqs) {
+      int i=0;
+
+      if( jalview.util.Comparison.isNucleotide(seqs))
+        type = NUCLEOTIDE;
+      else
+        type = PROTEIN;
+
+      sequences = new Vector();
+
+      for (i = 0; i < seqs.length; i++)
+      {
+        sequences.addElement(seqs[i]);
+      }
+
+    }
+    /** Make an alignment from an array of Sequences.
+     *
+     * @param sequences
+     */
+    public Alignment(SequenceI[] seqs)
+    {
+      initAlignment(seqs);
+    }
+    /**
+     * Make a new alignment from an array of SeqCigars
+     * @param seqs SeqCigar[]
+     */
+    public Alignment(SeqCigar[] alseqs) {
+
+      SequenceI[] seqs = new SequenceI[alseqs.length];
+      for (int i=0; i<alseqs.length; i++) {
+        seqs[i] = alseqs[i].getSeq(this.gapCharacter);
+      }
+      initAlignment(seqs);
+    }
+    /**
+     * Make a new alignment from an CigarArray
+     * JBPNote - can only do this when compactAlignment does not contain hidden regions.
+     * JBPNote - must also check that compactAlignment resolves to a set of SeqCigars - or construct them appropriately.
+     * @param compactAlignment CigarArray
+     */
+    public Alignment(CigarArray compactAlignment) {
+      throw new Error("Alignment(CigarArray) not yet implemented");
+      // this(compactAlignment.refCigars);
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public Vector getSequences()
+    {
+        return sequences;
+    }
+
+    public SequenceI [] getSequencesArray()
+    {
+      SequenceI [] reply = new SequenceI[sequences.size()];
+      for(int i=0; i<sequences.size(); i++)
+      {
+        reply[i] = (SequenceI)sequences.elementAt(i);
+      }
+      return reply;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param i DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public SequenceI getSequenceAt(int i)
+    {
+        if (i < sequences.size())
+        {
+            return (SequenceI) sequences.elementAt(i);
+        }
+
+        return null;
+    }
+
+    /** Adds a sequence to the alignment.  Recalculates maxLength and size.
+     *
+     * @param snew
+     */
+    public void addSequence(SequenceI snew)
+    {
+      if(dataset!=null)
+      {
+        if(snew.getDatasetSequence()!=null)
+        {
+          System.out.println(snew.getName());
+          getDataset().addSequence(snew.getDatasetSequence());
+        }
+        else
+        {
+          Sequence ds = new Sequence(snew.getName(),
+                                     AlignSeq.extractGaps("-. ",
+              snew.getSequence()),
+                                     snew.getStart(),
+                                     snew.getEnd());
+
+          snew.setDatasetSequence(ds);
+          getDataset().addSequence(ds);
+        }
+      }
+
+      sequences.addElement(snew);
+    }
+
+
+    /** Adds a sequence to the alignment.  Recalculates maxLength and size.
+     *
+     * @param snew
+     */
+    public void setSequenceAt(int i, SequenceI snew)
+    {
+        SequenceI oldseq = getSequenceAt(i);
+        deleteSequence(oldseq);
+
+        sequences.setElementAt(snew, i);
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public Vector getGroups()
+    {
+        return groups;
+    }
+
+    /** Takes out columns consisting entirely of gaps (-,.," ")
+     */
+    public void removeGaps()
+    {
+        SequenceI[] seqs = getVisibleAndRepresentedSeqs();
+        int j, jSize = seqs.length;
+
+        int width = 0;
+        for (int i = 0; i < jSize; i++)
+        {
+          if (seqs[i].getLength() > width)
+          {
+            width = seqs[i].getLength();
+          }
+        }
+
+        int startCol = -1, endCol = -1;
+        boolean delete = true;
+        for (int i = 0; i < width; i++)
+        {
+            delete = true;
+
+            for (j = 0; j < jSize; j++)
+            {
+                if (seqs[j].getLength() > i)
+                {
+                    if (!jalview.util.Comparison.isGap(seqs[j].getCharAt(i)))
+                    {
+                        if(delete)
+                          endCol = i;
+
+                        delete = false;
+                        break;
+                    }
+                }
+            }
+
+            if(delete && startCol==-1)
+            {
+              startCol = i;
+            }
+
+
+            if (!delete && startCol > -1)
+            {
+              deleteColumns(seqs, startCol, endCol);
+              width -= (endCol - startCol);
+              i -= (endCol - startCol);
+              startCol = -1;
+              endCol = -1;
+            }
+        }
+
+        if (delete && startCol > -1)
+        {
+          deleteColumns(seqs, startCol, endCol);
+        }
+    }
+
+    /** Removes a range of columns (start to end inclusive).
+     *
+     * @param seqs Sequences to remove columns from
+     * @param start Start column in the alignment
+     * @param end End column in the alignment
+     */
+    public void deleteColumns(SequenceI [] seqs, int start, int end)
+    {
+      for(int i=0; i<seqs.length; i++)
+        seqs[i].deleteChars(start, end);
+    }
+
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param i DOCUMENT ME!
+     */
+    public void trimLeft(int i)
+    {
+        SequenceI[] seqs = getVisibleAndRepresentedSeqs();
+        int j, jSize = seqs.length;
+        for (j = 0; j < jSize; j++)
+        {
+            int newstart = seqs[j].findPosition(i);
+
+            if(i>seqs[j].getLength())
+            {
+              sequences.removeElement(seqs[j]);
+              j--;
+              jSize--;
+            }
+            else
+            {
+              seqs[j].setStart(newstart);
+              seqs[j].setSequence(seqs[j].getSequence().substring(i));
+            }
+        }
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param i DOCUMENT ME!
+     */
+    public void trimRight(int i)
+    {
+        SequenceI[] seqs = getVisibleAndRepresentedSeqs();
+        int j, jSize = seqs.length;
+        for (j = 0; j < jSize; j++)
+        {
+            int newend = seqs[j].findPosition(i);
+
+            seqs[j].setEnd(newend);
+            if(seqs[j].getLength()>i)
+              seqs[j].setSequence(seqs[j].getSequence().substring(0, i + 1));
+        }
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param s DOCUMENT ME!
+     */
+    public void deleteSequence(SequenceI s)
+    {
+        for (int i = 0; i < getHeight(); i++)
+        {
+            if (getSequenceAt(i) == s)
+            {
+                deleteSequence(i);
+            }
+        }
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param i DOCUMENT ME!
+     */
+    public void deleteSequence(int i)
+    {
+        sequences.removeElementAt(i);
+    }
+
+
+    /**    */
+    public SequenceGroup findGroup(SequenceI s)
+    {
+        for (int i = 0; i < this.groups.size(); i++)
+        {
+            SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
+
+            if (sg.getSequences(false).contains(s))
+            {
+                return sg;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param s DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public SequenceGroup[] findAllGroups(SequenceI s)
+    {
+        Vector temp = new Vector();
+
+        int gSize = groups.size();
+        for (int i = 0; i < gSize; i++)
+        {
+            SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
+            if(sg==null || sg.getSequences(false)==null)
+            {
+              this.deleteGroup(sg);
+              gSize--;
+              continue;
+            }
+
+            if (sg.getSequences(false).contains(s))
+            {
+                temp.addElement(sg);
+            }
+        }
+
+        SequenceGroup[] ret = new SequenceGroup[temp.size()];
+
+        for (int i = 0; i < temp.size(); i++)
+        {
+            ret[i] = (SequenceGroup) temp.elementAt(i);
+        }
+
+        return ret;
+    }
+
+
+
+    /**    */
+    public void addGroup(SequenceGroup sg)
+    {
+        if (!groups.contains(sg))
+        {
+            groups.addElement(sg);
+        }
+    }
+
+    /**
+     * DOCUMENT ME!
+     */
+    public void deleteAllGroups()
+    {
+        groups.removeAllElements();
+
+        int i = 0;
+
+        while (i < sequences.size())
+        {
+            SequenceI s = getSequenceAt(i);
+            s.setColor(java.awt.Color.white);
+            i++;
+        }
+    }
+
+    /**    */
+    public void deleteGroup(SequenceGroup g)
+    {
+        if (groups.contains(g))
+        {
+            groups.removeElement(g);
+        }
+    }
+
+    /**    */
+    public SequenceI findName(String name)
+    {
+        int i = 0;
+
+        while (i < sequences.size())
+        {
+            if (getSequenceAt(i).getName().equals(name))
+            {
+                return getSequenceAt(i);
+            }
+
+            i++;
+        }
+
+        return null;
+    }
+
+
+    /**    */
+    public int findIndex(SequenceI s)
+    {
+        int i = 0;
+
+        while (i < sequences.size())
+        {
+            if (s == getSequenceAt(i))
+            {
+                return i;
+            }
+
+            i++;
+        }
+
+        return -1;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getHeight()
+    {
+        return sequences.size();
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getWidth()
+    {
+        int maxLength = -1;
+
+        for (int i = 0; i < sequences.size(); i++)
+        {
+            if (getSequenceAt(i).getLength() > maxLength)
+            {
+                maxLength = getSequenceAt(i).getLength();
+            }
+        }
+
+        return maxLength;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getMaxIdLength()
+    {
+        int max = 0;
+        int i = 0;
+
+        while (i < sequences.size())
+        {
+            SequenceI seq = getSequenceAt(i);
+            String tmp = seq.getName() + "/" + seq.getStart() + "-" +
+                seq.getEnd();
+
+            if (tmp.length() > max)
+            {
+                max = tmp.length();
+            }
+
+            i++;
+        }
+
+        return max;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param gc DOCUMENT ME!
+     */
+    public void setGapCharacter(char gc)
+    {
+        gapCharacter = gc;
+
+        for (int i = 0; i < sequences.size(); i++)
+        {
+            Sequence seq = (Sequence) sequences.elementAt(i);
+            seq.setSequence( seq.getSequence().replace('.', gc) );
+            seq.setSequence( seq.getSequence().replace('-', gc) );
+            seq.setSequence( seq.getSequence().replace(' ', gc) );
+        }
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public char getGapCharacter()
+    {
+        return gapCharacter;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public Vector getAAFrequency()
+    {
+        return AAFrequency.calculate(sequences, 0, getWidth());
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public boolean isAligned()
+    {
+        int width = getWidth();
+
+        for (int i = 0; i < sequences.size(); i++)
+        {
+            if (getSequenceAt(i).getLength() != width)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param aa DOCUMENT ME!
+     */
+    public void deleteAnnotation(AlignmentAnnotation aa)
+    {
+        int aSize = 1;
+
+        if (annotations != null)
+        {
+            aSize = annotations.length;
+        }
+
+        AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize - 1];
+
+        int tIndex = 0;
+
+        for (int i = 0; i < aSize; i++)
+        {
+            if (annotations[i] == aa)
+            {
+                continue;
+            }
+
+            temp[tIndex] = annotations[i];
+            tIndex++;
+        }
+
+        annotations = temp;
+    }
+
+
+    public void adjustSequenceAnnotations()
+    {
+      if(annotations!=null)
+      {
+        for (int a = 0; a < annotations.length; a++)
+        {
+          if (annotations[a].sequenceRef != null)
+          {
+            annotations[a].adjustForAlignment();
+          }
+        }
+      }
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param aa DOCUMENT ME!
+     */
+    public void addAnnotation(AlignmentAnnotation aa)
+    {
+        int aSize = 1;
+        if (annotations != null)
+        {
+            aSize = annotations.length + 1;
+        }
+
+        AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize];
+
+        temp[aSize-1] = aa;
+
+        int i = 0;
+
+        if (aSize > 1)
+        {
+            for (i = 0; i < (aSize-1); i++)
+            {
+                temp[i] = annotations[i];
+            }
+        }
+
+        annotations = temp;
+    }
+
+    public void setAnnotationIndex(AlignmentAnnotation aa, int index)
+    {
+      if(aa==null || annotations==null || annotations.length-1<index)
+        return;
+
+      int aSize = annotations.length;
+      AlignmentAnnotation[] temp = new AlignmentAnnotation[aSize];
+
+      temp[index] = aa;
+
+      for (int i = 0; i < aSize; i++)
+      {
+        if(i==index)
+          continue;
+
+        if(i<index)
+          temp[i] = annotations[i];
+        else
+          temp[i] = annotations[i-1];
+      }
+
+        annotations = temp;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public AlignmentAnnotation[] getAlignmentAnnotation()
+    {
+        return annotations;
+    }
+
+    public void setNucleotide(boolean b)
+    {
+      if(b)
+        type = NUCLEOTIDE;
+      else
+        type = PROTEIN;
+    }
+
+    public boolean isNucleotide()
+    {
+      if(type==NUCLEOTIDE)
+        return true;
+      else
+        return false;
+    }
+
+    public void setDataset(Alignment data)
+    {
+      if(dataset==null && data==null)
+      {
+        // Create a new dataset for this alignment.
+        // Can only be done once, if dataset is not null
+        // This will not be performed
+        Sequence[] seqs = new Sequence[getHeight()];
+        for (int i = 0; i < getHeight(); i++)
+        {
+          if(getSequenceAt(i).getDatasetSequence()!=null)
+          {
+            seqs[i] = (Sequence)getSequenceAt(i).getDatasetSequence();
+          }
+          else
+          {
+            seqs[i] = new Sequence(getSequenceAt(i).getName(),
+                                   AlignSeq.extractGaps(
+                                       jalview.util.Comparison.GapChars,
+                                       getSequenceAt(i).getSequence()
+                                   ),
+                                   getSequenceAt(i).getStart(),
+                                   getSequenceAt(i).getEnd());
+
+            getSequenceAt(i).setDatasetSequence(seqs[i]);
+          }
+        }
+
+        dataset = new Alignment(seqs);
+      }
+      else if(dataset==null && data!=null)
+      {
+        dataset = data;
+      }
+    }
+
+    public Alignment getDataset()
+    {
+      return dataset;
+    }
+
+    public boolean padGaps() {
+      boolean modified=false;
+
+      //Remove excess gaps from the end of alignment
+      int maxLength = -1;
+
+      SequenceI current;
+      for (int i = 0; i < sequences.size(); i++)
+      {
+        current = getSequenceAt(i);
+        for (int j = current.getLength(); j > maxLength; j--)
+        {
+          if (j > maxLength && !jalview.util.Comparison.isGap(
+              current.getCharAt(j)))
+          {
+            maxLength = j;
+            break;
+          }
+        }
+      }
+
+      maxLength++;
+
+      for (int i = 0; i < sequences.size();
+           i++)
+      {
+        current = getSequenceAt(i);
+
+        if (current.getLength() < maxLength)
+        {
+          current.insertCharAt(maxLength - 1, gapCharacter);
+          modified=true;
+        }
+        else if(current.getLength() > maxLength)
+        {
+          current.deleteChars(maxLength, current.getLength());
+        }
+      }
+      return modified;
+    }
+
+    public HiddenSequences getHiddenSequences()
+    {
+      return hiddenSequences;
+    }
+    SequenceI [] getVisibleAndRepresentedSeqs()
+    {
+      if(hiddenSequences==null || hiddenSequences.getSize()<1)
+        return getSequencesArray();
+
+      Vector seqs = new Vector();
+      SequenceI seq;
+      SequenceGroup hidden;
+      for (int i = 0; i < sequences.size(); i++)
+      {
+        seq = (SequenceI) sequences.elementAt(i);
+        seqs.addElement(seq);
+        hidden = seq.getHiddenSequences();
+        if(hidden!=null)
+        {
+          for(int j=0; j<hidden.getSize(false); j++)
+          {
+            seqs.addElement(hidden.getSequenceAt(j));
+          }
+        }
+      }
+      SequenceI [] result = new SequenceI[seqs.size()];
+      for(int i=0; i<seqs.size(); i++)
+        result[i] = (SequenceI)seqs.elementAt(i);
+
+      return result;
+
+    }
+
+  public CigarArray getCompactAlignment()
+  {
+    SeqCigar alseqs[] = new SeqCigar[sequences.size()];
+    for (int i=0; i<sequences.size(); i++) {
+      alseqs[i] = new SeqCigar((SequenceI) sequences.get(i));
+    }
+    return new CigarArray(alseqs);
+  }
+
+}
diff --git a/src/jalview/datamodel/AlignmentI.java b/src/jalview/datamodel/AlignmentI.java
index e62c8c2..06e93d7 100755
--- a/src/jalview/datamodel/AlignmentI.java
+++ b/src/jalview/datamodel/AlignmentI.java
@@ -270,5 +270,9 @@ public interface AlignmentI
     public void adjustSequenceAnnotations();
 
     public HiddenSequences getHiddenSequences();
-
+    /**
+     * Compact representation of alignment
+     * @return CigarArray
+     */
+    public CigarArray getCompactAlignment();
 }
diff --git a/src/jalview/datamodel/ColumnSelection.java b/src/jalview/datamodel/ColumnSelection.java
index ad66894..48f02e7 100644
--- a/src/jalview/datamodel/ColumnSelection.java
+++ b/src/jalview/datamodel/ColumnSelection.java
@@ -1,451 +1,464 @@
-/*
- * 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.datamodel;
-
-import java.util.*;
-
-/**
- * NOTE: Columns are zero based.
- */
-public class ColumnSelection
-{
-    Vector selected = new Vector();
-
-    //Vector of int [] {startCol, endCol}
-    Vector hiddenColumns;
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param col DOCUMENT ME!
-     */
-    public void addElement(int col)
-    {
-        if (!selected.contains(new Integer(col)))
-        {
-            selected.addElement(new Integer(col));
-        }
-    }
-
-    /**
-     * DOCUMENT ME!
-     */
-    public void clear()
-    {
-        selected.removeAllElements();
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param col DOCUMENT ME!
-     */
-    public void removeElement(int col)
-    {
-        Integer colInt = new Integer(col);
-
-        if (selected.contains(colInt))
-        {
-            selected.removeElement(colInt);
-        }
-    }
-
-    public void removeElements(int start, int end)
-    {
-      Integer colInt;
-      for(int i=start; i<end; i++)
-      {
-        colInt = new Integer(i);
-        if (selected.contains(colInt))
-        {
-            selected.removeElement(colInt);
-        }
-      }
-    }
-
-    public Vector getSelected()
-    {
-      return selected;
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param col DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public boolean contains(int col)
-    {
-        return selected.contains(new Integer(col));
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param i DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public int columnAt(int i)
-    {
-        return ((Integer) selected.elementAt(i)).intValue();
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public int size()
-    {
-        return selected.size();
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public int getMax()
-    {
-        int max = -1;
-
-        for (int i = 0; i < selected.size(); i++)
-        {
-            if (columnAt(i) > max)
-            {
-                max = columnAt(i);
-            }
-        }
-
-        return max;
-    }
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @return DOCUMENT ME!
-     */
-    public int getMin()
-    {
-        int min = 1000000000;
-
-        for (int i = 0; i < selected.size(); i++)
-        {
-            if (columnAt(i) < min)
-            {
-                min = columnAt(i);
-            }
-        }
-
-        return min;
-    }
-
-
-    /**
-     * DOCUMENT ME!
-     *
-     * @param start DOCUMENT ME!
-     * @param change DOCUMENT ME!
-     */
-    public void compensateForEdit(int start, int change)
-    {
-        for (int i = 0; i < size(); i++)
-        {
-            int temp = columnAt(i);
-
-            if (temp >= start)
-            {
-                selected.setElementAt(new Integer(temp - change), i);
-            }
-        }
-
-        if(hiddenColumns!=null)
-        {
-          for(int i=0; i<hiddenColumns.size(); i++)
-          {
-            int[] region = (int[]) hiddenColumns.elementAt(i);
-            if(region[0] > start)
-            {
-              region[0] -= change;
-              region[1] -= change;
-            }
-            if(region[0]<0)
-              region[0] = 0;
-            if(region[1] <0)
-             region[1] = 0;
-          }
-        }
-    }
-
-    /**
-     * This Method is used to return all the HiddenColumn regions
-     * less than the given index.
-     * @param end int
-     * @return Vector
-     */
-    public Vector getHiddenColumns()
-    {
-      return hiddenColumns;
-    }
-
-    public int adjustForHiddenColumns(int column)
-    {
-      int result = column;
-      if (hiddenColumns != null)
-      {
-        for (int i = 0; i < hiddenColumns.size(); i++)
-        {
-          int[] region = (int[]) hiddenColumns.elementAt(i);
-          if (result >= region[0])
-          {
-            result += region[1] - region[0] + 1;
-          }
-        }
-      }
-      return result;
-    }
-
-    /**
-     * Use this method to find out where a visible column is in the alignment
-     * when hidden columns exist
-     * @param hiddenColumn int
-     * @return int
-     */
-    public int findColumnPosition(int hiddenColumn)
-    {
-      int result = hiddenColumn;
-      if (hiddenColumns != null)
-      {
-        int index = 0;
-        int gaps = 0;
-        do
-        {
-          int[] region = (int[]) hiddenColumns.elementAt(index);
-          if (hiddenColumn > region[1])
-          {
-            result -= region[1]+1-region[0];
-          }
-          index++;
-        }
-        while (index < hiddenColumns.size());
-
-        result -= gaps;
-      }
-
-      return result;
-    }
-
-    /**
-     * Use this method to determine where the next hiddenRegion starts
-    */
-    public int findHiddenRegionPosition(int hiddenRegion)
-    {
-      int result = 0;
-      if (hiddenColumns != null)
-      {
-        int index = 0;
-        int gaps = 0;
-        do
-        {
-          int[] region = (int[]) hiddenColumns.elementAt(index);
-          if(hiddenRegion==0)
-          {
-            return region[0];
-          }
-
-            gaps +=  region[1] +1 - region[0];
-            result = region[1] +1;
-            index++;
-        }
-        while(index < hiddenRegion+1);
-
-        result -= gaps;
-      }
-
-      return result;
-    }
-
-    /**
-     * THis method returns the rightmost limit of a
-     * region of an alignment with hidden columns.
-     * In otherwords, the next hidden column.
-     * @param index int
-     */
-    public int getHiddenBoundaryRight(int alPos)
-    {
-      if (hiddenColumns != null)
-      {
-        int index = 0;
-        do
-        {
-          int[] region = (int[]) hiddenColumns.elementAt(index);
-          if(alPos < region[0])
-            return region[0];
-
-          index++;
-        }
-        while(index < hiddenColumns.size());
-      }
-
-      return alPos;
-
-    }
-    /**
-     * THis method returns the rightmost limit of a
-     * region of an alignment with hidden columns.
-     * In otherwords, the next hidden column.
-     * @param index int
-     */
-    public int getHiddenBoundaryLeft(int alPos)
-    {
-      if (hiddenColumns != null)
-      {
-        int index = hiddenColumns.size()-1;
-        do
-        {
-          int[] region = (int[]) hiddenColumns.elementAt(index);
-          if(alPos > region[1])
-            return region[1];
-
-          index--;
-        }
-        while(index >-1);
-      }
-
-      return alPos;
-    }
-
-    public void hideSelectedColumns()
-    {
-      while (size() > 0)
-      {
-        int column = ( (Integer) getSelected().firstElement()).intValue();
-        hideColumns(column);
-      }
-
-    }
-
-    public void hideColumns(int start, int end)
-    {
-      if(hiddenColumns==null)
-        hiddenColumns = new Vector();
-
-      boolean added = false;
-      boolean overlap = false;
-
-      for (int i = 0; i < hiddenColumns.size(); i++)
-      {
-        int[] region = (int[]) hiddenColumns.elementAt(i);
-        if ( start<=region[1] && end>=region[0])
-        {
-          hiddenColumns.removeElementAt(i);
-          overlap = true;
-          break;
-        }
-        else if (end < region[0] && start < region[0])
-        {
-          hiddenColumns.insertElementAt(new int[]
-                                        {start, end}, i);
-          added = true;
-          break;
-        }
-      }
-
-      if(overlap)
-      {
-         hideColumns(start, end);
-      }
-      else if (!added)
-        hiddenColumns.addElement(new int[] {start, end});
-
-    }
-
-    /**
-     * This method will find a range of selected columns
-     * around the column specified
-     * @param res int
-     */
-    public void hideColumns(int col)
-    {
-      // First find out range of columns to hide
-      int min = col, max = col+1;
-      while( contains(min) )
-      {  removeElement(min); min --;  }
-
-      while( contains(max) )
-      { removeElement(max);  max ++;  }
-
-      min++; max--;
-
-      hideColumns(min, max);
-    }
-
-    public void revealAllHiddenColumns()
-    {
-      if(hiddenColumns!=null)
-      {
-        for (int i = 0; i < hiddenColumns.size(); i++)
-        {
-          int[] region = (int[]) hiddenColumns.elementAt(i);
-          for (int j = region[0]; j < region[1]; j++)
-          {
-            addElement(j);
-          }
-        }
-      }
-
-      hiddenColumns = null;
-    }
-
-    public void revealHiddenColumns(int res)
-    {
-      for(int i=0; i<hiddenColumns.size(); i++)
-      {
-        int [] region = (int[])hiddenColumns.elementAt(i);
-        if( res == region[0])
-        {
-          for (int j = region[0]; j < region[1]; j++)
-          {
-            addElement(j);
-          }
-
-          hiddenColumns.removeElement(region);
-          break;
-        }
-      }
-      if(hiddenColumns.size()==0)
-        hiddenColumns = null;
-    }
-
-    public boolean isVisible(int column)
-    {
-      for(int i=0; i<hiddenColumns.size(); i++)
-      {
-        int [] region = (int[])hiddenColumns.elementAt(i);
-        if( column >= region[0] && column <= region[1])
-        {
-          return false;
-        }
-      }
-      return true;
-    }
-
-}
+/*
+ * 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.datamodel;
+
+import java.util.*;
+
+/**
+ * NOTE: Columns are zero based.
+ */
+public class ColumnSelection
+{
+    Vector selected = new Vector();
+
+    //Vector of int [] {startCol, endCol}
+    Vector hiddenColumns;
+
+    /**
+     * Add a column to the selection
+     *
+     * @param col index of column
+     */
+    public void addElement(int col)
+    {
+        Integer column = new Integer(col);
+        if (!selected.contains(column))
+        {
+            selected.addElement(column);
+        }
+    }
+
+    /**
+     * clears column selection
+     */
+    public void clear()
+    {
+        selected.removeAllElements();
+    }
+
+    /**
+     * removes col from selection
+     *
+     * @param col index of column to be removed
+     */
+    public void removeElement(int col)
+    {
+        Integer colInt = new Integer(col);
+
+        if (selected.contains(colInt))
+        {
+            selected.removeElement(colInt);
+        }
+    }
+
+    /**
+     * removes a range of columns from the selection
+     * @param start int - first column in range to be removed
+     * @param end int - last col
+     */
+    public void removeElements(int start, int end)
+    {
+      Integer colInt;
+      for(int i=start; i<end; i++)
+      {
+        colInt = new Integer(i);
+        if (selected.contains(colInt))
+        {
+            selected.removeElement(colInt);
+        }
+      }
+    }
+    /**
+     *
+     * @return Vector containing selected columns as Integers
+     */
+    public Vector getSelected()
+    {
+      return selected;
+    }
+
+    /**
+     *
+     * @param col index to search for in column selection
+     *
+     * @return true if Integer(col) is in selection.
+     */
+    public boolean contains(int col)
+    {
+        return selected.contains(new Integer(col));
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param i DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int columnAt(int i)
+    {
+        return ((Integer) selected.elementAt(i)).intValue();
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int size()
+    {
+        return selected.size();
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getMax()
+    {
+        int max = -1;
+
+        for (int i = 0; i < selected.size(); i++)
+        {
+            if (columnAt(i) > max)
+            {
+                max = columnAt(i);
+            }
+        }
+
+        return max;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getMin()
+    {
+        int min = 1000000000;
+
+        for (int i = 0; i < selected.size(); i++)
+        {
+            if (columnAt(i) < min)
+            {
+                min = columnAt(i);
+            }
+        }
+
+        return min;
+    }
+
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param start DOCUMENT ME!
+     * @param change DOCUMENT ME!
+     */
+    public void compensateForEdit(int start, int change)
+    {
+        for (int i = 0; i < size(); i++)
+        {
+            int temp = columnAt(i);
+
+            if (temp >= start)
+            {
+                selected.setElementAt(new Integer(temp - change), i);
+            }
+        }
+
+        if(hiddenColumns!=null)
+        {
+          for(int i=0; i<hiddenColumns.size(); i++)
+          {
+            int[] region = (int[]) hiddenColumns.elementAt(i);
+            if(region[0] > start)
+            {
+              region[0] -= change;
+              region[1] -= change;
+            }
+            if(region[0]<0)
+              region[0] = 0;
+            if(region[1] <0)
+             region[1] = 0;
+          }
+        }
+    }
+
+    /**
+     * This Method is used to return all the HiddenColumn regions
+     * less than the given index.
+     * @param end int
+     * @return Vector
+     */
+    public Vector getHiddenColumns()
+    {
+      return hiddenColumns;
+    }
+    /**
+     * Return absolute column index for a visible column index
+     * @param column int column index in alignment view
+     * @return alignment column index for column
+     */
+    public int adjustForHiddenColumns(int column)
+    {
+      int result = column;
+      if (hiddenColumns != null)
+      {
+        for (int i = 0; i < hiddenColumns.size(); i++)
+        {
+          int[] region = (int[]) hiddenColumns.elementAt(i);
+          if (result >= region[0])
+          {
+            result += region[1] - region[0] + 1;
+          }
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Use this method to find out where a visible column is in the alignment
+     * when hidden columns exist
+     * @param hiddenColumn int
+     * @return int
+     */
+    public int findColumnPosition(int hiddenColumn)
+    {
+      int result = hiddenColumn;
+      if (hiddenColumns != null)
+      {
+        int index = 0;
+        int gaps = 0;
+        do
+        {
+          int[] region = (int[]) hiddenColumns.elementAt(index);
+          if (hiddenColumn > region[1])
+          {
+            result -= region[1]+1-region[0];
+          }
+          index++;
+        }
+        while (index < hiddenColumns.size());
+
+        result -= gaps;
+      }
+
+      return result;
+    }
+
+    /**
+     * Use this method to determine where the next hiddenRegion starts
+    */
+    public int findHiddenRegionPosition(int hiddenRegion)
+    {
+      int result = 0;
+      if (hiddenColumns != null)
+      {
+        int index = 0;
+        int gaps = 0;
+        do
+        {
+          int[] region = (int[]) hiddenColumns.elementAt(index);
+          if(hiddenRegion==0)
+          {
+            return region[0];
+          }
+
+            gaps +=  region[1] +1 - region[0];
+            result = region[1] +1;
+            index++;
+        }
+        while(index < hiddenRegion+1);
+
+        result -= gaps;
+      }
+
+      return result;
+    }
+
+    /**
+     * THis method returns the rightmost limit of a
+     * region of an alignment with hidden columns.
+     * In otherwords, the next hidden column.
+     * @param index int
+     */
+    public int getHiddenBoundaryRight(int alPos)
+    {
+      if (hiddenColumns != null)
+      {
+        int index = 0;
+        do
+        {
+          int[] region = (int[]) hiddenColumns.elementAt(index);
+          if(alPos < region[0])
+            return region[0];
+
+          index++;
+        }
+        while(index < hiddenColumns.size());
+      }
+
+      return alPos;
+
+    }
+    /**
+     * THis method returns the rightmost limit of a
+     * region of an alignment with hidden columns.
+     * In otherwords, the next hidden column.
+     * @param index int
+     */
+    public int getHiddenBoundaryLeft(int alPos)
+    {
+      if (hiddenColumns != null)
+      {
+        int index = hiddenColumns.size()-1;
+        do
+        {
+          int[] region = (int[]) hiddenColumns.elementAt(index);
+          if(alPos > region[1])
+            return region[1];
+
+          index--;
+        }
+        while(index >-1);
+      }
+
+      return alPos;
+
+    }
+
+    public void hideSelectedColumns()
+    {
+      while (size() > 0)
+      {
+        int column = ( (Integer) getSelected().firstElement()).intValue();
+        hideColumns(column);
+      }
+
+    }
+
+    public void hideColumns(int start, int end)
+    {
+      if(hiddenColumns==null)
+        hiddenColumns = new Vector();
+
+      boolean added = false;
+      boolean overlap = false;
+
+      for (int i = 0; i < hiddenColumns.size(); i++)
+      {
+        int[] region = (int[]) hiddenColumns.elementAt(i);
+        if ( start<=region[1] && end>=region[0])
+        {
+          hiddenColumns.removeElementAt(i);
+          overlap = true;
+          break;
+        }
+        else if (end < region[0] && start < region[0])
+        {
+          hiddenColumns.insertElementAt(new int[]
+                                        {start, end}, i);
+          added = true;
+          break;
+        }
+      }
+
+      if(overlap)
+      {
+         hideColumns(start, end);
+      }
+      else if (!added)
+        hiddenColumns.addElement(new int[] {start, end});
+
+    }
+
+    /**
+     * This method will find a range of selected columns
+     * around the column specified
+     * @param res int
+     */
+    public void hideColumns(int col)
+    {
+      // First find out range of columns to hide
+      int min = col, max = col+1;
+      while( contains(min) )
+      {  removeElement(min); min --;  }
+
+      while( contains(max) )
+      { removeElement(max);  max ++;  }
+
+      min++; max--;
+
+      hideColumns(min, max);
+    }
+
+    public void revealAllHiddenColumns()
+    {
+      if(hiddenColumns!=null)
+      {
+        for (int i = 0; i < hiddenColumns.size(); i++)
+        {
+          int[] region = (int[]) hiddenColumns.elementAt(i);
+          for (int j = region[0]; j < region[1]; j++)
+          {
+            addElement(j);
+          }
+        }
+      }
+
+      hiddenColumns = null;
+    }
+
+    public void revealHiddenColumns(int res)
+    {
+      for(int i=0; i<hiddenColumns.size(); i++)
+      {
+        int [] region = (int[])hiddenColumns.elementAt(i);
+        if( res == region[0])
+        {
+          for (int j = region[0]; j < region[1]; j++)
+          {
+            addElement(j);
+          }
+
+          hiddenColumns.removeElement(region);
+          break;
+        }
+      }
+      if(hiddenColumns.size()==0)
+        hiddenColumns = null;
+    }
+
+    public boolean isVisible(int column)
+    {
+      for(int i=0; i<hiddenColumns.size(); i++)
+      {
+        int [] region = (int[])hiddenColumns.elementAt(i);
+        if( column >= region[0] && column <= region[1])
+        {
+          return false;
+        }
+      }
+      return true;
+    }
+
+}
diff --git a/src/jalview/gui/AlignViewport.java b/src/jalview/gui/AlignViewport.java
index 3ae0a52..af59388 100755
--- a/src/jalview/gui/AlignViewport.java
+++ b/src/jalview/gui/AlignViewport.java
@@ -1204,6 +1204,87 @@ public class AlignViewport
       return sequences;
     }
 
+    /**
+     * This method returns the visible alignment as text, as
+     * seen on the GUI, ie if columns are hidden they will not
+     * be returned in the result.
+     * Use this for calculating trees, PCA, redundancy etc on views
+     * which contain hidden columns.
+     * @return String[]
+     */
+    public jalview.datamodel.CigarArray getViewAsCigars(boolean selectedRegionOnly)
+    {
+      CigarArray selection=null;
+      SequenceI [] seqs= null;
+      int i, iSize;
+      int start = 0, end = 0;
+      if(selectedRegionOnly && selectionGroup!=null)
+      {
+        iSize = selectionGroup.getSize(false);
+        seqs = selectionGroup.getSequencesInOrder(alignment);
+        start = selectionGroup.getStartRes();
+        end = selectionGroup.getEndRes()+1;
+      }
+      else
+      {
+        iSize = alignment.getHeight();
+        seqs = alignment.getSequencesArray();
+        end = alignment.getWidth();
+      }
+      SeqCigar[] selseqs = new SeqCigar[iSize];
+      for(i=0; i<iSize; i++)
+      {
+        selseqs[i] = new SeqCigar(seqs[i], start, end);
+      }
+      selection=new CigarArray(selseqs);
+
+      int[] hiddenregions = null;
+      char[] hr_ops = null;
+      if (hasHiddenColumns) {
+        Vector _hiddenregions = new Vector();
+        Vector regions = colSel.getHiddenColumns();
+        int blockStart = start, blockEnd=end;
+        int [] region;
+        int hideStart, hideEnd;
+        int last=start;
+        for (int j = 0; last<end & j < regions.size(); j++)
+        {
+          region = (int[]) regions.elementAt(j);
+          hideStart = region[0];
+          hideEnd = region[1];
+          // edit hidden regions to selection range
+          if(hideStart<last) {
+            if (hideEnd > last)
+            {
+              hideStart = last;
+            } else
+              continue;
+          }
+
+          if (hideStart>end)
+            break;
+
+          if (hideEnd>end)
+            hideEnd=end;
+
+          if (hideStart>hideEnd)
+            break;
+          /**
+           * form operations...
+           */
+          if (last<hideStart)
+            selection.addOperation(CigarArray.M, hideStart-last);
+          selection.addOperation(CigarArray.D, 1+hideEnd-hideStart);
+          last = hideEnd+1;
+        }
+        // Final match if necessary.
+        if (last<end)
+          selection.addOperation(CigarArray.M, end-last);
+      } else {
+        selection.addOperation(CigarArray.M, end-start);
+      }
+      return selection;
+    }
 
     /**
      * This method returns the visible alignment as text, as
diff --git a/src/jalview/gui/TreePanel.java b/src/jalview/gui/TreePanel.java
index f636257..a0de682 100755
--- a/src/jalview/gui/TreePanel.java
+++ b/src/jalview/gui/TreePanel.java
@@ -71,7 +71,7 @@ public class TreePanel extends GTreePanel
       initTreePanel(av, type, pwtype, null);
 
       // We know this tree has distances. JBPNote TODO: prolly should add this as a userdefined default
-      showDistances(true);
+      // showDistances(true);
     }
 
     /**
@@ -137,7 +137,7 @@ public class TreePanel extends GTreePanel
     class TreeLoader extends Thread
     {
       NewickFile newtree;
-
+      jalview.datamodel.CigarArray odata=null;
       public TreeLoader(NewickFile newtree)
       {
         this.newtree = newtree;
@@ -153,19 +153,22 @@ public class TreePanel extends GTreePanel
       public void run()
       {
 
-        if(newtree!=null)
-          tree = new NJTree(av.alignment.getSequencesArray(),
-                            newtree);
+        if(newtree!=null) {
+
+          if (odata==null) {
+            tree = new NJTree(av.alignment.getSequencesArray(),
+                              newtree);
+          } else {
+            tree = new NJTree(av.alignment.getSequencesArray(), odata, newtree);
+          }
+          if (!tree.hasOriginalSequenceData())
+            allowOriginalSeqData(false);
+        }
         else
         {
           int start, end;
           SequenceI [] seqs;
-          String [] seqStrings = null;
-          if (av.hasHiddenColumns)
-          {
-            seqStrings = av.getViewAsString(true);
-          }
-
+          CigarArray seqStrings = av.getViewAsCigars(av.getSelectionGroup()!=null);
           if(av.getSelectionGroup()==null)
           {
             start = 0;
@@ -180,15 +183,14 @@ public class TreePanel extends GTreePanel
           }
 
           tree = new NJTree(seqs, seqStrings, type, pwtype, start, end);
+          showDistances(true);
         }
 
 
         tree.reCount(tree.getTopNode());
         tree.findHeight(tree.getTopNode());
         treeCanvas.setTree(tree);
-
         treeCanvas.repaint();
-
         av.setCurrentTree(tree);
 
       }
@@ -211,7 +213,9 @@ public class TreePanel extends GTreePanel
       placeholdersMenu.setState(b);
       treeCanvas.setMarkPlaceholders(b);
     }
-
+    private void allowOriginalSeqData(boolean b) {
+      originalSeqData.setVisible(b);
+    }
 
 
 
@@ -312,10 +316,16 @@ public class TreePanel extends GTreePanel
 
     public void originalSeqData_actionPerformed(ActionEvent e)
     {
-      CutAndPasteTransfer cap = new CutAndPasteTransfer();
-      cap.setText(tree.printOriginalSequenceData());
-      Desktop.addInternalFrame(cap, "Original Data",
-          400, 400);
+      String originalData = tree.printOriginalSequenceData();
+      if (originalData!=null) {
+        CutAndPasteTransfer cap = new CutAndPasteTransfer();
+        cap.setText(originalData);
+        Desktop.addInternalFrame(cap, "Original Data",
+                                 400, 400);
+      } else {
+        System.err.println("IMPLEMENTATION BUG! originalSeqData is not available.");
+      }
+
     }
 
 
diff --git a/src/jalview/jbgui/GTreePanel.java b/src/jalview/jbgui/GTreePanel.java
index a806a63..32b5364 100755
--- a/src/jalview/jbgui/GTreePanel.java
+++ b/src/jalview/jbgui/GTreePanel.java
@@ -41,7 +41,7 @@ public class GTreePanel
   JMenuItem epsTree = new JMenuItem();
   JMenu saveAsMenu = new JMenu();
   JMenuItem textbox = new JMenuItem();
-  JMenuItem originalSeqData = new JMenuItem();
+  public JMenuItem originalSeqData = new JMenuItem();
   public GTreePanel()
   {
     try
-- 
1.7.10.2