X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fappletgui%2FAlignViewport.java;h=4e1da95a47cbb7e8163c7b073a671de971ea6158;hb=7bc226b58110fa26d9dbd3f0c78095d06909ffc3;hp=209f9394768709490deaa61ff0246d009e50acb6;hpb=ee53965807b83bf93a21cbc341cee9a9e005b2cb;p=jalview.git

diff --git a/src/jalview/appletgui/AlignViewport.java b/src/jalview/appletgui/AlignViewport.java
index 209f939..4e1da95 100755
--- a/src/jalview/appletgui/AlignViewport.java
+++ b/src/jalview/appletgui/AlignViewport.java
@@ -1,6 +1,6 @@
 /*
  * Jalview - A Sequence Alignment Editor and Viewer
- * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ * Copyright (C) 2007 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
@@ -36,7 +36,9 @@ public class AlignViewport
   int startSeq;
   int endSeq;
 
-  boolean showFullId = true;
+  boolean cursorMode = false;
+
+  boolean showJVSuffix = true;
   boolean showText = true;
   boolean showColourText = false;
   boolean showBoxes = true;
@@ -47,19 +49,21 @@ public class AlignViewport
   boolean showConservation = true;
   boolean showQuality = true;
   boolean showConsensus = true;
+  boolean upperCasebold = false;
 
   boolean colourAppliesToAllGroups = true;
   ColourSchemeI globalColourScheme = null;
   boolean conservationColourSelected = false;
   boolean abovePIDThreshold = false;
 
-  SequenceGroup selectionGroup = new SequenceGroup();
+  SequenceGroup selectionGroup;
 
   int charHeight;
   int charWidth;
   int wrappedWidth;
 
   Font font = new Font("SansSerif", Font.PLAIN, 10);
+  boolean validCharWidth = true;
   AlignmentI alignment;
 
   ColumnSelection colSel = new ColumnSelection();
@@ -73,19 +77,44 @@ public class AlignViewport
   boolean scaleLeftWrapped = true;
   boolean scaleRightWrapped = true;
 
-  public Vector vconsensus;
+  // The following vector holds the features which are
+  // currently visible, in the correct order or rendering
+  public Hashtable featuresDisplayed;
+
+  boolean hasHiddenColumns = false;
+  boolean hasHiddenRows = false;
+  boolean showHiddenMarkers = true;
+
+  public Hashtable[] hconsensus;
   AlignmentAnnotation consensus;
   AlignmentAnnotation conservation;
   AlignmentAnnotation quality;
 
+  boolean autocalculateConsensus = true;
+
   public int ConsPercGaps = 25; // JBPNote : This should be a scalable property!
 
-  private java.beans.PropertyChangeSupport changeSupport = new java.beans.PropertyChangeSupport(this);
+  private java.beans.PropertyChangeSupport changeSupport = new java.beans.
+      PropertyChangeSupport(this);
 
   boolean ignoreGapsInConsensusCalculation = false;
 
+  jalview.bin.JalviewLite applet;
+
+  Hashtable sequenceColours;
+
+  boolean MAC = false;
+
+  Stack historyList = new Stack();
+  Stack redoList = new Stack();
+
+  String sequenceSetID;
+
+  Hashtable hiddenRepSequences;
+
   public AlignViewport(AlignmentI al, JalviewLite applet)
   {
+    this.applet = applet;
     setAlignment(al);
     this.startRes = 0;
     this.endRes = al.getWidth() - 1;
@@ -93,12 +122,17 @@ public class AlignViewport
     this.endSeq = al.getHeight() - 1;
     setFont(font);
 
+    if (System.getProperty("os.name").startsWith("Mac"))
+    {
+      MAC = true;
+    }
+
     if (applet != null)
     {
       String param = applet.getParameter("showFullId");
       if (param != null)
       {
-        showFullId = Boolean.valueOf(param).booleanValue();
+        showJVSuffix = Boolean.valueOf(param).booleanValue();
       }
 
       param = applet.getParameter("showAnnotation");
@@ -124,19 +158,89 @@ public class AlignViewport
       {
         showConsensus = Boolean.valueOf(param).booleanValue();
       }
+
+      param = applet.getParameter("upperCase");
+      if (param != null)
+      {
+        if (param.equalsIgnoreCase("bold"))
+        {
+          upperCasebold = true;
+        }
+      }
+
     }
-    // We must set conservation and consensus before setting colour,
-    // as Blosum and Clustal require this to be done
-    updateConservation();
-    updateConsensus();
 
-    if (applet != null && applet.getParameter("defaultColour") != null)
+    if (applet != null)
     {
-      globalColourScheme = ColourSchemeProperty.getColour(alignment,
-          applet.getParameter("defaultColour"));
-      if (globalColourScheme != null)
+      String colour = applet.getParameter("defaultColour");
+
+      if (colour == null)
       {
-        globalColourScheme.setConsensus(vconsensus);
+        colour = applet.getParameter("userDefinedColour");
+        if (colour != null)
+        {
+          colour = "User Defined";
+        }
+      }
+
+      if (colour != null)
+      {
+        globalColourScheme = ColourSchemeProperty.getColour(alignment, colour);
+        if (globalColourScheme != null)
+        {
+          globalColourScheme.setConsensus(hconsensus);
+        }
+      }
+
+      if (applet.getParameter("userDefinedColour") != null)
+      {
+        ( (UserColourScheme) globalColourScheme).parseAppletParameter(
+            applet.getParameter("userDefinedColour"));
+      }
+
+      if (hconsensus == null)
+      {
+        if (!alignment.isNucleotide())
+        {
+          conservation = new AlignmentAnnotation("Conservation",
+                                                 "Conservation of total alignment less than " +
+                                                 ConsPercGaps + "% gaps",
+                                                 new Annotation[1], 0f,
+                                                 11f,
+                                                 AlignmentAnnotation.BAR_GRAPH);
+          conservation.hasText = true;
+          conservation.autoCalculated = true;
+
+          if (showConservation)
+          {
+            alignment.addAnnotation(conservation);
+          }
+
+          if (showQuality)
+          {
+            quality = new AlignmentAnnotation("Quality",
+                                              "Alignment Quality based on Blosum62 scores",
+                                              new Annotation[1],
+                                              0f,
+                                              11f,
+                                              AlignmentAnnotation.BAR_GRAPH);
+            quality.hasText = true;
+            quality.autoCalculated = true;
+
+            alignment.addAnnotation(quality);
+          }
+        }
+
+        consensus = new AlignmentAnnotation("Consensus", "PID",
+                                            new Annotation[1], 0f, 100f,
+                                            AlignmentAnnotation.BAR_GRAPH);
+        consensus.hasText = true;
+        consensus.autoCalculated = true;
+
+        if (showConsensus)
+        {
+          alignment.addAnnotation(consensus);
+        }
       }
     }
   }
@@ -146,168 +250,327 @@ public class AlignViewport
     showSequenceFeatures = b;
   }
 
+  public boolean getShowSequenceFeatures()
+  {
+    return showSequenceFeatures;
+  }
 
-  public void updateConservation()
+  class ConservationThread
+      extends Thread
   {
-    if(alignment.isNucleotide())
-          return;
+    AlignmentPanel ap;
+    public ConservationThread(AlignmentPanel ap)
+    {
+      this.ap = ap;
+    }
 
-    Conservation cons = new jalview.analysis.Conservation("All",
-        jalview.schemes.ResidueProperties.propHash, 3,
-        alignment.getSequences(), 0,
-        alignment.getWidth() - 1);
-    cons.calculate();
-    cons.verdict(false, ConsPercGaps);
-    cons.findQuality();
-    int alWidth = alignment.getWidth();
-    Annotation[] annotations = new Annotation[alWidth];
-    Annotation[] qannotations = new Annotation[alWidth];
-    String sequence = cons.getConsSequence().getSequence();
-    float minR, minG, minB, maxR, maxG, maxB;
-    minR = 0.3f;
-    minG = 0.0f;
-    minB = 0f;
-    maxR = 1.0f - minR;
-    maxG = 0.9f - minG;
-    maxB = 0f - minB; // scalable range for colouring both Conservation and Quality
-    float min = 0f;
-    float max = 11f;
-    float qmin = cons.qualityRange[0].floatValue();
-    float qmax = cons.qualityRange[1].floatValue();
-
-    for (int i = 0; i < alWidth; i++)
-    {
-      float value = 0;
+    public void run()
+    {
       try
       {
-        value = Integer.parseInt(sequence.charAt(i) + "");
-      }
-      catch (Exception ex)
-      {
-        if (sequence.charAt(i) == '*')
+        updatingConservation = true;
+
+        while (UPDATING_CONSERVATION)
         {
-          value = 11;
+          try
+          {
+            if (ap != null)
+            {
+              ap.repaint();
+            }
+            Thread.sleep(200);
+          }
+          catch (Exception ex)
+          {
+            ex.printStackTrace();
+          }
+        }
+
+        UPDATING_CONSERVATION = true;
+
+        int alWidth = alignment.getWidth();
+        if (alWidth < 0)
+        {
+          return;
         }
-        if (sequence.charAt(i) == '+')
+
+        Conservation cons = new jalview.analysis.Conservation("All",
+            jalview.schemes.ResidueProperties.propHash, 3,
+            alignment.getSequences(), 0, alWidth - 1);
+
+        cons.calculate();
+        cons.verdict(false, ConsPercGaps);
+
+        if (quality != null)
+        {
+          cons.findQuality();
+        }
+
+        char[] sequence = cons.getConsSequence().getSequence();
+        float minR;
+        float minG;
+        float minB;
+        float maxR;
+        float maxG;
+        float maxB;
+        minR = 0.3f;
+        minG = 0.0f;
+        minB = 0f;
+        maxR = 1.0f - minR;
+        maxG = 0.9f - minG;
+        maxB = 0f - minB; // scalable range for colouring both Conservation and Quality
+
+        float min = 0f;
+        float max = 11f;
+        float qmin = 0f;
+        float qmax = 0f;
+
+        char c;
+
+        conservation.annotations = new Annotation[alWidth];
+
+        if (quality != null)
         {
-          value = 10;
+          quality.graphMax = cons.qualityRange[1].floatValue();
+          quality.annotations = new Annotation[alWidth];
+          qmin = cons.qualityRange[0].floatValue();
+          qmax = cons.qualityRange[1].floatValue();
+        }
+
+        for (int i = 0; i < alWidth; i++)
+        {
+          float value = 0;
+
+          c = sequence[i];
+
+          if (Character.isDigit(c))
+          {
+            value = (int) (c - '0');
+          }
+          else if (c == '*')
+          {
+            value = 11;
+          }
+          else if (c == '+')
+          {
+            value = 10;
+          }
+
+          float vprop = value - min;
+          vprop /= max;
+          conservation.annotations[i] =
+              new Annotation(String.valueOf(c),
+                             String.valueOf(value), ' ', value,
+                             new Color(minR + (maxR * vprop),
+                                       minG + (maxG * vprop),
+                                       minB + (maxB * vprop)));
+
+          // Quality calc
+          if (quality != null)
+          {
+            value = ( (Double) cons.quality.elementAt(i)).floatValue();
+            vprop = value - qmin;
+            vprop /= qmax;
+            quality.annotations[i] = new Annotation(" ", String.valueOf(value),
+                ' ',
+                value,
+                new Color(minR + (maxR * vprop),
+                          minG + (maxG * vprop),
+                          minB + (maxB * vprop)));
+          }
         }
       }
-      float vprop = value - min;
-      vprop /= max;
-
-      annotations[i] = new Annotation(sequence.charAt(i) + "",
-                                      "", ' ', value,
-                                      new Color(minR + maxR * vprop,
-                                                minG + maxG * vprop,
-                                                minB + maxB * vprop));
-      // Quality calc
-      value = ( (Double) cons.quality.elementAt(i)).floatValue();
-      vprop = value - qmin;
-      vprop /= qmax;
-      qannotations[i] = new Annotation(" ",
-                                       String.valueOf(value), ' ', value,
-                                       new
-                                       Color(minR + maxR * vprop,
-                                             minG + maxG * vprop,
-                                             minB + maxB * vprop));
-    }
-
-    if (conservation == null)
-    {
-      conservation = new AlignmentAnnotation("Conservation",
-                                             "Conservation of total alignment less than " +
-                                             ConsPercGaps + "% gaps",
-                                             annotations,
-                                             0f, // cons.qualityRange[0].floatValue(),
-                                             11f, // cons.qualityRange[1].floatValue()
-                                             1);
-      if (showConservation)
-      {
-        alignment.addAnnotation(conservation);
-      }
-      quality = new AlignmentAnnotation("Quality",
-                                        "Alignment Quality based on Blosum62 scores",
-                                        qannotations,
-                                        cons.qualityRange[0].floatValue(),
-                                        cons.qualityRange[1].floatValue(),
-                                        1);
-      if (showQuality)
-      {
-        alignment.addAnnotation(quality);
+      catch (OutOfMemoryError error)
+      {
+        System.out.println("Out of memory calculating conservation!!");
+        conservation = null;
+        quality = null;
+        System.gc();
+      }
+
+      UPDATING_CONSERVATION = false;
+      updatingConservation = false;
+
+      if (ap != null)
+      {
+        ap.repaint();
       }
+
     }
-    else
+  }
+
+  ConservationThread conservationThread;
+
+  ConsensusThread consensusThread;
+
+  boolean consUpdateNeeded = false;
+
+  static boolean UPDATING_CONSENSUS = false;
+
+  static boolean UPDATING_CONSERVATION = false;
+
+  boolean updatingConsensus = false;
+
+  boolean updatingConservation = false;
+
+  /**
+   * DOCUMENT ME!
+   */
+  public void updateConservation(final AlignmentPanel ap)
+  {
+    if (alignment.isNucleotide() || conservation == null)
     {
-      conservation.annotations = annotations;
-      quality.annotations = qannotations;
-      quality.graphMax = cons.qualityRange[1].floatValue();
+      return;
     }
 
+    conservationThread = new ConservationThread(ap);
+    conservationThread.start();
   }
 
