Check hiddenSequence before placing in tmp
[jalview.git] / src / jalview / gui / TreeCanvas.java
1 /*\r
2  * Jalview - A Sequence Alignment Editor and Viewer\r
3  * Copyright (C) 2006 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
4  *\r
5  * This program is free software; you can redistribute it and/or\r
6  * modify it under the terms of the GNU General Public License\r
7  * as published by the Free Software Foundation; either version 2\r
8  * of the License, or (at your option) any later version.\r
9  *\r
10  * This program is distributed in the hope that it will be useful,\r
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
13  * GNU General Public License for more details.\r
14  *\r
15  * You should have received a copy of the GNU General Public License\r
16  * along with this program; if not, write to the Free Software\r
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
18  */\r
19 package jalview.gui;\r
20 \r
21 import jalview.analysis.*;\r
22 \r
23 import jalview.datamodel.*;\r
24 \r
25 import jalview.schemes.*;\r
26 \r
27 import jalview.util.*;\r
28 \r
29 import java.awt.*;\r
30 import java.awt.event.*;\r
31 import java.awt.print.*;\r
32 \r
33 import java.util.*;\r
34 \r
35 import javax.swing.*;\r
36 \r
37 \r
38 /**\r
39  * DOCUMENT ME!\r
40  *\r
41  * @author $author$\r
42  * @version $Revision$\r
43  */\r
44 public class TreeCanvas extends JPanel implements MouseListener, Runnable,\r
45     Printable, MouseMotionListener\r
46 {\r
47     /** DOCUMENT ME!! */\r
48     public static final String PLACEHOLDER = " * ";\r
49     NJTree tree;\r
50     JScrollPane scrollPane;\r
51     AlignViewport av;\r
52     AlignmentPanel ap;\r
53     Font font;\r
54     FontMetrics fm;\r
55     boolean fitToWindow = true;\r
56     boolean showDistances = false;\r
57     boolean showBootstrap = false;\r
58     boolean markPlaceholders = false;\r
59     int offx = 20;\r
60     int offy;\r
61     float threshold;\r
62     String longestName;\r
63     int labelLength = -1;\r
64 \r
65     Hashtable nameHash = new Hashtable();\r
66     Hashtable nodeHash = new Hashtable();\r
67     SequenceNode highlightNode;\r
68 \r
69     /**\r
70      * Creates a new TreeCanvas object.\r
71      *\r
72      * @param av DOCUMENT ME!\r
73      * @param tree DOCUMENT ME!\r
74      * @param scroller DOCUMENT ME!\r
75      * @param label DOCUMENT ME!\r
76      */\r
77     public TreeCanvas(AlignmentPanel ap, JScrollPane scroller)\r
78     {\r
79         this.av = ap.av;\r
80         this.ap = ap;\r
81         font = av.getFont();\r
82         scrollPane = scroller;\r
83         addMouseListener(this);\r
84         addMouseMotionListener(this);\r
85         PaintRefresher.Register(this, ap.av.getSequenceSetId());\r
86     }\r
87 \r
88 \r
89     /**\r
90      * DOCUMENT ME!\r
91      *\r
92      * @param sequence DOCUMENT ME!\r
93      */\r
94     public void treeSelectionChanged(SequenceI sequence)\r
95     {\r
96         SequenceGroup selected = av.getSelectionGroup();\r
97 \r
98         if (selected == null)\r
99         {\r
100             selected = new SequenceGroup();\r
101             av.setSelectionGroup(selected);\r
102         }\r
103 \r
104         selected.setEndRes(av.alignment.getWidth()-1);\r
105         selected.addOrRemove(sequence, true);\r
106     }\r
107 \r
108     /**\r
109      * DOCUMENT ME!\r
110      *\r
111      * @param tree DOCUMENT ME!\r
112      */\r
113     public void setTree(NJTree tree)\r
114     {\r
115         this.tree = tree;\r
116         tree.findHeight(tree.getTopNode());\r
117 \r
118         // Now have to calculate longest name based on the leaves\r
119         Vector leaves = tree.findLeaves(tree.getTopNode(), new Vector());\r
120         boolean has_placeholders = false;\r
121         longestName = "";\r
122 \r
123         for (int i = 0; i < leaves.size(); i++)\r
124         {\r
125           SequenceNode lf = (SequenceNode) leaves.elementAt(i);\r
126 \r
127           if (lf.isPlaceholder())\r
128           {\r
129             has_placeholders = true;\r
130           }\r
131 \r
132           if (longestName.length() < ( (Sequence) lf.element()).getName()\r
133               .length())\r
134           {\r
135             longestName = TreeCanvas.PLACEHOLDER +\r
136                 ( (Sequence) lf.element()).getName();\r
137           }\r
138         }\r
139 \r
140         setMarkPlaceholders(has_placeholders);\r
141     }\r
142 \r
143     /**\r
144      * DOCUMENT ME!\r
145      *\r
146      * @param g DOCUMENT ME!\r
147      * @param node DOCUMENT ME!\r
148      * @param chunk DOCUMENT ME!\r
149      * @param scale DOCUMENT ME!\r
150      * @param width DOCUMENT ME!\r
151      * @param offx DOCUMENT ME!\r
152      * @param offy DOCUMENT ME!\r
153      */\r
154     public void drawNode(Graphics g, SequenceNode node, float chunk,\r
155         float scale, int width, int offx, int offy)\r
156     {\r
157         if (node == null)\r
158         {\r
159             return;\r
160         }\r
161 \r
162         if ((node.left() == null) && (node.right() == null))\r
163         {\r
164             // Drawing leaf node\r
165             float height = node.height;\r
166             float dist = node.dist;\r
167 \r
168             int xstart = (int) ((height - dist) * scale) + offx;\r
169             int xend = (int) (height * scale) + offx;\r
170 \r
171             int ypos = (int) (node.ycount * chunk) + offy;\r
172 \r
173             if (node.element() instanceof SequenceI)\r
174             {\r
175                 if (((SequenceI) ((SequenceNode) node).element()).getColor() == Color.white)\r
176                 {\r
177                     g.setColor(Color.black);\r
178                 }\r
179                 else\r
180                 {\r
181                     g.setColor(((SequenceI) ((SequenceNode) node).element()).getColor()\r
182                                 .darker());\r
183                 }\r
184             }\r
185             else\r
186             {\r
187                 g.setColor(Color.black);\r
188             }\r
189 \r
190             // Draw horizontal line\r
191             g.drawLine(xstart, ypos, xend, ypos);\r
192 \r
193             String nodeLabel = "";\r
194 \r
195             if (showDistances && (node.dist > 0))\r
196             {\r
197                 nodeLabel = new Format("%-.2f").form(node.dist);\r
198             }\r
199 \r
200             if (showBootstrap)\r
201             {\r
202                 if (showDistances)\r
203                 {\r
204                     nodeLabel = nodeLabel + " : ";\r
205                 }\r
206 \r
207                 nodeLabel = nodeLabel + String.valueOf(node.getBootstrap());\r
208             }\r
209 \r
210             if (!nodeLabel.equals(""))\r
211             {\r
212                 g.drawString(nodeLabel, xstart+2, ypos - 2);\r
213             }\r
214 \r
215             String name = (markPlaceholders && node.isPlaceholder())\r
216                 ? (PLACEHOLDER + node.getName()) : node.getName();\r
217 \r
218             int charWidth = fm.stringWidth(name) + 3;\r
219             int charHeight = font.getSize();\r
220 \r
221             Rectangle rect = new Rectangle(xend+10, ypos-charHeight/2,\r
222                     charWidth, charHeight);\r
223 \r
224             nameHash.put((SequenceI) node.element(), rect);\r
225 \r
226             // Colour selected leaves differently\r
227             SequenceGroup selected = av.getSelectionGroup();\r
228 \r
229             if ((selected != null) &&\r
230                     selected.getSequences(false).contains((SequenceI) node.element()))\r
231             {\r
232                 g.setColor(Color.gray);\r
233 \r
234                 g.fillRect(xend + 10, ypos-charHeight/2, charWidth,\r
235                     charHeight);\r
236                 g.setColor(Color.white);\r
237             }\r
238 \r
239             g.drawString(name, xend + 10, ypos+fm.getDescent());\r
240             g.setColor(Color.black);\r
241         }\r
242         else\r
243         {\r
244             drawNode(g, (SequenceNode) node.left(), chunk, scale, width, offx,\r
245                 offy);\r
246             drawNode(g, (SequenceNode) node.right(), chunk, scale, width, offx,\r
247                 offy);\r
248 \r
249             float height = node.height;\r
250             float dist = node.dist;\r
251 \r
252             int xstart = (int) ((height - dist) * scale) + offx;\r
253             int xend = (int) (height * scale) + offx;\r
254             int ypos = (int) (node.ycount * chunk) + offy;\r
255 \r
256             g.setColor(((SequenceNode) node).color.darker());\r
257 \r
258             // Draw horizontal line\r
259             g.drawLine(xstart, ypos, xend, ypos);\r
260             if (node == highlightNode)\r
261               g.fillRect(xend - 3, ypos - 3, 6, 6);\r
262             else\r
263               g.fillRect(xend - 2, ypos - 2, 4, 4);\r
264 \r
265             int ystart = (int) (((SequenceNode) node.left()).ycount * chunk) +\r
266                 offy;\r
267             int yend = (int) (((SequenceNode) node.right()).ycount * chunk) +\r
268                 offy;\r
269 \r
270             Rectangle pos = new Rectangle(xend - 2, ypos - 2, 5, 5);\r
271             nodeHash.put(node, pos);\r
272 \r
273             g.drawLine((int) (height * scale) + offx, ystart,\r
274                 (int) (height * scale) + offx, yend);\r
275 \r
276             if (showDistances && (node.dist > 0))\r
277             {\r
278                 g.drawString(new Format("%-.2f").form(node.dist).trim(), xstart+2,\r
279                     ypos - 2);\r
280             }\r
281         }\r
282     }\r
283 \r
284     /**\r
285      * DOCUMENT ME!\r
286      *\r
287      * @param x DOCUMENT ME!\r
288      * @param y DOCUMENT ME!\r
289      *\r
290      * @return DOCUMENT ME!\r
291      */\r
292     public Object findElement(int x, int y)\r
293     {\r
294         Enumeration keys = nameHash.keys();\r
295 \r
296         while (keys.hasMoreElements())\r
297         {\r
298             Object ob = keys.nextElement();\r
299             Rectangle rect = (Rectangle) nameHash.get(ob);\r
300 \r
301             if ((x >= rect.x) && (x <= (rect.x + rect.width)) && (y >= rect.y) &&\r
302                     (y <= (rect.y + rect.height)))\r
303             {\r
304                 return ob;\r
305             }\r
306         }\r
307 \r
308         keys = nodeHash.keys();\r
309 \r
310         while (keys.hasMoreElements())\r
311         {\r
312             Object ob = keys.nextElement();\r
313             Rectangle rect = (Rectangle) nodeHash.get(ob);\r
314 \r
315             if ((x >= rect.x) && (x <= (rect.x + rect.width)) && (y >= rect.y) &&\r
316                     (y <= (rect.y + rect.height)))\r
317             {\r
318                 return ob;\r
319             }\r
320         }\r
321 \r
322         return null;\r
323     }\r
324 \r
325     /**\r
326      * DOCUMENT ME!\r
327      *\r
328      * @param pickBox DOCUMENT ME!\r
329      */\r
330     public void pickNodes(Rectangle pickBox)\r
331     {\r
332         int width = getWidth();\r
333         int height = getHeight();\r
334 \r
335         SequenceNode top = tree.getTopNode();\r
336 \r
337         float wscale = (float) ((width * .8) - (offx * 2)) / tree.getMaxHeight();\r
338 \r
339         if (top.count == 0)\r
340         {\r
341             top.count = ((SequenceNode) top.left()).count +\r
342                 ((SequenceNode) top.right()).count;\r
343         }\r
344 \r
345         float chunk = (float) (height - (offy)) / top.count;\r
346 \r
347         pickNode(pickBox, top, chunk, wscale, width, offx, offy);\r
348     }\r
349 \r
350     /**\r
351      * DOCUMENT ME!\r
352      *\r
353      * @param pickBox DOCUMENT ME!\r
354      * @param node DOCUMENT ME!\r
355      * @param chunk DOCUMENT ME!\r
356      * @param scale DOCUMENT ME!\r
357      * @param width DOCUMENT ME!\r
358      * @param offx DOCUMENT ME!\r
359      * @param offy DOCUMENT ME!\r
360      */\r
361     public void pickNode(Rectangle pickBox, SequenceNode node, float chunk,\r
362         float scale, int width, int offx, int offy)\r
363     {\r
364         if (node == null)\r
365         {\r
366             return;\r
367         }\r
368 \r
369         if ((node.left() == null) && (node.right() == null))\r
370         {\r
371             float height = node.height;\r
372             float dist = node.dist;\r
373 \r
374             int xstart = (int) ((height - dist) * scale) + offx;\r
375             int xend = (int) (height * scale) + offx;\r
376 \r
377             int ypos = (int) (node.ycount * chunk) + offy;\r
378 \r
379             if (pickBox.contains(new Point(xend, ypos)))\r
380             {\r
381                 if (node.element() instanceof SequenceI)\r
382                 {\r
383                     SequenceI seq = (SequenceI) node.element();\r
384                     SequenceGroup sg = av.getSelectionGroup();\r
385 \r
386                     if (sg != null)\r
387                     {\r
388                         sg.addOrRemove(seq, true);\r
389                     }\r
390                 }\r
391             }\r
392         }\r
393         else\r
394         {\r
395             pickNode(pickBox, (SequenceNode) node.left(), chunk, scale, width,\r
396                 offx, offy);\r
397             pickNode(pickBox, (SequenceNode) node.right(), chunk, scale, width,\r
398                 offx, offy);\r
399         }\r
400     }\r
401 \r
402     /**\r
403      * DOCUMENT ME!\r
404      *\r
405      * @param node DOCUMENT ME!\r
406      * @param c DOCUMENT ME!\r
407      */\r
408     public void setColor(SequenceNode node, Color c)\r
409     {\r
410         if (node == null)\r
411         {\r
412             return;\r
413         }\r
414 \r
415         if ((node.left() == null) && (node.right() == null))\r
416         {\r
417             node.color = c;\r
418 \r
419             if (node.element() instanceof SequenceI)\r
420             {\r
421                 ((SequenceI) node.element()).setColor(c);\r
422             }\r
423         }\r
424         else\r
425         {\r
426             node.color = c;\r
427             setColor((SequenceNode) node.left(), c);\r
428             setColor((SequenceNode) node.right(), c);\r
429         }\r
430     }\r
431 \r
432     /**\r
433      * DOCUMENT ME!\r
434      */\r
435     void startPrinting()\r
436     {\r
437         Thread thread = new Thread(this);\r
438         thread.start();\r
439     }\r
440 \r
441     // put printing in a thread to avoid painting problems\r
442     public void run()\r
443     {\r
444         PrinterJob printJob = PrinterJob.getPrinterJob();\r
445         PageFormat pf = printJob.pageDialog(printJob.defaultPage());\r
446 \r
447         printJob.setPrintable(this, pf);\r
448 \r
449         if (printJob.printDialog())\r
450         {\r
451             try\r
452             {\r
453                 printJob.print();\r
454             }\r
455             catch (Exception PrintException)\r
456             {\r
457                 PrintException.printStackTrace();\r
458             }\r
459         }\r
460     }\r
461 \r
462     /**\r
463      * DOCUMENT ME!\r
464      *\r
465      * @param pg DOCUMENT ME!\r
466      * @param pf DOCUMENT ME!\r
467      * @param pi DOCUMENT ME!\r
468      *\r
469      * @return DOCUMENT ME!\r
470      *\r
471      * @throws PrinterException DOCUMENT ME!\r
472      */\r
473     public int print(Graphics pg, PageFormat pf, int pi)\r
474         throws PrinterException\r
475     {\r
476         pg.setFont(font);\r
477         pg.translate((int) pf.getImageableX(), (int) pf.getImageableY());\r
478 \r
479         int pwidth = (int) pf.getImageableWidth();\r
480         int pheight = (int) pf.getImageableHeight();\r
481 \r
482         int noPages = getHeight() / pheight;\r
483 \r
484         if (pi > noPages)\r
485         {\r
486             return Printable.NO_SUCH_PAGE;\r
487         }\r
488 \r
489         if (pwidth > getWidth())\r
490         {\r
491             pwidth = getWidth();\r
492         }\r
493 \r
494         if (fitToWindow)\r
495         {\r
496             if (pheight > getHeight())\r
497             {\r
498                 pheight = getHeight();\r
499             }\r
500 \r
501             noPages = 0;\r
502         }\r
503         else\r
504         {\r
505             FontMetrics fm = pg.getFontMetrics(font);\r
506             int height = fm.getHeight() * nameHash.size();\r
507             pg.translate(0, -pi * pheight);\r
508             pg.setClip(0, pi * pheight, pwidth, (pi * pheight) + pheight);\r
509 \r
510             // translate number of pages,\r
511             // height is screen size as this is the\r
512             // non overlapping text size\r
513             pheight = height;\r
514         }\r
515 \r
516         draw(pg, pwidth, pheight);\r
517 \r
518         return Printable.PAGE_EXISTS;\r
519     }\r
520 \r
521     /**\r
522      * DOCUMENT ME!\r
523      *\r
524      * @param g DOCUMENT ME!\r
525      */\r
526     public void paintComponent(Graphics g)\r
527     {\r
528         super.paintComponent(g);\r
529         g.setFont(font);\r
530 \r
531         if(tree==null)\r
532         {\r
533           g.drawString("Calculating tree....", 20, getHeight()/2);\r
534         }\r
535         else\r
536         {\r
537           fm = g.getFontMetrics(font);\r
538 \r
539           if (nameHash.size() == 0)\r
540           {\r
541             repaint();\r
542           }\r
543 \r
544           if (fitToWindow ||\r
545               (!fitToWindow &&\r
546                (scrollPane.getHeight() > ( (fm.getHeight() * nameHash.size()) +\r
547                                           offy))))\r
548           {\r
549             draw(g, scrollPane.getWidth(), scrollPane.getHeight());\r
550             setPreferredSize(null);\r
551           }\r
552           else\r
553           {\r
554             setPreferredSize(new Dimension(scrollPane.getWidth(),\r
555                                            fm.getHeight() * nameHash.size()));\r
556             draw(g, scrollPane.getWidth(), fm.getHeight() * nameHash.size());\r
557           }\r
558 \r
559           scrollPane.revalidate();\r
560         }\r
561     }\r
562 \r
563 \r
564     /**\r
565      * DOCUMENT ME!\r
566      *\r
567      * @param fontSize DOCUMENT ME!\r
568      */\r
569     public void setFont(Font font)\r
570     {\r
571         this.font = font;\r
572         repaint();\r
573     }\r
574 \r
575     /**\r
576      * DOCUMENT ME!\r
577      *\r
578      * @param g1 DOCUMENT ME!\r
579      * @param width DOCUMENT ME!\r
580      * @param height DOCUMENT ME!\r
581      */\r
582     public void draw(Graphics g1, int width, int height)\r
583     {\r
584         Graphics2D g2 = (Graphics2D) g1;\r
585         g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,\r
586             RenderingHints.VALUE_ANTIALIAS_ON);\r
587         g2.setColor(Color.white);\r
588         g2.fillRect(0, 0, width, height);\r
589 \r
590         g2.setFont(font);\r
591 \r
592         offy = font.getSize()+10;\r
593 \r
594         fm = g2.getFontMetrics(font);\r
595 \r
596         labelLength = fm.stringWidth(longestName) + 20; //20 allows for scrollbar\r
597 \r
598         float wscale = (float) (width - labelLength - (offx * 2)) / tree.getMaxHeight();\r
599 \r
600         SequenceNode top = tree.getTopNode();\r
601 \r
602         if (top.count == 0)\r
603         {\r
604             top.count = ((SequenceNode) top.left()).count +\r
605                 ((SequenceNode) top.right()).count;\r
606         }\r
607 \r
608         float chunk = (float) (height - (offy)) / top.count;\r
609 \r
610         drawNode(g2, tree.getTopNode(), chunk, wscale, width, offx, offy);\r
611 \r
612         if (threshold != 0)\r
613         {\r
614             if (av.getCurrentTree() == tree)\r
615             {\r
616                 g2.setColor(Color.red);\r
617             }\r
618             else\r
619             {\r
620                 g2.setColor(Color.gray);\r
621             }\r
622 \r
623             int x = (int) ((threshold * (float) (getWidth() - labelLength -\r
624                 (2 * offx))) + offx);\r
625 \r
626             g2.drawLine(x, 0, x, getHeight());\r
627         }\r
628     }\r
629 \r
630     /**\r
631      * DOCUMENT ME!\r
632      *\r
633      * @param e DOCUMENT ME!\r
634      */\r
635     public void mouseReleased(MouseEvent e)\r
636     {\r
637     }\r
638 \r
639     /**\r
640      * DOCUMENT ME!\r
641      *\r
642      * @param e DOCUMENT ME!\r
643      */\r
644     public void mouseEntered(MouseEvent e)\r
645     {\r
646     }\r
647 \r
648     /**\r
649      * DOCUMENT ME!\r
650      *\r
651      * @param e DOCUMENT ME!\r
652      */\r
653     public void mouseExited(MouseEvent e)\r
654     {\r
655     }\r
656 \r
657     /**\r
658      * DOCUMENT ME!\r
659      *\r
660      * @param e DOCUMENT ME!\r
661      */\r
662     public void mouseClicked(MouseEvent evt)\r
663     {\r
664       if(highlightNode!=null)\r
665       {\r
666         if(evt.getClickCount()>1)\r
667         {\r
668           tree.swapNodes(highlightNode);\r
669           tree.reCount(tree.getTopNode());\r
670           tree.findHeight(tree.getTopNode());\r
671         }\r
672         else\r
673         {\r
674           Vector leaves = new Vector();\r
675           tree.findLeaves(highlightNode, leaves);\r
676 \r
677           for (int i = 0; i < leaves.size(); i++)\r
678           {\r
679             SequenceI seq =\r
680                 (SequenceI) ( (SequenceNode) leaves.elementAt(i)).element();\r
681             treeSelectionChanged(seq);\r
682           }\r
683         }\r
684 \r
685         PaintRefresher.Refresh(this, av.getSequenceSetId());\r
686         repaint();\r
687       }\r
688     }\r
689 \r
690 \r
691 \r
692     public void mouseMoved(MouseEvent evt)\r
693     {\r
694       av.setCurrentTree(tree);\r
695 \r
696       Object ob = findElement(evt.getX(), evt.getY());\r
697 \r
698       if (ob instanceof SequenceNode)\r
699       {\r
700         highlightNode = (SequenceNode) ob;\r
701         repaint();\r
702       }\r
703       else\r
704       {\r
705         if (highlightNode != null)\r
706         {\r
707           highlightNode = null;\r
708           repaint();\r
709         }\r
710       }\r
711   }\r
712 \r
713     public void mouseDragged(MouseEvent ect)\r
714     {}\r
715 \r
716     /**\r
717      * DOCUMENT ME!\r
718      *\r
719      * @param e DOCUMENT ME!\r
720      */\r
721     public void mousePressed(MouseEvent e)\r
722     {\r
723         av.setCurrentTree(tree);\r
724 \r
725         int x = e.getX();\r
726         int y = e.getY();\r
727 \r
728         Object ob = findElement(x, y);\r
729 \r
730         if (ob instanceof SequenceI)\r
731         {\r
732           treeSelectionChanged( (Sequence) ob);\r
733           PaintRefresher.Refresh(this, ap.av.getSequenceSetId());\r
734           repaint();\r
735           return;\r
736         }\r
737         else if( !(ob instanceof SequenceNode) )\r
738         {\r
739             // Find threshold\r
740             if (tree.getMaxHeight() != 0)\r
741             {\r
742                 threshold = (float) (x - offx) / (float) (getWidth() -\r
743                     labelLength - (2 * offx));\r
744 \r
745                 tree.getGroups().removeAllElements();\r
746                 tree.groupNodes(tree.getTopNode(), threshold);\r
747                 setColor(tree.getTopNode(), Color.black);\r
748 \r
749                 av.setSelectionGroup(null);\r
750                 av.alignment.deleteAllGroups();\r
751 \r
752                 colourGroups();\r
753               }\r
754 \r
755               PaintRefresher.Refresh(this, ap.av.getSequenceSetId());\r
756               repaint();\r
757         }\r
758 \r
759 \r
760     }\r
761 \r
762     void colourGroups()\r
763     {\r
764       for (int i = 0; i < tree.getGroups().size(); i++)\r
765       {\r
766         Color col = new Color( (int) (Math.random() * 255),\r
767                               (int) (Math.random() * 255),\r
768                               (int) (Math.random() * 255));\r
769         setColor( (SequenceNode) tree.getGroups().elementAt(i),\r
770                  col.brighter());\r
771 \r
772         Vector l = tree.findLeaves( (SequenceNode) tree.getGroups()\r
773                                    .elementAt(i),\r
774                                    new Vector());\r
775 \r
776         Vector sequences = new Vector();\r
777 \r
778         for (int j = 0; j < l.size(); j++)\r
779         {\r
780           SequenceI s1 = (SequenceI) ( (SequenceNode) l.elementAt(j)).element();\r
781 \r
782           if (!sequences.contains(s1))\r
783           {\r
784             sequences.addElement(s1);\r
785           }\r
786         }\r
787 \r
788         ColourSchemeI cs = null;\r
789 \r
790         if (av.getGlobalColourScheme() != null)\r
791         {\r
792           if (av.getGlobalColourScheme() instanceof UserColourScheme)\r
793           {\r
794             cs = new UserColourScheme(\r
795                 ( (UserColourScheme) av.getGlobalColourScheme()).getColours());\r
796 \r
797           }\r
798           else\r
799             cs = ColourSchemeProperty.getColour(sequences,\r
800                                                 av.alignment.getWidth(),\r
801                                                 ColourSchemeProperty.\r
802                                                 getColourName(\r
803                                                     av.getGlobalColourScheme()));\r
804 \r
805           cs.setThreshold(av.getGlobalColourScheme().getThreshold(),\r
806                           av.getIgnoreGapsConsensus());\r
807         }\r
808 \r
809         SequenceGroup sg = new SequenceGroup(sequences,\r
810                                              "TreeGroup", cs, true, true, false,\r
811                                              0,\r
812                                              av.alignment.getWidth() - 1);\r
813 \r
814         if (av.getGlobalColourScheme() != null\r
815             && av.getGlobalColourScheme().conservationApplied())\r
816         {\r
817           Conservation c = new Conservation("Group",\r
818                                             ResidueProperties.propHash, 3,\r
819                                             sg.getSequences(false),\r
820                                             sg.getStartRes(), sg.getEndRes());\r
821 \r
822           c.calculate();\r
823           c.verdict(false, av.ConsPercGaps);\r
824           sg.cs.setConservation(c);\r
825         }\r
826 \r
827         av.alignment.addGroup(sg);\r
828       }\r
829 \r
830     }\r
831 \r
832     /**\r
833      * DOCUMENT ME!\r
834      *\r
835      * @param state DOCUMENT ME!\r
836      */\r
837     public void setShowDistances(boolean state)\r
838     {\r
839         this.showDistances = state;\r
840         repaint();\r
841     }\r
842 \r
843     /**\r
844      * DOCUMENT ME!\r
845      *\r
846      * @param state DOCUMENT ME!\r
847      */\r
848     public void setShowBootstrap(boolean state)\r
849     {\r
850         this.showBootstrap = state;\r
851         repaint();\r
852     }\r
853 \r
854     /**\r
855      * DOCUMENT ME!\r
856      *\r
857      * @param state DOCUMENT ME!\r
858      */\r
859     public void setMarkPlaceholders(boolean state)\r
860     {\r
861         this.markPlaceholders = state;\r
862         repaint();\r
863     }\r
864 }\r