X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fviewmodel%2FAlignmentViewport.java;h=8c34f31cdd5fe1d5e6f1ea71e4c8753df29a6b03;hb=42a69102cb90f11498687980f3592ef96a3cf9ea;hp=3cac289b11ae3692a5b679a1e886c857d6815f94;hpb=746d44733521ab266aea00b724175a6ade377bcd;p=jalview.git

diff --git a/src/jalview/viewmodel/AlignmentViewport.java b/src/jalview/viewmodel/AlignmentViewport.java
index 3cac289..8c34f31 100644
--- a/src/jalview/viewmodel/AlignmentViewport.java
+++ b/src/jalview/viewmodel/AlignmentViewport.java
@@ -1,22 +1,23 @@
 /*
  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
  * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle
- * 
+ *
  * This file is part of Jalview.
- * 
+ *
  * Jalview is free software: you can redistribute it and/or
- * modify it under the terms of the GNU General Public License 
+ * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
- * 
- * Jalview is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranty 
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
+ *
+ * Jalview is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  * PURPOSE.  See the GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  */
 package jalview.viewmodel;
 
+import jalview.analysis.AAFrequency;
 import jalview.analysis.Conservation;
 import jalview.api.AlignCalcManagerI;
 import jalview.api.AlignViewportI;
@@ -27,21 +28,27 @@ import jalview.datamodel.AlignmentView;
 import jalview.datamodel.Annotation;
 import jalview.datamodel.ColumnSelection;
 import jalview.datamodel.Sequence;
+import jalview.datamodel.SequenceCollectionI;
 import jalview.datamodel.SequenceGroup;
 import jalview.datamodel.SequenceI;
+import jalview.schemes.Blosum62ColourScheme;
 import jalview.schemes.ClustalxColourScheme;
 import jalview.schemes.ColourSchemeI;
+import jalview.schemes.PIDColourScheme;
 import jalview.schemes.ResidueProperties;
 import jalview.workers.AlignCalcManager;
 import jalview.workers.ConsensusThread;
-import jalview.workers.ConservationThread;
 import jalview.workers.StrucConsensusThread;
 
 import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
 import java.util.Vector;
 
 /**
- * base class holding visualization and analysis attributes and common logic for an active alignment view displayed in the GUI
+ * base class holding visualization and analysis attributes and common logic for
+ * an active alignment view displayed in the GUI
+ *
  * @author jimp
  *
  */
@@ -55,36 +62,217 @@ public abstract class AlignmentViewport implements AlignViewportI
   protected String sequenceSetID;
 
   /**
-   * probably unused indicator that view is of a dataset rather than an alignment
+   * probably unused indicator that view is of a dataset rather than an
+   * alignment
    */
   protected boolean isDataset = false;
 
-  private Hashtable hiddenRepSequences;
+  private Map<SequenceI, SequenceCollectionI> hiddenRepSequences;
 
   protected ColumnSelection colSel = new ColumnSelection();
 
-
   public boolean autoCalculateConsensus = true;
 
   protected boolean autoCalculateStrucConsensus = true;
 
   protected boolean ignoreGapsInConsensusCalculation = false;
-  
 
   protected ColourSchemeI globalColourScheme = null;
 
+  /**
+   * gui state - changes to colour scheme propagated to all groups
+   */
+  private boolean colourAppliesToAllGroups;
+
+  /**
+   * @param value
+   *          indicating if subsequent colourscheme changes will be propagated
+   *          to all groups
+   */
+  public void setColourAppliesToAllGroups(boolean b)
+  {
+    colourAppliesToAllGroups = b;
+  }
+
+  /**
+   *
+   *
+   * @return flag indicating if colourchanges propagated to all groups
+   */
+  public boolean getColourAppliesToAllGroups()
+  {
+    return colourAppliesToAllGroups;
+  }
+
+  boolean abovePIDThreshold = false;
 
