X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FAlignViewport.java;h=f79867132ec7daec4a2c974233f51af6f5cab18c;hb=942de34caf73a7d61104783c8d278c32eaf6b65d;hp=9a7df7ffc93bf2630d77f8d06f672f20c5672f2f;hpb=4259d021fb56cdc5272a3068e3d597474ab5a03c;p=jalview.git

diff --git a/src/jalview/gui/AlignViewport.java b/src/jalview/gui/AlignViewport.java
index 9a7df7f..f798671 100755
--- a/src/jalview/gui/AlignViewport.java
+++ b/src/jalview/gui/AlignViewport.java
@@ -1,6 +1,6 @@
  /*
  * Jalview - A Sequence Alignment Editor and Viewer
- * Copyright (C) 2006 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
@@ -18,6 +18,10 @@
  */
 package jalview.gui;
 
+import java.util.*;
+
+import java.awt.*;
+
 import jalview.analysis.*;
 
 import jalview.bin.*;
@@ -25,11 +29,7 @@ import jalview.bin.*;
 import jalview.datamodel.*;
 
 import jalview.schemes.*;
-
-import java.awt.*;
-
-import java.util.*;
-
+import jalview.structure.StructureSelectionManager;
 
 /**
  * DOCUMENT ME!
@@ -51,9 +51,6 @@ public class AlignViewport
     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;
@@ -64,6 +61,7 @@ public class AlignViewport
     boolean validCharWidth;
     int wrappedWidth;
     Font font;
+    boolean seqNameItalics;
     AlignmentI alignment;
     ColumnSelection colSel = new ColumnSelection();
     int threshold;
@@ -94,7 +92,8 @@ public class AlignViewport
     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);
+  private java.beans.PropertyChangeSupport changeSupport = new java.beans.
+      PropertyChangeSupport(this);
 
     boolean ignoreGapsInConsensusCalculation = false;
 
@@ -112,13 +111,20 @@ public class AlignViewport
 
     boolean gatherViewsHere = false;
 
+    Stack historyList = new Stack();
+    Stack redoList = new Stack();
+
+    Hashtable sequenceColours;
+
+    int thresholdTextColour = 0;
+    Color textColour = Color.black;
+    Color textColour2 = Color.white;
+
+    boolean rightAlignIds = false;
+
+    Hashtable hiddenRepSequences;
+
 
-    public AlignViewport(AlignmentI al, boolean dataset)
-    {
-      isDataset = dataset;
-      setAlignment(al);
-      init();
-    }
     /**
      * Creates a new AlignViewport object.
      *
@@ -134,13 +140,17 @@ public class AlignViewport
      * @param al AlignmentI
      * @param hiddenColumns ColumnSelection
      */
-    public AlignViewport(AlignmentI al, ColumnSelection hiddenColumns) {
+  public AlignViewport(AlignmentI al, ColumnSelection hiddenColumns)
+  {
       setAlignment(al);
-      if (hiddenColumns!=null) {
+    if (hiddenColumns != null)
+    {
         this.colSel = hiddenColumns;
         if (hiddenColumns.getHiddenColumns() != null)
+      {
           hasHiddenColumns = true;
       }
+    }
       init();
     }
 
@@ -155,19 +165,19 @@ public class AlignViewport
 
       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);
 
+      rightAlignIds = Cache.getDefault("RIGHT_ALIGN_IDS", false);
+      centreColumnLabels = Cache.getDefault("CENTRE_COLUMN_LABELS", false);
       autoCalculateConsensus = Cache.getDefault("AUTO_CALC_CONSENSUS", true);
 
-      padGaps = Cache.getDefault("PAD_GAPS", false);
+      padGaps = Cache.getDefault("PAD_GAPS", true);
 
        String fontName = Cache.getDefault("FONT_NAME", "SansSerif");
        String fontStyle = Cache.getDefault("FONT_STYLE", Font.PLAIN + "") ;
        String fontSize = Cache.getDefault("FONT_SIZE", "10");
 
+       seqNameItalics = Cache.getDefault("ID_ITALICS", true);
+
        int style = 0;
 
        if (fontStyle.equals("bold"))
@@ -181,7 +191,6 @@ public class AlignViewport
 
        setFont(new Font(fontName, style, Integer.parseInt(fontSize)));
 
-
        alignment.setGapCharacter( Cache.getDefault("GAP_SYMBOL", "-").charAt(0) );
 
 
@@ -198,13 +207,15 @@ public class AlignViewport
                 11f,
                 AlignmentAnnotation.BAR_GRAPH);
             conservation.hasText = true;
