From: kiramt <k.mourao@dundee.ac.uk>
Date: Wed, 1 Mar 2017 08:46:10 +0000 (+0000)
Subject: JAL-2388 Preliminary refactor check-in, does not compile
X-Git-Tag: Release_2_10_2~3^2~92^2~58
X-Git-Url: http://source.jalview.org/gitweb/?a=commitdiff_plain;h=79631ef84a124bfefa84c24b85dc77883366ad4a;p=jalview.git

JAL-2388 Preliminary refactor check-in, does not compile
---

diff --git a/src/jalview/gui/AlignViewport.java b/src/jalview/gui/AlignViewport.java
index 7bebfa9..f1bb8de 100644
--- a/src/jalview/gui/AlignViewport.java
+++ b/src/jalview/gui/AlignViewport.java
@@ -150,10 +150,11 @@ public class AlignViewport extends AlignmentViewport implements
   public AlignViewport(AlignmentI al, ColumnSelection hiddenColumns)
   {
     setAlignment(al);
-    if (hiddenColumns != null)
+    posProps.setHiddenColumns(hiddenColumns);
+    /*if (hiddenColumns != null)
     {
       colSel = hiddenColumns;
-    }
+    }*/
     init();
   }
 
@@ -197,10 +198,11 @@ public class AlignViewport extends AlignmentViewport implements
       Cache.log.debug("Setting viewport's view id : " + viewId);
     }
     setAlignment(al);
-    if (hiddenColumns != null)
+    posProps.setHiddenColumns(hiddenColumns);
+    /*if (hiddenColumns != null)
     {
       colSel = hiddenColumns;
-    }
+    }*/
     init();
   }
 
@@ -533,7 +535,9 @@ public class AlignViewport extends AlignmentViewport implements
     {
       end = alignment.getWidth();
     }
-    viscontigs = colSel.getVisibleContigs(start, end);
+    viscontigs = posProps.getColumnSelection()
+            .getVisibleContigs(start, end);
+    // viscontigs = colSel.getVisibleContigs(start, end);
     return viscontigs;
   }
 
diff --git a/src/jalview/viewmodel/AlignmentViewport.java b/src/jalview/viewmodel/AlignmentViewport.java
index 41248b1..b62c61c 100644
--- a/src/jalview/viewmodel/AlignmentViewport.java
+++ b/src/jalview/viewmodel/AlignmentViewport.java
@@ -589,9 +589,9 @@ public abstract class AlignmentViewport implements AlignViewportI,
     return isDataset;
   }
 
-  private Map<SequenceI, SequenceCollectionI> hiddenRepSequences;
 
-  protected ColumnSelection colSel = new ColumnSelection();
+
+  // protected ColumnSelection colSel = new ColumnSelection();
 
   public boolean autoCalculateConsensus = true;
 
@@ -632,7 +632,7 @@ public abstract class AlignmentViewport implements AlignViewportI,
       {
         residueShading.setConservation(hconservation);
       }
