X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=inline;f=src%2Fjalview%2Fappletgui%2FTreeCanvas.java;h=a6bc5dfb936ca339d322d599e7682bed78a0b490;hb=95a46891288f4fc63d690cab4f56879678f54fb6;hp=be3781358f45f61b53e92771ed1b1072c667f3c9;hpb=99c58ee0ae2a848f982552e53feaf6d5cb9925e5;p=jalview.git

diff --git a/src/jalview/appletgui/TreeCanvas.java b/src/jalview/appletgui/TreeCanvas.java
index be37813..a6bc5df 100755
--- a/src/jalview/appletgui/TreeCanvas.java
+++ b/src/jalview/appletgui/TreeCanvas.java
@@ -1,42 +1,43 @@
 /*
-* Jalview - A Sequence Alignment Editor and Viewer
-* Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
-*
-* This program is free software; you can redistribute it and/or
-* modify it under the terms of the GNU General Public License
-* as published by the Free Software Foundation; either version 2
-* of the License, or (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program; if not, write to the Free Software
-* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
-*/
+ * Jalview - A Sequence Alignment Editor and Viewer
+ * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
 
 package jalview.appletgui;
 
+import java.util.*;
 
-import jalview.analysis.*;
-import jalview.datamodel.*;
-import jalview.util.*;
-import jalview.schemes.*;
 import java.awt.*;
 import java.awt.event.*;
-import java.util.*;
 
+import jalview.analysis.*;
+import jalview.datamodel.*;
+import jalview.schemes.*;
+import jalview.util.*;
 
