X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fappletgui%2FTreeCanvas.java;h=928d21fb4ad6183ae34140297738b69be11cca5d;hb=e6879a932d0144d64a5ab703ae311aed0eeb83e5;hp=f00fd17ec82579c6a4d118ea8510571385f0ea46;hpb=c3db82330376f20423dc617cfa92d131dc40e515;p=jalview.git

diff --git a/src/jalview/appletgui/TreeCanvas.java b/src/jalview/appletgui/TreeCanvas.java
index f00fd17..928d21f 100755
--- a/src/jalview/appletgui/TreeCanvas.java
+++ b/src/jalview/appletgui/TreeCanvas.java
@@ -1,435 +1,634 @@
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer
+ * Copyright (C) 2006 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
 package jalview.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, MouseMotionListener
 {
   NJTree tree;
   ScrollPane scrollPane;
   AlignViewport av;
-  public static final String PLACEHOLDER=" * ";
+  public static final String PLACEHOLDER = " * ";
   Font font;
-  int  fontSize = 12;
-
   boolean fitToWindow = true;
   boolean showDistances = false;
   boolean showBootstrap = false;
   boolean markPlaceholders = false;
 
   int offx = 20;
-  int offy = 20;
+  int offy;
 
   float threshold;
 
   String longestName;
-  int labelLength=-1;
-
-  //RubberbandRectangle rubberband;
-
-  Vector    listeners;
+  int labelLength = -1;
 
   Hashtable nameHash = new Hashtable();
   Hashtable nodeHash = new Hashtable();
 
-  public TreeCanvas(AlignViewport av, NJTree tree, ScrollPane scroller, String label)
+  SequenceNode highlightNode;
+
+
+  public TreeCanvas(AlignViewport av, ScrollPane scroller)
   {
     this.av = av;
-    this.tree     = tree;
+    font = av.getFont();
     scrollPane = scroller;
     addMouseListener(this);
-    tree.findHeight(tree.getTopNode());
-    longestName = label;
+    addMouseMotionListener(this);
     setLayout(null);
 
-    PaintRefresher.Register(this);
+    PaintRefresher.Register(this, av.alignment);
   }
-  public void TreeSelectionChanged(Sequence sequence)
- {
+
+  public void treeSelectionChanged(SequenceI 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.setEndRes(av.alignment.getWidth()-1);
+    selected.addOrRemove(sequence, true);
+  }
+
+  public void setTree(NJTree tree)
+  {
+    this.tree = tree;
+    tree.findHeight(tree.getTopNode());
 
+    // Now have to calculate longest name based on the leaves
+    Vector leaves = tree.findLeaves(tree.getTopNode(), new Vector());
+    boolean has_placeholders = false;
+    longestName = "";
 
-    PaintRefresher.Refresh(this);
-    repaint();
- }
+    for (int i = 0; i < leaves.size(); i++)
+    {
+      SequenceNode lf = (SequenceNode) leaves.elementAt(i);
 
+      if (lf.isPlaceholder())
+      {
+        has_placeholders = true;
+      }
 
+      if (longestName.length() < ( (Sequence) lf.element()).getName()
+          .length())
+      {
+        longestName = TreeCanvas.PLACEHOLDER +
+            ( (Sequence) lf.element()).getName();
+      }
+    }
 
-  public void setTree(NJTree tree) {
-    this.tree = tree;
-    tree.findHeight(tree.getTopNode());
+    setMarkPlaceholders(has_placeholders);
   }
 
-    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) {
-        nodeLabel = new Format("%5.2f").form(node.dist);
+      if (showDistances && node.dist > 0)
+      {
+        nodeLabel = new Format("%-.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+2, ypos - 2);
       }
 
-      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 + 10, 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.getSequences(false).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);
+      if (node == highlightNode)
+        g.fillRect(xend - 3, ypos - 3, 6, 6);
+      else
+        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("%-.2f").form(node.dist), xstart+2, ypos - 2);
       }
 
     }
   }