+  /**
+   * GUI state
+   *
+   * @return true if percent identity threshold is applied to shading
+   */
+  public boolean getAbovePIDThreshold()
+  {
+    return abovePIDThreshold;
+  }
+
+  /**
+   * GUI state
+   *
+   *
+   * @param b
+   *          indicate if percent identity threshold is applied to shading
+   */
+  public void setAbovePIDThreshold(boolean b)
+  {
+    abovePIDThreshold = b;
+  }
+
+  int threshold;
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param thresh
+   *          DOCUMENT ME!
+   */
+  public void setThreshold(int thresh)
+  {
+    threshold = thresh;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public int getThreshold()
+  {
+    return threshold;
+  }
+
+  int increment;
+
+  /**
+   *
+   * @param inc
+   *          set the scalar for bleaching colourschemes according to degree of
+   *          conservation
+   */
+  public void setIncrement(int inc)
+  {
+    increment = inc;
+  }
+
+  /**
+   * GUI State
+   *
+   * @return get scalar for bleaching colourschemes by conservation
+   */
+  public int getIncrement()
+  {
+    return increment;
+  }
+
+  boolean conservationColourSelected = false;
+
+  /**
+   * GUI state
+   *
+   * @return true if conservation based shading is enabled
+   */
+  public boolean getConservationSelected()
+  {
+    return conservationColourSelected;
+  }
+
+  /**
+   * GUI state
+   *
+   * @param b
+   *          enable conservation based shading
+   */
+  public void setConservationSelected(boolean b)
+  {
+    conservationColourSelected = b;
+  }
+
+  @Override
   public void setGlobalColourScheme(ColourSchemeI cs)
   {
+    // TODO: logic refactored from AlignFrame changeColour -
+    // autorecalc stuff should be changed to rely on the worker system
+    // check to see if we should implement a changeColour(cs) method rather than
+    // put th logic in here
+    // - means that caller decides if they want to just modify state and defer
+    // calculation till later or to do all calculations in thread.
+    // via changecolour
     globalColourScheme = cs;
+    if (getColourAppliesToAllGroups())
+    {
+      for (SequenceGroup sg : getAlignment().getGroups())
+      {
+        if (cs == null)
+        {
+          sg.cs = null;
+          continue;
+        }
+        if (cs instanceof ClustalxColourScheme)
+        {
+          sg.cs = new ClustalxColourScheme(sg, getHiddenRepSequences());
+        }
+        else
+        {
+          try
+          {
+            sg.cs = cs.getClass().newInstance();
+          } catch (Exception ex)
+          {
+            ex.printStackTrace();
+            sg.cs = cs;
+          }
+        }
+
+        if (getAbovePIDThreshold() || cs instanceof PIDColourScheme
+                || cs instanceof Blosum62ColourScheme)
+        {
+          sg.cs.setThreshold(threshold, getIgnoreGapsConsensus());
+          sg.cs.setConsensus(AAFrequency.calculate(
+                  sg.getSequences(getHiddenRepSequences()), 0,
+                  sg.getWidth()));
+        }
+        else
+        {
+          sg.cs.setThreshold(0, getIgnoreGapsConsensus());
+        }
+
+        if (getConservationSelected())
+        {
+          Conservation c = new Conservation("Group",
+                  ResidueProperties.propHash, 3,
+                  sg.getSequences(getHiddenRepSequences()), 0,
+                  getAlignment().getWidth() - 1);
+          c.calculate();
+          c.verdict(false, getConsPercGaps());
+          sg.cs.setConservation(c);
+        }
+        else
+        {
+          sg.cs.setConservation(null);
+          sg.cs.setThreshold(0, getIgnoreGapsConsensus());
+        }
+
+      }
+    }
+
   }
 
+  @Override
   public ColourSchemeI getGlobalColourScheme()
   {
     return globalColourScheme;
   }
 
-
   protected AlignmentAnnotation consensus;
 
   protected AlignmentAnnotation strucConsensus;
@@ -97,31 +285,34 @@ public abstract class AlignmentViewport implements AlignViewportI
 
   protected AlignmentAnnotation[] groupConservation;
 
-  /** 
-   * results of alignment consensus analysis for visible portion of view 
+  /**
+   * results of alignment consensus analysis for visible portion of view
    */
-  protected Hashtable[] hconsensus=null;
+  protected Hashtable[] hconsensus = null;
 
   /**
-   * results of secondary structure base pair consensus for visible portion of view
+   * results of secondary structure base pair consensus for visible portion of
+   * view
    */
-  protected Hashtable[] hStrucConsensus=null;
+  protected Hashtable[] hStrucConsensus = null;
 
   /**
-   * percentage gaps allowed in a column before all amino acid properties should be considered unconserved
+   * percentage gaps allowed in a column before all amino acid properties should
+   * be considered unconserved
    */
   int ConsPercGaps = 25; // JBPNote : This should be a scalable property!
 
-
+  @Override
   public int getConsPercGaps()
   {
     return ConsPercGaps;
   }
+
   @Override
   public void setSequenceConsensusHash(Hashtable[] hconsensus)
   {
-    this.hconsensus=hconsensus;
-    
+    this.hconsensus = hconsensus;
+
   }
 
   @Override
@@ -135,12 +326,14 @@ public abstract class AlignmentViewport implements AlignViewportI
   {
     return hStrucConsensus;
   }
+
   @Override
   public void setRnaStructureConsensusHash(Hashtable[] hStrucConsensus)
   {
-    this.hStrucConsensus=hStrucConsensus;
-    
+    this.hStrucConsensus = hStrucConsensus;
+
   }
+
   @Override
   public AlignmentAnnotation getAlignmentQualityAnnot()
   {
@@ -152,25 +345,20 @@ public abstract class AlignmentViewport implements AlignViewportI
   {
     return conservation;
   }
+
   @Override
   public AlignmentAnnotation getAlignmentConsensusAnnotation()
   {
     return consensus;
   }
+
   @Override
   public AlignmentAnnotation getAlignmentStrucConsensusAnnotation()
   {
     return strucConsensus;
   }
-  
-  protected AlignCalcManagerI calculator=new AlignCalcManager();
-
-  jalview.workers.ConsensusThread consensusThread;
-
-  StrucConsensusThread strucConsensusThread;
 
-
-  private ConservationThread conservationThread;
+  protected AlignCalcManagerI calculator = new AlignCalcManager();
 
   /**
    * trigger update of conservation annotation
@@ -183,8 +371,12 @@ public abstract class AlignmentViewport implements AlignViewportI
     {
       return;
     }
-    
-    calculator.startWorker(conservationThread=new jalview.workers.ConservationThread(this, ap));
+    if (calculator
+            .getRegisteredWorkersOfClass(jalview.workers.ConservationThread.class)==null)
+    {
+      calculator.registerWorker(new jalview.workers.ConservationThread(
+              this, ap));
+    }
   }
 
   /**
@@ -197,15 +389,19 @@ public abstract class AlignmentViewport implements AlignViewportI
     {
       return;
     }
-    calculator.startWorker(consensusThread = new ConsensusThread(this, ap));
+    if (calculator.getRegisteredWorkersOfClass(ConsensusThread.class)==null)
+    {
+      calculator.registerWorker(new ConsensusThread(this, ap));
+    }
   }
 
   // --------START Structure Conservation
   public void updateStrucConsensus(final AlignmentViewPanel ap)
   {
-    if (autoCalculateStrucConsensus && strucConsensus==null && alignment.isNucleotide() && alignment.hasRNAStructure())
+    if (autoCalculateStrucConsensus && strucConsensus == null
+            && alignment.isNucleotide() && alignment.hasRNAStructure())
     {
-      
+
     }
 
     // see note in mantis : issue number 8585
@@ -213,7 +409,11 @@ public abstract class AlignmentViewport implements AlignViewportI
     {
       return;
     }
-    calculator.startWorker(strucConsensusThread = new StrucConsensusThread(this,ap));
+    if (calculator
+            .getRegisteredWorkersOfClass(StrucConsensusThread.class)==null)
+    {
+      calculator.registerWorker(new StrucConsensusThread(this, ap));
+    }
   }
 
   public boolean isCalcInProgress()
@@ -221,25 +421,26 @@ public abstract class AlignmentViewport implements AlignViewportI
     return calculator.isWorking();
   }
 
+  @Override
   public boolean isCalculationInProgress(
           AlignmentAnnotation alignmentAnnotation)
   {
     if (!alignmentAnnotation.autoCalculated)
       return false;
-    if ((calculator.isWorking(consensusThread) && consensus==alignmentAnnotation)
-            || (calculator.isWorking(conservationThread) &&  (conservation==alignmentAnnotation || quality==alignmentAnnotation))
-            || (calculator.isWorking(strucConsensusThread) && strucConsensus==alignmentAnnotation)
-            )
+    if (calculator.workingInvolvedWith(alignmentAnnotation))
     {
+      // System.err.println("grey out ("+alignmentAnnotation.label+")");
       return true;
     }
     return false;
   }
+
   @Override
   public boolean isClosed()
   {
-    // TODO: check that this isClosed is only true after panel is closed, not before it is fully constructed.
-    return alignment==null;
+    // TODO: check that this isClosed is only true after panel is closed, not
+    // before it is fully constructed.
+    return alignment == null;
   }
 
   @Override
@@ -262,10 +463,12 @@ public abstract class AlignmentViewport implements AlignViewportI
    * should consensus profile be rendered by default
    */
   protected boolean showSequenceLogo = false;
+
   /**
    * should consensus profile be rendered normalised to row height
    */
   protected boolean normaliseSequenceLogo = false;
+
   /**
    * should consensus histograms be rendered by default
    */
@@ -274,6 +477,7 @@ public abstract class AlignmentViewport implements AlignViewportI
   /**
    * @return the showConsensusProfile
    */
+  @Override
   public boolean isShowSequenceLogo()
   {
     return showSequenceLogo;
@@ -290,14 +494,8 @@ public abstract class AlignmentViewport implements AlignViewportI
       // TODO: decouple settings setting from calculation when refactoring
       // annotation update method from alignframe to viewport
       this.showSequenceLogo = showSequenceLogo;
-      if (consensusThread != null)
-      {
-        consensusThread.updateAnnotation();
-      }
-      if (strucConsensusThread != null)
-      {
-        strucConsensusThread.updateAnnotation();
-      }
+      calculator.updateAnnotationFor(ConsensusThread.class);
+      calculator.updateAnnotationFor(StrucConsensusThread.class);
     }
     this.showSequenceLogo = showSequenceLogo;
   }
@@ -346,10 +544,11 @@ public abstract class AlignmentViewport implements AlignViewportI
   }
 
   /**
-   * 
+   *
    * @return flag to indicate if the consensus histogram should be rendered by
    *         default
    */