-  public void updateConsensus()
+  /**
+   * DOCUMENT ME!
+   */
+  public void updateConsensus(final AlignmentPanel ap)
   {
-    Annotation[] annotations = new Annotation[alignment.getWidth()];
+    consensusThread = new ConsensusThread(ap);
+    consensusThread.start();
+  }
 
-    // this routine prevents vconsensus becoming a new object each time
-    // consenus is calculated. Important for speed of Blosum62
-    // and PID colouring of alignment
-    if (vconsensus == null)
+  class ConsensusThread
+      extends Thread
+  {
+    AlignmentPanel ap;
+    public ConsensusThread(AlignmentPanel ap)
     {
-      vconsensus = alignment.getAAFrequency();
+      this.ap = ap;
     }
-    else
+
+    public void run()
     {
-      Vector temp = alignment.getAAFrequency();
-      vconsensus.removeAllElements();
-      Enumeration e = temp.elements();
-      while (e.hasMoreElements())
+      updatingConsensus = true;
+      while (UPDATING_CONSENSUS)
       {
-        vconsensus.addElement(e.nextElement());
+        try
+        {
+          if (ap != null)
+          {
+            ap.repaint();
+          }
+
+          Thread.sleep(200);
+        }
+        catch (Exception ex)
+        {
+          ex.printStackTrace();
+        }
       }
-    }
-    Hashtable hash = null;
-    for (int i = 0; i < alignment.getWidth(); i++)
-    {
-      hash = (Hashtable) vconsensus.elementAt(i);
-      float value = 0;
-      if(ignoreGapsInConsensusCalculation)
-        value = ((Float)hash.get("pid_nogaps")).floatValue();
-      else
-        value = ((Float)hash.get("pid_gaps")).floatValue();
 
-      String maxRes = hash.get("maxResidue").toString();
-      String mouseOver = hash.get("maxResidue") + " ";
-      if (maxRes.length() > 1)
+      UPDATING_CONSENSUS = true;
+
+      try
       {
-        mouseOver = "[" + maxRes + "] ";
-        maxRes = "+";
-      }
+        int aWidth = alignment.getWidth();
+        if (aWidth < 0)
+        {
+          return;
+        }
+
+        consensus.annotations = null;
+        consensus.annotations = new Annotation[aWidth];
 
+        hconsensus = new Hashtable[aWidth];
+        AAFrequency.calculate(alignment.getSequencesArray(),
+                              0,
+                              alignment.getWidth(),
+                              hconsensus);
 
-      mouseOver += (int) value + "%";
-      annotations[i] = new Annotation(maxRes, mouseOver, ' ', value);
+        for (int i = 0; i < aWidth; i++)
+        {
+          float value = 0;
+          if (ignoreGapsInConsensusCalculation)
+          {
+            value = ( (Float) hconsensus[i].get(AAFrequency.PID_NOGAPS)).
+                floatValue();
+          }
+          else
+          {
+            value = ( (Float) hconsensus[i].get(AAFrequency.PID_GAPS)).
+                floatValue();
+          }
+
+          String maxRes = hconsensus[i].get(AAFrequency.MAXRESIDUE).toString();
+          String mouseOver = hconsensus[i].get(AAFrequency.MAXRESIDUE) + " ";
+
+          if (maxRes.length() > 1)
+          {
+            mouseOver = "[" + maxRes + "] ";
+            maxRes = "+";
+          }
+
+          mouseOver += ( (int) value + "%");
+          consensus.annotations[i] = new Annotation(maxRes, mouseOver, ' ',
+              value);
+        }
 
+        if (globalColourScheme != null)
+        {
+          globalColourScheme.setConsensus(hconsensus);
+        }
+
+      }
+      catch (OutOfMemoryError error)
+      {
+        alignment.deleteAnnotation(consensus);
+
+        consensus = null;
+        hconsensus = null;
+        System.out.println("Out of memory calculating consensus!!");
+        System.gc();
+      }
+      UPDATING_CONSENSUS = false;
+      updatingConsensus = false;
+
+      if (ap != null)
+      {
+        ap.repaint();
+      }
     }