-  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();
 
-            if (x >= rect.x && x <= (rect.x + rect.width) &&
-              y >= rect.y && y <= (rect.y + rect.height)) {
-              return 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;
+      }
     }
-      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) / 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)
+  public void update(Graphics g)
   {
+    paint(g);
+  }
 
-    font = new Font("Verdana",Font.PLAIN,fontSize);
-    g.setFont(font);
+  Image offscreen;
+  public void paint(Graphics g1)
+  {
 
-    FontMetrics fm = g.getFontMetrics(font);
+    if(tree==null)
+      return;
 
-    if(nameHash.size()==0)
+    if (nameHash.size() == 0)
+    {
       repaint();
+    }
+
+    FontMetrics fm = g1.getFontMetrics(font);
+
+    int width = scrollPane.getSize().width;
+    int height = scrollPane.getSize().height;
+    if(!fitToWindow)
+      height = fm.getHeight() * nameHash.size();
+
+
+    if(offscreen==null || offscreen.getWidth(this)!=width
+    || offscreen.getHeight(this)!=height)
+      offscreen = createImage(width, height);
+
+    Graphics g = offscreen.getGraphics();
 
+    g.setFont(font);
 
-    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());
+    }
 
+    g1.drawImage(offscreen, 0, 0, this);
     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 void draw(Graphics g, int width, int height)
+  {
+    offy = font.getSize()+10;
 
-      labelLength = g.getFontMetrics(font).stringWidth(longestName)+ 20;//20 allows for scrollbar
+    g.setColor(Color.white);
+    g.fillRect(0, 0, width, height);
 
-      float wscale =(float)(width - labelLength -offx*2)/tree.getMaxHeight();
+    labelLength = g.getFontMetrics(font).stringWidth(longestName) + 20; //20 allows for scrollbar
 
-      SequenceNode top = tree.getTopNode();
+    float wscale = (float) (width - labelLength - 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 ;
+    SequenceNode top = tree.getTopNode();
 
-      drawNode(g,tree.getTopNode(),chunk,wscale,width,offx,offy);
+    if (top.count == 0)
+    {
+      top.count = ( (SequenceNode) top.left()).count +
+          ( (SequenceNode) top.right()).count;
+    }
+    float chunk = (float) (height - offy) / top.count;
+
+    drawNode(g, tree.getTopNode(), chunk, wscale, width, offx, offy);
 
-      if (threshold != 0)
+    if (threshold != 0)
+    {
+      if (av.getCurrentTree() == tree)
       {
-        if(av.getCurrentTree() == tree)
-          g.setColor(Color.red);
-        else
-          g.setColor(Color.gray);
+        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);
+    }
+
+  }
 
-          int x = (int)(    threshold * (float)(getSize().width-labelLength - 2*offx) +offx   ) ;
+  public void mouseReleased(MouseEvent e)
+  {}
 
-          g.drawLine(x,0,x,getSize().height);
+  public void mouseEntered(MouseEvent e)
+  {}
+
+  public void mouseExited(MouseEvent e)
+  {}
+
+  public void mouseClicked(MouseEvent evt)
+  {
+    if (highlightNode != null)
+    {
+      if (evt.getClickCount() > 1)
+      {
+        tree.swapNodes(highlightNode);
+        tree.reCount(tree.getTopNode());
+        tree.findHeight(tree.getTopNode());
+      }
+      else
+      {
+        Vector leaves = new Vector();
+        tree.findLeaves(highlightNode, leaves);
+
+        for (int i = 0; i < leaves.size(); i++)
+        {
+          SequenceI seq =
+              (SequenceI) ( (SequenceNode) leaves.elementAt(i)).element();
+          treeSelectionChanged(seq);
+        }
       }
 
+      PaintRefresher.Refresh(this, av.alignment);
+      repaint();
+    }
   }
 
-  public void mouseReleased(MouseEvent e) { }
-  public void mouseEntered(MouseEvent e) { }
-  public void mouseExited(MouseEvent e) { }
-  public void mouseClicked(MouseEvent e) {
+  public void mouseDragged(MouseEvent ect)
+  {}
+
+
+  public void mouseMoved(MouseEvent evt)
+  {
+    av.setCurrentTree(tree);
+
+    Object ob = findElement(evt.getX(), evt.getY());
+
+    if (ob instanceof SequenceNode)
+    {
+      highlightNode = (SequenceNode) ob;
+      repaint();
+    }
+    else
+    {
+      if (highlightNode != null)
+      {
+        highlightNode = null;
+        repaint();
+      }
+    }
   }
 
-  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);
+      PaintRefresher.Refresh(this, av.alignment);
+      repaint();
+      return;
+    }
+    else if ( !(ob instanceof SequenceNode))
+    {
+      // Find threshold
 
-      if (ob instanceof SequenceI)
+      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);
+        colourGroups();
 