+  @Override
   public boolean isShowConsensusHistogram()
   {
     return this.showConsensusHistogram;
@@ -360,7 +559,6 @@ public abstract class AlignmentViewport implements AlignViewportI
    */
   protected boolean showUnconserved = false;
 
-
   /**
    * when set, updateAlignment will always ensure sequences are of equal length
    */
@@ -391,8 +589,8 @@ public abstract class AlignmentViewport implements AlignViewportI
   }
 
   /**
-   * 
-   * 
+   *
+   *
    * @return null or the currently selected sequence region
    */
   public SequenceGroup getSelectionGroup()
@@ -402,10 +600,10 @@ public abstract class AlignmentViewport implements AlignViewportI
 
   /**
    * Set the selection group for this window.
-   * 
+   *
    * @param sg
    *          - group holding references to sequences in this alignment view
-   * 
+   *
    */
   public void setSelectionGroup(SequenceGroup sg)
   {
@@ -421,32 +619,45 @@ public abstract class AlignmentViewport implements AlignViewportI
     }
   }
 
+  @Override
   public ColumnSelection getColumnSelection()
   {
     return colSel;
   }
+
   public void setColumnSelection(ColumnSelection colSel)
   {
-    this.colSel=colSel;
+    this.colSel = colSel;
   }
