X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fjalview%2Fappletgui%2FTreeCanvas.java;h=928d21fb4ad6183ae34140297738b69be11cca5d;hb=81aaad88042de8ba97baf33da5185c04ab71aacc;hp=b00d6cc7bb45a5cd76bcdc58a9119ecc00862b76;hpb=4ebc6d5b362bc093c39312aa1a69836e3dd6ae84;p=jalview.git

diff --git a/src/jalview/appletgui/TreeCanvas.java b/src/jalview/appletgui/TreeCanvas.java
index b00d6cc..928d21f 100755
--- a/src/jalview/appletgui/TreeCanvas.java
+++ b/src/jalview/appletgui/TreeCanvas.java
@@ -1,6 +1,6 @@
 /*
  * Jalview - A Sequence Alignment Editor and Viewer
- * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ * 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
@@ -30,50 +30,45 @@ import jalview.schemes.*;
 import jalview.util.*;
 
 public class TreeCanvas
-    extends Panel implements MouseListener
+    extends Panel implements MouseListener, MouseMotionListener
 {
   NJTree tree;
   ScrollPane scrollPane;
   AlignViewport av;
   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;
-
   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)
@@ -82,17 +77,38 @@ public class TreeCanvas
       av.setSelectionGroup(selected);
     }
 
-    selected.setEndRes(av.alignment.getWidth());
+    selected.setEndRes(av.alignment.getWidth()-1);
     selected.addOrRemove(sequence, true);
-
-    PaintRefresher.Refresh(this);
-    repaint();
   }
 
   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 = "";
+
+    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();
+      }
+    }
+
+    setMarkPlaceholders(has_placeholders);
   }
 
   public void drawNode(Graphics g, SequenceNode node, float chunk, float scale,
@@ -140,7 +156,7 @@ public class TreeCanvas
       String nodeLabel = "";
       if (showDistances && node.dist > 0)
       {
-        nodeLabel = new Format("%5.2f").form(node.dist);
+        nodeLabel = new Format("%-.2f").form(node.dist);
       }
       if (showBootstrap)
       {
@@ -152,7 +168,7 @@ public class TreeCanvas
       }
       if (!nodeLabel.equals(""))
       {
-        g.drawString(nodeLabel, xstart, ypos - 10);
+        g.drawString(nodeLabel, xstart+2, ypos - 2);
       }
 
       String name = (markPlaceholders && node.isPlaceholder()) ?
@@ -161,7 +177,7 @@ public class TreeCanvas
       int charWidth = fm.stringWidth(name) + 3;
       int charHeight = fm.getHeight();
 
-      Rectangle rect = new Rectangle(xend + 20, ypos - charHeight,
+      Rectangle rect = new Rectangle(xend + 10, ypos - charHeight,
                                      charWidth, charHeight);
 
       nameHash.put( (SequenceI) node.element(), rect);
@@ -169,7 +185,7 @@ public class TreeCanvas
       // Colour selected leaves differently
       SequenceGroup selected = av.getSelectionGroup();
       if (selected != null &&
-          selected.sequences.contains( (SequenceI) node.element()))
+          selected.getSequences(false).contains( (SequenceI) node.element()))
       {
         g.setColor(Color.gray);
 
@@ -195,7 +211,10 @@ public class TreeCanvas
 
       // Draw horizontal line
       g.drawLine(xstart, ypos, xend, ypos);
-      g.fillRect(xend - 2, ypos - 2, 4, 4);
+      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;
@@ -208,7 +227,7 @@ public class TreeCanvas
 
       if (showDistances && node.dist > 0)
       {
-        g.drawString(new Format("%5.2f").form(node.dist), xstart, ypos - 5);
+        g.drawString(new Format("%-.2f").form(node.dist), xstart+2, ypos - 2);
       }
 
     }
@@ -260,7 +279,7 @@ public class TreeCanvas
       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);
   }
@@ -276,9 +295,9 @@ public class TreeCanvas
     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 xstart = (int) ( (height - dist) * scale) + offx;
       int xend = (int) (height * scale) + offx;
 
       int ypos = (int) (node.ycount * chunk) + offy;
@@ -329,19 +348,39 @@ public class TreeCanvas
     }
   }
 
-  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)
     {
       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))
@@ -355,22 +394,14 @@ public class TreeCanvas
       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)
   {
+    offy = font.getSize()+10;
 
     g.setColor(Color.white);
     g.fillRect(0, 0, width, height);
@@ -386,7 +417,7 @@ public class TreeCanvas
       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;
 
     drawNode(g, tree.getTopNode(), chunk, wscale, width, offx, offy);
 
@@ -418,13 +449,61 @@ public class TreeCanvas
   public void mouseExited(MouseEvent e)
   {}
 
-  public void mouseClicked(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 mousePressed(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)
+  {
     av.setCurrentTree(tree);
 
     int x = e.getX();
@@ -434,19 +513,12 @@ public class TreeCanvas
 
     if (ob instanceof SequenceI)
     {
-      TreeSelectionChanged( (Sequence) ob);
+      treeSelectionChanged( (Sequence) ob);
+      PaintRefresher.Refresh(this, av.alignment);
       repaint();
       return;
-
-    }
-    else if (ob instanceof SequenceNode)
-    {
-      SequenceNode tmpnode = (SequenceNode) ob;
-      tree.swapNodes(tmpnode);
-      tree.reCount(tree.getTopNode());
-      tree.findHeight(tree.getTopNode());
     }
-    else
+    else if ( !(ob instanceof SequenceNode))
     {
       // Find threshold
 
@@ -462,7 +534,19 @@ public class TreeCanvas
         av.setSelectionGroup(null);
         av.alignment.deleteAllGroups();
 
-        for (int i = 0; i < tree.getGroups().size(); i++)
+        colourGroups();
+
+      }
+    }
+
+    PaintRefresher.Refresh(this, av.alignment);
+    repaint();
+
+  }
+
+  void colourGroups()
+  {
+    for (int i = 0; i < tree.getGroups().size(); i++)
         {
 
           Color col = new Color( (int) (Math.random() * 255),
@@ -472,39 +556,60 @@ public class TreeCanvas
 
           Vector l = tree.findLeaves( (SequenceNode) tree.getGroups().elementAt(
               i), new Vector());
-          SequenceGroup sg = new SequenceGroup("TreeGroup", av.getGlobalColourScheme(), true, true, false,
-                                     0, av.alignment.getWidth());
+
+          Vector sequences = new Vector();
           for (int j = 0; j < l.size(); j++)
           {
-            SequenceNode sn = (SequenceNode) l.elementAt(j);
-            sg.addSequence( (Sequence) sn.element(), false);
+            SequenceI s1 = (SequenceI) ( (SequenceNode) l.elementAt(j)).element();
+            if(!sequences.contains(s1))
+              sequences.addElement(s1);
           }
 
-          if (av.getGlobalColourScheme() instanceof ConservationColourScheme)
+          ColourSchemeI cs = null;
+
+          if (av.getGlobalColourScheme() != null)
           {
-            ConservationColourScheme ccs = (ConservationColourScheme) av.
-                getGlobalColourScheme();
+            if (av.getGlobalColourScheme() instanceof UserColourScheme)
+            {
+              cs = new UserColourScheme(
+                  ( (UserColourScheme) av.getGlobalColourScheme()).getColours());
+
+            }
+            else
+              cs = ColourSchemeProperty.getColour(sequences,
+                                                  av.alignment.getWidth(),
+                                                  ColourSchemeProperty.getColourName(
+                                                      av.getGlobalColourScheme()));
+
+              cs.setThreshold(av.getGlobalColourScheme().getThreshold(),
+                                                   av.getIgnoreGapsConsensus());
+          }
+
+          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.sequences, sg.getStartRes(),
+                                              sg.getSequences(false),
+                                              sg.getStartRes(),
                                               sg.getEndRes());
 
             c.calculate();
             c.verdict(false, av.ConsPercGaps);
-            ccs = new ConservationColourScheme(c, ccs.cs);
+            cs.setConservation(c);
 
-            sg.cs = ccs;
+            sg.cs = cs;
 
           }
 
           av.alignment.addGroup(sg);
 
         }
-      }
-    }
-
-    PaintRefresher.Refresh(this);
-    repaint();
 
   }