48e9d643ab12f25d6c7e3e4cd3e05d04788b8720
[jalview.git] / 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 }