+  }
 
+  /**
+   * get the consensus sequence as displayed under the PID consensus annotation row.
+   * @return consensus sequence as a new sequence object
+   */
+  /**
+   * get the consensus sequence as displayed under the PID consensus annotation row.
+   * @return consensus sequence as a new sequence object
+   */
+  public SequenceI getConsensusSeq()
+  {
     if (consensus == null)
     {
-      consensus = new AlignmentAnnotation("Consensus",
-                                          "PID", annotations, 0f, 100f, 1);
-      if (showConsensus)
-      {
-        alignment.addAnnotation(consensus);
-      }
+      return null;
     }
-    else
+    StringBuffer seqs = new StringBuffer();
+    for (int i = 0; i < consensus.annotations.length; i++)
     {
-      consensus.annotations = annotations;
+      if (consensus.annotations[i] != null)
+      {
+        if (consensus.annotations[i].description.charAt(0) == '[')
+        {
+          seqs.append(consensus.annotations[i].description.charAt(1));
+        }
+        else
+        {
+          seqs.append(consensus.annotations[i].displayCharacter);
+        }
+      }
     }
-
-    if(globalColourScheme!=null)
-          globalColourScheme.setConsensus(vconsensus);
-
+    SequenceI sq = new Sequence("Consensus", seqs.toString());
+    sq.setDescription("Percentage Identity Consensus " +
+                      ( (ignoreGapsInConsensusCalculation) ? " without gaps" :
+                       ""));
+    return sq;
   }
 
   public SequenceGroup getSelectionGroup()
