X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FColumnSelection.java;h=94e26422a5d29c857f706d1353959072db4424b6;hb=f5f5806de6923a8a62906c5a62c6276ba56ae0da;hp=2116d50192e796749a36b14ea1cfb2cb04c273e9;hpb=714c122e48957117de140264e762f48a4aeb96fc;p=jalview.git

diff --git a/src/jalview/gui/ColumnSelection.java b/src/jalview/gui/ColumnSelection.java
index 2116d50..94e2642 100755
--- a/src/jalview/gui/ColumnSelection.java
+++ b/src/jalview/gui/ColumnSelection.java
@@ -25,88 +25,394 @@ import java.util.*;
  */
 public class ColumnSelection
 {
-  Vector selected = new Vector();
+    Vector selected = new Vector();
 
-  public void addElement(int col)
-  {
-    if(!selected.contains(new Integer(col)))
-      selected.addElement(new Integer(col));
-  }
+    //Vector of int [] {startCol, endCol}
+    Vector hiddenColumns;
 
-  public void clear()
-  {
-    selected.removeAllElements();
-  }
+    /**
+     * 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();
+    }
 
-  public void removeElement(int col)
-  {
-    Integer colInt = new Integer(col);
-    if (selected.contains(colInt))
+    /**
+     * DOCUMENT ME!
+     *
+     * @param col DOCUMENT ME!
+     */
+    public void removeElement(int col)
     {
-      selected.removeElement(colInt);
+        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 boolean contains(int col)
-  {
-    return selected.contains(new Integer(col));
-  }
+    /**
+     * 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;
+    }
 
-  public int columnAt(int i)
-  {
-    return ( (Integer) selected.elementAt(i)).intValue();
-  }
+    /**
+     * 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());
 
-  public int size()
-  {
-    return selected.size();
-  }
+        result -= gaps;
+      }
 
-  public int getMax()
-  {
-    int max = -1;
+      return result;
+    }
 
-    for (int i = 0; i < selected.size(); i++)
+    /**
+     * Use this method to determine where the next hiddenRegion starts
+    */
+    public int findHiddenRegionPosition(int hiddenRegion)
     {
-      if (columnAt(i) > max)
+      int result = 0;
+      if (hiddenColumns != null)
       {
-        max = columnAt(i);
+        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;
     }
 
-    return max;
-  }
+    /**
+     * 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];
 
-  public int getMin()
-  {
-    int min = 1000000000;
+          index++;
+        }
+        while(index < hiddenColumns.size());
+      }
+
+      return alPos;
 
-    for (int i = 0; i < selected.size(); i++)
+    }
+    /**
+     * 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 (columnAt(i) < min)
+      if (hiddenColumns != null)
       {
-        min = columnAt(i);
+        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;
+
     }
 
-    return min;
-  }
 
-  public Vector asVector()
-  {
-    return selected;
-  }
 
-  public void compensateForEdit(int start, int change)
-  {
-    for (int i = 0; i < size(); i++)
+    public void hideColumns(int res)
     {
-      int temp = columnAt(i);
+      if(hiddenColumns==null)
+        hiddenColumns = new Vector();
+
+      // First find out range of columns to hide
+      int min = res, max = res+1;
+      while( contains(min) )
+      {  removeElement(min); min --;  }
+
+      while( contains(max) )
+      { removeElement(max);  max ++;  }
 
-      if (temp >= start)
+      min++; max--;
+
+      boolean added = false;
+      for(int i=0; i<hiddenColumns.size(); i++)
       {
-        selected.setElementAt(new Integer(temp - change), i);
+        int [] region = (int[])hiddenColumns.elementAt(i);
+        if( max < region[0])
+        {
+          hiddenColumns.insertElementAt(new int[]{min, max}, i);
+          added = true;
+          break;
+        }
       }
+
+      if(!added)
+        hiddenColumns.addElement(new int[]{min, max});
+
+    }
+
+    public void revealAllHiddenColumns(AlignViewport av)
+    {
+      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);
+          }
+        }
+      }
+      av.hasHiddenColumns = false;
+      hiddenColumns = null;
+    }
+
+    public void revealHiddenColumns(int res, AlignViewport av)
+    {
+      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.remove(region);
+          break;
+        }
+      }
+
+
+      if(hiddenColumns.size()<1)
+        av.hasHiddenColumns = false;
+    }
+
+    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;
     }
-  }
+
 }