-  public Hashtable getHiddenRepSequences()
+
+  /**
+   *
+   * @return
+   */
+  @Override
+  public Map<SequenceI, SequenceCollectionI> getHiddenRepSequences()
   {
     return hiddenRepSequences;
   }
-  public void setHiddenRepSequences(Hashtable hiddenRepSequences)
+
+  @Override
+  public void setHiddenRepSequences(
+          Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
   {
     this.hiddenRepSequences = hiddenRepSequences;
   }
+
   protected boolean hasHiddenColumns = false;
 
   public void updateHiddenColumns()
   {
-    hasHiddenColumns = colSel.getHiddenColumns() != null;  
+    hasHiddenColumns = colSel.getHiddenColumns() != null;
   }
-  
+
   protected boolean hasHiddenRows = false;
-  
-  public boolean hasHiddenRows() {
+
+  public boolean hasHiddenRows()
+  {
     return hasHiddenRows;
   }
 
@@ -454,12 +665,14 @@ public abstract class AlignmentViewport implements AlignViewportI
 
   public void setSequenceSetId(String newid)
   {
-    if (sequenceSetID!=null)
+    if (sequenceSetID != null)
     {
-      System.err.println("Warning - overwriting a sequenceSetId for a viewport!");
+      System.err
+              .println("Warning - overwriting a sequenceSetId for a viewport!");
     }
-    sequenceSetID=new String(newid);
+    sequenceSetID = new String(newid);
   }
+
   public String getSequenceSetId()
   {
     if (sequenceSetID == null)
@@ -469,9 +682,10 @@ public abstract class AlignmentViewport implements AlignViewportI
 
     return sequenceSetID;
   }
+
   /**
    * unique viewId for synchronizing state (e.g. with stored Jalview Project)
-   * 
+   *
    */
   protected String viewId = null;
 
@@ -483,26 +697,31 @@ public abstract class AlignmentViewport implements AlignViewportI
     }
     return viewId;
   }