-public class TreeCanvas extends Panel implements MouseListener
+public class TreeCanvas
+    extends Panel implements MouseListener
 {
   NJTree tree;
   ScrollPane scrollPane;
   AlignViewport av;
-  public static final String PLACEHOLDER=" * ";
+  public static final String PLACEHOLDER = " * ";
   Font font;
-  int  fontSize = 12;
+  int fontSize = 12;
 
   boolean fitToWindow = true;
   boolean showDistances = false;
@@ -49,406 +50,488 @@ public class TreeCanvas extends Panel implements MouseListener
   float threshold;
 
   String longestName;
-  int labelLength=-1;
+  int labelLength = -1;
 
   //RubberbandRectangle rubberband;
 
-  Vector    listeners;
+  Vector listeners;
 
   Hashtable nameHash = new Hashtable();
   Hashtable nodeHash = new Hashtable();
 
-  public TreeCanvas(AlignViewport av, NJTree tree, ScrollPane scroller, String label)
+  public TreeCanvas(AlignViewport av, NJTree tree, ScrollPane scroller,
+                    String label)
   {
     this.av = av;
-    this.tree     = tree;
+    this.tree = tree;
     scrollPane = scroller;
     addMouseListener(this);
     tree.findHeight(tree.getTopNode());
     longestName = label;
     setLayout(null);
 
-    PaintRefresher.Register(this);
+    PaintRefresher.Register(this, av.alignment);
   }
+
   public void TreeSelectionChanged(Sequence sequence)
- {
+  {
     SequenceGroup selected = av.getSelectionGroup();
-    if(selected == null)
+    if (selected == null)
     {
       selected = new SequenceGroup();
       av.setSelectionGroup(selected);
     }
 
     selected.setEndRes(av.alignment.getWidth());
-    selected.addOrRemove(sequence);
+    selected.addOrRemove(sequence, true);
 
-
-    PaintRefresher.Refresh(this);
+System.out.println("called here");
+    PaintRefresher.Refresh(this, av.alignment);
     repaint();
- }
-
-
+  }
 
-  public void setTree(NJTree tree) {
+  public void setTree(NJTree tree)
+  {
     this.tree = tree;
     tree.findHeight(tree.getTopNode());
   }
 
-    public void drawNode(Graphics g,SequenceNode node, float chunk, float scale, int width,int offx, int offy) {
-    if (node == null) {
+  public void drawNode(Graphics g, SequenceNode node, float chunk, float scale,
+                       int width, int offx, int offy)
+  {
+    if (node == null)
+    {
       return;
     }
 
-    if (node.left() == null && node.right() == null) {
+    if (node.left() == null && node.right() == null)
+    {
       // Drawing leaf node
 
       float height = node.height;
-      float dist   = node.dist;
+      float dist = node.dist;
 
-      int xstart = (int)((height-dist)*scale) + offx;
-      int xend =   (int)(height*scale)        + offx;
+      int xstart = (int) ( (height - dist) * scale) + offx;
+      int xend = (int) (height * scale) + offx;
 
-      int ypos = (int)(node.ycount * chunk) + offy;
+      int ypos = (int) (node.ycount * chunk) + offy;
 
       if (node.element() instanceof SequenceI)
       {
-       if ( ( (SequenceI) ( (SequenceNode) node).element()).getColor() == Color.white)
-       {
-         g.setColor(Color.black);
-       }
-       else
-        g.setColor( ( (SequenceI) ( (SequenceNode) node).element()).getColor().
-                   darker());
+        if ( ( (SequenceI) ( (SequenceNode) node).element()).getColor() ==
+            Color.white)
+        {
+          g.setColor(Color.black);
+        }
+        else
+        {
+          g.setColor( ( (SequenceI) ( (SequenceNode) node).element()).getColor().
+                     darker());
+        }
 
       }
       else
-          g.setColor(Color.black);
-
+      {
+        g.setColor(Color.black);
+      }
 
       // Draw horizontal line
-      g.drawLine(xstart,ypos,xend,ypos);
+      g.drawLine(xstart, ypos, xend, ypos);
 
       String nodeLabel = "";
-      if (showDistances && node.dist > 0) {
+      if (showDistances && node.dist > 0)
+      {
         nodeLabel = new Format("%5.2f").form(node.dist);
       }
-      if (showBootstrap) {
-        if (showDistances) {
+      if (showBootstrap)
+      {
+        if (showDistances)
+        {
           nodeLabel = nodeLabel + " : ";
         }
         nodeLabel = nodeLabel + String.valueOf(node.getBootstrap());
       }
-      if (! nodeLabel.equals("")) {
-      g.drawString(nodeLabel,xstart,ypos - 10);
+      if (!nodeLabel.equals(""))
+      {
+        g.drawString(nodeLabel, xstart, ypos - 10);
       }
 
-      String name    = (markPlaceholders && node.isPlaceholder()) ? (PLACEHOLDER+node.getName()) : node.getName();
+      String name = (markPlaceholders && node.isPlaceholder()) ?
+          (PLACEHOLDER + node.getName()) : node.getName();
       FontMetrics fm = g.getFontMetrics(font);
-      int charWidth  = fm.stringWidth(name) + 3;
+      int charWidth = fm.stringWidth(name) + 3;
       int charHeight = fm.getHeight();
 
-      Rectangle rect = new Rectangle(xend+20,ypos-charHeight,
-                                     charWidth,charHeight);
+      Rectangle rect = new Rectangle(xend + 20, ypos - charHeight,
+                                     charWidth, charHeight);
 
-      nameHash.put((SequenceI)node.element(),rect);
+      nameHash.put( (SequenceI) node.element(), rect);
 
       // Colour selected leaves differently
       SequenceGroup selected = av.getSelectionGroup();
-      if (selected!=null && selected.sequences.contains((SequenceI)node.element())) {
+      if (selected != null &&
+          selected.sequences.contains( (SequenceI) node.element()))
+      {
         g.setColor(Color.gray);
 
-        g.fillRect(xend + 10, ypos - charHeight + 3,charWidth,charHeight);
+        g.fillRect(xend + 10, ypos - charHeight + 3, charWidth, charHeight);
         g.setColor(Color.white);
       }
-      g.drawString(name,xend+10,ypos);
+      g.drawString(name, xend + 10, ypos);
       g.setColor(Color.black);
-    } else {
-      drawNode(g,(SequenceNode)node.left(), chunk,scale,width,offx,offy);
-      drawNode(g,(SequenceNode)node.right(),chunk,scale,width,offx,offy);
+    }
+    else
+    {
+      drawNode(g, (SequenceNode) node.left(), chunk, scale, width, offx, offy);
+      drawNode(g, (SequenceNode) node.right(), chunk, scale, width, offx, offy);
 
       float height = node.height;
-      float dist   = node.dist;
+      float dist = node.dist;
 
-      int xstart = (int)((height-dist)*scale) + offx;
-      int xend   = (int)(height       *scale) + offx;
-      int ypos   = (int)(node.ycount  *chunk) + offy;
+      int xstart = (int) ( (height - dist) * scale) + offx;
+      int xend = (int) (height * scale) + offx;
+      int ypos = (int) (node.ycount * chunk) + offy;
 
-      g.setColor(((SequenceNode)node).color.darker());
+      g.setColor( ( (SequenceNode) node).color.darker());
 
       // Draw horizontal line
-      g.drawLine(xstart,ypos,xend,ypos);
-      g.fillRect(xend-2, ypos-2, 4,4);
+      g.drawLine(xstart, ypos, xend, ypos);
+      g.fillRect(xend - 2, ypos - 2, 4, 4);
 
-      int ystart = (int)(((SequenceNode)node.left()) .ycount * chunk) + offy;
-      int yend   = (int)(((SequenceNode)node.right()).ycount * chunk) + offy;
+      int ystart = (int) ( ( (SequenceNode) node.left()).ycount * chunk) + offy;
+      int yend = (int) ( ( (SequenceNode) node.right()).ycount * chunk) + offy;
 
-      Rectangle pos = new Rectangle(xend-2,ypos-2,5,5);
-      nodeHash.put(node,pos);
+      Rectangle pos = new Rectangle(xend - 2, ypos - 2, 5, 5);
+      nodeHash.put(node, pos);
 
-      g.drawLine((int)(height*scale) + offx, ystart,
-                 (int)(height*scale) + offx, yend);
+      g.drawLine( (int) (height * scale) + offx, ystart,
+                 (int) (height * scale) + offx, yend);
 
-      if (showDistances && node.dist > 0) {
-        g.drawString(new Format("%5.2f").form(node.dist),xstart,ypos - 5);
+      if (showDistances && node.dist > 0)
+      {
+        g.drawString(new Format("%5.2f").form(node.dist), xstart, ypos - 5);
       }
 
     }
   }
-  public Object findElement(int x, int y) {
-       Enumeration keys = nameHash.keys();
 
-    while (keys.hasMoreElements()) {
-            Object ob = keys.nextElement();
-            Rectangle rect = (Rectangle)nameHash.get(ob);
+  public Object findElement(int x, int y)
+  {
+    Enumeration keys = nameHash.keys();
 
-            if (x >= rect.x && x <= (rect.x + rect.width) &&
-              y >= rect.y && y <= (rect.y + rect.height)) {
-              return ob;
-            }
-  }
-  keys = nodeHash.keys();
+    while (keys.hasMoreElements())
+    {
+      Object ob = keys.nextElement();
+      Rectangle rect = (Rectangle) nameHash.get(ob);
 
-    while (keys.hasMoreElements()) {
-            Object ob = keys.nextElement();
-            Rectangle rect = (Rectangle)nodeHash.get(ob);
+      if (x >= rect.x && x <= (rect.x + rect.width) &&
+          y >= rect.y && y <= (rect.y + rect.height))
+      {
+        return ob;
+      }
+    }
+    keys = nodeHash.keys();
+
+    while (keys.hasMoreElements())
+    {
+      Object ob = keys.nextElement();
+      Rectangle rect = (Rectangle) nodeHash.get(ob);
 
-            if (x >= rect.x && x <= (rect.x + rect.width) &&
-              y >= rect.y && y <= (rect.y + rect.height)) {
-              return ob;
-            }
+      if (x >= rect.x && x <= (rect.x + rect.width) &&
+          y >= rect.y && y <= (rect.y + rect.height))
+      {
+        return ob;
+      }
     }
-      return null;
+    return null;
 
   }
 
-  public void pickNodes(Rectangle pickBox) {
-    int width  = getSize().width;
+  public void pickNodes(Rectangle pickBox)
+  {
+    int width = getSize().width;
     int height = getSize().height;
 
     SequenceNode top = tree.getTopNode();
 
-    float wscale = (float)(width*.8-offx*2)/tree.getMaxHeight()
-;
-    if (top.count == 0) {
-      top.count = ((SequenceNode)top.left()).count + ((SequenceNode)top.right()).count ;
+    float wscale = (float) (width * .8 - offx * 2) / tree.getMaxHeight()
+        ;
+    if (top.count == 0)
+    {
+      top.count = ( (SequenceNode) top.left()).count +
+          ( (SequenceNode) top.right()).count;
     }
-    float chunk = (float)(height-offy*2)/top.count;
+    float chunk = (float) (height - offy * 2) / top.count;
 
-    pickNode(pickBox,top,chunk,wscale,width,offx,offy);
+    pickNode(pickBox, top, chunk, wscale, width, offx, offy);
   }
 
-  public void pickNode(Rectangle pickBox, SequenceNode node, float chunk, float scale, int width,int offx, int offy) {
-    if (node == null) {
+  public void pickNode(Rectangle pickBox, SequenceNode node, float chunk,
+                       float scale, int width, int offx, int offy)
+  {
+    if (node == null)
+    {
       return;
     }
 
-    if (node.left() == null && node.right() == null) {
+    if (node.left() == null && node.right() == null)
+    {
       float height = node.height;
-      float dist   = node.dist;
+      float dist = node.dist;
 
-      int xstart = (int)((height-dist)*scale) + offx;
-      int xend   = (int)(height*scale) + offx;
+      int xstart = (int) ( (height - dist) * scale) + offx;
+      int xend = (int) (height * scale) + offx;
 
-      int ypos = (int)(node.ycount * chunk) + offy;
+      int ypos = (int) (node.ycount * chunk) + offy;
 
-      if (pickBox.contains(new Point(xend,ypos))) {
-        if (node.element() instanceof SequenceI) {
-          SequenceI seq = (SequenceI)node.element();
+      if (pickBox.contains(new Point(xend, ypos)))
+      {
+        if (node.element() instanceof SequenceI)
+        {
+          SequenceI seq = (SequenceI) node.element();
           SequenceGroup sg = av.getSelectionGroup();
-          if(sg!=null)
-            sg.addOrRemove(seq);
+          if (sg != null)
+          {
+            sg.addOrRemove(seq, true);
+          }
         }
       }
-    } else {
-      pickNode(pickBox,(SequenceNode)node.left(), chunk,scale,width,offx,offy);
-      pickNode(pickBox,(SequenceNode)node.right(),chunk,scale,width,offx,offy);
+    }
+    else
+    {
+      pickNode(pickBox, (SequenceNode) node.left(), chunk, scale, width, offx,
+               offy);
+      pickNode(pickBox, (SequenceNode) node.right(), chunk, scale, width, offx,
+               offy);
     }
   }
 
   public void setColor(SequenceNode node, Color c)
   {
     if (node == null)
+    {
       return;
+    }
 
     if (node.left() == null && node.right() == null)
     {
       node.color = c;
 
       if (node.element() instanceof SequenceI)
-          ((SequenceI)node.element()).setColor(c);
-    } else
+      {
+        ( (SequenceI) node.element()).setColor(c);
+      }
+    }
+    else
     {
       node.color = c;
-      setColor((SequenceNode)node.left(),c);
-      setColor((SequenceNode)node.right(),c);
+      setColor( (SequenceNode) node.left(), c);
+      setColor( (SequenceNode) node.right(), c);
     }
   }
 
-
   public void paint(Graphics g)
   {
 
-    font = new Font("Verdana",Font.PLAIN,fontSize);
+    font = new Font("Verdana", Font.PLAIN, fontSize);
     g.setFont(font);
 
     FontMetrics fm = g.getFontMetrics(font);
 
-    if(nameHash.size()==0)
+    if (nameHash.size() == 0)
+    {
       repaint();
+    }
 
-
-    if( fitToWindow || (!fitToWindow && scrollPane.getSize().height > fm.getHeight() * nameHash.size()+offy ) )
-     {
-         draw(g,scrollPane.getSize().width,scrollPane.getSize().height);
-     }
+    if (fitToWindow ||
+        (!fitToWindow &&
+         scrollPane.getSize().height > fm.getHeight() * nameHash.size() + offy))
+    {
+      draw(g, scrollPane.getSize().width, scrollPane.getSize().height);
+    }
     else
-     {
-         setSize(new Dimension(scrollPane.getSize().width, fm.getHeight() * nameHash.size()));
-         draw( g,scrollPane.getSize().width, fm.getHeight() * nameHash.size());
-     }
+    {
+      setSize(new Dimension(scrollPane.getSize().width,
+                            fm.getHeight() * nameHash.size()));
+      draw(g, scrollPane.getSize().width, fm.getHeight() * nameHash.size());
+    }
 
     scrollPane.validate();
   }
-    public int getFontSize() {
-        return fontSize;
-    }
-    public void setFontSize(int fontSize) {
-        this.fontSize = fontSize;
-        repaint();
-    }
-  public void draw(Graphics g, int width, int height) {
 
-      g.setColor(Color.white);
-      g.fillRect(0,0,width,height);
+  public int getFontSize()
+  {
+    return fontSize;
+  }
 
+  public void setFontSize(int fontSize)
+  {
+    this.fontSize = fontSize;
+    repaint();
+  }
 
-      labelLength = g.getFontMetrics(font).stringWidth(longestName)+ 20;//20 allows for scrollbar
+  public void draw(Graphics g, int width, int height)
+  {
 
-      float wscale =(float)(width - labelLength -offx*2)/tree.getMaxHeight();
+    g.setColor(Color.white);
+    g.fillRect(0, 0, width, height);
 
-      SequenceNode top = tree.getTopNode();
+    labelLength = g.getFontMetrics(font).stringWidth(longestName) + 20; //20 allows for scrollbar
 
-      if (top.count == 0) {
-          top.count = ((SequenceNode)top.left()).count + ((SequenceNode)top.right()).count ;
-      }
-      float chunk = (float)(height-offy*2)/top.count ;
+    float wscale = (float) (width - labelLength - offx * 2) / tree.getMaxHeight();
 
-      drawNode(g,tree.getTopNode(),chunk,wscale,width,offx,offy);
+    SequenceNode top = tree.getTopNode();
 
-      if (threshold != 0)
-      {
-        if(av.getCurrentTree() == tree)
-          g.setColor(Color.red);
-        else
-          g.setColor(Color.gray);
+    if (top.count == 0)
+    {
+      top.count = ( (SequenceNode) top.left()).count +
+          ( (SequenceNode) top.right()).count;
+    }
+    float chunk = (float) (height - offy * 2) / top.count;
 
-          int x = (int)(    threshold * (float)(getSize().width-labelLength - 2*offx) +offx   ) ;
+    drawNode(g, tree.getTopNode(), chunk, wscale, width, offx, offy);
 
-          g.drawLine(x,0,x,getSize().height);
+    if (threshold != 0)
+    {
+      if (av.getCurrentTree() == tree)
+      {
+        g.setColor(Color.red);
       }
+      else
+      {
+        g.setColor(Color.gray);
+      }
+
+      int x = (int) (threshold *
+                     (float) (getSize().width - labelLength - 2 * offx) + offx);
+
+      g.drawLine(x, 0, x, getSize().height);
+    }
 
   }
 
-  public void mouseReleased(MouseEvent e) { }
-  public void mouseEntered(MouseEvent e) { }
-  public void mouseExited(MouseEvent e) { }
-  public void mouseClicked(MouseEvent e) {
+  public void mouseReleased(MouseEvent e)
+  {}
+
+  public void mouseEntered(MouseEvent e)
+  {}
+
+  public void mouseExited(MouseEvent e)
+  {}
+
+  public void mouseClicked(MouseEvent e)
+  {
   }
 
-  public void mousePressed(MouseEvent e) {
+  public void mousePressed(MouseEvent e)
+  {
+    av.setCurrentTree(tree);
 
-      av.setCurrentTree(tree);
+    int x = e.getX();
+    int y = e.getY();
 
-      int x = e.getX();
-      int y = e.getY();
+    Object ob = findElement(x, y);
 
-      Object ob = findElement(x,y);
+    if (ob instanceof SequenceI)
+    {
+      TreeSelectionChanged( (Sequence) ob);
+      repaint();
+      return;
 
-      if (ob instanceof SequenceI)
+    }
+    else if (ob instanceof SequenceNode)
+    {
+      SequenceNode tmpnode = (SequenceNode) ob;
+      tree.swapNodes(tmpnode);
+      tree.reCount(tree.getTopNode());
+      tree.findHeight(tree.getTopNode());
+    }
+    else
+    {
+      // Find threshold
+
+      if (tree.getMaxHeight() != 0)
       {
-          TreeSelectionChanged((Sequence)ob);
-          repaint();
-          return;
+        threshold = (float) (x - offx) /
+            (float) (getSize().width - labelLength - 2 * offx);
 
-      } else if (ob instanceof SequenceNode) {
-          SequenceNode tmpnode = (SequenceNode)ob;
-          tree.swapNodes(tmpnode);
-          tree.reCount(tree.getTopNode());
-          tree.findHeight(tree.getTopNode());
-      } else {
-          // Find threshold
+        tree.getGroups().removeAllElements();
+        tree.groupNodes(tree.getTopNode(), threshold);
+        setColor(tree.getTopNode(), Color.black);
 
-          if (tree.getMaxHeight() != 0) {
-              threshold = (float)(x - offx)/(float)(getSize().width-labelLength - 2*offx);
+        av.setSelectionGroup(null);
+        av.alignment.deleteAllGroups();
 
-              tree.getGroups().removeAllElements();
-              tree.groupNodes(tree.getTopNode(),threshold);
-              setColor(tree.getTopNode(),Color.black);
+        for (int i = 0; i < tree.getGroups().size(); i++)
+        {
 
-              av.setSelectionGroup(null);
-              av.alignment.deleteAllGroups();
+          Color col = new Color( (int) (Math.random() * 255),
+                                (int) (Math.random() * 255),
+                                (int) (Math.random() * 255));
+          setColor( (SequenceNode) tree.getGroups().elementAt(i), col.brighter());
 
-              for (int i=0; i < tree.getGroups().size(); i++)
-              {
+          Vector l = tree.findLeaves( (SequenceNode) tree.getGroups().elementAt(
+              i), new Vector());
 
-                  Color col = new Color((int)(Math.random()*255),
-                                        (int)(Math.random()*255),
-                                        (int)(Math.random()*255));
-                  setColor((SequenceNode)tree.getGroups().elementAt(i),col.brighter());
+          Vector sequences = new Vector();
+          for (int j = 0; j < l.size(); j++)
+          {
+            SequenceI s1 = (SequenceI) ( (SequenceNode) l.elementAt(j)).element();
+            if(!sequences.contains(s1))
+              sequences.addElement(s1);
+          }
 
-                  Vector l = tree.findLeaves((SequenceNode)tree.getGroups().elementAt(i),new Vector());
-                  SequenceGroup sg = null;
-                  for (int j = 0; j < l.size(); j++)
-                  {
-                    SequenceNode sn = (SequenceNode) l.elementAt(j);
-                    if(sg==null)
-                       sg = new SequenceGroup("TreeGroup", av.getGlobalColourScheme(), true, true,false,0,av.alignment.getWidth());
+          ColourSchemeI cs = ColourSchemeProperty.getColour(sequences, av.alignment.getWidth(),
+              ColourSchemeProperty.getColourName(av.getGlobalColourScheme()));
 
-                    sg.addSequence( (Sequence) sn.element());
-                  }
 
-                  if (av.getGlobalColourScheme() instanceof ConservationColourScheme)
-                  {
-                    ConservationColourScheme ccs = (ConservationColourScheme) av.getGlobalColourScheme();
-                    Conservation c = new Conservation("Group",
-                                                      ResidueProperties.propHash, 3,
-                                                      sg.sequences, sg.getStartRes(),
-                                                      sg.getEndRes());
+          SequenceGroup sg = new SequenceGroup(sequences, "TreeGroup",
+                                               cs, true, true,
+                                               false, 0, av.alignment.getWidth());
 
-                    c.calculate();
-                    c.verdict(false, av.ConsPercGaps);
-                    ccs = new ConservationColourScheme(c, ccs.cs);
 
-                    sg.cs = ccs;
+          if (av.getGlobalColourScheme().conservationApplied())
+          {
+            Conservation c = new Conservation("Group",
+                                              ResidueProperties.propHash, 3,
+                                              sg.sequences, sg.getStartRes(),
+                                              sg.getEndRes());
 
-                  }
+            c.calculate();
+            c.verdict(false, av.ConsPercGaps);
+            cs.setConservation(c);
 
+            sg.cs = cs;
 
+          }
 
-                  av.alignment.addGroup(sg);
+          av.alignment.addGroup(sg);
 
-              }
-          }
+        }
       }
+    }
 
-      PaintRefresher.Refresh(this);
-      repaint();
+    PaintRefresher.Refresh(this, av.alignment);
+    repaint();
 
   }
 
-    public void setShowDistances(boolean state) {
-        this.showDistances = state;
-        repaint();
-    }
+  public void setShowDistances(boolean state)
+  {
+    this.showDistances = state;
+    repaint();
+  }
 
-    public void setShowBootstrap(boolean state) {
-      this.showBootstrap = state;
-      repaint();
-    }
-    public void setMarkPlaceholders(boolean state) {
-            this.markPlaceholders = state;
-            repaint();
-    }
+  public void setShowBootstrap(boolean state)
+  {
+    this.showBootstrap = state;
+    repaint();
+  }
 
-}
+  public void setMarkPlaceholders(boolean state)
+  {
+    this.markPlaceholders = state;
+    repaint();
+  }
 
+}