@@ -407,14 +670,26 @@ public class AlignViewport
     return endSeq;
   }
 
+  java.awt.Frame nullFrame;
   public void setFont(Font f)
   {
     font = f;
-    java.awt.Frame temp = new java.awt.Frame();
-    temp.addNotify();
-    java.awt.FontMetrics fm = temp.getGraphics().getFontMetrics(font);
+    if (nullFrame == null)
+    {
+      nullFrame = new java.awt.Frame();
+      nullFrame.addNotify();
+    }
+
+    java.awt.FontMetrics fm = nullFrame.getGraphics().getFontMetrics(font);
     setCharHeight(fm.getHeight());
-    setCharWidth(fm.charWidth('M'));
+    charWidth = fm.charWidth('M');
+
+    if (upperCasebold)
+    {
+      Font f2 = new Font(f.getName(), Font.BOLD, f.getSize());
+      fm = nullFrame.getGraphics().getFontMetrics(f2);
+      charWidth = fm.stringWidth("MMMMMMMMMMM") / 10;
+    }
   }
 
   public Font getFont()
@@ -422,11 +697,6 @@ public class AlignViewport
     return font;
   }
 
-  public void setCharWidth(int w)
-  {
-    this.charWidth = w;
-  }
-
   public int getCharWidth()
   {
     return charWidth;
@@ -540,30 +810,13 @@ public class AlignViewport
     return increment;
   }
 