+
   public void setIgnoreGapsConsensus(boolean b, AlignmentViewPanel ap)
   {
     ignoreGapsInConsensusCalculation = b;
-    if (ap!=null) {updateConsensus(ap);
-    if (globalColourScheme != null)
+    if (ap != null)
     {
-      globalColourScheme.setThreshold(globalColourScheme.getThreshold(),
-              ignoreGapsInConsensusCalculation);
-    }}
-    
+      updateConsensus(ap);
+      if (globalColourScheme != null)
+      {
+        globalColourScheme.setThreshold(globalColourScheme.getThreshold(),
+                ignoreGapsInConsensusCalculation);
+      }
+    }
+
   }
+
   private long sgrouphash = -1, colselhash = -1;
 
   /**
    * checks current SelectionGroup against record of last hash value, and
    * updates record.
-   * 
+   *
    * @param b
    *          update the record of last hash value
-   * 
+   *
    * @return true if SelectionGroup changed since last call (when b is true)
    */
   public boolean isSelectionGroupChanged(boolean b)
@@ -523,7 +742,7 @@ public abstract class AlignmentViewport implements AlignViewportI
   /**
    * checks current colsel against record of last hash value, and optionally
    * updates record.
-   * 
+   *
    * @param b
    *          update the record of last hash value
    * @return true if colsel changed since last call (when b is true)
@@ -543,15 +762,16 @@ public abstract class AlignmentViewport implements AlignViewportI
     return false;
   }
 
+  @Override
   public boolean getIgnoreGapsConsensus()
   {
     return ignoreGapsInConsensusCalculation;
   }
 
-  /// property change stuff
+  // / property change stuff
 
   // JBPNote Prolly only need this in the applet version.
-  private java.beans.PropertyChangeSupport changeSupport = new java.beans.PropertyChangeSupport(
+  private final java.beans.PropertyChangeSupport changeSupport = new java.beans.PropertyChangeSupport(
           this);
 
   protected boolean showConservation = true;
@@ -560,10 +780,9 @@ public abstract class AlignmentViewport implements AlignViewportI
 
   protected boolean showConsensus = true;
 
-
   /**
    * Property change listener for changes in alignment
-   * 
+   *
    * @param listener
    *          DOCUMENT ME!
    */