-      residueShading.alignmentChanged(alignment, hiddenRepSequences);
+      residueShading.alignmentChanged(alignment, getHiddenRepSequences());
     }
 
     /*
@@ -651,7 +651,8 @@ public abstract class AlignmentViewport implements AlignViewportI,
         if (cs != null)
         {
           sg.getGroupColourScheme()
-                  .alignmentChanged(sg, hiddenRepSequences);
+.alignmentChanged(sg,
+                  getHiddenRepSequences());
         }
       }
     }
@@ -1094,24 +1095,27 @@ public abstract class AlignmentViewport implements AlignViewportI,
 
   public void setHiddenColumns(ColumnSelection colsel)
   {
-    this.colSel = colsel;
+    posProps.setHiddenColumns(colsel);
+    // this.colSel = colsel;
   }
 
   @Override
   public ColumnSelection getColumnSelection()
   {
-    return colSel;
+    return posProps.getColumnSelection();
+    // return colSel;
   }
 
   @Override
   public void setColumnSelection(ColumnSelection colSel)
   {
-    this.colSel = colSel;
+    posProps.setColumnSelection(colSel);
+    /*this.colSel = colSel;
     if (colSel != null)
     {
       updateHiddenColumns();
     }
-    isColSelChanged(true);
+    isColSelChanged(true);*/
   }
 
   /**
@@ -1121,14 +1125,14 @@ public abstract class AlignmentViewport implements AlignViewportI,
   @Override
   public Map<SequenceI, SequenceCollectionI> getHiddenRepSequences()
   {
-    return hiddenRepSequences;
+    return posProps.getHiddenRepSequences();
   }
 
   @Override
   public void setHiddenRepSequences(
           Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
   {
-    this.hiddenRepSequences = hiddenRepSequences;
+    posProps.getHiddenRepSequences();
   }
 
   @Override
@@ -1141,7 +1145,8 @@ public abstract class AlignmentViewport implements AlignViewportI,
   @Override
   public boolean hasHiddenColumns()
   {
-    return colSel != null && colSel.hasHiddenColumns();
+    return posProps.hasHiddenColumns();
+    // return colSel != null && colSel.hasHiddenColumns();
   }
 
   public void updateHiddenColumns()
@@ -1211,7 +1216,7 @@ public abstract class AlignmentViewport implements AlignViewportI,
 
   }
 
-  private long sgrouphash = -1, colselhash = -1;
+  private long sgrouphash = -1;
 
   /**
    * checks current SelectionGroup against record of last hash value, and
@@ -1247,7 +1252,8 @@ public abstract class AlignmentViewport implements AlignViewportI,
    */
   public boolean isColSelChanged(boolean b)
   {
-    int hc = (colSel == null || colSel.isEmpty()) ? -1 : colSel.hashCode();
+    return posProps.isColSelChanged(b);
+    /*int hc = (colSel == null || colSel.isEmpty()) ? -1 : colSel.hashCode();
     if (hc != -1 && hc != colselhash)
     {
       if (b)
@@ -1256,7 +1262,7 @@ public abstract class AlignmentViewport implements AlignViewportI,
       }
       return true;
     }
-    return false;
+    return false;*/
   }
 
   @Override
@@ -1337,6 +1343,21 @@ public abstract class AlignmentViewport implements AlignViewportI,
 
   // common hide/show column stuff
 
+  public void hideColumns(int start, int end)
+  {
+    posProps.hideColumns(start, end);
+  }
+
+  public void showColumn(int col)
+  {
+    posProps.showColumn(col);
+  }
+
+  public void showAllHiddenColumns()
+  {
+    posProps.showAllHiddenColumns();
+  }
+
   public void hideSelectedColumns()
   {
     if (colSel.isEmpty())
@@ -1349,61 +1370,41 @@ public abstract class AlignmentViewport implements AlignViewportI,
     isColSelChanged(true);
   }
 
-  public void hideColumns(int start, int end)
-  {
-    if (start == end)
-    {
-      colSel.hideColumns(start);
-    }
-    else
-    {
-      colSel.hideColumns(start, end);
-    }
-    isColSelChanged(true);
-  }
-
-  public void showColumn(int col)
-  {
-    colSel.revealHiddenColumns(col);
-    isColSelChanged(true);
-  }
 