+            conservation.autoCalculated=true;
+
 
-            if (showConservation)
+            if (Cache.getDefault("SHOW_CONSERVATION", true))
             {
               alignment.addAnnotation(conservation);
             }
 
-            if (showQuality)
+            if (Cache.getDefault("SHOW_QUALITY", true))
             {
               quality = new AlignmentAnnotation("Quality",
                                                 "Alignment Quality based on Blosum62 scores",
@@ -213,6 +224,7 @@ public class AlignViewport
                                                 11f,
                                                 AlignmentAnnotation.BAR_GRAPH);
               quality.hasText = true;
+              quality.autoCalculated=true;
 
               alignment.addAnnotation(quality);
             }
@@ -222,12 +234,12 @@ public class AlignViewport
                                                new Annotation[1], 0f, 100f,
                                                AlignmentAnnotation.BAR_GRAPH);
           consensus.hasText = true;
+          consensus.autoCalculated=true;
 
-           if (showIdentity)
+           if (Cache.getDefault("SHOW_IDENTITY", true))
            {
              alignment.addAnnotation(consensus);
            }
-
         }
 
         if (jalview.bin.Cache.getProperty("DEFAULT_COLOUR") != null)
@@ -238,7 +250,8 @@ public class AlignViewport
             if (globalColourScheme instanceof UserColourScheme)
             {
                 globalColourScheme = UserDefinedColours.loadDefaultColours();
-                ((UserColourScheme)globalColourScheme).setThreshold(0, getIgnoreGapsConsensus());
+        ( (UserColourScheme) globalColourScheme).setThreshold(0,
+            getIgnoreGapsConsensus());
             }
 
             if (globalColourScheme != null)
@@ -246,6 +259,8 @@ public class AlignViewport
                 globalColourScheme.setConsensus(hconsensus);
             }
         }
+
+        wrapAlignment = jalview.bin.Cache.getDefault("WRAP_ALIGNMENT", false);
     }
 
 
@@ -265,9 +280,8 @@ public class AlignViewport
       return showSequenceFeatures;
     }
 
