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