-  public int getIndex(int y)
+  public void setHiddenColumns(ColumnSelection colsel)
   {
-    int y1 = 0;
-    int starty = getStartSeq();
-    int endy = getEndSeq();
-
-    for (int i = starty; i <= endy; i++)
+    this.colSel = colsel;
+    if (colSel.getHiddenColumns() != null)
     {
-      if (i < alignment.getHeight() && alignment.getSequenceAt(i) != null)
-      {
-        int y2 = y1 + getCharHeight();
-
-        if (y >= y1 && y <= y2)
-        {
-          return i;
-        }
-        y1 = y2;
-      }
-      else
-      {
-        return -1;
-      }
+      hasHiddenColumns = true;
     }
-    return -1;
   }
 
   public ColumnSelection getColumnSelection()
@@ -596,14 +849,14 @@ public class AlignViewport
     return colourAppliesToAllGroups;
   }
 
-  public boolean getShowFullId()
+  public boolean getShowJVSuffix()
   {
-    return showFullId;
+    return showJVSuffix;
   }
 
-  public void setShowFullId(boolean b)
+  public void setShowJVSuffix(boolean b)
   {
-    showFullId = b;
+    showJVSuffix = b;
   }
 
   public boolean getShowAnnotation()
@@ -649,11 +902,11 @@ public class AlignViewport
   public void setIgnoreGapsConsensus(boolean b)
   {
     ignoreGapsInConsensusCalculation = b;
-    updateConsensus();
-    if (globalColourScheme!=null)
+    updateConsensus(null);
+    if (globalColourScheme != null)
     {
       globalColourScheme.setThreshold(globalColourScheme.getThreshold(),
-          ignoreGapsInConsensusCalculation);
+                                      ignoreGapsInConsensusCalculation);
 
     }
   }
