X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FTreeCanvas.java;h=73b5b748984e820dd675740b050c606a09dead33;hb=f62c6e30180c7a0c5e0e2d6ded1178a12b66c255;hp=b5200d5f328b22d0af28dedda8cd3dc1db0a04f5;hpb=7fec702aa740923869b87bafeec45e6f56e8b830;p=jalview.git

diff --git a/src/jalview/gui/TreeCanvas.java b/src/jalview/gui/TreeCanvas.java
index b5200d5..73b5b74 100755
--- a/src/jalview/gui/TreeCanvas.java
+++ b/src/jalview/gui/TreeCanvas.java
@@ -1,266 +1,339 @@
+/*
+ * 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.gui;
 
+import java.util.*;
 
-import jalview.analysis.*;
-import jalview.datamodel.*;
-import jalview.util.*;
-import jalview.schemes.*;
-import javax.swing.*;
 import java.awt.*;
 import java.awt.event.*;
-import java.util.*;
 import java.awt.print.*;
+import javax.swing.*;
 
-public class TreeCanvas extends JPanel implements MouseListener, Runnable, Printable
+import jalview.analysis.*;
+import jalview.datamodel.*;
+import jalview.schemes.*;
+import jalview.util.*;
+
+public class TreeCanvas
+    extends JPanel implements MouseListener, Runnable,
+    Printable
 {
+  public static final String PLACEHOLDER = " * ";
   NJTree tree;
   JScrollPane scrollPane;
   AlignViewport av;
-
   Font font;
-  int  fontSize = 12;
-
+  int fontSize = 12;
   boolean fitToWindow = true;
   boolean showDistances = false;
   boolean showBootstrap = false;
-
+  boolean markPlaceholders = false;
   int offx = 20;
   int offy = 20;
-
   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, JScrollPane scroller, String label)
+  public TreeCanvas(AlignViewport av, NJTree tree, JScrollPane scroller,
+                    String label)
   {
     this.av = av;
-    this.tree     = tree;
+    this.tree = tree;
     scrollPane = scroller;
     addMouseListener(this);
     tree.findHeight(tree.getTopNode());
     longestName = label;
 
-    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);
+    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);
       }
 
-      // Colour selected leaves differently
-      String name    = node.getName();
+      String name = (markPlaceholders && node.isPlaceholder())
+          ? (PLACEHOLDER + node.getName()) : node.getName();
       FontMetrics fm = g.getFontMetrics(font);
-      int charWidth  = fm.stringWidth(node.getName()) + 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(node.getName(),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();
 
-            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  = getWidth();
+  public void pickNodes(Rectangle pickBox)
+  {
+    int width = getWidth();
     int height = getHeight();
 
     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;
 
-    pickNode(pickBox,top,chunk,wscale,width,offx,offy);
+    float chunk = (float) (height - (offy * 2)) / top.count;
+
+    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)
+    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);
     }
   }
 
@@ -275,7 +348,9 @@ public class TreeCanvas extends JPanel implements MouseListener, Runnable, Print
   {
     PrinterJob printJob = PrinterJob.getPrinterJob();
     PageFormat pf = printJob.pageDialog(printJob.defaultPage());
+
     printJob.setPrintable(this, pf);
+
     if (printJob.printDialog())
     {
       try
@@ -289,187 +364,264 @@ public class TreeCanvas extends JPanel implements MouseListener, Runnable, Print
     }
   }
 
-
-  public int print(Graphics pg, PageFormat pf, int pi) throws PrinterException
+  public int print(Graphics pg, PageFormat pf, int pi)
+      throws PrinterException
   {
     pg.setFont(font);
-    FontMetrics fm = pg.getFontMetrics(font);
-
-    pg.translate((int)pf.getImageableX(), (int)pf.getImageableY());
+    pg.translate( (int) pf.getImageableX(), (int) pf.getImageableY());
 
     int pwidth = (int) pf.getImageableWidth();
     int pheight = (int) pf.getImageableHeight();
 
-    // adjust pheight to row height
-    pheight -= (pheight%fm.getHeight());
-    pg.setClip(0,0, pwidth, pheight);
-
-    int noPages = (fm.getHeight() * nameHash.size()) / pheight;
+    int noPages = getHeight() / pheight;
 
-    if(pi>noPages)
+    if (pi > noPages)
+    {
       return Printable.NO_SUCH_PAGE;
+    }
 
-    pg.translate(0, -pheight*pi );
-    draw(pg, pwidth, fm.getHeight() * nameHash.size());
+    if (pwidth > getWidth())
+    {
+      pwidth = getWidth();
+    }
 
-    return Printable.PAGE_EXISTS;
+    if (fitToWindow)
+    {
+      if (pheight > getHeight())
+      {
+        pheight = getHeight();
+      }
 
+      noPages = 0;
+    }
+    else
+    {
+      FontMetrics fm = pg.getFontMetrics(font);
+      int height = fm.getHeight() * nameHash.size();
+      pg.translate(0, -pi * pheight);
+      pg.setClip(0, pi * pheight, pwidth, (pi * pheight) + pheight);
+
+      // translate number of pages,
+      // height is screen size as this is the
+      // non overlapping text size
+      pheight = height;
+    }
+
+    draw(pg, pwidth, pheight);
+
+    return Printable.PAGE_EXISTS;
   }
 
   public void paintComponent(Graphics g)
   {
-
-    font = new Font("Verdana",Font.PLAIN,fontSize);
+    super.paintComponent(g);
+    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.getHeight() > fm.getHeight() * nameHash.size()+offy ) )
-     {
-         draw(g,scrollPane.getWidth(),scrollPane.getHeight());
-         setPreferredSize(null);
-     }
+    if (fitToWindow ||
+        (!fitToWindow &&
+         (scrollPane.getHeight() > ( (fm.getHeight() * nameHash.size()) +
+                                    offy))))
+    {
+      draw(g, scrollPane.getWidth(), scrollPane.getHeight());
+      setPreferredSize(null);
+    }
     else
-     {
-         setPreferredSize(new Dimension(scrollPane.getWidth(), fm.getHeight() * nameHash.size()));
-         draw( g,scrollPane.getWidth(), fm.getHeight() * nameHash.size());
-     }
-
-
-    if (threshold != 0)
     {
-        g.setColor(Color.red);
-
-        int x = (int)(    threshold * (float)(getWidth()-labelLength - 2*offx) +offx   ) ;
-
-        g.drawLine(x,0,x,getHeight());
+      setPreferredSize(new Dimension(scrollPane.getWidth(),
+                                     fm.getHeight() * nameHash.size()));
+      draw(g, scrollPane.getWidth(), fm.getHeight() * nameHash.size());
     }
 
     scrollPane.revalidate();
   }
-    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;
+  }
 
-      labelLength = g.getFontMetrics(font).stringWidth(longestName)+ 20;//20 allows for scrollbar
+  public void setFontSize(int fontSize)
+  {
+    this.fontSize = fontSize;
+    repaint();
+  }
+
+  public void draw(Graphics g1, int width, int height)
+  {
+    Graphics2D g2 = (Graphics2D) g1;
+    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                        RenderingHints.VALUE_ANTIALIAS_ON);
+    g2.setColor(Color.white);
+    g2.fillRect(0, 0, width, height);
 
-      float wscale =(float)(width - labelLength -offx*2)/tree.getMaxHeight();
+    labelLength = g2.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 ;
+    SequenceNode top = tree.getTopNode();
+
+    if (top.count == 0)
+    {
+      top.count = ( (SequenceNode) top.left()).count +
+          ( (SequenceNode) top.right()).count;
+    }
+
+    float chunk = (float) (height - (offy * 2)) / top.count;
+
+    drawNode(g2, tree.getTopNode(), chunk, wscale, width, offx, offy);
+
+    if (threshold != 0)
+    {
+      if (av.getCurrentTree() == tree)
+      {
+        g2.setColor(Color.red);
+      }
+      else
+      {
+        g2.setColor(Color.gray);
       }
-      float chunk = (float)(height-offy*2)/top.count ;
 
-      drawNode(g,tree.getTopNode(),chunk,wscale,width,offx,offy);
-  }
+      int x = (int) ( (threshold * (float) (getWidth() - labelLength -
+                                            (2 * offx))) + offx);
 
-  public void mouseReleased(MouseEvent e) { }
-  public void mouseEntered(MouseEvent e) { }
-  public void mouseExited(MouseEvent e) { }
-  public void mouseClicked(MouseEvent e) {
+      g2.drawLine(x, 0, x, getHeight());
+    }
   }
 
-  public void mousePressed(MouseEvent e) {
-      int x = e.getX();
-      int y = e.getY();
+  public void mouseReleased(MouseEvent e)
+  {
+  }
 
-      Object ob = findElement(x,y);
+  public void mouseEntered(MouseEvent e)
+  {
+  }
 
-      if (ob instanceof SequenceI)
-      {
-          TreeSelectionChanged((Sequence)ob);
-          repaint();
-          return;
+  public void mouseExited(MouseEvent e)
+  {
+  }
 
-      } else if (ob instanceof SequenceNode) {
-          SequenceNode tmpnode = (SequenceNode)ob;
-          tree.swapNodes(tmpnode);
-          tree.reCount(tree.getTopNode());
-          tree.findHeight(tree.getTopNode());
-      } else {
-          // Find threshold
+  public void mouseClicked(MouseEvent e)
+  {
+  }
 
-          if (tree.getMaxHeight() != 0) {
-              threshold = (float)(x - offx)/(float)(getWidth()-labelLength - 2*offx);
+  public void mousePressed(MouseEvent e)
+  {
+    av.setCurrentTree(tree);
 
-              tree.getGroups().removeAllElements();
-              tree.groupNodes(tree.getTopNode(),threshold);
-              setColor(tree.getTopNode(),Color.black);
+    int x = e.getX();
+    int y = e.getY();
 
-              av.setSelectionGroup(null);
-              av.alignment.deleteAllGroups();
+    Object ob = findElement(x, y);
 
-              for (int i=0; i < tree.getGroups().size(); i++)
-              {
+    if (ob instanceof SequenceI)
+    {
+      TreeSelectionChanged( (Sequence) ob);
+      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());
+      return;
+    }
+    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)
+      {
+        threshold = (float) (x - offx) / (float) (getWidth() -
+                                                  labelLength - (2 * offx));
+
+        tree.getGroups().removeAllElements();
+        tree.groupNodes(tree.getTopNode(), threshold);
+        setColor(tree.getTopNode(), Color.black);
+
+        av.setSelectionGroup(null);
+        av.alignment.deleteAllGroups();
+
+        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++)
+          {
+            sequences.add( (Sequence)((SequenceNode) l.elementAt(j)).element());
+          }
 
-                  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());
-                  }
+          SequenceGroup sg = new SequenceGroup(sequences, "TreeGroup",
+                           cs, true, true,
+                           false, 0, av.alignment.getWidth());
 
-                  if (av.getGlobalColourScheme() instanceof ConservationColourScheme)
-                  {
-                    ConservationColourScheme ccs = (ConservationColourScheme) av.getGlobalColourScheme();
-                    Conservation c = new Conservation("Group",
-                                                      ResidueProperties.propHash, 3,
-                                                      sg.sequences, sg.getStartRes(),
-                                                      sg.getEndRes());
 
-                    c.calculate();
-                    c.verdict(false, 100);
-                    ccs = new ConservationColourScheme(c, ccs.cs);
+           ( (ResidueColourScheme) sg.cs).setThreshold(25);
 
-                    sg.cs = ccs;
 
-                  }
 
 
+          if (av.getGlobalColourScheme() instanceof ConservationColourScheme)
+          {
+            ConservationColourScheme ccs = (ConservationColourScheme) av.
+                getGlobalColourScheme();
+            Conservation c = new Conservation("Group",
+                                              ResidueProperties.propHash, 3,
+                                              sg.sequences,
+                                              sg.getStartRes(), sg.getEndRes());
 
-                  av.alignment.addGroup(sg);
+            c.calculate();
+            c.verdict(false, av.ConsPercGaps);
+            ccs = new ConservationColourScheme(c, ccs.cs);
 
-              }
+            sg.cs = ccs;
           }
-      }
 
-      PaintRefresher.Refresh(this);
-      repaint();
+          av.alignment.addGroup(sg);
+        }
+      }
+    }
 
+    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 setShowBootstrap(boolean state)
+  {
+    this.showBootstrap = state;
+    repaint();
+  }
 
+  public void setMarkPlaceholders(boolean state)
+  {
+    this.markPlaceholders = state;
+    repaint();
+  }
 }
-