-              av.setSelectionGroup(null);
-              av.alignment.deleteAllGroups();
+      }
+    }
 
-              for (int i=0; i < tree.getGroups().size(); i++)
-              {
+    PaintRefresher.Refresh(this, av.alignment);
+    repaint();
 
-                  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 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());
+  void colourGroups()
+  {
+    for (int i = 0; i < tree.getGroups().size(); i++)
+        {
+
+          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 l = tree.findLeaves( (SequenceNode) tree.getGroups().elementAt(
+              i), new Vector());
+
+          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);
+          }
 
-                    sg.addSequence( (Sequence) sn.element());
-                  }
+          ColourSchemeI cs = null;
 
-                  if (av.getGlobalColourScheme() instanceof ConservationColourScheme)
-                  {
-                    ConservationColourScheme ccs = (ConservationColourScheme) av.getGlobalColourScheme();
-                    Conservation c = new Conservation("Group",
-                                                      ResidueProperties.propHash, 3,
-                                                      sg.sequences, sg.getStartRes(),
-                                                      sg.getEndRes());
+          if (av.getGlobalColourScheme() != null)
+          {
+            if (av.getGlobalColourScheme() instanceof UserColourScheme)
+            {
+              cs = new UserColourScheme(
+                  ( (UserColourScheme) av.getGlobalColourScheme()).getColours());
 
-                    c.calculate();
-                    c.verdict(false, av.ConsPercGaps);
-                    ccs = new ConservationColourScheme(c, ccs.cs);
+            }
+            else
+              cs = ColourSchemeProperty.getColour(sequences,
+                                                  av.alignment.getWidth(),
+                                                  ColourSchemeProperty.getColourName(
+                                                      av.getGlobalColourScheme()));
+
+              cs.setThreshold(av.getGlobalColourScheme().getThreshold(),
+                                                   av.getIgnoreGapsConsensus());
+          }
 
-                    sg.cs = ccs;
+          SequenceGroup sg = new SequenceGroup(sequences, "TreeGroup",
+                                               cs, true, true,
+                                               false, 0, av.alignment.getWidth()-1);
 
-                  }
 
+          if (  av.getGlobalColourScheme()!=null
+             && av.getGlobalColourScheme().conservationApplied())
+            {
+            Conservation c = new Conservation("Group",
+                                              ResidueProperties.propHash, 3,
+                                              sg.getSequences(false),
+                                              sg.getStartRes(),
+                                              sg.getEndRes());
 
+            c.calculate();
+            c.verdict(false, av.ConsPercGaps);
+            cs.setConservation(c);
 
-                  av.alignment.addGroup(sg);
+            sg.cs = cs;
 
-              }
           }
-      }
 
-      PaintRefresher.Refresh(this);
-      repaint();
+          av.alignment.addGroup(sg);
+
+        }
 
   }
 
-    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();
+  }
 
+}