X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FAlignViewport.java;h=743c8dd5f8baa122df4d80400e563256af0c3a7d;hb=b45345a4ee49f07b6f66e80535ca5f140a954e41;hp=905255a11536bf27745f262fc94d1b4d7c3185a5;hpb=157004a864888ed2e690b907a28f715d3d42b666;p=jalview.git

diff --git a/src/jalview/gui/AlignViewport.java b/src/jalview/gui/AlignViewport.java
index 905255a..743c8dd 100755
--- a/src/jalview/gui/AlignViewport.java
+++ b/src/jalview/gui/AlignViewport.java
@@ -1,355 +1,1506 @@
-package jalview.gui;
-
-import java.awt.*;
-import jalview.io.*;
-import jalview.analysis.NJTree;
-import jalview.datamodel.*;
-import jalview.schemes.*;
-import java.util.*;
-
-public class AlignViewport
-{
-  int startRes;
-  int endRes;
-
-  int startSeq;
-  int endSeq;
-
-  boolean showScores=false;
-  boolean showText=true;
-  boolean showColourText=false;
-  boolean showBoxes=true;
-  boolean wrapAlignment=false;
-  boolean renderGaps = false;
-  boolean groupEdit    = false;
-  boolean groupDefiningMode = true;
-
-  ColourSchemeI globalColourScheme = null;
-
-  RendererI renderer = new SequenceRenderer(this);
-
-  int             charHeight;
-  int          charWidth;
-  int             chunkWidth;
-  int             chunkHeight;
-
-  Font            font = new Font("SansSerif",Font.PLAIN,10);
-  AlignmentI      alignment;
-
-  Selection       sel    = new Selection();
-  ColumnSelection colSel = new ColumnSelection();
-
-  OutputGenerator og;
-
-  String visibleConsensus;
-
-  int threshold;
-  int increment;
-
-  NJTree currentTree = null;
-
-  int window   = 50;
-  int baseline = 30;
-
-  Vector kmers;
-
-  public AlignViewport(AlignmentI da,
-                       boolean showScores,
-                       boolean showText,
-                       boolean showBoxes,
-                       boolean wrapAlignment) {
-    this(0,da.getWidth()-1,0,da.getHeight()-1,showScores,
-         showText,
-         showBoxes,
-         wrapAlignment);
-
-    setAlignment(da);
-  }
-
-  public AlignViewport(int startRes, int endRes,
-                       int startSeq, int endSeq,
-                       boolean showScores,
-                       boolean showText,
-                       boolean showBoxes,
-                       boolean wrapAlignment) {
-
-    this.startRes = startRes;
-    this.endRes   = endRes;
-    this.startSeq = startSeq;
-    this.endSeq   = endSeq;
-
-    this.showScores    = showScores;
-    this.showText      = showText;
-    this.showBoxes     = showBoxes;
-    this.wrapAlignment = wrapAlignment;
-
-   // og  = new AlignmentOutputGenerator(this);
-
-    setFont( font );
- }
-
-
-  public String getVisibleConsensus()
-  {
-    return visibleConsensus;
-  }
-
-  Vector consensus = new Vector();
-  public Vector getConsensus(boolean recalculate)
-  {
-    if(recalculate || consensus.size()<1)
-    {
-      consensus = alignment.getAAFrequency();
-      StringBuffer sb = new StringBuffer();
-      Hashtable hash = null;
-      for (int i = 0; i < consensus.size(); i++)
-      {
-        hash = (Hashtable) consensus.elementAt(i);
-        sb.append(hash.get("maxResidue").toString().charAt(0));
-      }
-      visibleConsensus = sb.toString();
-    }
-
-
-    return consensus;
-  }
-
-
-  public int getStartRes() {
-    return startRes;
-  }
-
-  public int getEndRes() {
-    return endRes;
-  }
-
-  public int getStartSeq() {
-    return startSeq;
-  }
-
-  public void setGlobalColourScheme(ColourSchemeI cs)
-  {
-     globalColourScheme = cs;
-  }
-
-  public ColourSchemeI getGlobalColourScheme()
-  {
-    return globalColourScheme;
-  }
-
-
-  public void setStartRes(int res) {
-    this.startRes = res;
-  }
-  public void setStartSeq(int seq) {
-    this.startSeq = seq;
-  }
-  public void setEndRes(int res) {
-    if (res > alignment.getWidth()-1) {
-      System.out.println(" Corrected res from " + res + " to maximum " + (alignment.getWidth()-1));
-       res = alignment.getWidth() -1;
-    }
-    if (res < 0) {
-      res = 0;
-    }
-    this.endRes = res;
-  }
-  public void setEndSeq(int seq) {
-    if (seq > alignment.getHeight()) {
-      seq = alignment.getHeight();
-    }
-    if (seq < 0) {
-      seq = 0;
-    }
-    this.endSeq = seq;
-  }
-  public int getEndSeq() {
-    return endSeq;
-  }
-
-  public void setFont(Font f) {
-    font = f;
-    javax.swing.JFrame temp = new javax.swing.JFrame();
-    temp.addNotify();
-    java.awt.FontMetrics fm = temp.getGraphics().getFontMetrics(font);
-    setCharHeight(fm.getHeight());
-    setCharWidth(fm.charWidth('M'));
-  }
-
-  public Font getFont() {
-    return font;
-  }
-  public void setCharWidth(int w) {
-    this.charWidth = w;
-  }
-  public int getCharWidth() {
-    return charWidth;
-  }
-  public void setCharHeight(int h) {
-    this.charHeight = h;
-  }
-  public int getCharHeight() {
-    return charHeight;
-  }
-  public void setChunkWidth(int w) {
-    this.chunkWidth = w;
-  }
-  public int getChunkWidth() {
-    return chunkWidth;
-  }
-  public void setChunkHeight(int h) {
-    this.chunkHeight = h;
-  }
-  public int getChunkHeight() {
-    return chunkHeight;
-  }
-  public AlignmentI getAlignment() {
-    return alignment;
-  }
-  public void setAlignment(AlignmentI align) {
-    this.alignment = align;
-  }
-  public void setShowScores(boolean state) {
-    showScores = state;
-  }
-  public void setWrapAlignment(boolean state) {
-    wrapAlignment = state;
-  }
-  public void setShowText(boolean state) {
-    showText = state;
-  }
-
-  public void setRenderGaps(boolean state){
-    renderGaps = state;
-    if(renderer instanceof SequenceRenderer)
-    {
-      SequenceRenderer sr = (SequenceRenderer)renderer;
-      sr.renderGaps(state);
-    }
-  }
-
-
-  public boolean getColourText()
-  {
-    return showColourText;
-  }
-
-  public void setColourText(boolean state)
-  {
-    showColourText = state;
-  }
-
-  public void setShowBoxes(boolean state) {
-    showBoxes = state;
-  }
-  public boolean getShowScores() {
-    return showScores;
-  }
-  public boolean getWrapAlignment() {
-      return wrapAlignment;
-  }
-  public boolean getShowText() {
-    return showText;
-  }
-  public boolean getShowBoxes() {
-    return showBoxes;
-  }
- // public CommandParser getCommandLog() {
- ///   return log;
- // }
-  public boolean getGroupEdit() {
-    return groupEdit;
-  }
-  public void setGroupEdit(boolean state) {
-    groupEdit = state;
-  }
-  public char getGapCharacter() {
-    return getAlignment().getGapCharacter();
-  }
-  public void setGapCharacter(char gap) {
-    if (getAlignment() != null) {
-      getAlignment().setGapCharacter(gap);
-    }
-  }
-  public void setThreshold(int thresh) {
-    threshold = thresh;
-  }
-  public int getThreshold() {
-    return threshold;
-  }
-  public void setIncrement(int inc) {
-    increment = inc;
-  }
-  public int getIncrement() {
-    return increment;
-  }
-  public int getIndex(int y) {
-    int y1     = 0;
-    int starty = getStartSeq();
-    int endy   = getEndSeq();
-
-    for (int i = starty; i <= endy; i++) {
-      if (i < alignment.getHeight() && alignment.getSequenceAt(i) != null) {
-        int y2 = y1 + getCharHeight();
-
-        if (y>=y1 && y <=y2) {
-          return i;
-        }
-        y1  = y2;
-      } else {
-        return -1;
-      }
-    }
-    return -1;
-  }
-  public Selection getSelection() {
-    return sel;
-  }
-  public ColumnSelection getColumnSelection() {
-    return colSel;
-  }
-  public OutputGenerator getOutputGenerator() {
-    return og;
-  }
-  public void resetSeqLimits(int height) {
-    setStartSeq(0);
-    setEndSeq(height/getCharHeight());
-  }
-  public void setCurrentTree(NJTree tree) {
-      currentTree = tree;
-  }
-  public NJTree getCurrentTree() {
-    return currentTree;
-  }
-
-    public void setRenderer(RendererI rend) {
-	this.renderer = rend;
-    }
-
-    public RendererI getRenderer() {
-	return renderer;
-    }
-    public int getPIDWindow() {
-	return window;
-    }
-    public void setPIDWindow(int window) {
-	this.window = window;
-    }
-
-    public int getPIDBaseline() {
-	return baseline;
-    }
-    public void setPIDBaseline(int baseline) {
-	this.baseline = baseline;
-    }
-
-    public void setKmers(Vector kmers) {
-        this.kmers = kmers;
-    }
-
-    public Vector getKmers() {
-        return this.kmers;
-    }
-
-
-}
+ /*
+ * Jalview - A Sequence Alignment Editor and Viewer
+ * Copyright (C) 2006 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
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+package jalview.gui;
+
+import jalview.analysis.*;
+
+import jalview.bin.*;
+
+import jalview.datamodel.*;
+
+import jalview.schemes.*;
+
+import java.awt.*;
+
+import java.util.*;
+
+
+/**
+ * DOCUMENT ME!
+ *
+ * @author $author$
+ * @version $Revision$
+ */
+public class AlignViewport
+{
+    int startRes;
+    int endRes;
+    int startSeq;
+    int endSeq;
+    boolean showJVSuffix = true;
+    boolean showText = true;
+    boolean showColourText = false;
+    boolean showBoxes = true;
+    boolean wrapAlignment = false;
+    boolean renderGaps = true;
+    boolean showSequenceFeatures = false;
+    boolean showAnnotation = true;
+    boolean showConservation = true;
+    boolean showQuality = true;
+    boolean showIdentity = true;
+    boolean colourAppliesToAllGroups = true;
+    ColourSchemeI globalColourScheme = null;
+    boolean conservationColourSelected = false;
+    boolean abovePIDThreshold = false;
+    SequenceGroup selectionGroup;
+    int charHeight;
+    int charWidth;
+    boolean validCharWidth;
+    int wrappedWidth;
+    Font font;
+    AlignmentI alignment;
+    ColumnSelection colSel = new ColumnSelection();
+    int threshold;
+    int increment;
+    NJTree currentTree = null;
+    boolean scaleAboveWrapped = false;
+    boolean scaleLeftWrapped = true;
+    boolean scaleRightWrapped = true;
+    boolean hasHiddenColumns = false;
+    boolean hasHiddenRows = false;
+    boolean showHiddenMarkers = true;
+
+    boolean cursorMode = false;
+
+    // The following vector holds the features which are
+    // currently visible, in the correct order or rendering
+    Hashtable featuresDisplayed = null;
+
+
+    /** DOCUMENT ME!! */
+    public Hashtable [] hconsensus;
+    AlignmentAnnotation consensus;
+    AlignmentAnnotation conservation;
+    AlignmentAnnotation quality;
+    boolean autoCalculateConsensus = true;
+
+    /** DOCUMENT ME!! */
+    public int ConsPercGaps = 25; // JBPNote : This should be a scalable property!
+
+    // JBPNote Prolly only need this in the applet version.
+    private java.beans.PropertyChangeSupport changeSupport = new java.beans.PropertyChangeSupport(this);
+
+    boolean ignoreGapsInConsensusCalculation = false;
+
+    boolean isDataset = false;
+
+    boolean antiAlias = false;
+
+    boolean padGaps = false;
+
+    Rectangle explodedPosition;
+
+    String viewName;
+
+    String sequenceSetID;
+
+    boolean gatherViewsHere = false;
+
+
+    public AlignViewport(AlignmentI al, boolean dataset)
+    {
+      isDataset = dataset;
+      setAlignment(al);
+      init();
+    }
+    /**
+     * Creates a new AlignViewport object.
+     *
+     * @param al DOCUMENT ME!
+     */
+    public AlignViewport(AlignmentI al)
+    {
+        setAlignment(al);
+        init();
+    }
+    /**
+     * Create a new AlignViewport with hidden regions
+     * @param al AlignmentI
+     * @param hiddenColumns ColumnSelection
+     */
+    public AlignViewport(AlignmentI al, ColumnSelection hiddenColumns) {
+      setAlignment(al);
+      if (hiddenColumns!=null) {
+        this.colSel = hiddenColumns;
+        if (hiddenColumns.getHiddenColumns() != null)
+          hasHiddenColumns = true;
+      }
+      init();
+    }
+
+    void init()
+    {
+        this.startRes = 0;
+        this.endRes = alignment.getWidth() - 1;
+        this.startSeq = 0;
+        this.endSeq = alignment.getHeight() - 1;
+
+      antiAlias = Cache.getDefault("ANTI_ALIAS", false);
+
+      showJVSuffix = Cache.getDefault("SHOW_JVSUFFIX", true);
+      showAnnotation = Cache.getDefault("SHOW_ANNOTATIONS", true);
+      showConservation = Cache.getDefault("SHOW_CONSERVATION", true);
+
+      showQuality = Cache.getDefault("SHOW_QUALITY", true);
+      showIdentity = Cache.getDefault("SHOW_IDENTITY", true);
+
+      autoCalculateConsensus = Cache.getDefault("AUTO_CALC_CONSENSUS", true);
+
+      padGaps = Cache.getDefault("PAD_GAPS", false);
+
+       String fontName = Cache.getDefault("FONT_NAME", "SansSerif");
+       String fontStyle = Cache.getDefault("FONT_STYLE", Font.PLAIN + "") ;
+       String fontSize = Cache.getDefault("FONT_SIZE", "10");
+
+       int style = 0;
+
+       if (fontStyle.equals("bold"))
+       {
+         style = 1;
+       }
+       else if (fontStyle.equals("italic"))
+       {
+         style = 2;
+       }
+
+       setFont(new Font(fontName, style, Integer.parseInt(fontSize)));
+
+
+       alignment.setGapCharacter( Cache.getDefault("GAP_SYMBOL", "-").charAt(0) );
+
+
+        // We must set conservation and consensus before setting colour,
+        // as Blosum and Clustal require this to be done
+        if(hconsensus==null && !isDataset)
+        {
+          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;
+
+            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);
+
+              alignment.addAnnotation(quality);
+            }
+          }
+
+          consensus = new AlignmentAnnotation("Consensus", "PID",
+                                               new Annotation[1], 0f, 100f,
+                                               AlignmentAnnotation.BAR_GRAPH);
+          consensus.hasText = true;
+
+           if (showIdentity)
+           {
+             alignment.addAnnotation(consensus);
+           }
+
+        }
+
+        if (jalview.bin.Cache.getProperty("DEFAULT_COLOUR") != null)
+        {
+          globalColourScheme = ColourSchemeProperty.getColour(alignment,
+              jalview.bin.Cache.getProperty("DEFAULT_COLOUR"));
+
+            if (globalColourScheme instanceof UserColourScheme)
+            {
+                globalColourScheme = UserDefinedColours.loadDefaultColours();
+                ((UserColourScheme)globalColourScheme).setThreshold(0, getIgnoreGapsConsensus());
+            }
+
+            if (globalColourScheme != null)
+            {
+                globalColourScheme.setConsensus(hconsensus);
+            }
+        }
+    }
+
+
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param b DOCUMENT ME!
+     */
+    public void setShowSequenceFeatures(boolean b)
+    {
+        showSequenceFeatures = b;
+    }
+
+    public boolean getShowSequenceFeatures()
+    {
+      return showSequenceFeatures;
+    }
+
+
+
+    class ConservationThread extends Thread
+    {
+      AlignmentPanel ap;
+      public ConservationThread(AlignmentPanel ap)
+      {
+        this.ap = ap;
+      }
+
+      public void run()
+      {
+        try
+        {
+          long t = System.currentTimeMillis();
+
+          Conservation cons = new jalview.analysis.Conservation("All",
+              jalview.schemes.ResidueProperties.propHash, 3,
+              alignment.getSequences(), 0, alignment.getWidth() - 1);
+
+          cons.calculate();
+          cons.verdict(false, ConsPercGaps);
+
+          if (showQuality)
+          {
+            cons.findQuality();
+          }
+
+          System.out.println("Conservation took " + (System.currentTimeMillis() - t) +
+                             "ms");
+
+          int alWidth = alignment.getWidth();
+          String 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 (showQuality)
+          {
+            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.charAt(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 (showQuality)
+            {
+              value = ( (Double) cons.quality.get(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)));
+            }
+          }
+
+          if (quality != null)
+          {
+            quality.graphMax = cons.qualityRange[1].floatValue();
+          }
+        }
+        catch (OutOfMemoryError error)
+        {
+          javax.swing.SwingUtilities.invokeLater(new Runnable()
+          {
+            public void run()
+            {
+              javax.swing.JOptionPane.showInternalMessageDialog(Desktop.desktop,
+                  "Out of memory calculating conservation!!"
+                  +
+                  "\nSee help files for increasing Java Virtual Machine memory."
+                  , "Out of memory",
+                  javax.swing.JOptionPane.WARNING_MESSAGE);
+            }
+          });
+
+          System.out.println("Conservation calculation: " + error);
+          System.gc();
+
+        }
+
+        if(ap!=null)
+        {
+          ap.repaint();
+        }
+        updatingConservation = false;
+      }
+    }
+
+
+    ConservationThread conservationThread;
+
+    ConsensusThread consensusThread;
+
+    boolean consUpdateNeeded = false;
+
+    boolean updatingConsensus = false;
+
+    boolean updatingConservation = false;
+
+    /**
+     * DOCUMENT ME!
+     */
+    public void updateConservation(AlignmentPanel ap)
+    {
+      if (alignment.isNucleotide())
+        return;
+
+      updatingConservation = true;
+
+      if (conservationThread == null || !conservationThread.isAlive())
+      {
+        conservationThread = new ConservationThread(ap);
+        conservationThread.start();
+      }
+      else
+      {
+        consUpdateNeeded = true;
+        System.out.println("come back later");
+      }
+    }
+
+    /**
+     * DOCUMENT ME!
+     */
+    public void updateConsensus(AlignmentPanel ap)
+    {
+      updatingConsensus = true;
+
+      if (consensusThread == null || !consensusThread.isAlive())
+      {
+        consensusThread = new ConsensusThread(ap);
+        consensusThread.start();
+      }
+      else
+      {
+        consUpdateNeeded = true;
+        System.out.println("come back later");
+      }
+    }
+
+
+    class ConsensusThread extends Thread
+    {
+      AlignmentPanel ap;
+      public ConsensusThread(AlignmentPanel ap)
+      {
+        this.ap = ap;
+      }
+      public void run()
+      {
+        try
+        {
+          int aWidth = alignment.getWidth();
+
+          consensus.annotations = null;
+          consensus.annotations = new Annotation[aWidth];
+
+          long t = System.currentTimeMillis();
+          hconsensus = new Hashtable[aWidth];
+          AAFrequency.calculate(alignment.getSequencesArray(),
+                                0,
+                                alignment.getWidth(),
+                                hconsensus);
+
+          System.out.println("Consensus took " +
+                             (System.currentTimeMillis() - t) + "ms");
+
+          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)
+        {
+          javax.swing.SwingUtilities.invokeLater(new Runnable()
+          {
+            public void run()
+            {
+              javax.swing.JOptionPane.showInternalMessageDialog(Desktop.desktop,
+                  "Out of memory calculating consensus!!"
+                  +
+                  "\nSee help files for increasing Java Virtual Machine memory."
+                  , "Out of memory",
+                  javax.swing.JOptionPane.WARNING_MESSAGE);
+            }
+          });
+
+          System.out.println("Consensus calculation: " + error);
+          System.gc();
+        }
+
+        if (ap != null)
+        {
+          ap.repaint();
+        }
+
+
+        updatingConsensus = false;
+      }
+    }
+    /**
+     * 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)
+        updateConsensus(null);
+      if (consensus==null)
+        return null;
+      StringBuffer seqs=new StringBuffer();
+      for (int i=0; i<consensus.annotations.length; i++) {
+        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);
+        }
+      }
+      SequenceI sq = new Sequence("Consensus", seqs.toString());
+      sq.setDescription("Percentage Identity Consensus "+((ignoreGapsInConsensusCalculation) ? " without gaps" : ""));
+      return sq;
+    }
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public SequenceGroup getSelectionGroup()
+    {
+        return selectionGroup;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param sg DOCUMENT ME!
+     */
+    public void setSelectionGroup(SequenceGroup sg)
+    {
+        selectionGroup = sg;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public boolean getConservationSelected()
+    {
+        return conservationColourSelected;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param b DOCUMENT ME!
+     */
+    public void setConservationSelected(boolean b)
+    {
+        conservationColourSelected = b;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public boolean getAbovePIDThreshold()
+    {
+        return abovePIDThreshold;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param b DOCUMENT ME!
+     */
+    public void setAbovePIDThreshold(boolean b)
+    {
+        abovePIDThreshold = b;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getStartRes()
+    {
+        return startRes;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getEndRes()
+    {
+        return endRes;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getStartSeq()
+    {
+        return startSeq;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param cs DOCUMENT ME!
+     */
+    public void setGlobalColourScheme(ColourSchemeI cs)
+    {
+        globalColourScheme = cs;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public ColourSchemeI getGlobalColourScheme()
+    {
+        return globalColourScheme;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param res DOCUMENT ME!
+     */
+    public void setStartRes(int res)
+    {
+        this.startRes = res;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param seq DOCUMENT ME!
+     */
+    public void setStartSeq(int seq)
+    {
+        this.startSeq = seq;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param res DOCUMENT ME!
+     */
+    public void setEndRes(int res)
+    {
+        if (res > (alignment.getWidth() - 1))
+        {
+            // log.System.out.println(" Corrected res from " + res + " to maximum " + (alignment.getWidth()-1));
+            res = alignment.getWidth() - 1;
+        }
+
+        if (res < 0)
+        {
+            res = 0;
+        }
+
+        this.endRes = res;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param seq DOCUMENT ME!
+     */
+    public void setEndSeq(int seq)
+    {
+        if (seq > alignment.getHeight())
+        {
+            seq = alignment.getHeight();
+        }
+
+        if (seq < 0)
+        {
+            seq = 0;
+        }
+
+        this.endSeq = seq;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getEndSeq()
+    {
+        return endSeq;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param f DOCUMENT ME!
+     */
+    public void setFont(Font f)
+    {
+        font = f;
+
+        Container c = new Container();
+
+        java.awt.FontMetrics fm = c.getFontMetrics(font);
+        setCharHeight(fm.getHeight());
+        setCharWidth(fm.charWidth('M'));
+        validCharWidth = true;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public Font getFont()
+    {
+        return font;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param w DOCUMENT ME!
+     */
+    public void setCharWidth(int w)
+    {
+        this.charWidth = w;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getCharWidth()
+    {
+        return charWidth;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param h DOCUMENT ME!
+     */
+    public void setCharHeight(int h)
+    {
+        this.charHeight = h;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getCharHeight()
+    {
+        return charHeight;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param w DOCUMENT ME!
+     */
+    public void setWrappedWidth(int w)
+    {
+        this.wrappedWidth = w;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getWrappedWidth()
+    {
+        return wrappedWidth;
+    }
+
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public AlignmentI getAlignment()
+    {
+        return alignment;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param align DOCUMENT ME!
+     */
+    public void setAlignment(AlignmentI align)
+    {
+        this.alignment = align;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param state DOCUMENT ME!
+     */
+    public void setWrapAlignment(boolean state)
+    {
+        wrapAlignment = state;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param state DOCUMENT ME!
+     */
+    public void setShowText(boolean state)
+    {
+        showText = state;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param state DOCUMENT ME!
+     */
+    public void setRenderGaps(boolean state)
+    {
+        renderGaps = state;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public boolean getColourText()
+    {
+        return showColourText;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param state DOCUMENT ME!
+     */
+    public void setColourText(boolean state)
+    {
+        showColourText = state;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param state DOCUMENT ME!
+     */
+    public void setShowBoxes(boolean state)
+    {
+        showBoxes = state;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public boolean getWrapAlignment()
+    {
+        return wrapAlignment;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public boolean getShowText()
+    {
+        return showText;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public boolean getShowBoxes()
+    {
+        return showBoxes;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public char getGapCharacter()
+    {
+        return getAlignment().getGapCharacter();
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param gap DOCUMENT ME!
+     */
+    public void setGapCharacter(char gap)
+    {
+        if (getAlignment() != null)
+        {
+            getAlignment().setGapCharacter(gap);
+        }
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param thresh DOCUMENT ME!
+     */
+    public void setThreshold(int thresh)
+    {
+        threshold = thresh;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getThreshold()
+    {
+        return threshold;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param inc DOCUMENT ME!
+     */
+    public void setIncrement(int inc)
+    {
+        increment = inc;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public int getIncrement()
+    {
+        return increment;
+    }
+
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public ColumnSelection getColumnSelection()
+    {
+        return colSel;
+    }
+
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param tree DOCUMENT ME!
+     */
+    public void setCurrentTree(NJTree tree)
+    {
+        currentTree = tree;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public NJTree getCurrentTree()
+    {
+        return currentTree;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param b DOCUMENT ME!
+     */
+    public void setColourAppliesToAllGroups(boolean b)
+    {
+        colourAppliesToAllGroups = b;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public boolean getColourAppliesToAllGroups()
+    {
+        return colourAppliesToAllGroups;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public boolean getShowJVSuffix()
+    {
+        return showJVSuffix;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param b DOCUMENT ME!
+     */
+    public void setShowJVSuffix(boolean b)
+    {
+        showJVSuffix = b;
+    }
+
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public boolean getShowAnnotation()
+    {
+        return showAnnotation;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param b DOCUMENT ME!
+     */
+    public void setShowAnnotation(boolean b)
+    {
+        showAnnotation = b;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public boolean getScaleAboveWrapped()
+    {
+        return scaleAboveWrapped;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public boolean getScaleLeftWrapped()
+    {
+        return scaleLeftWrapped;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public boolean getScaleRightWrapped()
+    {
+        return scaleRightWrapped;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param b DOCUMENT ME!
+     */
+    public void setScaleAboveWrapped(boolean b)
+    {
+        scaleAboveWrapped = b;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param b DOCUMENT ME!
+     */
+    public void setScaleLeftWrapped(boolean b)
+    {
+        scaleLeftWrapped = b;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param b DOCUMENT ME!
+     */
+    public void setScaleRightWrapped(boolean b)
+    {
+        scaleRightWrapped = b;
+    }
+
+    /**
+     * Property change listener for changes in alignment
+     *
+     * @param listener DOCUMENT ME!
+     */
+    public void addPropertyChangeListener(
+        java.beans.PropertyChangeListener listener)
+    {
+        changeSupport.addPropertyChangeListener(listener);
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param listener DOCUMENT ME!
+     */
+    public void removePropertyChangeListener(
+        java.beans.PropertyChangeListener listener)
+    {
+        changeSupport.removePropertyChangeListener(listener);
+    }
+
+    /**
+     * Property change listener for changes in alignment
+     *
+     * @param prop DOCUMENT ME!
+     * @param oldvalue DOCUMENT ME!
+     * @param newvalue DOCUMENT ME!
+     */
+    public void firePropertyChange(String prop, Object oldvalue, Object newvalue)
+    {
+        changeSupport.firePropertyChange(prop, oldvalue, newvalue);
+    }
+
+    public void setIgnoreGapsConsensus(boolean b, AlignmentPanel ap)
+    {
+      ignoreGapsInConsensusCalculation = b;
+      updateConsensus(ap);
+      if(globalColourScheme!=null)
+      {
+        globalColourScheme.setThreshold(globalColourScheme.getThreshold(), ignoreGapsInConsensusCalculation);
+      }
+    }
+
+    public boolean getIgnoreGapsConsensus()
+    {
+     return ignoreGapsInConsensusCalculation;
+    }
+
+    public void setDataset(boolean b)
+    {
+      isDataset = b;
+    }
+
+    public boolean isDataset()
+    {
+      return isDataset;
+    }
+
+
+    public void hideSelectedColumns()
+    {
+      if (colSel.size() < 1)
+        return;
+
+      colSel.hideSelectedColumns();
+      setSelectionGroup(null);
+
+      hasHiddenColumns = true;
+    }
+
+
+    public void hideColumns(int start, int end)
+    {
+      if(start==end)
+        colSel.hideColumns(start);
+      else
+        colSel.hideColumns(start, end);
+
+      hasHiddenColumns = true;
+    }
+
+    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 showSequence(int index)
+    {
+      Vector tmp = alignment.getHiddenSequences().showSequence(index);
+      if(tmp.size()>0)
+      {
+        if(selectionGroup==null)
+        {
+          selectionGroup = new SequenceGroup();
+          selectionGroup.setEndRes(alignment.getWidth()-1);
+        }
+
+        for (int t = 0; t < tmp.size(); t++)
+        {
+          selectionGroup.addSequence(
+              (SequenceI) tmp.elementAt(t), false
+              );
+        }
+        firePropertyChange("alignment", null, alignment.getSequences());
+      }
+
+      if(alignment.getHiddenSequences().getSize()<1)
+        hasHiddenRows = false;
+    }
+
+    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();
+        for(int t=0; t<tmp.size(); t++)
+        {
+          selectionGroup.addSequence(
+              (SequenceI)tmp.elementAt(t), false
+              );
+        }
+        firePropertyChange("alignment", null, alignment.getSequences());
+        hasHiddenRows = false;
+      }
+    }
+
+    public void invertColumnSelection()
+    {
+      int column;
+      for(int i=0; i<alignment.getWidth(); i++)
+      {
+        column = i;
+
+        if(colSel.contains(column))
+          colSel.removeElement(column);
+        else
+          colSel.addElement(column);
+
+      }
+
+    }
+
+    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(false);
+        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(false);
+        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];
+      if (hasHiddenColumns) {
+        selection = colSel.getVisibleSequenceStrings(start, end, seqs);
+      } else {
+        for(i=0; i<iSize; i++)
+        {
+          selection[i] = seqs[i].getSequence(start, end);
+        }
+
+      }
+      return selection;
+    }
+
+    public boolean getShowHiddenMarkers()
+    {
+      return showHiddenMarkers;
+    }
+
+    public void setShowHiddenMarkers(boolean show)
+    {
+      showHiddenMarkers = show;
+    }
+
+    public String getSequenceSetId()
+    {
+      if(sequenceSetID==null)
+        sequenceSetID =  alignment.hashCode()+"";
+
+      return sequenceSetID;
+    }
+
+}