-
-
-    class ConservationThread extends Thread
+  class ConservationThread
+      extends Thread
     {
       AlignmentPanel ap;
       public ConservationThread(AlignmentPanel ap)
@@ -279,7 +293,32 @@ public class AlignViewport
       {
         try
         {
+          updatingConservation = true;
+
+          while (UPDATING_CONSERVATION)
+          {
+            try
+            {
+              if (ap != null)
+              {
+                ap.paintAlignment(false);
+              }
+              Thread.sleep(200);
+            }
+            catch (Exception ex)
+            {
+              ex.printStackTrace();
+            }
+          }
+
+          UPDATING_CONSERVATION = true;
+
+
           int alWidth = alignment.getWidth();
+          if(alWidth<0)
+        {
+            return;
+        }
 
           Conservation cons = new jalview.analysis.Conservation("All",
               jalview.schemes.ResidueProperties.propHash, 3,
@@ -293,8 +332,7 @@ public class AlignViewport
             cons.findQuality();
           }
 
-
-          String sequence = cons.getConsSequence().getSequence();
+          char [] sequence = cons.getConsSequence().getSequence();
           float minR;
           float minG;
           float minB;
@@ -329,14 +367,20 @@ public class AlignViewport
           {
             float value = 0;
 
-            c = sequence.charAt(i);
+            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;
@@ -353,7 +397,8 @@ public class AlignViewport
               value = ( (Double) cons.quality.get(i)).floatValue();
               vprop = value - qmin;
               vprop /= qmax;
-              quality.annotations[i] = new Annotation(" ", String.valueOf(value), ' ',
+            quality.annotations[i] = new Annotation(" ", String.valueOf(value),
+                ' ',
                                                value,
                                                new Color(minR + (maxR * vprop),
                   minG + (maxG * vprop),
@@ -365,6 +410,8 @@ public class AlignViewport
         {
           javax.swing.SwingUtilities.invokeLater(new Runnable()
           {
+
+
             public void run()
             {
               javax.swing.JOptionPane.showInternalMessageDialog(Desktop.desktop,
@@ -376,16 +423,22 @@ public class AlignViewport
             }
           });
 
+          conservation = null;
+          quality = null;
+
           System.out.println("Conservation calculation: " + error);
           System.gc();
 
         }
 
+        UPDATING_CONSERVATION = false;
+        updatingConservation = false;
+
         if(ap!=null)
         {
-          ap.repaint();
+        ap.paintAlignment(true);
         }
-        updatingConservation = false;
+
       }
     }
 
@@ -396,53 +449,44 @@ public class AlignViewport
 
     boolean consUpdateNeeded = false;
 
+    static boolean UPDATING_CONSENSUS = false;
+
+    static boolean UPDATING_CONSERVATION = false;
+
     boolean updatingConsensus = false;
 
     boolean updatingConservation = false;
+    /**
+     * centre columnar annotation labels in displayed alignment annotation
+     * TODO: add to jalviewXML and annotation display settings
+     */
+    boolean centreColumnLabels=false;
 
     /**
-     * DOCUMENT ME!
+     * trigger update of conservation annotation
      */
-    public void updateConservation(AlignmentPanel ap)
+    public void updateConservation(final AlignmentPanel ap)
+    {
+      if (alignment.isNucleotide() || conservation==null)
     {
-      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");
-      }
+      conservationThread = new ConservationThread(ap);
+      conservationThread.start();
     }
 
     /**
-     * DOCUMENT ME!
+     * trigger update of consensus annotation
      */
-    public void updateConsensus(AlignmentPanel ap)
+    public void updateConsensus(final AlignmentPanel ap)
     {
-      updatingConsensus = true;
-
-      if (consensusThread == null || !consensusThread.isAlive())
-      {
-        consensusThread = new ConsensusThread(ap);
-        consensusThread.start();
-      }
-      else
-      {
-        consUpdateNeeded = true;
-        System.out.println("come back later");
-      }
+      consensusThread = new ConsensusThread(ap);
+      consensusThread.start();
     }
 
-
-    class ConsensusThread extends Thread
+  class ConsensusThread
+      extends Thread
     {
       AlignmentPanel ap;
       public ConsensusThread(AlignmentPanel ap)
@@ -451,9 +495,34 @@ public class AlignViewport
       }
       public void run()
       {
+        updatingConsensus = true;
+        while (UPDATING_CONSENSUS)
+        {
+          try
+          {
+            if (ap != null)
+            {
+            ap.paintAlignment(false);
+            }
+
+            Thread.sleep(200);
+          }
+          catch (Exception ex)
+          {
+            ex.printStackTrace();
+          }
+        }
+
+
+        UPDATING_CONSENSUS = true;
+
         try
         {
-          int aWidth = alignment.getWidth();
+          int aWidth = (alignment!=null) ? alignment.getWidth() : 0; // null pointer possibility here.
+          if(aWidth<0)
+        {
+            return;
+        }
 
           consensus.annotations = null;
           consensus.annotations = new Annotation[aWidth];
@@ -469,11 +538,15 @@ public class AlignViewport
           {
             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) + " ";
@@ -485,16 +558,23 @@ public class AlignViewport
             }
 
             mouseOver += ( (int) value + "%");
-            consensus.annotations[i] = new Annotation(maxRes, mouseOver, ' ', 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;
           javax.swing.SwingUtilities.invokeLater(new Runnable()
           {
             public void run()
@@ -511,36 +591,49 @@ public class AlignViewport
           System.out.println("Consensus calculation: " + error);
           System.gc();
         }
+        UPDATING_CONSENSUS = false;
+        updatingConsensus = false;
 
         if (ap != null)
         {
-          ap.repaint();
+        ap.paintAlignment(true);
         }
-
-
-        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() {
+  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) {
+    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" : ""));
+    sq.setDescription("Percentage Identity Consensus " +
+                      ( (ignoreGapsInConsensusCalculation) ? " without gaps" :
+                       ""));
       return sq;
     }
     /**
@@ -829,7 +922,15 @@ public class AlignViewport
      */
     public void setAlignment(AlignmentI align)
     {
+      if (alignment!=null && alignment.getCodonFrames()!=null)
+      {
+        StructureSelectionManager.getStructureSelectionManager().removeMappings(alignment.getCodonFrames());
+      }
         this.alignment = align;
+        if (alignment.getCodonFrames()!=null)
+        {
+          StructureSelectionManager.getStructureSelectionManager().addMappings(alignment.getCodonFrames());
+        }
     }
 
     /**
@@ -1178,7 +1279,8 @@ public class AlignViewport
       updateConsensus(ap);
       if(globalColourScheme!=null)
       {
-        globalColourScheme.setThreshold(globalColourScheme.getThreshold(), ignoreGapsInConsensusCalculation);
+      globalColourScheme.setThreshold(globalColourScheme.getThreshold(),
+                                      ignoreGapsInConsensusCalculation);
       }
     }
 
@@ -1201,7 +1303,9 @@ public class AlignViewport
     public void hideSelectedColumns()
     {
       if (colSel.size() < 1)
+    {
         return;
+    }
 
       colSel.hideSelectedColumns();
       setSelectionGroup(null);
@@ -1213,17 +1317,58 @@ public class AlignViewport
     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)
+    if (selectionGroup == null || selectionGroup.getSize()<1)
+    {
         return;
+    }
 
       SequenceI[] seqs = selectionGroup.getSequencesInOrder(alignment);
 
@@ -1237,8 +1382,9 @@ public class AlignViewport
       if(seq!=null)
       {
         for (int i = 0; i < seq.length; i++)
+        {
           alignment.getHiddenSequences().hideSequence(seq[i]);
-
+        }
         hasHiddenRows = true;
         firePropertyChange("alignment", null, alignment.getSequences());
       }
@@ -1246,7 +1392,8 @@ public class AlignViewport
 
     public void showSequence(int index)
     {
-      Vector tmp = alignment.getHiddenSequences().showSequence(index);
+      Vector tmp = alignment.getHiddenSequences().showSequence(index
+          , hiddenRepSequences);
       if(tmp.size()>0)
       {
         if(selectionGroup==null)
@@ -1265,15 +1412,19 @@ public class AlignViewport
       }
 
       if(alignment.getHiddenSequences().getSize()<1)
+    {
         hasHiddenRows = false;
     }
+  }
 
     public void showColumn(int col)
     {
       colSel.revealHiddenColumns(col);
       if(colSel.getHiddenColumns()==null)
+    {
         hasHiddenColumns = false;
     }
+  }
 
     public void showAllHiddenColumns()
     {
@@ -1290,7 +1441,7 @@ public class AlignViewport
           selectionGroup = new SequenceGroup();
           selectionGroup.setEndRes(alignment.getWidth()-1);
         }
-        Vector tmp = alignment.getHiddenSequences().showAll();
+        Vector tmp = alignment.getHiddenSequences().showAll(hiddenRepSequences);
         for(int t=0; t<tmp.size(); t++)
         {
           selectionGroup.addSequence(
@@ -1299,23 +1450,15 @@ public class AlignViewport
         }
         firePropertyChange("alignment", null, alignment.getSequences());
         hasHiddenRows = false;
+        hiddenRepSequences = null;
       }
     }
 
-    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 void invertColumnSelection()
+    {
+      colSel.invertColumnSelection(0,alignment.getWidth());
     }
 
     public int adjustForHiddenSeqs(int alignmentIndex)
@@ -1324,22 +1467,50 @@ public class AlignViewport
     }
 
     /**
-     * This method returns the a new SequenceI [] with
-     * the selection sequence and start and end points adjusted
-     * @return String[]
+     * This method returns an array of new SequenceI objects
+     * derived from the whole alignment or just the current
+     * selection with start and end points adjusted
+     * @note if you need references to the actual SequenceI objects in the alignment or currently selected then use getSequenceSelection()
+     * @return selection as new sequenceI objects
      */
     public SequenceI[] getSelectionAsNewSequence()
     {
       SequenceI[] sequences;
 
       if (selectionGroup == null)
+    {
         sequences = alignment.getSequencesArray();
+        AlignmentAnnotation[] annots = alignment.getAlignmentAnnotation();
+        for (int i=0; i<sequences.length; i++)
+        {
+          sequences[i] = new Sequence(sequences[i], annots); // construct new sequence with subset of visible annotation
+        }
+    }
       else
+    {
         sequences = selectionGroup.getSelectionAsNewSequences(alignment);
+    }
 
       return sequences;
     }
-
+    
+    /**
+     * get the currently selected sequence objects or all the sequences in the alignment.
+     * @return array of references to sequence objects
+     */
+    public SequenceI[] getSequenceSelection()
+    {
+      SequenceI[] sequences;
+      if (selectionGroup==null)
+      {
+        sequences = alignment.getSequencesArray();
+      }
+      else
+      {
+        sequences = selectionGroup.getSequencesInOrder(alignment);
+      }
+      return sequences;
+    }
     /**
      * This method returns the visible alignment as text, as
      * seen on the GUI, ie if columns are hidden they will not
@@ -1348,7 +1519,8 @@ public class AlignViewport
      * which contain hidden columns.
      * @return String[]
      */
-    public jalview.datamodel.CigarArray getViewAsCigars(boolean selectedRegionOnly)
+  public jalview.datamodel.CigarArray getViewAsCigars(boolean
+      selectedRegionOnly)
     {
       CigarArray selection=null;
       SequenceI [] seqs= null;
@@ -1356,7 +1528,7 @@ public class AlignViewport
       int start = 0, end = 0;
       if(selectedRegionOnly && selectionGroup!=null)
       {
-        iSize = selectionGroup.getSize(false);
+        iSize = selectionGroup.getSize();
         seqs = selectionGroup.getSequencesInOrder(alignment);
         start = selectionGroup.getStartRes();
         end = selectionGroup.getEndRes(); // inclusive for start and end in SeqCigar constructor
@@ -1374,7 +1546,8 @@ public class AlignViewport
       }
       selection=new CigarArray(selseqs);
       // now construct the CigarArray operations
-      if (hasHiddenColumns) {
+    if (hasHiddenColumns)
+    {
         Vector regions = colSel.getHiddenColumns();
         int [] region;
         int hideStart, hideEnd;
@@ -1385,34 +1558,50 @@ public class AlignViewport
           hideStart = region[0];
           hideEnd = region[1];
           // edit hidden regions to selection range
-          if(hideStart<last) {
+        if (hideStart < last)
+        {
             if (hideEnd > last)
             {
               hideStart = last;
-            } else
+          }
+          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 {
+      }
+    }
+    else
+    {
         selection.addOperation(CigarArray.M, end-start+1);
       }
       return selection;
@@ -1423,15 +1612,18 @@ public class AlignViewport
      * @param selectedOnly boolean true to just return the selected view
      * @return AlignmentView
      */
-    jalview.datamodel.AlignmentView getAlignmentView(boolean selectedOnly) {
+  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) {
+    if (aligview != null)
+    {
         return new AlignmentView(aligview,
-            (selectedOnly && selectionGroup!=null) ? selectionGroup.getStartRes() : 0);
+                               (selectedOnly && selectionGroup != null) ?
+                               selectionGroup.getStartRes() : 0);
       }
       return null;
     }
@@ -1451,7 +1643,7 @@ public class AlignViewport
       int start = 0, end = 0;
       if(selectedRegionOnly && selectionGroup!=null)
       {
-        iSize = selectionGroup.getSize(false);
+        iSize = selectionGroup.getSize();
         seqs = selectionGroup.getSequencesInOrder(alignment);
         start = selectionGroup.getStartRes();
         end = selectionGroup.getEndRes()+1;
@@ -1464,18 +1656,66 @@ public class AlignViewport
       }
 
       selection = new String[iSize];
-      if (hasHiddenColumns) {
+    if (hasHiddenColumns)
+    {
         selection = colSel.getVisibleSequenceStrings(start, end, seqs);
-      } else {
+    }
+    else
+    {
         for(i=0; i<iSize; i++)
         {
-          selection[i] = seqs[i].getSequence(start, end);
+          selection[i] = seqs[i].getSequenceAsString(start, end);
         }
 
       }
       return selection;
     }
 
+  public int [][] getVisibleRegionBoundaries(int min, int max)
+  {
+    Vector regions = new Vector();
+    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.addElement(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];
+
+    regions.copyInto(startEnd);
+
+    return startEnd;
+
+  }
+
     public boolean getShowHiddenMarkers()
     {
       return showHiddenMarkers;
@@ -1489,9 +1729,202 @@ public class AlignViewport
     public String getSequenceSetId()
     {
       if(sequenceSetID==null)
+    {
         sequenceSetID =  alignment.hashCode()+"";
+    }
 
       return sequenceSetID;
     }
 
+    public void alignmentChanged(AlignmentPanel ap)
+    {
+        if (padGaps)
+    {
+          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();
+
+       // 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();
+      }
+    }
+
+
+    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);
+    }
+    }
+    /**
+     * returns the visible column regions of the alignment
+     * @param selectedRegionOnly true to just return the contigs intersecting with the selected area
+     * @return
+     */
+    public int[] getViewAsVisibleContigs(boolean selectedRegionOnly) {
+      int[] viscontigs=null;
+      int start = 0, end = 0;
+      if(selectedRegionOnly && selectionGroup!=null)
+      {
+        start = selectionGroup.getStartRes();
+        end = selectionGroup.getEndRes()+1;
+      }
+      else
+      {
+        end = alignment.getWidth();
+      }
+      viscontigs = colSel.getVisibleContigs(start, end);
+      return viscontigs;
+    }
+    /**
+     * get hash of undo and redo list for the alignment
+     * @return long[] { historyList.hashCode, redoList.hashCode };
+     */
+    public long[] getUndoRedoHash()
+    {
+      if (historyList==null || redoList==null)
+        return new long[] { -1, -1};
+      return new long[] { historyList.hashCode(), this.redoList.hashCode() };
+    }
+    /**
+     * test if a particular set of hashcodes are different to the hashcodes for the undo and redo list.
+     * @param undoredo the stored set of hashcodes as returned by getUndoRedoHash
+     * @return true if the hashcodes differ (ie the alignment has been edited) or the stored hashcode array differs in size
+     */
+    public boolean isUndoRedoHashModified(long[] undoredo)
+    {
+      if (undoredo==null)
+      {
+        return true;
+      }
+      long[] cstate = getUndoRedoHash();
+      if (cstate.length!=undoredo.length)
+      {  return true; }
+      
+      for (int i=0; i<cstate.length; i++)
+      {
+        if (cstate[i]!=undoredo[i])
+        {
+          return true;
+        }
+      }
+      return false;
+    }
+    
+    public boolean getCentreColumnLabels()
+    {
+      return centreColumnLabels;
+    }
+    public void setCentreColumnLabels(boolean centrecolumnlabels)
+    {
+      centreColumnLabels =  centrecolumnlabels;
+    }
+    public void updateSequenceIdColours()
+    {
+      Vector groups = alignment.getGroups();
+      if (sequenceColours==null)
+      {
+        sequenceColours = new Hashtable();
+      }
+      for (int ig=0,igSize=groups.size(); ig<igSize; ig++)
+      {
+        SequenceGroup sg = (SequenceGroup) groups.elementAt(ig);
+        if (sg.idColour!=null)
+        {
+          Vector sqs = sg.getSequences(hiddenRepSequences);
+          for (int s=0,sSize=sqs.size();s<sSize;s++)
+          {
+            sequenceColours.put(sqs.elementAt(s), sg.idColour);
+          } 
+        }
+      }
+    }
 }