-  public void showAllHiddenColumns()
-  {
-    colSel.revealAllHiddenColumns();
-    isColSelChanged(true);
-  }
 
   // common hide/show seq stuff
   public void showAllHiddenSeqs()
   {
-    if (alignment.getHiddenSequences().getSize() > 0)
-    {
-      if (selectionGroup == null)
-      {
-        selectionGroup = new SequenceGroup();
-        selectionGroup.setEndRes(alignment.getWidth() - 1);
-      }
-      List<SequenceI> tmp = alignment.getHiddenSequences().showAll(
-              hiddenRepSequences);
-      for (SequenceI seq : tmp)
-      {
-        selectionGroup.addSequence(seq, false);
-        setSequenceAnnotationsVisible(seq, true);
-      }
+    selectionGroup = posProps.showAllHiddenSeqs(selectionGroup);
 
-      hiddenRepSequences = null;
+    /*    if (alignment.getHiddenSequences().getSize() > 0)
+        {
+          if (selectionGroup == null)
+          {
+            selectionGroup = new SequenceGroup();
+            selectionGroup.setEndRes(alignment.getWidth() - 1);
+          }
+          List<SequenceI> tmp = alignment.getHiddenSequences().showAll(
+                  hiddenRepSequences);
+          for (SequenceI seq : tmp)
+          {
+            selectionGroup.addSequence(seq, false);
+            setSequenceAnnotationsVisible(seq, true);
+          }
 
-      firePropertyChange("alignment", null, alignment.getSequences());
-      // used to set hasHiddenRows/hiddenRepSequences here, after the property
-      // changed event
-      sendSelection();
-    }
+          hiddenRepSequences = null;
+
+          firePropertyChange("alignment", null, alignment.getSequences());
+          // used to set hasHiddenRows/hiddenRepSequences here, after the property
+          // changed event
+          sendSelection();
+        }*/
   }
 
   public void showSequence(int index)
   {
-    List<SequenceI> tmp = alignment.getHiddenSequences().showSequence(
+    posProps.showSequence(index, selectionGroup);
+    /*List<SequenceI> tmp = alignment.getHiddenSequences().showSequence(
             index, hiddenRepSequences);
     if (tmp.size() > 0)
     {
@@ -1420,12 +1421,13 @@ public abstract class AlignmentViewport implements AlignViewportI,
       }
       firePropertyChange("alignment", null, alignment.getSequences());
       sendSelection();
-    }
+    }*/
   }
 
   public void hideAllSelectedSeqs()
   {
-    if (selectionGroup == null || selectionGroup.getSize() < 1)
+    posProps.hideAllSelectedSeqs(selectionGroup);
+    /*if (selectionGroup == null || selectionGroup.getSize() < 1)
     {
       return;
     }
@@ -1434,12 +1436,13 @@ public abstract class AlignmentViewport implements AlignViewportI,
 
     hideSequence(seqs);
 
-    setSelectionGroup(null);
+    setSelectionGroup(null);*/
   }
 
   public void hideSequence(SequenceI[] seq)
   {
-    if (seq != null)
+    posProps.hideSequence(seq);
+    /*if (seq != null)
     {
       for (int i = 0; i < seq.length; i++)
       {
@@ -1447,7 +1450,7 @@ public abstract class AlignmentViewport implements AlignViewportI,
         setSequenceAnnotationsVisible(seq[i], false);
       }
       firePropertyChange("alignment", null, alignment.getSequences());
-    }
+    }*/
   }
 
   /**
@@ -1461,7 +1464,8 @@ public abstract class AlignmentViewport implements AlignViewportI,
    */
   public void hideSequences(SequenceI sequence, boolean representGroup)
   {
-    if (selectionGroup == null || selectionGroup.getSize() < 1)
+    posProps.hideSequences(sequence, representGroup, selectionGroup);
+    /*if (selectionGroup == null || selectionGroup.getSize() < 1)
     {
       hideSequence(new SequenceI[] { sequence });
       return;
@@ -1480,33 +1484,14 @@ public abstract class AlignmentViewport implements AlignViewportI,
 
     hideSequence(hseqs);
     setSelectionGroup(null);
-    sendSelection();
+    sendSelection();*/
   }
 
-  /**
-   * Set visibility for any annotations for the given sequence.
-   * 
-   * @param sequenceI
-   */
-  protected void setSequenceAnnotationsVisible(SequenceI sequenceI,
-          boolean visible)
-  {
-    AlignmentAnnotation[] anns = alignment.getAlignmentAnnotation();
-    if (anns != null)
-    {
-      for (AlignmentAnnotation ann : anns)
-      {
-        if (ann.sequenceRef == sequenceI)
-        {
-          ann.visible = visible;
-        }
-      }
-    }
-  }
 
   public void hideRepSequences(SequenceI repSequence, SequenceGroup sg)
   {
-    int sSize = sg.getSize();
+    posProps.hideRepSequences(repSequence, sg);
+    /*int sSize = sg.getSize();
     if (sSize < 2)
     {
       return;
@@ -1536,7 +1521,7 @@ public abstract class AlignmentViewport implements AlignViewportI,
     }
     sg.setSeqrep(repSequence); // note: not done in 2.7applet
     sg.setHidereps(true); // note: not done in 2.7applet
-    hideSequence(seqs);
+    hideSequence(seqs);*/
 
   }
 
@@ -1566,8 +1551,9 @@ public abstract class AlignmentViewport implements AlignViewportI,
    */
   public boolean isHiddenRepSequence(SequenceI seq)
   {
-    return (hiddenRepSequences != null && hiddenRepSequences
-            .containsKey(seq));
+    return posProps.isHiddenRepSequence(seq);
+    // return (hiddenRepSequences != null && hiddenRepSequences
+    // .containsKey(seq));
   }
 
   /**
@@ -1578,21 +1564,24 @@ public abstract class AlignmentViewport implements AlignViewportI,
    */
   public SequenceGroup getRepresentedSequences(SequenceI seq)
   {
-    return (SequenceGroup) (hiddenRepSequences == null ? null
-            : hiddenRepSequences.get(seq));
+    return posProps.getRepresentedSequences(seq);
+    // return (SequenceGroup) (hiddenRepSequences == null ? null
+    // : hiddenRepSequences.get(seq));
   }
 
   @Override
   public int adjustForHiddenSeqs(int alignmentIndex)
   {
-    return alignment.getHiddenSequences().adjustForHiddenSeqs(
-            alignmentIndex);
+    return posProps.adjustForHiddenSeqs(alignmentIndex);
+    // return alignment.getHiddenSequences().adjustForHiddenSeqs(
+    // alignmentIndex);
   }
 
   @Override
   public void invertColumnSelection()
   {
-    colSel.invertColumnSelection(0, alignment.getWidth());
+    posProps.invertColumnSelection();
+    // colSel.invertColumnSelection(0, alignment.getWidth());
   }
 
   @Override
@@ -1640,7 +1629,7 @@ public abstract class AlignmentViewport implements AlignViewportI,
   @Override
   public CigarArray getViewAsCigars(boolean selectedRegionOnly)
   {
-    return new CigarArray(alignment, colSel,
+    return new CigarArray(alignment, posProps.getColumnSelection(),
             (selectedRegionOnly ? selectionGroup : null));
   }
 
@@ -1655,8 +1644,8 @@ public abstract class AlignmentViewport implements AlignViewportI,
   public jalview.datamodel.AlignmentView getAlignmentView(
           boolean selectedOnly, boolean markGroups)
   {
-    return new AlignmentView(alignment, colSel, selectionGroup,
-            colSel != null && colSel.hasHiddenColumns(), selectedOnly,
+    return new AlignmentView(alignment, posProps.getColumnSelection(),
+            selectionGroup, posProps.hasHiddenColumns(), selectedOnly,
             markGroups);
   }
 
@@ -1700,9 +1689,9 @@ public abstract class AlignmentViewport implements AlignViewportI,
     }
 
     selection = new String[iSize];
-    if (colSel != null && colSel.hasHiddenColumns())
+    if (posProps.hasHiddenColumns())
     {
-      selection = colSel.getVisibleSequenceStrings(start, end, seqs);
+      selection = posProps.getVisibleSequenceStrings(start, end, seqs);
     }
     else
     {
@@ -1718,49 +1707,52 @@ public abstract class AlignmentViewport implements AlignViewportI,
   @Override
   public List<int[]> getVisibleRegionBoundaries(int min, int max)
   {
-    ArrayList<int[]> regions = new ArrayList<int[]>();
-    int start = min;
-    int end = max;
+    return posProps.getVisibleRegionBoundaries(min, max);
+    /*    ArrayList<int[]> regions = new ArrayList<int[]>();
+        int start = min;
+        int end = max;
 
-    do
-    {
-      if (colSel != null && colSel.hasHiddenColumns())
-      {
-        if (start == 0)
+        do
         {
-          start = colSel.adjustForHiddenColumns(start);
-        }
-
-        end = colSel.getHiddenBoundaryRight(start);
-        if (start == end)
-        {
-          end = max;
-        }
-        if (end > max)
-        {
-          end = max;
-        }
-      }
+          if (colSel != null && colSel.hasHiddenColumns())
+          {
+            if (start == 0)
+            {
+              start = colSel.adjustForHiddenColumns(start);
+            }
+
+            end = colSel.getHiddenBoundaryRight(start);
+            if (start == end)
+            {
+              end = max;
+            }
+            if (end > max)
+            {
+              end = max;
+            }
+          }
 
-      regions.add(new int[] { start, end });
+          regions.add(new int[] { start, end });
 
-      if (colSel != null && colSel.hasHiddenColumns())
-      {
-        start = colSel.adjustForHiddenColumns(end);
-        start = colSel.getHiddenBoundaryLeft(start) + 1;
-      }
-    } while (end < max);
+          if (posProps.hasHiddenColumns())
+          {
+            start = colSel.adjustForHiddenColumns(end);
+            start = colSel.getHiddenBoundaryLeft(start) + 1;
+          }
+        } while (end < max);
 
-    int[][] startEnd = new int[regions.size()][2];
+        int[][] startEnd = new int[regions.size()][2];
 
-    return regions;
+        return regions;*/
   }
 
   @Override
   public List<AlignmentAnnotation> getVisibleAlignmentAnnotation(
           boolean selectedOnly)
   {
-    ArrayList<AlignmentAnnotation> ala = new ArrayList<AlignmentAnnotation>();
+    return posProps.getVisibleAlignmentAnnotation(selectedOnly,
+            selectionGroup);
+    /*ArrayList<AlignmentAnnotation> ala = new ArrayList<AlignmentAnnotation>();
     AlignmentAnnotation[] aa;
     if ((aa = alignment.getAlignmentAnnotation()) != null)
     {
@@ -1779,7 +1771,7 @@ public abstract class AlignmentViewport implements AlignViewportI,
         ala.add(clone);
       }
     }
-    return ala;
+    return ala;*/
   }
 
   @Override
@@ -1852,7 +1844,7 @@ public abstract class AlignmentViewport implements AlignViewportI,
     ResidueShaderI rs = residueShading;
     if (rs != null)
     {
-      rs.alignmentChanged(alignment, hiddenRepSequences);
+      rs.alignmentChanged(alignment, posProps.getHiddenRepSequences());
 
       rs.setConsensus(hconsensus);
       if (rs.conservationApplied())
@@ -1867,7 +1859,7 @@ public abstract class AlignmentViewport implements AlignViewportI,
     {
       if (sg.cs != null)
       {
-        sg.cs.alignmentChanged(sg, hiddenRepSequences);
+        sg.cs.alignmentChanged(sg, posProps.getHiddenRepSequences());
       }
       sg.recalcConservation();
     }
@@ -2808,7 +2800,11 @@ public abstract class AlignmentViewport implements AlignViewportI,
    */
   public void expandColSelection(SequenceGroup sg, boolean wholewidth)
   {
-    int sgs, sge;
+    if (!this.hasSelectedColumns())
+    {
+      posProps.expandColSelection(sg, wholewidth);
+    }
+    /*int sgs, sge;
     if (sg != null && (sgs = sg.getStartRes()) >= 0
             && sg.getStartRes() <= (sge = sg.getEndRes())
             && !this.hasSelectedColumns())
@@ -2826,7 +2822,7 @@ public abstract class AlignmentViewport implements AlignViewportI,
       {
         colSel.addElement(cspos);
       }
-    }
+    }*/
   }
 
   /**
diff --git a/src/jalview/viewmodel/ViewportPositionProps.java b/src/jalview/viewmodel/ViewportPositionProps.java
index 1bb49af..4f67cc6 100644
--- a/src/jalview/viewmodel/ViewportPositionProps.java
+++ b/src/jalview/viewmodel/ViewportPositionProps.java
@@ -21,7 +21,17 @@
 package jalview.viewmodel;
 
 import jalview.api.ViewStyleI;
+import jalview.datamodel.AlignmentAnnotation;
 import jalview.datamodel.AlignmentI;
+import jalview.datamodel.ColumnSelection;
+import jalview.datamodel.SequenceCollectionI;
+import jalview.datamodel.SequenceGroup;
+import jalview.datamodel.SequenceI;
+
+import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
 
 /**
  * Supplies and updates viewport properties relating to position such as: start
@@ -54,6 +64,14 @@ public class ViewportPositionProps extends ViewportProperties
   // viewstyle
   private ViewStyleI viewstyle;
 
+  // hidden column data
+  protected ColumnSelection colSel = new ColumnSelection();
+
+  private long colselhash = -1;
+
+  // hidden sequence data
+  private Map<SequenceI, SequenceCollectionI> hiddenRepSequences;
+
   /**
    * Constructor
    * @param alignment TODO
@@ -209,7 +227,6 @@ public class ViewportPositionProps extends ViewportProperties
   public int convertPixelsToResidues(int x)
   {
     return Math.round((float) x / viewstyle.getCharWidth());
-    // return (int) ((float) x / viewstyle.getCharWidth());
   }
 
   /**
@@ -222,7 +239,6 @@ public class ViewportPositionProps extends ViewportProperties
   public int convertPixelsToSequences(int y)
   {
     return Math.round((float) y / viewstyle.getCharHeight());
-    // return (int) ((float) y / viewstyle.getCharHeight());
   }
   
   /**
@@ -248,4 +264,389 @@ public class ViewportPositionProps extends ViewportProperties
   {
     return (r * viewstyle.getCharWidth());
   }
+
+  public void setHiddenColumns(ColumnSelection colsel)
+  {
+    this.colSel = colsel;
+  }
+
+  public ColumnSelection getColumnSelection()
+  {
+    return colSel;
+  }
+
+  public void setColumnSelection(ColumnSelection colSel)
+  {
+    this.colSel = colSel;
+    if (colSel != null)
+    {
+      // updateHiddenColumns(); - does nothing
+    }
+    isColSelChanged(true);
+  }
+
+  public boolean hasHiddenColumns()
+  {
+    return colSel != null && colSel.hasHiddenColumns();
+  }
+
+  /**
+   * checks current colsel against record of last hash value, and optionally
+   * updates record.
+   * 
+   * @param b
+   *          update the record of last hash value
+   * @return true if colsel changed since last call (when b is true)
+   */
+  public boolean isColSelChanged(boolean b)
+  {
+    int hc = (colSel == null || colSel.isEmpty()) ? -1 : colSel.hashCode();
+    if (hc != -1 && hc != colselhash)
+    {
+      if (b)
+      {
+        colselhash = hc;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  public void hideColumns(int start, int end)
+  {
+    if (start == end)
+    {
+      colSel.hideColumns(start);
+    }
+    else
+    {
+      colSel.hideColumns(start, end);
+    }
+    isColSelChanged(true);
+  }
+
+  public void showColumn(int col)
+  {
+    colSel.revealHiddenColumns(col);
+    isColSelChanged(true);
+  }
+
+  public void showAllHiddenColumns()
+  {
+    colSel.revealAllHiddenColumns();
+    isColSelChanged(true);
+  }
+
+  public void invertColumnSelection()
+  {
+    colSel.invertColumnSelection(0, al.getWidth());
+  }
+
+  public List<int[]> getVisibleRegionBoundaries(int min, int max)
+  {
+    ArrayList<int[]> regions = new ArrayList<int[]>();
+    int start = min;
+    int end = max;
+
+    do
+    {
+      if (hasHiddenColumns())
+      {
+        if (start == 0)
+        {
+          start = colSel.adjustForHiddenColumns(start);
+        }
+
+        end = colSel.getHiddenBoundaryRight(start);
+        if (start == end)
+        {
+          end = max;
+        }
+        if (end > max)
+        {
+          end = max;
+        }
+      }
+
+      regions.add(new int[] { start, end });
+
+      if (hasHiddenColumns())
+      {
+        start = colSel.adjustForHiddenColumns(end);
+        start = colSel.getHiddenBoundaryLeft(start) + 1;
+      }
+    } while (end < max);
+
+    int[][] startEnd = new int[regions.size()][2];
+
+    return regions;
+  }
+
+  /**
+   * synthesize a column selection if none exists so it covers the given
+   * selection group. if wholewidth is false, no column selection is made if the
+   * selection group covers the whole alignment width.
+   * 
+   * @param sg
+   * @param wholewidth
+   */
+  public void expandColSelection(SequenceGroup sg, boolean wholewidth)
+  {
+    int sgs, sge;
+    if (sg != null && (sgs = sg.getStartRes()) >= 0
+            && sg.getStartRes() <= (sge = sg.getEndRes()))
+    {
+      if (!wholewidth && al.getWidth() == (1 + sge - sgs))
+      {
+        // do nothing
+        return;
+      }
+      if (colSel == null)
+      {
+        colSel = new ColumnSelection();
+      }
+      for (int cspos = sg.getStartRes(); cspos <= sg.getEndRes(); cspos++)
+      {
+        colSel.addElement(cspos);
+      }
+    }
+  }
+
+  public List<AlignmentAnnotation> getVisibleAlignmentAnnotation(
+          boolean selectedOnly, SequenceGroup selectionGroup)
+  {
+    ArrayList<AlignmentAnnotation> ala = new ArrayList<AlignmentAnnotation>();
+    AlignmentAnnotation[] aa;
+    if ((aa = al.getAlignmentAnnotation()) != null)
+    {
+      for (AlignmentAnnotation annot : aa)
+      {
+        AlignmentAnnotation clone = new AlignmentAnnotation(annot);
+        if (selectedOnly && selectionGroup != null)
+        {
+          colSel.makeVisibleAnnotation(selectionGroup.getStartRes(),
+                  selectionGroup.getEndRes(), clone);
+        }
+        else
+        {
+          colSel.makeVisibleAnnotation(clone);
+        }
+        ala.add(clone);
+      }
+    }
+    return ala;
+  }
+
+  public String[] getVisibleSequenceStrings(int start, int end,
+          SequenceI[] seqs)
+  {
+    return colSel.getVisibleSequenceStrings(start, end, seqs);
+  }
+
+  /**
+   * Set visibility for any annotations for the given sequence.
+   * 
+   * @param sequenceI
+   */
+  protected void setSequenceAnnotationsVisible(SequenceI sequenceI,
+          boolean visible)
+  {
+    AlignmentAnnotation[] anns = al.getAlignmentAnnotation();
+    if (anns != null)
+    {
+      for (AlignmentAnnotation ann : anns)
+      {
+        if (ann.sequenceRef == sequenceI)
+        {
+          ann.visible = visible;
+        }
+      }
+    }
+  }
+
+  public void setHiddenRepSequences(
+          Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
+  {
+    this.hiddenRepSequences = hiddenRepSequences;
+  }
+
+  public Map<SequenceI, SequenceCollectionI> getHiddenRepSequences()
+  {
+    return hiddenRepSequences;
+  }
+
+  // common hide/show seq stuff
+  public SequenceGroup showAllHiddenSeqs(SequenceGroup selectionGroup)
+  {
+    if (al.getHiddenSequences().getSize() > 0)
+    {
+      if (selectionGroup == null)
+      {
+        selectionGroup = new SequenceGroup();
+        selectionGroup.setEndRes(al.getWidth() - 1);
+      }
+      List<SequenceI> tmp = al.getHiddenSequences().showAll(
+              hiddenRepSequences);
+      for (SequenceI seq : tmp)
+      {
+        selectionGroup.addSequence(seq, false);
+        setSequenceAnnotationsVisible(seq, true);
+      }
+
+      hiddenRepSequences = null;
+
+      firePropertyChange("alignment", null, al.getSequences());
+      // used to set hasHiddenRows/hiddenRepSequences here, after the property
+      // changed event
+      sendSelection();
+    }
+  }
+
+  public void showSequence(int index, SequenceGroup selectionGroup)
+  {
+    List<SequenceI> tmp = al.getHiddenSequences().showSequence(index,
+            hiddenRepSequences);
+    if (tmp.size() > 0)
+    {
+      if (selectionGroup == null)
+      {
+        selectionGroup = new SequenceGroup();
+        selectionGroup.setEndRes(al.getWidth() - 1);
+      }
+
+      for (SequenceI seq : tmp)
+      {
+        selectionGroup.addSequence(seq, false);
+        setSequenceAnnotationsVisible(seq, true);
+      }
+      firePropertyChange("alignment", null, al.getSequences());
+      sendSelection();
+    }
+  }
+
+  public void hideAllSelectedSeqs(SequenceGroup selectionGroup)
+  {
+    if (selectionGroup == null || selectionGroup.getSize() < 1)
+    {
+      return;
+    }
+
+    SequenceI[] seqs = selectionGroup.getSequencesInOrder(al);
+
+    hideSequence(seqs);
+
+    setSelectionGroup(null);
+  }
+
+  public void hideSequence(SequenceI[] seq)
+  {
+    if (seq != null)
+    {
+      for (int i = 0; i < seq.length; i++)
+      {
+        al.getHiddenSequences().hideSequence(seq[i]);
+        setSequenceAnnotationsVisible(seq[i], false);
+      }
+      firePropertyChange("alignment", null, al.getSequences());
+    }
+  }
+
+  /**
+   * Hides the specified sequence, or the sequences it represents
+   * 
+   * @param sequence
+   *          the sequence to hide, or keep as representative
+   * @param representGroup
+   *          if true, hide the current selection group except for the
+   *          representative sequence
+   */
+  public void hideSequences(SequenceI sequence, boolean representGroup,
+          SequenceGroup selectionGroup)
+  {
+    if (selectionGroup == null || selectionGroup.getSize() < 1)
+    {
+      hideSequence(new SequenceI[] { sequence });
+      return;
+    }
+
+    if (representGroup)
+    {
+      hideRepSequences(sequence, selectionGroup);
+      setSelectionGroup(null);
+      return;
+    }
+
+    int gsize = selectionGroup.getSize();
+    SequenceI[] hseqs = selectionGroup.getSequences().toArray(
+            new SequenceI[gsize]);
+
+    hideSequence(hseqs);
+    setSelectionGroup(null);
+    sendSelection();
+  }
+
+  public void hideRepSequences(SequenceI repSequence, SequenceGroup sg)
+  {
+    int sSize = sg.getSize();
+    if (sSize < 2)
+    {
+      return;
+    }
+
+    if (hiddenRepSequences == null)
+    {
+      hiddenRepSequences = new Hashtable<SequenceI, SequenceCollectionI>();
+    }
+
+    hiddenRepSequences.put(repSequence, sg);
+
+    // Hide all sequences except the repSequence
+    SequenceI[] seqs = new SequenceI[sSize - 1];
+    int index = 0;
+    for (int i = 0; i < sSize; i++)
+    {
+      if (sg.getSequenceAt(i) != repSequence)
+      {
+        if (index == sSize - 1)
+        {
+          return;
+        }
+
+        seqs[index++] = sg.getSequenceAt(i);
+      }
+    }
+    sg.setSeqrep(repSequence); // note: not done in 2.7applet
+    sg.setHidereps(true); // note: not done in 2.7applet
+    hideSequence(seqs);
+
+  }
+
+  /**
+   * 
+   * @param seq
+   * @return true if there are sequences represented by this sequence that are
+   *         currently hidden
+   */
+  public boolean isHiddenRepSequence(SequenceI seq)
+  {
+    return (hiddenRepSequences != null && hiddenRepSequences
+            .containsKey(seq));
+  }
+
+  /**
+   * 
+   * @param seq
+   * @return null or a sequence group containing the sequences that seq
+   *         represents
+   */
+  public SequenceGroup getRepresentedSequences(SequenceI seq)
+  {
+    return (SequenceGroup) (hiddenRepSequences == null ? null
+            : hiddenRepSequences.get(seq));
+  }
+
+  public int adjustForHiddenSeqs(int alignmentIndex)
+  {
+    return al.getHiddenSequences().adjustForHiddenSeqs(alignmentIndex);
+  }
 }