X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=inline;f=src%2Fjalview%2Fdatamodel%2FHiddenColumns.java;h=169b0a4e4dca973dd5da9abd0d5ef1204243758a;hb=5a9eb84110b75bca3de6489501c17a499de98054;hp=1e1a58bd61037e14c904c732c00621fba7d827ed;hpb=1c251a57c7b2fb70dabceb480d0170363357558f;p=jalview.git

diff --git a/src/jalview/datamodel/HiddenColumns.java b/src/jalview/datamodel/HiddenColumns.java
index 1e1a58b..169b0a4 100644
--- a/src/jalview/datamodel/HiddenColumns.java
+++ b/src/jalview/datamodel/HiddenColumns.java
@@ -1,3 +1,23 @@
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
+ * Copyright (C) $$Year-Rel$$ The Jalview Authors
+ * 
+ * This file is part of Jalview.
+ * 
+ * Jalview 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 3
+ * of the License, or (at your option) any later version.
+ *  
+ * Jalview 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 Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
+ */
 package jalview.datamodel;
 
 import jalview.util.Comparison;
@@ -6,74 +26,120 @@ import jalview.util.ShiftList;
 import java.util.ArrayList;
 import java.util.BitSet;
 import java.util.Collections;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Vector;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
-public class HiddenColumns implements Iterable<int[]>
+public class HiddenColumns
 {
-  private static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+  private static final ReentrantReadWriteLock LOCK = new ReentrantReadWriteLock();
   
   /*
    * list of hidden column [start, end] ranges; the list is maintained in
    * ascending start column order
    */
-  private Vector<int[]> hiddenColumns;
+  private ArrayList<int[]> hiddenColumns;
 
   /**
-   * This Method is used to return all the HiddenColumn regions
+   * Constructor
+   */
+  public HiddenColumns()
+  {
+  }
+
+  /**
+   * Copy constructor
+   * 
+   * @param copy
+   */
+  public HiddenColumns(HiddenColumns copy)
+  {
+    try
+    {
+      LOCK.writeLock().lock();
+      if (copy != null)
+      {
+        if (copy.hiddenColumns != null)
+        {
+          hiddenColumns = copy.copyHiddenRegionsToArrayList();
+        }
+      }
+    } finally
+    {
+      LOCK.writeLock().unlock();
+    }
+  }
+
+  /**
+   * This method is used to return all the HiddenColumn regions and is intended
+   * to remain private. External callers which need a copy of the regions can
+   * call getHiddenColumnsCopyAsList.
    * 
    * @return empty list or List of hidden column intervals
    */
-  public List<int[]> getHiddenRegions()
+  private List<int[]> getHiddenRegions()
   {
     return hiddenColumns == null ? Collections.<int[]> emptyList()
             : hiddenColumns;
   }
 
   /**
-   * Find the number of hidden columns
+   * Output regions data as a string. String is in the format:
+   * reg0[0]<between>reg0[1]<delimiter>reg1[0]<between>reg1[1] ... regn[1]
    * 
-   * @return number of hidden columns
+   * @param delimiter
+   *          string to delimit regions
+   * @param betweenstring
+   *          to put between start and end region values
+   * @return regions formatted according to delimiter and between strings
    */
-  public int getSize()
+  public String regionsToString(String delimiter, String between)
   {
     try
     {
-      lock.readLock().lock();
-      int size = 0;
-      if (hasHidden())
+      LOCK.readLock().lock();
+      StringBuilder regionBuilder = new StringBuilder();
+      if (hiddenColumns != null)
       {
         for (int[] range : hiddenColumns)
         {
-          size += range[1] - range[0] + 1;
+          regionBuilder.append(delimiter).append(range[0]).append(between)
+                  .append(range[1]);
         }
+
+        regionBuilder.deleteCharAt(0);
       }
-      return size;
-    }
-    finally
+      return regionBuilder.toString();
+    } finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
   /**
-   * Answers if there are any hidden columns
+   * Find the number of hidden columns
    * 
-   * @return true if there are hidden columns
+   * @return number of hidden columns
    */
-  public boolean hasHidden()
+  public int getSize()
   {
     try
     {
-      lock.readLock().lock();
-      return (hiddenColumns != null) && (!hiddenColumns.isEmpty());
-    } finally
+      LOCK.readLock().lock();
+      int size = 0;
+      if (hasHiddenColumns())
+      {
+        for (int[] range : hiddenColumns)
+        {
+          size += range[1] - range[0] + 1;
+        }
+      }
+      return size;
+    }
+    finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
-
   }
 
   @Override