@@ -666,7 +919,7 @@ public class AlignViewport
   public void addPropertyChangeListener(
       java.beans.PropertyChangeListener listener)
   {
-      changeSupport.addPropertyChangeListener(listener);
+    changeSupport.addPropertyChangeListener(listener);
   }
 
   /**
@@ -677,7 +930,7 @@ public class AlignViewport
   public void removePropertyChangeListener(
       java.beans.PropertyChangeListener listener)
   {
-      changeSupport.removePropertyChangeListener(listener);
+    changeSupport.removePropertyChangeListener(listener);
   }
 
   /**
@@ -689,15 +942,507 @@ public class AlignViewport
    */
   public void firePropertyChange(String prop, Object oldvalue, Object newvalue)
   {
-      changeSupport.firePropertyChange(prop, oldvalue, newvalue);
+    changeSupport.firePropertyChange(prop, oldvalue, newvalue);
   }
 
-
-
   public boolean getIgnoreGapsConsensus()
   {
     return ignoreGapsInConsensusCalculation;
   }
 
+  public void hideSelectedColumns()
+  {
+    if (colSel.size() < 1)
+    {
+      return;
+    }
+
+    colSel.hideSelectedColumns();
+    setSelectionGroup(null);
+
+    hasHiddenColumns = true;
+  }
+
+  public void invertColumnSelection()
+  {
+    for (int i = 0; i < alignment.getWidth(); i++)
+    {
+      if (colSel.contains(i))
+      {
+        colSel.removeElement(i);
+      }
+      else
+      {
+        if (!hasHiddenColumns || colSel.isVisible(i))
+        {
+          colSel.addElement(i);
+        }
+      }
+    }
+  }
+
+  public void hideColumns(int start, int end)
+  {
+    if (start == end)
+    {
+      colSel.hideColumns(start);
+    }
+    else
+    {
+      colSel.hideColumns(start, end);
+    }
+
+    hasHiddenColumns = true;
+  }
+
+  public void hideRepSequences(SequenceI repSequence, SequenceGroup sg)
+  {
+    int sSize = sg.getSize();
+    if (sSize < 2)
+    {
+      return;
+    }
+
+    if (hiddenRepSequences == null)
+    {
+      hiddenRepSequences = new Hashtable();
+    }
+
+    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);
+      }
+    }
+
+    hideSequence(seqs);
+
+  }
+
+  public void hideAllSelectedSeqs()
+  {
+    if (selectionGroup == null)
+    {
+      return;
+    }
+
+    SequenceI[] seqs = selectionGroup.getSequencesInOrder(alignment);
+
+    hideSequence(seqs);
+
+    setSelectionGroup(null);
+  }
+
+  public void hideSequence(SequenceI[] seq)
+  {
+    if (seq != null)
+    {
+      for (int i = 0; i < seq.length; i++)
+      {
+        alignment.getHiddenSequences().hideSequence(seq[i]);
+      }
+
+      hasHiddenRows = true;
+      firePropertyChange("alignment", null, alignment.getSequences());
+    }
+  }
+
+  public void showColumn(int col)
+  {
+    colSel.revealHiddenColumns(col);
+    if (colSel.getHiddenColumns() == null)
+    {
+      hasHiddenColumns = false;
+    }
+  }
+
+  public void showAllHiddenColumns()
+  {
+    colSel.revealAllHiddenColumns();
+    hasHiddenColumns = false;
+  }
+
+  public void showAllHiddenSeqs()
+  {
+    if (alignment.getHiddenSequences().getSize() > 0)
+    {
+      if (selectionGroup == null)
+      {
+        selectionGroup = new SequenceGroup();
+        selectionGroup.setEndRes(alignment.getWidth() - 1);
+      }
+      Vector tmp = alignment.getHiddenSequences().showAll(hiddenRepSequences);
+      for (int t = 0; t < tmp.size(); t++)
+      {
+        selectionGroup.addSequence(
+            (SequenceI) tmp.elementAt(t), false
+            );
+      }
+      firePropertyChange("alignment", null, alignment.getSequences());
+      hasHiddenRows = false;
+      hiddenRepSequences = null;
+    }
+  }
+
+  public int adjustForHiddenSeqs(int alignmentIndex)
+  {
+    return alignment.getHiddenSequences().adjustForHiddenSeqs(alignmentIndex);
+  }
+
+  /**
+   * This method returns the a new SequenceI [] with
+   * the selection sequence and start and end points adjusted
+   * @return String[]
+   */
+  public SequenceI[] getSelectionAsNewSequence()
+  {
+    SequenceI[] sequences;
+
+    if (selectionGroup == null)
+    {
+      sequences = alignment.getSequencesArray();
+    }
+    else
+    {
+      sequences = selectionGroup.getSelectionAsNewSequences(alignment);
+    }
+
+    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();
+      seqs = selectionGroup.getSequencesInOrder(alignment);
+      start = selectionGroup.getStartRes();
+      end = selectionGroup.getEndRes(); // inclusive for start and end in SeqCigar constructor
+    }
+    else
+    {
+      iSize = alignment.getHeight();
+      seqs = alignment.getSequencesArray();
+      end = alignment.getWidth() - 1;
+    }
+    SeqCigar[] selseqs = new SeqCigar[iSize];
+    for (i = 0; i < iSize; i++)
+    {
+      selseqs[i] = new SeqCigar(seqs[i], start, end);
+    }
+    selection = new CigarArray(selseqs);
+    // now construct the CigarArray operations
+    if (hasHiddenColumns)
+    {
+      Vector regions = colSel.getHiddenColumns();
+      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 + 1);
+      }
+    }
+    else
+    {
+      selection.addOperation(CigarArray.M, end - start + 1);
+    }
+    return selection;
+  }
+
+  /**
+   * return a compact representation of the current alignment selection to
+   * pass to an analysis function
+   * @param selectedOnly boolean true to just return the selected view
+   * @return AlignmentView
+   */
+  jalview.datamodel.AlignmentView getAlignmentView(boolean selectedOnly)
+  {
+    // JBPNote:
+    // this is here because the AlignmentView constructor modifies the CigarArray
+    // object. Refactoring of Cigar and alignment view representation should
+    // be done to remove redundancy.
+    CigarArray aligview = getViewAsCigars(selectedOnly);
+    if (aligview != null)
+    {
+      return new AlignmentView(aligview,
+                               (selectedOnly && selectionGroup != null) ?
+                               selectionGroup.getStartRes() : 0);
+    }
+    return null;
+  }
+
+  /**
+   * 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 String[] getViewAsString(boolean selectedRegionOnly)
+  {
+    String[] selection = null;
+    SequenceI[] seqs = null;
+    int i, iSize;
+    int start = 0, end = 0;
+    if (selectedRegionOnly && selectionGroup != null)
+    {
+      iSize = selectionGroup.getSize();
+      seqs = selectionGroup.getSequencesInOrder(alignment);
+      start = selectionGroup.getStartRes();
+      end = selectionGroup.getEndRes() + 1;
+    }
+    else
+    {
+      iSize = alignment.getHeight();
+      seqs = alignment.getSequencesArray();
+      end = alignment.getWidth();
+    }
+
+    selection = new String[iSize];
+
+    for (i = 0; i < iSize; i++)
+    {
+      if (hasHiddenColumns)
+      {
+        StringBuffer visibleSeq = new StringBuffer();
+        Vector regions = colSel.getHiddenColumns();
+
+        int blockStart = start, blockEnd = end;
+        int[] region;
+        int hideStart, hideEnd;
+
+        for (int j = 0; j < regions.size(); j++)
+        {
+          region = (int[]) regions.elementAt(j);
+          hideStart = region[0];
+          hideEnd = region[1];
+
+          if (hideStart < start)
+          {
+            continue;
+          }
+
+          blockStart = Math.min(blockStart, hideEnd + 1);
+          blockEnd = Math.min(blockEnd, hideStart);
+
+          if (blockStart > blockEnd)
+          {
+            break;
+          }
+
+          visibleSeq.append(seqs[i].getSequence(blockStart, blockEnd));
+
+          blockStart = hideEnd + 1;
+          blockEnd = end;
+        }
+
+        if (end > blockStart)
+        {
+          visibleSeq.append(seqs[i].getSequence(blockStart, end));
+        }
+
+        selection[i] = visibleSeq.toString();
+      }
+      else
+      {
+        selection[i] = seqs[i].getSequenceAsString(start, end);
+      }
+    }
+
+    return selection;
+  }
+
+  public boolean getShowHiddenMarkers()
+  {
+    return showHiddenMarkers;
+  }
+
+  public void setShowHiddenMarkers(boolean show)
+  {
+    showHiddenMarkers = show;
+  }
+
+  public Color getSequenceColour(SequenceI seq)
+  {
+    if (sequenceColours == null || !sequenceColours.containsKey(seq))
+    {
+      return Color.white;
+    }
+    else
+    {
+      return (Color) sequenceColours.get(seq);
+    }
+  }
+
+  public void setSequenceColour(SequenceI seq, Color col)
+  {
+    if (sequenceColours == null)
+    {
+      sequenceColours = new Hashtable();
+    }
+
+    if (col == null)
+    {
+      sequenceColours.remove(seq);
+    }
+    else
+    {
+      sequenceColours.put(seq, col);
+    }
+  }
+
+  public String getSequenceSetId()
+  {
+    if (sequenceSetID == null)
+    {
+      sequenceSetID = alignment.hashCode() + "";
+    }
+
+    return sequenceSetID;
+  }
+
+  public void alignmentChanged(AlignmentPanel ap)
+  {
+    alignment.padGaps();
+
+    if (hconsensus != null && autocalculateConsensus)
+    {
+      updateConsensus(ap);
+      updateConservation(ap);
+    }
+
+    //Reset endRes of groups if beyond alignment width
+    int alWidth = alignment.getWidth();
+    Vector groups = alignment.getGroups();
+    if (groups != null)
+    {
+      for (int i = 0; i < groups.size(); i++)
+      {
+        SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
+        if (sg.getEndRes() > alWidth)
+        {
+          sg.setEndRes(alWidth - 1);
+        }
+      }
+    }
+
+    if (selectionGroup != null && selectionGroup.getEndRes() > alWidth)
+    {
+      selectionGroup.setEndRes(alWidth - 1);
+    }
+
+    resetAllColourSchemes();
+
+    //AW  alignment.adjustSequenceAnnotations();
+  }
+
+  void resetAllColourSchemes()
+  {
+    ColourSchemeI cs = globalColourScheme;
+    if (cs != null)
+    {
+      if (cs instanceof ClustalxColourScheme)
+      {
+        ( (ClustalxColourScheme) cs).
+            resetClustalX(alignment.getSequences(),
+                          alignment.getWidth());
+      }
+
+      cs.setConsensus(hconsensus);
+      if (cs.conservationApplied())
+      {
+        Alignment al = (Alignment) alignment;
+        Conservation c = new Conservation("All",
+                                          ResidueProperties.propHash, 3,
+                                          al.getSequences(), 0,
+                                          al.getWidth() - 1);
+        c.calculate();
+        c.verdict(false, ConsPercGaps);
+
+        cs.setConservation(c);
+      }
+    }
+
+    int s, sSize = alignment.getGroups().size();
+    for (s = 0; s < sSize; s++)
+    {
+      SequenceGroup sg = (SequenceGroup) alignment.getGroups().elementAt(s);
+      if (sg.cs != null && sg.cs instanceof ClustalxColourScheme)
+      {
+        ( (ClustalxColourScheme) sg.cs).resetClustalX(
+            sg.getSequences(hiddenRepSequences), sg.getWidth());
+      }
+      sg.recalcConservation();
+    }
+  }
 
 }