From 6a52231af31721231478e6ff3a553bbe23ee863f Mon Sep 17 00:00:00 2001
From: amwaterhouse <Andrew Waterhouse>
Date: Wed, 26 Jul 2006 08:56:08 +0000
Subject: [PATCH] Remove left, right, empty cols work on hidden reps

---
 src/jalview/datamodel/Alignment.java  |  128 ++++++++++++++++++++++-----------
 src/jalview/datamodel/AlignmentI.java |   11 +--
 2 files changed, 87 insertions(+), 52 deletions(-)

diff --git a/src/jalview/datamodel/Alignment.java b/src/jalview/datamodel/Alignment.java
index 90d6740..c0c4ae0 100755
--- a/src/jalview/datamodel/Alignment.java
+++ b/src/jalview/datamodel/Alignment.java
@@ -115,7 +115,6 @@ public class Alignment implements AlignmentI
         }
         else
         {
-          System.out.println("CLEARED HERE");
           Sequence ds = new Sequence(snew.getName(),
                                      AlignSeq.extractGaps("-. ",
               snew.getSequence()),
@@ -157,14 +156,26 @@ public class Alignment implements AlignmentI
      */
     public void removeGaps()
     {
+        SequenceI[] seqs = getVisibleAndRepresentedSeqs();
+        int j, jSize = seqs.length;
+
         SequenceI current;
-        int iSize = getWidth();
+        int width = 0;
+        for (int i = 0; i < jSize; i++)
+        {
+          if (seqs[i].getLength() > width)
+          {
+            width = seqs[i].getLength();
+          }
+        }
 
-        for (int i = 0; i < iSize; i++)
+        int startCol = -1, endCol = -1;
+        boolean delete = true;
+        for (int i = 0; i < width; i++)
         {
-            boolean delete = true;
+            delete = true;
 
-            for (int j = 0; j < getHeight(); j++)
+            for (j = 0; j < jSize; j++)
             {
                 current = getSequenceAt(j);
 
@@ -172,48 +183,51 @@ public class Alignment implements AlignmentI
                 {
                     if (!jalview.util.Comparison.isGap(current.getCharAt(i)))
                     {
+                        if(delete)
+                          endCol = i;
+
                         delete = false;
+                        break;
                     }
                 }
+
+            }
+
+            if(delete && startCol==-1)
+            {
+              startCol = i;
             }
 
-            if (delete)
+
+            if (!delete && startCol > -1)
             {
-                deleteColumns(i, i);
-                iSize--;
-                i--;
+              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(int start, int end)
+    public void deleteColumns(SequenceI [] seqs, int start, int end)
     {
-        deleteColumns(0, getHeight() - 1, start, end);
+      for(int i=0; i<seqs.length; i++)
+        seqs[i].deleteChars(start, end);
     }
 
-    /**
-     * DOCUMENT ME!
-     *
-     * @param seq1 DOCUMENT ME!
-     * @param seq2 DOCUMENT ME!
-     * @param start DOCUMENT ME!
-     * @param end DOCUMENT ME!
-     */
-    public void deleteColumns(int seq1, int seq2, int start, int end)
-    {
-        for (int i = 0; i <= (end - start); i++)
-        {
-            for (int j = seq1; j <= seq2; j++)
-            {
-                getSequenceAt(j).deleteCharAt(start);
-            }
-        }
-    }
 
     /**
      * DOCUMENT ME!
@@ -222,22 +236,22 @@ public class Alignment implements AlignmentI
      */
     public void trimLeft(int i)
     {
-        int j, jSize = getHeight();
+        SequenceI[] seqs = getVisibleAndRepresentedSeqs();
+        int j, jSize = seqs.length;
         for (j = 0; j < jSize; j++)
         {
-            SequenceI s = getSequenceAt(j);
-            int newstart = s.findPosition(i);
+            int newstart = seqs[j].findPosition(i);
 
-            if(i>s.getLength())
+            if(i>seqs[j].getLength())
             {
-              sequences.removeElement(s);
+              sequences.removeElement(seqs[j]);
               j--;
               jSize--;
             }
             else
             {
-              s.setStart(newstart);
-              s.setSequence(s.getSequence().substring(i));
+              seqs[j].setStart(newstart);
+              seqs[j].setSequence(seqs[j].getSequence().substring(i));
             }
         }
     }
@@ -249,14 +263,15 @@ public class Alignment implements AlignmentI
      */
     public void trimRight(int i)
     {
-        for (int j = 0; j < getHeight(); j++)
+        SequenceI[] seqs = getVisibleAndRepresentedSeqs();
+        int j, jSize = seqs.length;
+        for (j = 0; j < jSize; j++)
         {
-            SequenceI s = getSequenceAt(j);
-            int newend = s.findPosition(i);
+            int newend = seqs[j].findPosition(i);
 
-            s.setEnd(newend);
-            if(s.getLength()>i)
-              s.setSequence(s.getSequence().substring(0, i + 1));
+            seqs[j].setEnd(newend);
+            if(seqs[j].getLength()>i)
+              seqs[j].setSequence(seqs[j].getSequence().substring(0, i + 1));
         }
     }
 
@@ -744,4 +759,33 @@ public class Alignment implements AlignmentI
       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;
+
+    }
+
 }
diff --git a/src/jalview/datamodel/AlignmentI.java b/src/jalview/datamodel/AlignmentI.java
index dbf3c35..e62c8c2 100755
--- a/src/jalview/datamodel/AlignmentI.java
+++ b/src/jalview/datamodel/AlignmentI.java
@@ -111,17 +111,8 @@ public interface AlignmentI
      * @param start Start index of columns to delete.
      * @param end End index to columns to delete.
      */
-    public void deleteColumns(int start, int end);
+    public void deleteColumns(SequenceI seqs [], int start, int end);
 
-    /**
-     * Deletes all residues in every sequence of alignment within given columns.
-     *
-     * @param seq1 Index of first sequence to delete columns from.
-     * @param seq2 Index of last sequence to delete columns from.
-     * @param start Start index of columns to delete.
-     * @param end End index of columns to delete.
-     */
-    public void deleteColumns(int seq1, int seq2, int start, int end);
 
     /**
      * Finds sequence in alignment using sequence name as query.
-- 
1.7.10.2