@@ -575,7 +794,7 @@ public abstract class AlignmentViewport implements AlignViewportI
 
   /**
    * DOCUMENT ME!
-   * 
+   *
    * @param listener
    *          DOCUMENT ME!
    */
@@ -587,7 +806,7 @@ public abstract class AlignmentViewport implements AlignViewportI
 
   /**
    * Property change listener for changes in alignment
-   * 
+   *
    * @param prop
    *          DOCUMENT ME!
    * @param oldvalue
@@ -602,7 +821,6 @@ public abstract class AlignmentViewport implements AlignViewportI
   }
 
   // common hide/show column stuff
-  
 
   public void hideSelectedColumns()
   {
@@ -646,7 +864,6 @@ public abstract class AlignmentViewport implements AlignViewportI
     hasHiddenColumns = false;
   }
 
-  
   // common hide/show seq stuff
   public void showAllHiddenSeqs()
   {
@@ -668,7 +885,8 @@ public abstract class AlignmentViewport implements AlignViewportI
       hiddenRepSequences = null;
 
       firePropertyChange("alignment", null, alignment.getSequences());
-      // used to set hasHiddenRows/hiddenRepSequences here, after the property changed event
+      // used to set hasHiddenRows/hiddenRepSequences here, after the property
+      // changed event
       sendSelection();
     }
   }
@@ -689,7 +907,8 @@ public abstract class AlignmentViewport implements AlignViewportI
       {
         selectionGroup.addSequence((SequenceI) tmp.elementAt(t), false);
       }
-      // JBPNote: refactor: only update flag if we modified visiblity (used to do this regardless) 
+      // JBPNote: refactor: only update flag if we modified visiblity (used to
+      // do this regardless)
       if (alignment.getHiddenSequences().getSize() < 1)
       {
         hasHiddenRows = false;
@@ -699,8 +918,6 @@ public abstract class AlignmentViewport implements AlignViewportI
     }
   }
 
-
-  
   public void hideAllSelectedSeqs()
   {
     if (selectionGroup == null || selectionGroup.getSize() < 1)
@@ -714,7 +931,6 @@ public abstract class AlignmentViewport implements AlignViewportI
 
     setSelectionGroup(null);
   }
-  
 
   public void hideSequence(SequenceI[] seq)
   {
@@ -759,7 +975,7 @@ public abstract class AlignmentViewport implements AlignViewportI
         seqs[index++] = sg.getSequenceAt(i);
       }
     }
-    sg.setSeqrep(repSequence); // note: not done in 2.7applet 
+    sg.setSeqrep(repSequence); // note: not done in 2.7applet
     sg.setHidereps(true); // note: not done in 2.7applet
     hideSequence(seqs);
 
@@ -768,11 +984,13 @@ public abstract class AlignmentViewport implements AlignViewportI
   public boolean isHiddenRepSequence(SequenceI seq)
   {
     return hiddenRepSequences != null
-          && hiddenRepSequences.containsKey(seq);
+            && hiddenRepSequences.containsKey(seq);
   }
+
   public SequenceGroup getRepresentedSequences(SequenceI seq)
   {
-    return (SequenceGroup) (hiddenRepSequences == null ? null : hiddenRepSequences.get(seq));
+    return (SequenceGroup) (hiddenRepSequences == null ? null
+            : hiddenRepSequences.get(seq));
   }
 
   public int adjustForHiddenSeqs(int alignmentIndex)
@@ -786,19 +1004,17 @@ public abstract class AlignmentViewport implements AlignViewportI
    * broadcast selection to any interested parties
    */
   public abstract void sendSelection();
