X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FAlignViewport.java;h=be7f8f4a9d67471d645f527146718ac03d8a25f1;hb=0452450533728e478ef8c893ea2cb3483c740fb3;hp=07a745336b2b9c14e3404e494847151655d96f2d;hpb=d69ea8f1997771890b44e4b332a7ca84fe6f0893;p=jalview.git

diff --git a/src/jalview/gui/AlignViewport.java b/src/jalview/gui/AlignViewport.java
index 07a7453..be7f8f4 100755
--- a/src/jalview/gui/AlignViewport.java
+++ b/src/jalview/gui/AlignViewport.java
@@ -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;
@@ -112,13 +109,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.
      *
@@ -155,14 +159,12 @@ 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);
 
       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 + "") ;
@@ -181,7 +183,6 @@ public class AlignViewport
 
        setFont(new Font(fontName, style, Integer.parseInt(fontSize)));
 
-
        alignment.setGapCharacter( Cache.getDefault("GAP_SYMBOL", "-").charAt(0) );
 
 
@@ -189,8 +190,45 @@ public class AlignViewport
         // as Blosum and Clustal require this to be done
         if(hconsensus==null && !isDataset)
         {
-          updateConservation();
-          updateConsensus();
+          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 (Cache.getDefault("SHOW_CONSERVATION", true))
+            {
+              alignment.addAnnotation(conservation);
+            }
+
+            if (Cache.getDefault("SHOW_QUALITY", true))
+            {
+              quality = new AlignmentAnnotation("Quality",
+                                                "Alignment Quality based on Blosum62 scores",
+                                                new Annotation[1],
+                                                0f,
+                                                11f,
+                                                AlignmentAnnotation.BAR_GRAPH);
+              quality.hasText = true;
+
+              alignment.addAnnotation(quality);
+            }
+          }
+
+          consensus = new AlignmentAnnotation("Consensus", "PID",
+                                               new Annotation[1], 0f, 100f,
+                                               AlignmentAnnotation.BAR_GRAPH);
+          consensus.hasText = true;
+
+           if (Cache.getDefault("SHOW_IDENTITY", true))
+           {
+             alignment.addAnnotation(consensus);
+           }
         }
 
         if (jalview.bin.Cache.getProperty("DEFAULT_COLOUR") != null)
@@ -209,6 +247,8 @@ public class AlignViewport
                 globalColourScheme.setConsensus(hconsensus);
             }
         }
+
+        wrapAlignment = jalview.bin.Cache.getDefault("WRAP_ALIGNMENT", false);
     }
 
 
@@ -228,216 +268,301 @@ public class AlignViewport
       return showSequenceFeatures;
     }
 
