src/jalview/appletgui/TreeCanvas.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
   3  * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  10  *
  11  * Jalview is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty
  13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14  * PURPOSE.  See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 package jalview.appletgui;
  19
  20 import java.util.*;
  21
  22 import java.awt.*;
  23 import java.awt.event.*;
  24
  25 import jalview.analysis.*;
  26 import jalview.datamodel.*;
  27 import jalview.schemes.*;
  28 import jalview.util.*;
  29
  30 public class TreeCanvas extends Panel implements MouseListener,
  31         MouseMotionListener
  32 {
  33   NJTree tree;
  34
  35   ScrollPane scrollPane;
  36
  37   AlignViewport av;
  38
  39   public static final String PLACEHOLDER = " * ";
  40
  41   Font font;
  42
  43   boolean fitToWindow = true;
  44
  45   boolean showDistances = false;
  46
  47   boolean showBootstrap = false;
  48
  49   boolean markPlaceholders = false;
  50
  51   int offx = 20;
  52
  53   int offy;
  54
  55   float threshold;
  56
  57   String longestName;
  58
  59   int labelLength = -1;
  60
  61   Hashtable nameHash = new Hashtable();
  62
  63   Hashtable nodeHash = new Hashtable();
  64
  65   SequenceNode highlightNode;
  66
  67   AlignmentPanel ap;
  68
  69   public TreeCanvas(AlignmentPanel ap, ScrollPane scroller)
  70   {
  71     this.ap = ap;
  72     this.av = ap.av;
  73     font = av.getFont();
  74     scrollPane = scroller;
  75     addMouseListener(this);
  76     addMouseMotionListener(this);
  77     setLayout(null);
  78
  79     PaintRefresher.Register(this, av.getSequenceSetId());
  80   }
  81
  82   public void treeSelectionChanged(SequenceI sequence)
  83   {
  84     SequenceGroup selected = av.getSelectionGroup();
  85     if (selected == null)
  86     {
  87       selected = new SequenceGroup();
  88       av.setSelectionGroup(selected);
  89     }
  90
  91     selected.setEndRes(av.getAlignment().getWidth() - 1);
  92     selected.addOrRemove(sequence, true);
  93   }
  94
  95   public void setTree(NJTree tree)
  96   {
  97     this.tree = tree;
  98     tree.findHeight(tree.getTopNode());
  99
 100     // Now have to calculate longest name based on the leaves
 101     Vector leaves = tree.findLeaves(tree.getTopNode(), new Vector());
 102     boolean has_placeholders = false;
 103     longestName = "";
 104
 105     for (int i = 0; i < leaves.size(); i++)
 106     {
 107       SequenceNode lf = (SequenceNode) leaves.elementAt(i);
 108
 109       if (lf.isPlaceholder())
 110       {
 111         has_placeholders = true;
 112       }
 113
 114       if (longestName.length() < ((Sequence) lf.element()).getName()
 115               .length())
 116       {
 117         longestName = TreeCanvas.PLACEHOLDER
 118                 + ((Sequence) lf.element()).getName();
 119       }
 120     }
 121
 122     setMarkPlaceholders(has_placeholders);
 123   }
 124
 125   public void drawNode(Graphics g, SequenceNode node, float chunk,
 126           float scale, int width, int offx, int offy)
 127   {
 128     if (node == null)
 129     {
 130       return;
 131     }
 132
 133     if (node.left() == null && node.right() == null)
 134     {
 135       // Drawing leaf node
 136
 137       float height = node.height;
 138       float dist = node.dist;
 139
 140       int xstart = (int) ((height - dist) * scale) + offx;
 141       int xend = (int) (height * scale) + offx;
 142
 143       int ypos = (int) (node.ycount * chunk) + offy;
 144
 145       if (node.element() instanceof SequenceI)
 146       {
 147         SequenceI seq = (SequenceI) node.element();
 148
 149         if (av.getSequenceColour(seq) == Color.white)
 150         {
 151           g.setColor(Color.black);
 152         }
 153         else
 154         {
 155           g.setColor(av.getSequenceColour(seq).darker());
 156         }
 157
 158       }
 159       else
 160       {
 161         g.setColor(Color.black);
 162       }
 163
 164       // Draw horizontal line
 165       g.drawLine(xstart, ypos, xend, ypos);
 166
 167       String nodeLabel = "";
 168       if (showDistances && node.dist > 0)
 169       {
 170         nodeLabel = new Format("%-.2f").form(node.dist);
 171       }
 172       if (showBootstrap)
 173       {
 174         int btstrap = node.getBootstrap();
 175         if (btstrap > -1)
 176         {
 177           if (showDistances)
 178           {
 179             nodeLabel = nodeLabel + " : ";
 180           }
 181           nodeLabel = nodeLabel + String.valueOf(node.getBootstrap());
 182         }
 183       }
 184       if (!nodeLabel.equals(""))
 185       {
 186         g.drawString(nodeLabel, xstart + 2, ypos - 2);
 187       }
 188
 189       String name = (markPlaceholders && node.isPlaceholder()) ? (PLACEHOLDER + node
 190               .getName()) : node.getName();
 191       FontMetrics fm = g.getFontMetrics(font);
 192       int charWidth = fm.stringWidth(name) + 3;
 193       int charHeight = fm.getHeight();
 194
 195       Rectangle rect = new Rectangle(xend + 10, ypos - charHeight,
 196               charWidth, charHeight);
 197
 198       nameHash.put(node.element(), rect);
 199
 200       // Colour selected leaves differently
 201       SequenceGroup selected = av.getSelectionGroup();
 202       if (selected != null
 203               && selected.getSequences(null).contains(node.element()))
 204       {
 205         g.setColor(Color.gray);
 206
 207         g.fillRect(xend + 10, ypos - charHeight + 3, charWidth, charHeight);
 208         g.setColor(Color.white);
 209       }
 210       g.drawString(name, xend + 10, ypos);
 211       g.setColor(Color.black);
 212     }
 213     else
 214     {
 215       drawNode(g, (SequenceNode) node.left(), chunk, scale, width, offx,
 216               offy);
 217       drawNode(g, (SequenceNode) node.right(), chunk, scale, width, offx,
 218               offy);
 219
 220       float height = node.height;
 221       float dist = node.dist;
 222
 223       int xstart = (int) ((height - dist) * scale) + offx;
 224       int xend = (int) (height * scale) + offx;
 225       int ypos = (int) (node.ycount * chunk) + offy;
 226
 227       g.setColor(node.color.darker());
 228
 229       // Draw horizontal line
 230       g.drawLine(xstart, ypos, xend, ypos);
 231       if (node == highlightNode)
 232       {
 233         g.fillRect(xend - 3, ypos - 3, 6, 6);
 234       }
 235       else
 236       {
 237         g.fillRect(xend - 2, ypos - 2, 4, 4);
 238       }
 239
 240       int ystart = (int) (((SequenceNode) node.left()).ycount * chunk)
 241               + offy;
 242       int yend = (int) (((SequenceNode) node.right()).ycount * chunk)
 243               + offy;
 244
 245       Rectangle pos = new Rectangle(xend - 2, ypos - 2, 5, 5);
 246       nodeHash.put(node, pos);
 247
 248       g.drawLine((int) (height * scale) + offx, ystart,
 249               (int) (height * scale) + offx, yend);
 250
 251       String nodeLabel = "";
 252
 253       if (showDistances && (node.dist > 0))
 254       {
 255         nodeLabel = new Format("%-.2f").form(node.dist);
 256       }
 257
 258       if (showBootstrap)
 259       {
 260         int btstrap = node.getBootstrap();
 261         if (btstrap > -1)
 262         {
 263           if (showDistances)
 264           {
 265             nodeLabel = nodeLabel + " : ";
 266           }
 267           nodeLabel = nodeLabel + String.valueOf(node.getBootstrap());
 268         }
 269       }
 270
 271       if (!nodeLabel.equals(""))
 272       {
 273         g.drawString(nodeLabel, xstart + 2, ypos - 2);
 274       }
 275
 276     }
 277   }
 278
 279   public Object findElement(int x, int y)
 280   {
 281     Enumeration keys = nameHash.keys();
 282
 283     while (keys.hasMoreElements())
 284     {
 285       Object ob = keys.nextElement();
 286       Rectangle rect = (Rectangle) nameHash.get(ob);
 287
 288       if (x >= rect.x && x <= (rect.x + rect.width) && y >= rect.y
 289               && y <= (rect.y + rect.height))
 290       {
 291         return ob;
 292       }
 293     }
 294     keys = nodeHash.keys();
 295
 296     while (keys.hasMoreElements())
 297     {
 298       Object ob = keys.nextElement();
 299       Rectangle rect = (Rectangle) nodeHash.get(ob);
 300
 301       if (x >= rect.x && x <= (rect.x + rect.width) && y >= rect.y
 302               && y <= (rect.y + rect.height))
 303       {
 304         return ob;
 305       }
 306     }
 307     return null;
 308
 309   }
 310
 311   public void pickNodes(Rectangle pickBox)
 312   {
 313     int width = getSize().width;
 314     int height = getSize().height;
 315
 316     SequenceNode top = tree.getTopNode();
 317
 318     float wscale = (float) (width * .8 - offx * 2) / tree.getMaxHeight();
 319     if (top.count == 0)
 320     {
 321       top.count = ((SequenceNode) top.left()).count
 322               + ((SequenceNode) top.right()).count;
 323     }
 324     float chunk = (float) (height - offy) / top.count;
 325
 326     pickNode(pickBox, top, chunk, wscale, width, offx, offy);
 327   }
 328
 329   public void pickNode(Rectangle pickBox, SequenceNode node, float chunk,
 330           float scale, int width, int offx, int offy)
 331   {
 332     if (node == null)
 333     {
 334       return;
 335     }
 336
 337     if (node.left() == null && node.right() == null)
 338     {
 339       float height = node.height;
 340       // float dist = node.dist;
 341
 342       // int xstart = (int) ( (height - dist) * scale) + offx;
 343       int xend = (int) (height * scale) + offx;
 344
 345       int ypos = (int) (node.ycount * chunk) + offy;
 346
 347       if (pickBox.contains(new Point(xend, ypos)))
 348       {
 349         if (node.element() instanceof SequenceI)
 350         {
 351           SequenceI seq = (SequenceI) node.element();
 352           SequenceGroup sg = av.getSelectionGroup();
 353           if (sg != null)
 354           {
 355             sg.addOrRemove(seq, true);
 356           }
 357         }
 358       }
 359     }
 360     else
 361     {
 362       pickNode(pickBox, (SequenceNode) node.left(), chunk, scale, width,
 363               offx, offy);
 364       pickNode(pickBox, (SequenceNode) node.right(), chunk, scale, width,
 365               offx, offy);
 366     }
 367   }
 368
 369   public void setColor(SequenceNode node, Color c)
 370   {
 371     if (node == null)
 372     {
 373       return;
 374     }
 375
 376     if (node.left() == null && node.right() == null)
 377     {
 378       node.color = c;
 379
 380       if (node.element() instanceof SequenceI)
 381       {
 382         av.setSequenceColour((SequenceI) node.element(), c);
 383       }
 384     }
 385     else
 386     {
 387       node.color = c;
 388       setColor((SequenceNode) node.left(), c);
 389       setColor((SequenceNode) node.right(), c);
 390     }
 391   }
 392
 393   @Override
 394   public void update(Graphics g)
 395   {
 396     paint(g);
 397   }
 398
 399   @Override
 400   public void paint(Graphics g)
 401   {
 402     if (tree == null)
 403     {
 404       return;
 405     }
 406
 407     if (nameHash.size() == 0)
 408     {
 409       repaint();
 410     }
 411
 412     int width = scrollPane.getSize().width;
 413     int height = scrollPane.getSize().height;
 414     if (!fitToWindow)
 415     {
 416       height = g.getFontMetrics(font).getHeight() * nameHash.size();
 417     }
 418
 419     if (getSize().width > width)
 420     {
 421       setSize(new Dimension(width, height));
 422       scrollPane.validate();
 423       return;
 424     }
 425
 426     setSize(new Dimension(width, height));
 427
 428     g.setFont(font);
 429     draw(g, width, height);
 430     validate();
 431   }
 432
 433   public void draw(Graphics g, int width, int height)
 434   {
 435     offy = font.getSize() + 10;
 436
 437     g.setColor(Color.white);
 438     g.fillRect(0, 0, width, height);
 439
 440     labelLength = g.getFontMetrics(font).stringWidth(longestName) + 20; // 20
 441     // allows
 442     // for
 443     // scrollbar
 444
 445     float wscale = (width - labelLength - offx * 2) / tree.getMaxHeight();
 446
 447     SequenceNode top = tree.getTopNode();
 448
 449     if (top.count == 0)
 450     {
 451       top.count = ((SequenceNode) top.left()).count
 452               + ((SequenceNode) top.right()).count;
 453     }
 454     float chunk = (float) (height - offy) / top.count;
 455
 456     drawNode(g, tree.getTopNode(), chunk, wscale, width, offx, offy);
 457
 458     if (threshold != 0)
 459     {
 460       if (av.getCurrentTree() == tree)
 461       {
 462         g.setColor(Color.red);
 463       }
 464       else
 465       {
 466         g.setColor(Color.gray);
 467       }
 468
 469       int x = (int) (threshold * (getSize().width - labelLength - 2 * offx) + offx);
 470
 471       g.drawLine(x, 0, x, getSize().height);
 472     }
 473
 474   }
 475
 476   @Override
 477   public void mouseReleased(MouseEvent e)
 478   {
 479   }
 480
 481   @Override
 482   public void mouseEntered(MouseEvent e)
 483   {
 484   }
 485
 486   @Override
 487   public void mouseExited(MouseEvent e)
 488   {
 489   }
 490
 491   @Override
 492   public void mouseClicked(MouseEvent evt)
 493   {
 494     if (highlightNode != null)
 495     {
 496       if (evt.getClickCount() > 1)
 497       {
 498         tree.swapNodes(highlightNode);
 499         tree.reCount(tree.getTopNode());
 500         tree.findHeight(tree.getTopNode());
 501       }
 502       else
 503       {
 504         Vector leaves = new Vector();
 505         tree.findLeaves(highlightNode, leaves);
 506
 507         for (int i = 0; i < leaves.size(); i++)
 508         {
 509           SequenceI seq = (SequenceI) ((SequenceNode) leaves.elementAt(i))
 510                   .element();
 511           treeSelectionChanged(seq);
 512         }
 513       }
 514
 515       PaintRefresher.Refresh(this, av.getSequenceSetId());
 516       repaint();
 517       av.sendSelection();
 518     }
 519   }
 520
 521   @Override
 522   public void mouseDragged(MouseEvent ect)
 523   {
 524   }
 525
 526   @Override
 527   public void mouseMoved(MouseEvent evt)
 528   {
 529     av.setCurrentTree(tree);
 530
 531     Object ob = findElement(evt.getX(), evt.getY());
 532
 533     if (ob instanceof SequenceNode)
 534     {
 535       highlightNode = (SequenceNode) ob;
 536       repaint();
 537     }
 538     else
 539     {
 540       if (highlightNode != null)
 541       {
 542         highlightNode = null;
 543         repaint();
 544       }
 545     }
 546   }
 547
 548   @Override
 549   public void mousePressed(MouseEvent e)
 550   {
 551     av.setCurrentTree(tree);
 552
 553     int x = e.getX();
 554     int y = e.getY();
 555
 556     Object ob = findElement(x, y);
 557
 558     if (ob instanceof SequenceI)
 559     {
 560       treeSelectionChanged((Sequence) ob);
 561       PaintRefresher.Refresh(this, av.getSequenceSetId());
 562       repaint();
 563       av.sendSelection();
 564       return;
 565     }
 566     else if (!(ob instanceof SequenceNode))
 567     {
 568       // Find threshold
 569
 570       if (tree.getMaxHeight() != 0)
 571       {
 572         threshold = (float) (x - offx)
 573                 / (float) (getSize().width - labelLength - 2 * offx);
 574
 575         tree.getGroups().removeAllElements();
 576         tree.groupNodes(tree.getTopNode(), threshold);
 577         setColor(tree.getTopNode(), Color.black);
 578
 579         av.setSelectionGroup(null);
 580         av.getAlignment().deleteAllGroups();
 581         av.sequenceColours = null;
 582
 583         colourGroups();
 584
 585       }
 586     }
 587
 588     PaintRefresher.Refresh(this, av.getSequenceSetId());
 589     repaint();
 590
 591   }
 592
 593   void colourGroups()
 594   {
 595     for (int i = 0; i < tree.getGroups().size(); i++)
 596     {
 597
 598       Color col = new Color((int) (Math.random() * 255),
 599               (int) (Math.random() * 255), (int) (Math.random() * 255));
 600       setColor((SequenceNode) tree.getGroups().elementAt(i), col.brighter());
 601
 602       Vector l = tree.findLeaves(
 603               (SequenceNode) tree.getGroups().elementAt(i), new Vector());
 604
 605       Vector sequences = new Vector();
 606       for (int j = 0; j < l.size(); j++)
 607       {
 608         SequenceI s1 = (SequenceI) ((SequenceNode) l.elementAt(j))
 609                 .element();
 610         if (!sequences.contains(s1))
 611         {
 612           sequences.addElement(s1);
 613         }
 614       }
 615
 616       ColourSchemeI cs = null;
 617
 618       SequenceGroup sg = new SequenceGroup(sequences, "", cs, true, true,
 619               false, 0, av.getAlignment().getWidth() - 1);
 620
 621       if (av.getGlobalColourScheme() != null)
 622       {
 623         if (av.getGlobalColourScheme() instanceof UserColourScheme)
 624         {
 625           cs = new UserColourScheme(
 626                   ((UserColourScheme) av.getGlobalColourScheme())
 627                           .getColours());
 628
 629         }
 630         else
 631         {
 632           cs = ColourSchemeProperty.getColour(sg, ColourSchemeProperty
 633                   .getColourName(av.getGlobalColourScheme()));
 634         }
 635         // cs is null if shading is an annotationColourGradient
 636         if (cs != null)
 637         {
 638           cs.setThreshold(av.getGlobalColourScheme().getThreshold(),
 639                   av.getIgnoreGapsConsensus());
 640         }
 641       }
 642       // TODO: cs used to be initialized with a sequence collection and
 643       // recalcConservation called automatically
 644       // instead we set it manually - recalc called after updateAnnotation
 645       sg.cs = cs;
 646
 647       sg.setName("JTreeGroup:" + sg.hashCode());
 648       sg.setIdColour(col);
 649       if (av.getGlobalColourScheme() != null
 650               && av.getGlobalColourScheme().conservationApplied())
 651       {
 652         Conservation c = new Conservation("Group",
 653                 ResidueProperties.propHash, 3, sg.getSequences(null),
 654                 sg.getStartRes(), sg.getEndRes());
 655
 656         c.calculate();
 657         c.verdict(false, av.getConsPercGaps());
 658         cs.setConservation(c);
 659
 660         sg.cs = cs;
 661
 662       }
 663
 664       av.getAlignment().addGroup(sg);
 665
 666     }
 667     ap.updateAnnotation();
 668
 669   }
 670
 671   public void setShowDistances(boolean state)
 672   {
 673     this.showDistances = state;
 674     repaint();
 675   }
 676
 677   public void setShowBootstrap(boolean state)
 678   {
 679     this.showBootstrap = state;
 680     repaint();
 681   }
 682
 683   public void setMarkPlaceholders(boolean state)
 684   {
 685     this.markPlaceholders = state;
 686     repaint();
 687   }
 688
 689 }