-  
 
   public void invertColumnSelection()
   {
     colSel.invertColumnSelection(0, alignment.getWidth());
   }
 
-
   /**
    * 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
@@ -806,8 +1022,11 @@ public abstract class AlignmentViewport implements AlignViewportI
   public SequenceI[] getSelectionAsNewSequence()
   {
     SequenceI[] sequences;
-    // JBPNote: Need to test jalviewLite.getSelectedSequencesAsAlignmentFrom - this was the only caller in the applet for this method
-    // JBPNote: in applet, this method returned references to the alignment sequences, and it did not honour the presence/absence of annotation attached to the alignment (probably!)
+    // JBPNote: Need to test jalviewLite.getSelectedSequencesAsAlignmentFrom -
+    // this was the only caller in the applet for this method
+    // JBPNote: in applet, this method returned references to the alignment
+    // sequences, and it did not honour the presence/absence of annotation
+    // attached to the alignment (probably!)
     if (selectionGroup == null)
     {
       sequences = alignment.getSequencesArray();
@@ -828,11 +1047,10 @@ public abstract class AlignmentViewport implements AlignViewportI
     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()
@@ -849,13 +1067,12 @@ public abstract class AlignmentViewport implements AlignViewportI
     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(
@@ -869,7 +1086,7 @@ public abstract class AlignmentViewport implements AlignViewportI
   /**
    * 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
@@ -883,7 +1100,7 @@ public abstract class AlignmentViewport implements AlignViewportI
   /**
    * 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
    * @param markGroups
@@ -899,13 +1116,12 @@ public abstract class AlignmentViewport implements AlignViewportI
             hasHiddenColumns, selectedOnly, markGroups);
   }
 
-
   /**
    * 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)
@@ -944,11 +1160,13 @@ public abstract class AlignmentViewport implements AlignViewportI
     return selection;
   }
 
-
   /**
    * return visible region boundaries within given column range
-   * @param min first column (inclusive, from 0)
-   * @param max last column (exclusive)
+   *
+   * @param min
+   *          first column (inclusive, from 0)
+   * @param max
+   *          last column (exclusive)
    * @return int[][] range of {start,end} visible positions
    */
   public int[][] getVisibleRegionBoundaries(int min, int max)
@@ -994,6 +1212,7 @@ public abstract class AlignmentViewport implements AlignViewportI
     return startEnd;
 
   }
+
   /**
    * @return the padGaps
    */
@@ -1001,15 +1220,20 @@ public abstract class AlignmentViewport implements AlignViewportI
   {
     return padGaps;
   }
+
   /**
-   * @param padGaps the padGaps to set
+   * @param padGaps
+   *          the padGaps to set
    */
   public void setPadGaps(boolean padGaps)
   {
     this.padGaps = padGaps;
   }
+
   /**
-   * apply any post-edit constraints and trigger any calculations needed after an edit has been performed on the alignment 
+   * apply any post-edit constraints and trigger any calculations needed after
+   * an edit has been performed on the alignment
+   *
    * @param ap
    */
   public void alignmentChanged(AlignmentViewPanel ap)
@@ -1033,12 +1257,11 @@ public abstract class AlignmentViewport implements AlignViewportI
 
     // Reset endRes of groups if beyond alignment width
     int alWidth = alignment.getWidth();