-    /**
-     * DOCUMENT ME!
-     */
-    public void updateConservation()
-    {
-      if(alignment.isNucleotide())
-          return;
 
-     // System.out.println("UPDATING CONSERVATION");
 
-      try{
-        Conservation cons = new jalview.analysis.Conservation("All",
-            jalview.schemes.ResidueProperties.propHash, 3,
-            alignment.getSequences(), 0, alignment.getWidth() - 1);
-        cons.calculate();
-        cons.verdict(false, ConsPercGaps);
-        cons.findQuality();
+    class ConservationThread extends Thread
+    {
+      AlignmentPanel ap;
+      public ConservationThread(AlignmentPanel ap)
+      {
+        this.ap = ap;
+      }
 
-        int alWidth = alignment.getWidth();
-        Annotation[] annotations = new Annotation[alWidth];
-        Annotation[] qannotations = new Annotation[alWidth];
-        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 = cons.qualityRange[0].floatValue();
-        float qmax = cons.qualityRange[1].floatValue();
-
-        for (int i = 0; i < alWidth; i++)
+      public void run()
+      {
+        try
         {
-          float value = 0;
+          updatingConservation = true;
 
-          try
-          {
-            value = Integer.parseInt(sequence.charAt(i) + "");
-          }
-          catch (Exception ex)
+          while (UPDATING_CONSERVATION)
           {
-            if (sequence.charAt(i) == '*')
+            try
             {
-              value = 11;
+              if (ap != null)
+              {
+                ap.repaint();
+              }
+              Thread.sleep(200);
             }
-
-            if (sequence.charAt(i) == '+')
+            catch (Exception ex)
             {
-              value = 10;
+              ex.printStackTrace();
             }
           }
 
-          float vprop = value - min;
-          vprop /= max;
-          annotations[i] = new Annotation(sequence.charAt(i) + "",
-                                          String.valueOf(value), ' ', value,
-                                          new Color(minR + (maxR * vprop),
-              minG + (maxG * vprop),
-              minB + (maxB * vprop)));
-
-          // Quality calc
-          value = ( (Double) cons.quality.get(i)).floatValue();
-          vprop = value - qmin;
-          vprop /= qmax;
-          qannotations[i] = new Annotation(" ", String.valueOf(value), ' ',
-                                           value,
-                                           new Color(minR + (maxR * vprop),
-              minG + (maxG * vprop),
-              minB + (maxB * vprop)));
-        }
+          UPDATING_CONSERVATION = true;
 
-        if (conservation == null)
-        {
-          conservation = new AlignmentAnnotation("Conservation",
-                                                 "Conservation of total alignment less than " +
-                                                 ConsPercGaps + "% gaps",
-                                                 annotations, 0f, // cons.qualityRange[0].floatValue(),
-                                                 11f, // cons.qualityRange[1].floatValue()
-                                                 AlignmentAnnotation.BAR_GRAPH);
-
-          if (showConservation)
+
+          int alWidth = alignment.getWidth();
+          if(alWidth<0)
+            return;
+
+          Conservation cons = new jalview.analysis.Conservation("All",
+              jalview.schemes.ResidueProperties.propHash, 3,
+              alignment.getSequences(), 0, alWidth -1);
+
+          cons.calculate();
+          cons.verdict(false, ConsPercGaps);
+
+          if (quality!=null)
           {
-            alignment.addAnnotation(conservation);
+            cons.findQuality();
           }
 
-          quality = new AlignmentAnnotation("Quality",
-                                            "Alignment Quality based on Blosum62 scores",
-                                            qannotations,
-                                            cons.qualityRange[0].floatValue(),
-                                            cons.qualityRange[1].floatValue(),
-                                            AlignmentAnnotation.BAR_GRAPH);
+          char [] sequence = cons.getConsSequence().getSequence();
+          float minR;
+          float minG;
+          float minB;
+          float maxR;
+          float maxG;
+          float maxB;
+          minR = 0.3f;
+          minG = 0.0f;
+          minB = 0f;
+          maxR = 1.0f - minR;
+          maxG = 0.9f - minG;
+          maxB = 0f - minB; // scalable range for colouring both Conservation and Quality
+
+          float min = 0f;
+          float max = 11f;
+          float qmin = 0f;
+          float qmax = 0f;
+
+          char c;
+
+          conservation.annotations = new Annotation[alWidth];
+
+          if (quality!=null)
+          {
+            quality.graphMax = cons.qualityRange[1].floatValue();
+            quality.annotations = new Annotation[alWidth];
+            qmin = cons.qualityRange[0].floatValue();
+            qmax = cons.qualityRange[1].floatValue();
+          }
 
-          if (showQuality)
+          for (int i = 0; i < alWidth; i++)
           {
-            alignment.addAnnotation(quality);
+            float value = 0;
+
+            c = sequence[i];
+
+            if (Character.isDigit(c))
+              value = (int) (c - '0');
+            else if (c == '*')
+              value = 11;
+            else if (c == '+')
+              value = 10;
+
+            float vprop = value - min;
+            vprop /= max;
+            conservation.annotations[i] =
+                new Annotation(String.valueOf(c),
+                               String.valueOf(value), ' ', value,
+                               new Color(minR + (maxR * vprop),
+                                         minG + (maxG * vprop),
+                                         minB + (maxB * vprop)));
+
+            // Quality calc
+            if (quality!=null)
+            {
+              value = ( (Double) cons.quality.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)));
+            }
           }
         }
-        else
-        {
-          conservation.annotations = annotations;
-          quality.annotations = qannotations;
-          quality.graphMax = cons.qualityRange[1].floatValue();
-        }
-      }
-      catch (OutOfMemoryError error)
-      {
-        javax.swing.SwingUtilities.invokeLater(new Runnable()
+        catch (OutOfMemoryError error)
         {
-          public void run()
+          javax.swing.SwingUtilities.invokeLater(new Runnable()
           {
-            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();
+
+            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);
+            }
+          });
+
+          conservation = null;
+          quality = null;
+
+          System.out.println("Conservation calculation: " + error);
+          System.gc();
+
+        }
+
+        UPDATING_CONSERVATION = false;
+        updatingConservation = false;
+
+        if(ap!=null)
+        {
+          ap.repaint();
+        }
 
       }
     }
 
 