@@ -81,7 +147,7 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
+      LOCK.readLock().lock();
 
       if (!(obj instanceof HiddenColumns))
       {
@@ -113,7 +179,7 @@ public class HiddenColumns implements Iterable<int[]>
       return true;
     } finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
@@ -128,13 +194,13 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
+      LOCK.readLock().lock();
       int result = column;
       if (hiddenColumns != null)
       {
         for (int i = 0; i < hiddenColumns.size(); i++)
         {
-          int[] region = hiddenColumns.elementAt(i);
+          int[] region = hiddenColumns.get(i);
           if (result >= region[0])
           {
             result += region[1] - region[0] + 1;
@@ -144,7 +210,7 @@ public class HiddenColumns implements Iterable<int[]>
       return result;
     } finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
@@ -161,7 +227,7 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
+      LOCK.readLock().lock();
       int result = hiddenColumn;
       if (hiddenColumns != null)
       {
@@ -169,7 +235,7 @@ public class HiddenColumns implements Iterable<int[]>
         int[] region;
         do
         {
-          region = hiddenColumns.elementAt(index++);
+          region = hiddenColumns.get(index++);
           if (hiddenColumn > region[1])
           {
             result -= region[1] + 1 - region[0];
@@ -203,7 +269,7 @@ public class HiddenColumns implements Iterable<int[]>
                      // columns.
     } finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
@@ -223,7 +289,7 @@ public class HiddenColumns implements Iterable<int[]>
     try
     {
 
-      lock.readLock().lock();
+      LOCK.readLock().lock();
     int distance = visibleDistance;
 
     // in case startColumn is in a hidden region, move it to the left
@@ -267,7 +333,7 @@ public class HiddenColumns implements Iterable<int[]>
     return start - distance;
     } finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
 
   }
@@ -281,37 +347,45 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
-      List<Integer> positions = new ArrayList<>(
-              hiddenColumns.size());
+      LOCK.readLock().lock();
+      List<Integer> positions = null;
 
-      positions.add(hiddenColumns.elementAt(0)[0]);
-      for (int i = 1; i < hiddenColumns.size(); ++i)
+      if (hiddenColumns != null)
       {
+        positions = new ArrayList<>(hiddenColumns.size());
 
-        int result = 0;
-        if (hiddenColumns != null)
+        positions.add(hiddenColumns.get(0)[0]);
+        for (int i = 1; i < hiddenColumns.size(); ++i)
         {
-          int index = 0;
-          int gaps = 0;
-          do
+
+          int result = 0;
+          if (hiddenColumns != null)
           {
-            int[] region = hiddenColumns.elementAt(index);
-            gaps += region[1] + 1 - region[0];
-            result = region[1] + 1;
-            index++;
-          } while (index <= i);
+            int index = 0;
+            int gaps = 0;
+            do
+            {
+              int[] region = hiddenColumns.get(index);
+              gaps += region[1] + 1 - region[0];
+              result = region[1] + 1;
+              index++;
+            } while (index <= i);
 
-          result -= gaps;
+            result -= gaps;
+          }
+          positions.add(result);
         }
-        positions.add(result);
+      }
+      else
+      {
+        positions = new ArrayList<>();
       }
 
       return positions;
     }
     finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
@@ -326,13 +400,13 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
+      LOCK.readLock().lock();
       if (hiddenColumns != null)
       {
         int index = 0;
         do
         {
-          int[] region = hiddenColumns.elementAt(index);
+          int[] region = hiddenColumns.get(index);
           if (alPos < region[0])
           {
             return region[0];
@@ -345,7 +419,7 @@ public class HiddenColumns implements Iterable<int[]>
       return alPos;
     } finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
 
   }
@@ -361,14 +435,14 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
+      LOCK.readLock().lock();
 
     if (hiddenColumns != null)
     {
       int index = hiddenColumns.size() - 1;
       do
       {
-        int[] region = hiddenColumns.elementAt(index);
+          int[] region = hiddenColumns.get(index);
         if (alPos > region[1])
         {
           return region[1];
@@ -381,7 +455,7 @@ public class HiddenColumns implements Iterable<int[]>
     return alPos;
     } finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
@@ -398,13 +472,13 @@ public class HiddenColumns implements Iterable<int[]>
     try
     {
 
-      lock.readLock().lock();
+      LOCK.readLock().lock();
     if (hiddenColumns != null)
     {
       int index = hiddenColumns.size() - 1;
       do
       {
-        int[] region = hiddenColumns.elementAt(index);
+          int[] region = hiddenColumns.get(index);
         if (pos > region[1])
         {
           return index;
@@ -417,7 +491,7 @@ public class HiddenColumns implements Iterable<int[]>
     return -1;
     } finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
 
   }
@@ -430,96 +504,91 @@ public class HiddenColumns implements Iterable<int[]>
    */
   public void hideColumns(int start, int end)
   {
-    hideColumns(start, end, false);
-  }
-
-  /**
-   * Adds the specified column range to the hidden columns
-   * 
-   * @param start
-   * @param end
-   */
-  private void hideColumns(int start, int end, boolean alreadyLocked)
-  {
+    boolean wasAlreadyLocked = false;
     try
     {
-
-      if (!alreadyLocked)
+      // check if the write lock was already locked by this thread,
+      // as this method can be called internally in loops within HiddenColumns
+      if (!LOCK.isWriteLockedByCurrentThread())
       {
-        lock.writeLock().lock();
+        LOCK.writeLock().lock();
       }
-
-    if (hiddenColumns == null)
-    {
-      hiddenColumns = new Vector<>();
-    }
-
-    /*
-     * traverse existing hidden ranges and insert / amend / append as
-     * appropriate
-     */
-    for (int i = 0; i < hiddenColumns.size(); i++)
-    {
-      int[] region = hiddenColumns.elementAt(i);
-
-      if (end < region[0] - 1)
+      else
       {
-        /*
-         * insert discontiguous preceding range
-         */
-        hiddenColumns.insertElementAt(new int[] { start, end }, i);
-        return;
+        wasAlreadyLocked = true;
       }
 
-      if (end <= region[1])
+      if (hiddenColumns == null)
       {
-        /*
-         * new range overlaps existing, or is contiguous preceding it - adjust
-         * start column
-         */
-        region[0] = Math.min(region[0], start);
-        return;
+        hiddenColumns = new ArrayList<>();
       }
 
-      if (start <= region[1] + 1)
+      /*
+       * traverse existing hidden ranges and insert / amend / append as
+       * appropriate
+       */
+      for (int i = 0; i < hiddenColumns.size(); i++)
       {
-        /*
-         * new range overlaps existing, or is contiguous following it - adjust
-         * start and end columns
-         */
-        region[0] = Math.min(region[0], start);
-        region[1] = Math.max(region[1], end);
-
-        /*
-         * also update or remove any subsequent ranges 
-         * that are overlapped
-         */
-        while (i < hiddenColumns.size() - 1)
+        int[] region = hiddenColumns.get(i);
+
+        if (end < region[0] - 1)
+        {
+          /*
+           * insert discontiguous preceding range
+           */
+          hiddenColumns.add(i, new int[] { start, end });
+          return;
+        }
+
+        if (end <= region[1])
         {
-          int[] nextRegion = hiddenColumns.get(i + 1);
-          if (nextRegion[0] > end + 1)
+          /*
+           * new range overlaps existing, or is contiguous preceding it - adjust
+           * start column
+           */
+          region[0] = Math.min(region[0], start);
+          return;
+        }
+
+        if (start <= region[1] + 1)
+        {
+          /*
+           * new range overlaps existing, or is contiguous following it - adjust
+           * start and end columns
+           */
+          region[0] = Math.min(region[0], start);
+          region[1] = Math.max(region[1], end);
+
+          /*
+           * also update or remove any subsequent ranges 
+           * that are overlapped
+           */
+          while (i < hiddenColumns.size() - 1)
           {
-            /*
-             * gap to next hidden range - no more to update
-             */
-            break;
+            int[] nextRegion = hiddenColumns.get(i + 1);
+            if (nextRegion[0] > end + 1)
+            {
+              /*
+               * gap to next hidden range - no more to update
+               */
+              break;
+            }
+            region[1] = Math.max(nextRegion[1], end);
+            hiddenColumns.remove(i + 1);
           }
-          region[1] = Math.max(nextRegion[1], end);
-          hiddenColumns.remove(i + 1);
+          return;
         }
-        return;
-      }
     }
 
     /*
      * remaining case is that the new range follows everything else
      */
-    hiddenColumns.addElement(new int[] { start, end });
+      hiddenColumns.add(new int[] { start, end });
     } finally
     {
-      if (!alreadyLocked)
+      if (!wasAlreadyLocked)
       {
-        lock.writeLock().unlock();
+        LOCK.writeLock().unlock();
       }
     }
   }
@@ -528,7 +597,7 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
+      LOCK.readLock().lock();
 
     if (hiddenColumns != null)
     {
@@ -544,66 +613,24 @@ public class HiddenColumns implements Iterable<int[]>
     return true;
     } finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
-  /**
-   * ColumnSelection
-   */
-  public HiddenColumns()
-  {
-  }
-
-  /**
-   * Copy constructor
-   * 
-   * @param copy
-   */
-  public HiddenColumns(HiddenColumns copy)
-  {
-    try
-    {
-
-      lock.readLock().lock();
-      if (copy != null)
-      {
-        if (copy.hiddenColumns != null)
-        {
-          hiddenColumns = copy.copyHiddenRegions();
-        }
-      }
-    }
-    finally
-    {
-      lock.readLock().unlock();
-    }
-  }
-
-  private Vector<int[]> copyHiddenRegions()
+  private ArrayList<int[]> copyHiddenRegionsToArrayList()
   {
-    Vector<int[]> copy = new Vector<>(hiddenColumns.size());
-    for (int i = 0, j = hiddenColumns.size(); i < j; i++)
+    int size = 0;
+    if (hiddenColumns != null)
     {
-      int[] rh, cp;
-      rh = hiddenColumns.elementAt(i);
-      if (rh != null)
-      {
-        cp = new int[rh.length];
-        System.arraycopy(rh, 0, cp, 0, rh.length);
-        copy.addElement(cp);
-      }
+      size = hiddenColumns.size();
     }
-    return copy;
-  }
+    ArrayList<int[]> copy = new ArrayList<>(size);
 
-  private ArrayList<int[]> copyHiddenRegionsToArrayList()
-  {
-    ArrayList<int[]> copy = new ArrayList<>(hiddenColumns.size());
-    for (int i = 0, j = hiddenColumns.size(); i < j; i++)
+    for (int i = 0, j = size; i < j; i++)
     {
-      int[] rh, cp;
-      rh = hiddenColumns.elementAt(i);
+      int[] rh;
+      int[] cp;
+      rh = hiddenColumns.get(i);
       if (rh != null)
       {
         cp = new int[rh.length];
@@ -611,30 +638,27 @@ public class HiddenColumns implements Iterable<int[]>
         copy.add(cp);
       }
     }
-    return copy;
-  }
 
-  public void getHiddenColumnsCopy(Vector<int[]> copy)
-  {
-    try
-    {
-      lock.readLock().lock();
-      copy = copyHiddenRegions();
-    } finally
-    {
-      lock.readLock().unlock();
-    }
+    return copy;
   }
-
-  public void getHiddenColumnsCopy(ArrayList<int[]> copy)
+  
+  /**
+   * Returns a copy of the vector of hidden regions, as an ArrayList. Before
+   * using this method please consider if you really need access to the hidden
+   * regions - a new (or existing!) method on HiddenColumns might be more
+   * appropriate.
+   * 
+   * @return hidden regions as an ArrayList of [start,end] pairs
+   */
+  public ArrayList<int[]> getHiddenColumnsCopy()
   {
     try
     {
-      lock.readLock().lock();
-      copy = copyHiddenRegionsToArrayList();
+      LOCK.readLock().lock();
+      return copyHiddenRegionsToArrayList();
     } finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
@@ -651,7 +675,7 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.writeLock().lock();
+      LOCK.writeLock().lock();
       List<int[]> deletedHiddenColumns = null;
 
       if (hiddenColumns != null)
@@ -660,12 +684,12 @@ public class HiddenColumns implements Iterable<int[]>
         int hSize = hiddenColumns.size();
         for (int i = 0; i < hSize; i++)
         {
-          int[] region = hiddenColumns.elementAt(i);
+          int[] region = hiddenColumns.get(i);
           if (region[0] > start && start + change > region[1])
           {
             deletedHiddenColumns.add(region);
 
-            hiddenColumns.removeElementAt(i);
+            hiddenColumns.remove(i);
             i--;
             hSize--;
             continue;
@@ -690,7 +714,7 @@ public class HiddenColumns implements Iterable<int[]>
       return deletedHiddenColumns;
     } finally
     {
-      lock.writeLock().unlock();
+      LOCK.writeLock().unlock();
     }
   }
 
@@ -707,12 +731,12 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.writeLock().lock();
+      LOCK.writeLock().lock();
       if (hiddenColumns != null)
       {
         for (int i = 0; i < hiddenColumns.size(); i++)
         {
-          int[] region = hiddenColumns.elementAt(i);
+          int[] region = hiddenColumns.get(i);
           if (region[0] >= start)
           {
             region[0] -= change;
@@ -723,7 +747,7 @@ public class HiddenColumns implements Iterable<int[]>
           }
           if (region[1] < region[0])
           {
-            hiddenColumns.removeElementAt(i--);
+            hiddenColumns.remove(i--);
           }
 
           if (region[0] < 0)
@@ -739,7 +763,7 @@ public class HiddenColumns implements Iterable<int[]>
     }
     finally
     {
-      lock.writeLock().unlock();
+      LOCK.writeLock().unlock();
     }
   }
 
@@ -757,7 +781,7 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
+      LOCK.readLock().lock();
       if (hiddenColumns != null && hiddenColumns.size() > 0)
       {
         List<int[]> visiblecontigs = new ArrayList<>();
@@ -765,7 +789,8 @@ public class HiddenColumns implements Iterable<int[]>
 
         int vstart = start;
         int[] region;
-        int hideStart, hideEnd;
+        int hideStart;
+        int hideEnd;
 
         for (int j = 0; vstart < end && j < regions.size(); j++)
         {
@@ -806,7 +831,7 @@ public class HiddenColumns implements Iterable<int[]>
     }
     finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
@@ -815,19 +840,21 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
-      int i, iSize = seqs.length;
-      String selections[] = new String[iSize];
+      LOCK.readLock().lock();
+      int iSize = seqs.length;
+      String[] selections = new String[iSize];
       if (hiddenColumns != null && hiddenColumns.size() > 0)
       {
-        for (i = 0; i < iSize; i++)
+        for (int i = 0; i < iSize; i++)
         {
           StringBuffer visibleSeq = new StringBuffer();
           List<int[]> regions = getHiddenRegions();
 
-          int blockStart = start, blockEnd = end;
+          int blockStart = start;
+          int blockEnd = end;
           int[] region;
-          int hideStart, hideEnd;
+          int hideStart;
+          int hideEnd;
 
           for (int j = 0; j < regions.size(); j++)
           {
@@ -864,7 +891,7 @@ public class HiddenColumns implements Iterable<int[]>
       }
       else
       {
-        for (i = 0; i < iSize; i++)
+        for (int i = 0; i < iSize; i++)
         {
           selections[i] = seqs[i].getSequenceAsString(start, end);
         }
@@ -874,7 +901,7 @@ public class HiddenColumns implements Iterable<int[]>
     }
     finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
@@ -892,23 +919,30 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
-      int fpos = seq.getStart(), lpos = seq.getEnd();
+      LOCK.readLock().lock();
+      int fpos = seq.getStart();
+      int lpos = seq.getEnd();
       int start = 0;
 
       if (hiddenColumns == null || hiddenColumns.size() == 0)
       {
-        int ifpos = seq.findIndex(fpos) - 1,
-                ilpos = seq.findIndex(lpos) - 1;
+        int ifpos = seq.findIndex(fpos) - 1;
+        int ilpos = seq.findIndex(lpos) - 1;
         return new int[] { ifpos, ilpos, fpos, lpos, ifpos, ilpos };
       }
 
       // Simply walk along the sequence whilst watching for hidden column
       // boundaries
       List<int[]> regions = getHiddenRegions();
-      int spos = fpos, lastvispos = -1, rcount = 0,
-              hideStart = seq.getLength(), hideEnd = -1;
-      int visPrev = 0, visNext = 0, firstP = -1, lastP = -1;
+      int spos = fpos;
+      int lastvispos = -1;
+      int rcount = 0;
+      int hideStart = seq.getLength();
+      int hideEnd = -1;
+      int visPrev = 0;
+      int visNext = 0;
+      int firstP = -1;
+      int lastP = -1;
       boolean foundStart = false;
       for (int p = 0, pLen = seq.getLength(); spos <= seq.getEnd()
               && p < pLen; p++)
@@ -961,7 +995,7 @@ public class HiddenColumns implements Iterable<int[]>
     }
     finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
@@ -992,7 +1026,7 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
+      LOCK.readLock().lock();
       if (alignmentAnnotation.annotations == null)
       {
         return;
@@ -1008,9 +1042,12 @@ public class HiddenColumns implements Iterable<int[]>
         Vector<Annotation[]> annels = new Vector<>();
         Annotation[] els = null;
         List<int[]> regions = getHiddenRegions();
-        int blockStart = start, blockEnd = end;
+        int blockStart = start;
+        int blockEnd = end;
         int[] region;
-        int hideStart, hideEnd, w = 0;
+        int hideStart;
+        int hideEnd;
+        int w = 0;
 
         for (int j = 0; j < regions.size(); j++)
         {
@@ -1080,7 +1117,7 @@ public class HiddenColumns implements Iterable<int[]>
     }
     finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
@@ -1092,11 +1129,11 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
+      LOCK.readLock().lock();
       return hiddenColumns != null && hiddenColumns.size() > 0;
     } finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
@@ -1108,11 +1145,11 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
+      LOCK.readLock().lock();
       return hiddenColumns != null && hiddenColumns.size() > 1;
     } finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
@@ -1126,15 +1163,15 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.writeLock().lock();
+      LOCK.writeLock().lock();
       List<int[]> inserts = sr.getInsertions();
       for (int[] r : inserts)
       {
-        hideColumns(r[0], r[1], true);
+        hideColumns(r[0], r[1]);
       }
     } finally
     {
-      lock.writeLock().unlock();
+      LOCK.writeLock().unlock();
     }
   }
 
@@ -1145,12 +1182,12 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.writeLock().lock();
+      LOCK.writeLock().lock();
       if (hiddenColumns != null)
       {
         for (int i = 0; i < hiddenColumns.size(); i++)
         {
-          int[] region = hiddenColumns.elementAt(i);
+          int[] region = hiddenColumns.get(i);
           for (int j = region[0]; j < region[1] + 1; j++)
           {
             sel.addElement(j);
@@ -1162,7 +1199,7 @@ public class HiddenColumns implements Iterable<int[]>
     }
     finally
     {
-      lock.writeLock().unlock();
+      LOCK.writeLock().unlock();
     }
   }
 
@@ -1176,10 +1213,10 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.writeLock().lock();
+      LOCK.writeLock().lock();
       for (int i = 0; i < hiddenColumns.size(); i++)
       {
-        int[] region = hiddenColumns.elementAt(i);
+        int[] region = hiddenColumns.get(i);
         if (start == region[0])
         {
           for (int j = region[0]; j < region[1] + 1; j++)
@@ -1187,7 +1224,7 @@ public class HiddenColumns implements Iterable<int[]>
             sel.addElement(j);
           }
 
-          hiddenColumns.removeElement(region);
+          hiddenColumns.remove(region);
           break;
         }
       }
@@ -1198,7 +1235,7 @@ public class HiddenColumns implements Iterable<int[]>
     }
     finally
     {
-      lock.writeLock().unlock();
+      LOCK.writeLock().unlock();
     }
   }
 
@@ -1210,13 +1247,16 @@ public class HiddenColumns implements Iterable<int[]>
    * @param intervals
    * @return
    */
-  private boolean pruneIntervalVector(final List<int[]> shifts,
-          Vector<int[]> intervals)
+  private boolean pruneIntervalList(final List<int[]> shifts,
+          ArrayList<int[]> intervals)
   {
     boolean pruned = false;
-    int i = 0, j = intervals.size() - 1, s = 0, t = shifts.size() - 1;
-    int hr[] = intervals.elementAt(i);
-    int sr[] = shifts.get(s);
+    int i = 0;
+    int j = intervals.size() - 1;
+    int s = 0;
+    int t = shifts.size() - 1;
+    int[] hr = intervals.get(i);
+    int[] sr = shifts.get(s);
     while (i <= j && s <= t)
     {
       boolean trailinghn = hr[1] >= sr[0];
@@ -1224,7 +1264,7 @@ public class HiddenColumns implements Iterable<int[]>
       {
         if (i < j)
         {
-          hr = intervals.elementAt(++i);
+          hr = intervals.get(++i);
         }
         else
         {
@@ -1252,12 +1292,12 @@ public class HiddenColumns implements Iterable<int[]>
       {
         if (trailinghc)
         { // deleted hidden region.
-          intervals.removeElementAt(i);
+          intervals.remove(i);
           pruned = true;
           j--;
           if (i <= j)
           {
-            hr = intervals.elementAt(i);
+            hr = intervals.get(i);
           }
           continue;
         }
@@ -1307,11 +1347,11 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.writeLock().lock();
+      LOCK.writeLock().lock();
       // delete any intervals intersecting.
       if (hiddenColumns != null)
       {
-        pruneIntervalVector(shifts, hiddenColumns);
+        pruneIntervalList(shifts, hiddenColumns);
         if (hiddenColumns != null && hiddenColumns.size() == 0)
         {
           hiddenColumns = null;
@@ -1320,7 +1360,7 @@ public class HiddenColumns implements Iterable<int[]>
     }
     finally
     {
-      lock.writeLock().unlock();
+      LOCK.writeLock().unlock();
     }
   }
 
@@ -1367,8 +1407,7 @@ public class HiddenColumns implements Iterable<int[]>
     // recover mapping between sequence's non-gap positions and positions
     // mapping to view.
     pruneDeletions(ShiftList.parseMap(origseq.gapMap()));
-    int[] viscontigs = al.getHiddenColumns().getVisibleContigs(0,
-            profileseq.getLength());
+    int[] viscontigs = getVisibleContigs(0, profileseq.getLength());
     int spos = 0;
     int offset = 0;
 
@@ -1522,7 +1561,7 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
+      LOCK.readLock().lock();
       int hashCode = 1;
       if (hiddenColumns != null)
       {
@@ -1536,7 +1575,7 @@ public class HiddenColumns implements Iterable<int[]>
     }
     finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
@@ -1550,17 +1589,17 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.writeLock().lock();
+      LOCK.writeLock().lock();
       for (int firstSet = inserts
               .nextSetBit(0), lastSet = 0; firstSet >= 0; firstSet = inserts
                       .nextSetBit(lastSet))
       {
         lastSet = inserts.nextClearBit(firstSet);
-        hideColumns(firstSet, lastSet - 1, true);
+        hideColumns(firstSet, lastSet - 1);
       }
     } finally
     {
-      lock.writeLock().unlock();
+      LOCK.writeLock().unlock();
     }
   }
 
@@ -1573,7 +1612,7 @@ public class HiddenColumns implements Iterable<int[]>
   {
     try
     {
-      lock.readLock().lock();
+      LOCK.readLock().lock();
       if (hiddenColumns == null)
       {
         return;
@@ -1585,18 +1624,96 @@ public class HiddenColumns implements Iterable<int[]>
     }
     finally
     {
-      lock.readLock().unlock();
+      LOCK.readLock().unlock();
     }
   }
 
-  @Override
-  public Iterator<int[]> iterator()
+  /**
+   * Calculate the visible start and end index of an alignment.
+   * 
+   * @param width
+   *          full alignment width
+   * @return integer array where: int[0] = startIndex, and int[1] = endIndex
+   */
+  public int[] getVisibleStartAndEndIndex(int width)
+  {
+    try
+    {
+      LOCK.readLock().lock();
+      int[] alignmentStartEnd = new int[] { 0, width - 1 };
+      int startPos = alignmentStartEnd[0];
+      int endPos = alignmentStartEnd[1];
+
+      int[] lowestRange = new int[] { -1, -1 };
+      int[] higestRange = new int[] { -1, -1 };
+
+      if (hiddenColumns == null)
+      {
+        return new int[] { startPos, endPos };
+      }
+
+      for (int[] hiddenCol : hiddenColumns)
+      {
+        lowestRange = (hiddenCol[0] <= startPos) ? hiddenCol : lowestRange;
+        higestRange = (hiddenCol[1] >= endPos) ? hiddenCol : higestRange;
+      }
+
+      if (lowestRange[0] == -1 && lowestRange[1] == -1)
+      {
+        startPos = alignmentStartEnd[0];
+      }
+      else
+      {
+        startPos = lowestRange[1] + 1;
+      }
+
+      if (higestRange[0] == -1 && higestRange[1] == -1)
+      {
+        endPos = alignmentStartEnd[1];
+      }
+      else
+      {
+        endPos = higestRange[0] - 1;
+      }
+      return new int[] { startPos, endPos };
+    } finally
+    {
+      LOCK.readLock().unlock();
+    }
+
+  }
+
+  /**
+   * Finds the hidden region (if any) which starts or ends at res
+   * 
+   * @param res
+   *          visible residue position, unadjusted for hidden columns
+   * @return region as [start,end] or null if no matching region is found
+   */
+  public int[] getRegionWithEdgeAtRes(int res)
   {
-    if (hiddenColumns == null)
+    try
+    {
+      LOCK.readLock().lock();
+      int adjres = adjustForHiddenColumns(res);
+
+      int[] reveal = null;
+      if (hiddenColumns != null)
+      {
+        for (int[] region : hiddenColumns)
+        {
+          if (adjres + 1 == region[0] || adjres - 1 == region[1])
+          {
+            reveal = region;
+            break;
+          }
+        }
+      }
+      return reveal;
+    } finally
     {
-      return Collections.<int[]> emptyList().iterator();
+      LOCK.readLock().unlock();
     }
-    return hiddenColumns.iterator();
   }
 
 }