-    Vector groups = alignment.getGroups();
+    List<SequenceGroup> groups = alignment.getGroups();
     if (groups != null)
     {
-      for (int i = 0; i < groups.size(); i++)
+      for (SequenceGroup sg : groups)
       {
-        SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
         if (sg.getEndRes() > alWidth)
         {
           sg.setEndRes(alWidth - 1);
@@ -1052,11 +1275,10 @@ public abstract class AlignmentViewport implements AlignViewportI
     }
 
     resetAllColourSchemes();
-
+    calculator.restartWorkers();
     // alignment.adjustSequenceAnnotations();
   }
 
-  
   /**
    * reset scope and do calculations for all applied colourschemes on alignment
    */
@@ -1065,11 +1287,7 @@ public abstract class AlignmentViewport implements AlignViewportI
     ColourSchemeI cs = globalColourScheme;
     if (cs != null)
     {
-      if (cs instanceof ClustalxColourScheme)
-      {
-        ((ClustalxColourScheme) cs).resetClustalX(alignment.getSequences(),
-                alignment.getWidth());
-      }
+      cs.alignmentChanged(alignment, null);
 
       cs.setConsensus(hconsensus);
       if (cs.conservationApplied())
@@ -1080,14 +1298,11 @@ public abstract class AlignmentViewport implements AlignViewportI
       }
     }
 
-    int s, sSize = alignment.getGroups().size();
-    for (s = 0; s < sSize; s++)
+    for (SequenceGroup sg : alignment.getGroups())
     {
-      SequenceGroup sg = (SequenceGroup) alignment.getGroups().elementAt(s);
-      if (sg.cs != null && sg.cs instanceof ClustalxColourScheme)
+      if (sg.cs != null)
       {
-        ((ClustalxColourScheme) sg.cs).resetClustalX(sg
-                .getSequences(hiddenRepSequences), sg.getWidth());
+        sg.cs.alignmentChanged(sg, hiddenRepSequences);
       }
       sg.recalcConservation();
     }
@@ -1105,48 +1320,53 @@ public abstract class AlignmentViewport implements AlignViewportI
       {
         if (showConservation)
         {
-          if (conservation==null)
-        {
-        conservation = new AlignmentAnnotation("Conservation",
-                "Conservation of total alignment less than " + getConsPercGaps()
-                        + "% gaps", new Annotation[1], 0f, 11f,
-                AlignmentAnnotation.BAR_GRAPH);
-        conservation.hasText = true;
-        conservation.autoCalculated = true;
-          alignment.addAnnotation(conservation);
-        }
+          if (conservation == null)
+          {
+            conservation = new AlignmentAnnotation("Conservation",
+                    "Conservation of total alignment less than "
+                            + getConsPercGaps() + "% gaps",
+                    new Annotation[1], 0f, 11f,
+                    AlignmentAnnotation.BAR_GRAPH);
+            conservation.hasText = true;
+            conservation.autoCalculated = true;
+            alignment.addAnnotation(conservation);
+          }
         }
         if (showQuality)
         {
-          if (quality==null)
+          if (quality == null)
           {
-          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);
+            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);
+          }
         }
-        }
-      } else {
+      }
+      else
+      {
         if (alignment.hasRNAStructure())
         {
           strucConsensus = new AlignmentAnnotation("StrucConsensus", "PID",
-                  new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
+                  new Annotation[1], 0f, 100f,
+                  AlignmentAnnotation.BAR_GRAPH);
           strucConsensus.hasText = true;
           strucConsensus.autoCalculated = true;
         }
       }
-        
+
       consensus = new AlignmentAnnotation("Consensus", "PID",
               new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
       consensus.hasText = true;
       consensus.autoCalculated = true;
-  
+
       if (showConsensus)
       {
         alignment.addAnnotation(consensus);
-        if (strucConsensus!=null)
+        if (strucConsensus != null)
         {
           alignment.addAnnotation(strucConsensus);
         }