+    ConservationThread conservationThread;
+
+    ConsensusThread consensusThread;
+
+    boolean consUpdateNeeded = false;
+
+    static boolean UPDATING_CONSENSUS = false;
+
+    static boolean UPDATING_CONSERVATION = false;
+
+    boolean updatingConsensus = false;
+
+    boolean updatingConservation = false;
+
     /**
      * DOCUMENT ME!
      */
-    public void updateConsensus()
+    public void updateConservation(final AlignmentPanel ap)
     {
-      try{
-        int aWidth = alignment.getWidth();
+      if (alignment.isNucleotide() || conservation==null)
+        return;
 
-        Annotation[] annotations = new Annotation[aWidth];
+      conservationThread = new ConservationThread(ap);
+      conservationThread.start();
+    }
+
+    /**
+     * DOCUMENT ME!
+     */
+    public void updateConsensus(final AlignmentPanel ap)
+    {
+      consensusThread = new ConsensusThread(ap);
+      consensusThread.start();
+    }
 
-        hconsensus = new Hashtable[aWidth];
-        AAFrequency.calculate(alignment.getSequencesArray(),
-                              0,
-                              alignment.getWidth(),
-                              hconsensus);
 
-        for (int  i = 0; i < aWidth; i++)
+    class ConsensusThread extends Thread
+    {
+      AlignmentPanel ap;
+      public ConsensusThread(AlignmentPanel ap)
+      {
+        this.ap = ap;
+      }
+      public void run()
+      {
+        updatingConsensus = true;
+        while (UPDATING_CONSENSUS)
         {
-          float value = 0;
-          if (ignoreGapsInConsensusCalculation)
-            value = ( (Float) hconsensus[i].get("pid_nogaps")).floatValue();
-          else
-            value = ( (Float) hconsensus[i].get("pid_gaps")).floatValue();
-
-          String maxRes = hconsensus[i].get("maxResidue").toString();
-          String mouseOver = hconsensus[i].get("maxResidue") + " ";
+          try
+          {
+            if (ap != null)
+            {
+              ap.repaint();
+            }
 
-          if (maxRes.length() > 1)
+            Thread.sleep(200);
+          }
+          catch (Exception ex)
           {
-            mouseOver = "[" + maxRes + "] ";
-            maxRes = "+";
+            ex.printStackTrace();
           }
-
-          mouseOver += ( (int) value + "%");
-          annotations[i] = new Annotation(maxRes, mouseOver, ' ', value);
         }
 
-        if (consensus == null)
+
+        UPDATING_CONSENSUS = true;
+
+        try
         {
-          consensus = new AlignmentAnnotation("Consensus", "PID",
-                                              annotations, 0f, 100f,AlignmentAnnotation.BAR_GRAPH);
+          int aWidth = alignment.getWidth();
+          if(aWidth<0)
+            return;
+
+          consensus.annotations = null;
+          consensus.annotations = new Annotation[aWidth];
 
-          if (showIdentity)
+
+          hconsensus = new Hashtable[aWidth];
+          AAFrequency.calculate(alignment.getSequencesArray(),
+                                0,
+                                alignment.getWidth(),
+                                hconsensus);
+
+          for (int i = 0; i < aWidth; i++)
           {
-            alignment.addAnnotation(consensus);
+            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);
           }
-        }
-        else
-        {
-          consensus.annotations = annotations;
-        }
 
-        if (globalColourScheme != null)
-          globalColourScheme.setConsensus(hconsensus);
 
-      }catch(OutOfMemoryError error)
-      {
-        javax.swing.SwingUtilities.invokeLater(new Runnable()
+          if (globalColourScheme != null)
+            globalColourScheme.setConsensus(hconsensus);
+
+        }
+        catch (OutOfMemoryError error)
         {
-          public void run()
+          alignment.deleteAnnotation(consensus);
+
+          consensus = null;
+          hconsensus = null;
+          javax.swing.SwingUtilities.invokeLater(new Runnable()
           {
-            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);
-          }
-        });
+            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();
+        }
+        UPDATING_CONSENSUS = false;
+        updatingConsensus = false;
 
