src/jalview/appletgui/TreeCanvas.java

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