src/jalview/appletgui/TreeCanvas.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
   3  * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, 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   public TreeCanvas(AlignmentPanel ap, ScrollPane scroller)
  69   {
  70     this.ap = ap;
  71     this.av = ap.av;
  72     font = av.getFont();
  73     scrollPane = scroller;
  74     addMouseListener(this);
  75     addMouseMotionListener(this);
  76     setLayout(null);
  77
  78     PaintRefresher.Register(this, av.getSequenceSetId());
  79   }
  80
  81   public void treeSelectionChanged(SequenceI sequence)
  82   {
  83     SequenceGroup selected = av.getSelectionGroup();
  84     if (selected == null)
  85     {
  86       selected = new SequenceGroup();
  87       av.setSelectionGroup(selected);
  88     }
  89
  90     selected.setEndRes(av.getAlignment().getWidth() - 1);
  91     selected.addOrRemove(sequence, true);
  92   }
  93
  94   public void setTree(NJTree tree)
  95   {
  96     this.tree = tree;
  97     tree.findHeight(tree.getTopNode());
  98
  99     // Now have to calculate longest name based on the leaves
 100     Vector leaves = tree.findLeaves(tree.getTopNode(), new Vector());
 101     boolean has_placeholders = false;
 102     longestName = "";
 103
 104     for (int i = 0; i < leaves.size(); i++)
 105     {
 106       SequenceNode lf = (SequenceNode) leaves.elementAt(i);
 107
 108       if (lf.isPlaceholder())
 109       {
 110         has_placeholders = true;
 111       }
 112
 113       if (longestName.length() < ((Sequence) lf.element()).getName()
 114               .length())
 115       {
 116         longestName = TreeCanvas.PLACEHOLDER
 117                 + ((Sequence) lf.element()).getName();
 118       }
 119     }
 120
 121     setMarkPlaceholders(has_placeholders);
 122   }
 123
 124   public void drawNode(Graphics g, SequenceNode node, float chunk,
 125           float scale, int width, int offx, int offy)
 126   {
 127     if (node == null)
 128     {
 129       return;
 130     }
 131
 132     if (node.left() == null && node.right() == null)
 133     {
 134       // Drawing leaf node
 135
 136       float height = node.height;
 137       float dist = node.dist;
 138
 139       int xstart = (int) ((height - dist) * scale) + offx;
 140       int xend = (int) (height * scale) + offx;
 141
 142       int ypos = (int) (node.ycount * chunk) + offy;
 143
 144       if (node.element() instanceof SequenceI)
 145       {
 146         SequenceI seq = (SequenceI) node.element();
 147
 148         if (av.getSequenceColour(seq) == Color.white)
 149         {
 150           g.setColor(Color.black);
 151         }
 152         else
 153         {
 154           g.setColor(av.getSequenceColour(seq).darker());
 155         }
 156
 157       }
 158       else
 159       {
 160         g.setColor(Color.black);
 161       }
 162
 163       // Draw horizontal line
 164       g.drawLine(xstart, ypos, xend, ypos);
 165
 166       String nodeLabel = "";
 167       if (showDistances && node.dist > 0)
 168       {
 169         nodeLabel = new Format("%-.2f").form(node.dist);
 170       }
 171       if (showBootstrap)
 172       {
 173         int btstrap = node.getBootstrap();
 174         if (btstrap > -1)
 175         {
 176           if (showDistances)
 177           {
 178             nodeLabel = nodeLabel + " : ";
 179           }
 180           nodeLabel = nodeLabel + String.valueOf(node.getBootstrap());
 181         }
 182       }
 183       if (!nodeLabel.equals(""))
 184       {
 185         g.drawString(nodeLabel, xstart + 2, ypos - 2);
 186       }
 187
 188       String name = (markPlaceholders && node.isPlaceholder()) ? (PLACEHOLDER + node
 189               .getName()) : node.getName();
 190       FontMetrics fm = g.getFontMetrics(font);
 191       int charWidth = fm.stringWidth(name) + 3;
 192       int charHeight = fm.getHeight();
 193
 194       Rectangle rect = new Rectangle(xend + 10, ypos - charHeight,
 195               charWidth, charHeight);
 196
 197       nameHash.put(node.element(), rect);
 198
 199       // Colour selected leaves differently
 200       SequenceGroup selected = av.getSelectionGroup();
 201       if (selected != null
 202               && selected.getSequences(null).contains(
 203                       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)
 446             / tree.getMaxHeight();
 447
 448     SequenceNode top = tree.getTopNode();
 449
 450     if (top.count == 0)
 451     {
 452       top.count = ((SequenceNode) top.left()).count
 453               + ((SequenceNode) top.right()).count;
 454     }
 455     float chunk = (float) (height - offy) / top.count;
 456
 457     drawNode(g, tree.getTopNode(), chunk, wscale, width, offx, offy);
 458
 459     if (threshold != 0)
 460     {
 461       if (av.getCurrentTree() == tree)
 462       {
 463         g.setColor(Color.red);
 464       }
 465       else
 466       {
 467         g.setColor(Color.gray);
 468       }
 469
 470       int x = (int) (threshold
 471               * (getSize().width - labelLength - 2 * offx) + offx);
 472
 473       g.drawLine(x, 0, x, getSize().height);
 474     }
 475
 476   }
 477
 478   @Override
 479   public void mouseReleased(MouseEvent e)
 480   {
 481   }
 482
 483   @Override
 484   public void mouseEntered(MouseEvent e)
 485   {
 486   }
 487
 488   @Override
 489   public void mouseExited(MouseEvent e)
 490   {
 491   }
 492
 493   @Override
 494   public void mouseClicked(MouseEvent evt)
 495   {
 496     if (highlightNode != null)
 497     {
 498       if (evt.getClickCount() > 1)
 499       {
 500         tree.swapNodes(highlightNode);
 501         tree.reCount(tree.getTopNode());
 502         tree.findHeight(tree.getTopNode());
 503       }
 504       else
 505       {
 506         Vector leaves = new Vector();
 507         tree.findLeaves(highlightNode, leaves);
 508
 509         for (int i = 0; i < leaves.size(); i++)
 510         {
 511           SequenceI seq = (SequenceI) ((SequenceNode) leaves.elementAt(i))
 512                   .element();
 513           treeSelectionChanged(seq);
 514         }
 515       }
 516
 517       PaintRefresher.Refresh(this, av.getSequenceSetId());
 518       repaint();
 519       av.sendSelection();
 520     }
 521   }
 522
 523   @Override
 524   public void mouseDragged(MouseEvent ect)
 525   {
 526   }
 527
 528   @Override
 529   public void mouseMoved(MouseEvent evt)
 530   {
 531     av.setCurrentTree(tree);
 532
 533     Object ob = findElement(evt.getX(), evt.getY());
 534
 535     if (ob instanceof SequenceNode)
 536     {
 537       highlightNode = (SequenceNode) ob;
 538       repaint();
 539     }
 540     else
 541     {
 542       if (highlightNode != null)
 543       {
 544         highlightNode = null;
 545         repaint();
 546       }
 547     }
 548   }
 549
 550   @Override
 551   public void mousePressed(MouseEvent e)
 552   {
 553     av.setCurrentTree(tree);
 554
 555     int x = e.getX();
 556     int y = e.getY();
 557
 558     Object ob = findElement(x, y);
 559
 560     if (ob instanceof SequenceI)
 561     {
 562       treeSelectionChanged((Sequence) ob);
 563       PaintRefresher.Refresh(this, av.getSequenceSetId());
 564       repaint();
 565       av.sendSelection();
 566       return;
 567     }
 568     else if (!(ob instanceof SequenceNode))
 569     {
 570       // Find threshold
 571
 572       if (tree.getMaxHeight() != 0)
 573       {
 574         threshold = (float) (x - offx)
 575                 / (float) (getSize().width - labelLength - 2 * offx);
 576
 577         tree.getGroups().removeAllElements();
 578         tree.groupNodes(tree.getTopNode(), threshold);
 579         setColor(tree.getTopNode(), Color.black);
 580
 581         av.setSelectionGroup(null);
 582         av.getAlignment().deleteAllGroups();
 583         av.sequenceColours = null;
 584
 585         colourGroups();
 586
 587       }
 588     }
 589
 590     PaintRefresher.Refresh(this, av.getSequenceSetId());
 591     repaint();
 592
 593   }
 594
 595   void colourGroups()
 596   {
 597     for (int i = 0; i < tree.getGroups().size(); i++)
 598     {
 599
 600       Color col = new Color((int) (Math.random() * 255),
 601               (int) (Math.random() * 255), (int) (Math.random() * 255));
 602       setColor((SequenceNode) tree.getGroups().elementAt(i), col.brighter());
 603
 604       Vector l = tree.findLeaves(
 605               (SequenceNode) tree.getGroups().elementAt(i), new Vector());
 606
 607       Vector sequences = new Vector();
 608       for (int j = 0; j < l.size(); j++)
 609       {
 610         SequenceI s1 = (SequenceI) ((SequenceNode) l.elementAt(j))
 611                 .element();
 612         if (!sequences.contains(s1))
 613         {
 614           sequences.addElement(s1);
 615         }
 616       }
 617
 618       ColourSchemeI cs = null;
 619
 620       SequenceGroup sg = new SequenceGroup(sequences, "", cs, true, true,
 621               false, 0, av.getAlignment().getWidth() - 1);
 622
 623       if (av.getGlobalColourScheme() != null)
 624       {
 625         if (av.getGlobalColourScheme() instanceof UserColourScheme)
 626         {
 627           cs = new UserColourScheme(
 628                   ((UserColourScheme) av.getGlobalColourScheme())
 629                           .getColours());
 630
 631         }
 632         else
 633         {
 634           cs = ColourSchemeProperty.getColour(sg, ColourSchemeProperty.getColourName(av
 635                   .getGlobalColourScheme()));
 636         }
 637         // cs is null if shading is an annotationColourGradient
 638         if (cs!=null)
 639         {
 640           cs.setThreshold(av.getGlobalColourScheme().getThreshold(),
 641                   av.getIgnoreGapsConsensus());
 642         }
 643       }
 644       // TODO: cs used to be initialized with a sequence collection and recalcConservation called automatically
 645       // instead we set it manually - recalc called after updateAnnotation
 646       sg.cs=cs;
 647
 648       sg.setName("JTreeGroup:" + sg.hashCode());
 649       sg.setIdColour(col);
 650       if (av.getGlobalColourScheme() != null
 651               && av.getGlobalColourScheme().conservationApplied())
 652       {
 653         Conservation c = new Conservation("Group",
 654                 ResidueProperties.propHash, 3, sg.getSequences(null),
 655                 sg.getStartRes(), sg.getEndRes());
 656
 657         c.calculate();
 658         c.verdict(false, av.getConsPercGaps());
 659         cs.setConservation(c);
 660
 661         sg.cs = cs;
 662
 663       }
 664
 665       av.getAlignment().addGroup(sg);
 666
 667     }
 668     ap.updateAnnotation();
 669
 670   }
 671
 672   public void setShowDistances(boolean state)
 673   {
 674     this.showDistances = state;
 675     repaint();
 676   }
 677
 678   public void setShowBootstrap(boolean state)
 679   {
 680     this.showBootstrap = state;
 681     repaint();
 682   }
 683
 684   public void setMarkPlaceholders(boolean state)
 685   {
 686     this.markPlaceholders = state;
 687     repaint();
 688   }
 689
 690 }