-        System.out.println("Consensus calculation: " + error);
-        System.gc();
+        if (ap != null)
+        {
+          ap.repaint();
+        }
       }
-
     }
     /**
      * get the consensus sequence as displayed under the PID consensus annotation row.
@@ -445,7 +570,7 @@ public class AlignViewport
      */
     public SequenceI getConsensusSeq() {
       if (consensus==null)
-        updateConsensus();
+        updateConsensus(null);
       if (consensus==null)
         return null;
       StringBuffer seqs=new StringBuffer();
@@ -457,6 +582,7 @@ public class AlignViewport
             seqs.append(consensus.annotations[i].displayCharacter);
         }
       }
+
       SequenceI sq = new Sequence("Consensus", seqs.toString());
       sq.setDescription("Percentage Identity Consensus "+((ignoreGapsInConsensusCalculation) ? " without gaps" : ""));
       return sq;
@@ -1090,10 +1216,10 @@ public class AlignViewport
         changeSupport.firePropertyChange(prop, oldvalue, newvalue);
     }
 
-    public void setIgnoreGapsConsensus(boolean b)
+    public void setIgnoreGapsConsensus(boolean b, AlignmentPanel ap)
     {
       ignoreGapsInConsensusCalculation = b;
-      updateConsensus();
+      updateConsensus(ap);
       if(globalColourScheme!=null)
       {
         globalColourScheme.setThreshold(globalColourScheme.getThreshold(), ignoreGapsInConsensusCalculation);
@@ -1138,6 +1264,33 @@ public class AlignViewport
       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)
@@ -1155,8 +1308,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());
       }
@@ -1164,7 +1318,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)
@@ -1208,7 +1363,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(
@@ -1217,23 +1372,26 @@ 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);
+        if(colSel.contains(i))
+          colSel.removeElement(i);
         else
-          colSel.addElement(column);
-
+        {
+          if (!hasHiddenColumns || colSel.isVisible(i))
+          {
+            colSel.addElement(i);
+          }
+        }
       }
-
     }
 
     public int adjustForHiddenSeqs(int alignmentIndex)
@@ -1274,7 +1432,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
@@ -1347,8 +1505,10 @@ public class AlignViewport
       // 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);
+      if (aligview!=null) {
+        return new AlignmentView(aligview,
+            (selectedOnly && selectionGroup!=null) ? selectionGroup.getStartRes() : 0);
+      }
       return null;
     }
     /**
@@ -1367,7 +1527,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;
@@ -1385,7 +1545,7 @@ public class AlignViewport
       } else {
         for(i=0; i<iSize; i++)
         {
-          selection[i] = seqs[i].getSequence(start, end);
+          selection[i] = seqs[i].getSequenceAsString(start, end);
         }
 
       }
@@ -1410,4 +1570,98 @@ public class AlignViewport
       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);
+    }
+
+
 }