src/jalview/gui/TreePanel.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
   3  * Copyright (C) 2014 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.gui;
  22
  23 import jalview.analysis.AlignmentSorter;
  24 import jalview.analysis.NJTree;
  25 import jalview.commands.CommandI;
  26 import jalview.commands.OrderCommand;
  27 import jalview.datamodel.Alignment;
  28 import jalview.datamodel.AlignmentI;
  29 import jalview.datamodel.AlignmentView;
  30 import jalview.datamodel.BinaryNode;
  31 import jalview.datamodel.ColumnSelection;
  32 import jalview.datamodel.DBRefEntry;
  33 import jalview.datamodel.NodeTransformI;
  34 import jalview.datamodel.SequenceFeature;
  35 import jalview.datamodel.SequenceI;
  36 import jalview.datamodel.SequenceNode;
  37 import jalview.io.JalviewFileChooser;
  38 import jalview.io.JalviewFileView;
  39 import jalview.io.NewickFile;
  40 import jalview.jbgui.GTreePanel;
  41 import jalview.util.MessageManager;
  42
  43 import java.awt.Font;
  44 import java.awt.Graphics;
  45 import java.awt.event.ActionEvent;
  46 import java.awt.event.ActionListener;
  47 import java.awt.image.BufferedImage;
  48 import java.beans.PropertyChangeEvent;
  49 import java.io.FileOutputStream;
  50 import java.util.ArrayList;
  51 import java.util.List;
  52
  53 import javax.imageio.ImageIO;
  54 import javax.swing.ButtonGroup;
  55 import javax.swing.JMenuItem;
  56 import javax.swing.JRadioButtonMenuItem;
  57
  58 import org.jibble.epsgraphics.EpsGraphics2D;
  59
  60 /**
  61  * DOCUMENT ME!
  62  *
  63  * @author $author$
  64  * @version $Revision$
  65  */
  66 public class TreePanel extends GTreePanel
  67 {
  68   String type;
  69
  70   String pwtype;
  71
  72   TreeCanvas treeCanvas;
  73
  74   NJTree tree;
  75
  76   AlignViewport av;
  77
  78   /**
  79    * Creates a new TreePanel object.
  80    *
  81    * @param av
  82    *          DOCUMENT ME!
  83    * @param seqVector
  84    *          DOCUMENT ME!
  85    * @param type
  86    *          DOCUMENT ME!
  87    * @param pwtype
  88    *          DOCUMENT ME!
  89    * @param s
  90    *          DOCUMENT ME!
  91    * @param e
  92    *          DOCUMENT ME!
  93    */
  94   public TreePanel(AlignmentPanel ap, String type, String pwtype)
  95   {
  96     super();
  97     initTreePanel(ap, type, pwtype, null, null);
  98
  99     // We know this tree has distances. JBPNote TODO: prolly should add this as
 100     // a userdefined default
 101     // showDistances(true);
 102   }
 103
 104   /**
 105    * Creates a new TreePanel object.
 106    *
 107    * @param av
 108    *          DOCUMENT ME!
 109    * @param seqVector
 110    *          DOCUMENT ME!
 111    * @param newtree
 112    *          DOCUMENT ME!
 113    * @param type
 114    *          DOCUMENT ME!
 115    * @param pwtype
 116    *          DOCUMENT ME!
 117    */
 118   public TreePanel(AlignmentPanel ap, String type, String pwtype,
 119           NewickFile newtree)
 120   {
 121     super();
 122     initTreePanel(ap, type, pwtype, newtree, null);
 123   }
 124
 125   public TreePanel(AlignmentPanel av, String type, String pwtype,
 126           NewickFile newtree, AlignmentView inputData)
 127   {
 128     super();
 129     initTreePanel(av, type, pwtype, newtree, inputData);
 130   }
 131
 132   public AlignmentI getAlignment()
 133   {
 134     return treeCanvas.av.getAlignment();
 135   }
 136
 137   public AlignViewport getViewPort()
 138   {
 139     return treeCanvas.av;
 140   }
 141
 142   void initTreePanel(AlignmentPanel ap, String type, String pwtype,
 143           NewickFile newTree, AlignmentView inputData)
 144   {
 145
 146     av = ap.av;
 147     this.type = type;
 148     this.pwtype = pwtype;
 149
 150     treeCanvas = new TreeCanvas(this, ap, scrollPane);
 151     scrollPane.setViewportView(treeCanvas);
 152
 153     PaintRefresher.Register(this, ap.av.getSequenceSetId());
 154
 155     buildAssociatedViewMenu();
 156
 157     av.addPropertyChangeListener(new java.beans.PropertyChangeListener()
 158     {
 159       public void propertyChange(PropertyChangeEvent evt)
 160       {
 161         if (evt.getPropertyName().equals("alignment"))
 162         {
 163           if (tree == null)
 164           {
 165             System.out.println("tree is null");
 166             // TODO: deal with case when a change event is received whilst a
 167             // tree is still being calculated - should save reference for
 168             // processing message later.
 169             return;
 170           }
 171           if (evt.getNewValue() == null)
 172           {
 173             System.out
 174                     .println("new alignment sequences vector value is null");
 175           }
 176
 177           tree.UpdatePlaceHolders((List<SequenceI>) evt.getNewValue());
 178           treeCanvas.nameHash.clear(); // reset the mapping between canvas
 179           // rectangles and leafnodes
 180           repaint();
 181         }
 182       }
 183     });
 184
 185     TreeLoader tl = new TreeLoader(newTree);
 186     if (inputData != null)
 187     {
 188       tl.odata = inputData;
 189     }
 190     tl.start();
 191
 192   }
 193
 194   public void viewMenu_menuSelected()
 195   {
 196     buildAssociatedViewMenu();
 197   }
 198
 199   void buildAssociatedViewMenu()
 200   {
 201     AlignmentPanel[] aps = PaintRefresher.getAssociatedPanels(av
 202             .getSequenceSetId());
 203     if (aps.length == 1 && treeCanvas.ap == aps[0])
 204     {
 205       associateLeavesMenu.setVisible(false);
 206       return;
 207     }
 208
 209     associateLeavesMenu.setVisible(true);
 210
 211     if ((viewMenu.getItem(viewMenu.getItemCount() - 2) instanceof JMenuItem))
 212     {
 213       viewMenu.insertSeparator(viewMenu.getItemCount() - 1);
 214     }
 215
 216     associateLeavesMenu.removeAll();
 217
 218     JRadioButtonMenuItem item;
 219     ButtonGroup buttonGroup = new ButtonGroup();
 220     int i, iSize = aps.length;
 221     final TreePanel thisTreePanel = this;
 222     for (i = 0; i < iSize; i++)
 223     {
 224       final AlignmentPanel ap = aps[i];
 225       item = new JRadioButtonMenuItem(ap.av.viewName, ap == treeCanvas.ap);
 226       buttonGroup.add(item);
 227       item.addActionListener(new ActionListener()
 228       {
 229         public void actionPerformed(ActionEvent evt)
 230         {
 231           treeCanvas.applyToAllViews = false;
 232           treeCanvas.ap = ap;
 233           treeCanvas.av = ap.av;
 234           PaintRefresher.Register(thisTreePanel, ap.av.getSequenceSetId());
 235         }
 236       });
 237
 238       associateLeavesMenu.add(item);
 239     }
 240
 241     final JRadioButtonMenuItem itemf = new JRadioButtonMenuItem(
 242             MessageManager.getString("label.all_views"));
 243     buttonGroup.add(itemf);
 244     itemf.setSelected(treeCanvas.applyToAllViews);
 245     itemf.addActionListener(new ActionListener()
 246     {
 247       public void actionPerformed(ActionEvent evt)
 248       {
 249         treeCanvas.applyToAllViews = itemf.isSelected();
 250       }
 251     });
 252     associateLeavesMenu.add(itemf);
 253
 254   }
 255
 256   class TreeLoader extends Thread
 257   {
 258     NewickFile newtree;
 259
 260     jalview.datamodel.AlignmentView odata = null;
 261
 262     public TreeLoader(NewickFile newtree)
 263     {
 264       this.newtree = newtree;
 265       if (newtree != null)
 266       {
 267         // Must be outside run(), as Jalview2XML tries to
 268         // update distance/bootstrap visibility at the same time
 269         showBootstrap(newtree.HasBootstrap());
 270         showDistances(newtree.HasDistances());
 271       }
 272     }
 273
 274     public void run()
 275     {
 276
 277       if (newtree != null)
 278       {
 279         if (odata == null)
 280         {
 281           tree = new NJTree(av.getAlignment().getSequencesArray(), newtree);
 282         }
 283         else
 284         {
 285           tree = new NJTree(av.getAlignment().getSequencesArray(), odata,
 286                   newtree);
 287         }
 288         if (!tree.hasOriginalSequenceData())
 289         {
 290           allowOriginalSeqData(false);
 291         }
 292       }
 293       else
 294       {
 295         int start, end;
 296         SequenceI[] seqs;
 297         boolean selview = av.getSelectionGroup() != null
 298                 && av.getSelectionGroup().getSize() > 1;
 299         AlignmentView seqStrings = av.getAlignmentView(selview);
 300         if (!selview)
 301         {
 302           start = 0;
 303           end = av.getAlignment().getWidth();
 304           seqs = av.getAlignment().getSequencesArray();
 305         }
 306         else
 307         {
 308           start = av.getSelectionGroup().getStartRes();
 309           end = av.getSelectionGroup().getEndRes() + 1;
 310           seqs = av.getSelectionGroup().getSequencesInOrder(
 311                   av.getAlignment());
 312         }
 313
 314         tree = new NJTree(seqs, seqStrings, type, pwtype, start, end);
 315         showDistances(true);
 316       }
 317
 318       tree.reCount(tree.getTopNode());
 319       tree.findHeight(tree.getTopNode());
 320       treeCanvas.setTree(tree);
 321       treeCanvas.repaint();
 322       av.setCurrentTree(tree);
 323       if (av.getSortByTree())
 324       {
 325         sortByTree_actionPerformed();
 326       }
 327     }
 328   }
 329
 330   public void showDistances(boolean b)
 331   {
 332     treeCanvas.setShowDistances(b);
 333     distanceMenu.setSelected(b);
 334   }
 335
 336   public void showBootstrap(boolean b)
 337   {
 338     treeCanvas.setShowBootstrap(b);
 339     bootstrapMenu.setSelected(b);
 340   }
 341
 342   public void showPlaceholders(boolean b)
 343   {
 344     placeholdersMenu.setState(b);
 345     treeCanvas.setMarkPlaceholders(b);
 346   }
 347
 348   private void allowOriginalSeqData(boolean b)
 349   {
 350     originalSeqData.setVisible(b);
 351   }
 352
 353   /**
 354    * DOCUMENT ME!
 355    *
 356    * @return DOCUMENT ME!
 357    */
 358   public NJTree getTree()
 359   {
 360     return tree;
 361   }
 362
 363   /**
 364    * DOCUMENT ME!
 365    *
 366    * @param e
 367    *          DOCUMENT ME!
 368    */
 369   public void textbox_actionPerformed(ActionEvent e)
 370   {
 371     CutAndPasteTransfer cap = new CutAndPasteTransfer();
 372
 373     StringBuffer buffer = new StringBuffer();
 374
 375     if (type.equals("AV"))
 376     {
 377       buffer.append("Average distance tree using ");
 378     }
 379     else
 380     {
 381       buffer.append("Neighbour joining tree using ");
 382     }
 383
 384     if (pwtype.equals("BL"))
 385     {
 386       buffer.append("BLOSUM62");
 387     }
 388     else
 389     {
 390       buffer.append("PID");
 391     }
 392
 393     jalview.io.NewickFile fout = new jalview.io.NewickFile(
 394             tree.getTopNode());
 395     try
 396     {
 397       cap.setText(fout.print(tree.isHasBootstrap(), tree.isHasDistances(),
 398               tree.isHasRootDistance()));
 399       Desktop.addInternalFrame(cap, buffer.toString(), 500, 100);
 400     } catch (OutOfMemoryError oom)
 401     {
 402       new OOMWarning("generating newick tree file", oom);
 403       cap.dispose();
 404     }
 405
 406   }
 407
 408   /**
 409    * DOCUMENT ME!
 410    *
 411    * @param e
 412    *          DOCUMENT ME!
 413    */
 414   public void saveAsNewick_actionPerformed(ActionEvent e)
 415   {
 416     JalviewFileChooser chooser = new JalviewFileChooser(
 417             jalview.bin.Cache.getProperty("LAST_DIRECTORY"));
 418     chooser.setFileView(new JalviewFileView());
 419     chooser.setDialogTitle(MessageManager.getString("label.save_tree_as_newick"));
 420     chooser.setToolTipText(MessageManager.getString("action.save"));
 421
 422     int value = chooser.showSaveDialog(null);
 423
 424     if (value == JalviewFileChooser.APPROVE_OPTION)
 425     {
 426       String choice = chooser.getSelectedFile().getPath();
 427       jalview.bin.Cache.setProperty("LAST_DIRECTORY", chooser
 428               .getSelectedFile().getParent());
 429
 430       try
 431       {
 432         jalview.io.NewickFile fout = new jalview.io.NewickFile(
 433                 tree.getTopNode());
 434         String output = fout.print(tree.isHasBootstrap(),
 435                 tree.isHasDistances(), tree.isHasRootDistance());
 436         java.io.PrintWriter out = new java.io.PrintWriter(
 437                 new java.io.FileWriter(choice));
 438         out.println(output);
 439         out.close();
 440       } catch (Exception ex)
 441       {
 442         ex.printStackTrace();
 443       }
 444     }
 445   }
 446
 447   /**
 448    * DOCUMENT ME!
 449    *
 450    * @param e
 451    *          DOCUMENT ME!
 452    */
 453   public void printMenu_actionPerformed(ActionEvent e)
 454   {
 455     // Putting in a thread avoids Swing painting problems
 456     treeCanvas.startPrinting();
 457   }
 458
 459   public void originalSeqData_actionPerformed(ActionEvent e)
 460   {
 461     if (!tree.hasOriginalSequenceData())
 462     {
 463       jalview.bin.Cache.log
 464               .info("Unexpected call to originalSeqData_actionPerformed - should have hidden this menu action.");
 465       return;
 466     }
 467     // decide if av alignment is sufficiently different to original data to
 468     // warrant a new window to be created
 469     // create new alignmnt window with hidden regions (unhiding hidden regions
 470     // yields unaligned seqs)
 471     // or create a selection box around columns in alignment view
 472     // test Alignment(SeqCigar[])
 473     char gc = '-';
 474     try
 475     {
 476       // we try to get the associated view's gap character
 477       // but this may fail if the view was closed...
 478       gc = av.getGapCharacter();
 479
 480     } catch (Exception ex)
 481     {
 482     }
 483     ;
 484     Object[] alAndColsel = tree.seqData.getAlignmentAndColumnSelection(gc);
 485
 486     if (alAndColsel != null && alAndColsel[0] != null)
 487     {
 488       // AlignmentOrder origorder = new AlignmentOrder(alAndColsel[0]);
 489
 490       Alignment al = new Alignment((SequenceI[]) alAndColsel[0]);
 491       Alignment dataset = (av != null && av.getAlignment() != null) ? av
 492               .getAlignment().getDataset() : null;
 493       if (dataset != null)
 494       {
 495         al.setDataset(dataset);
 496       }
 497
 498       if (true)
 499       {
 500         // make a new frame!
 501         AlignFrame af = new AlignFrame(al,
 502                 (ColumnSelection) alAndColsel[1], AlignFrame.DEFAULT_WIDTH,
 503                 AlignFrame.DEFAULT_HEIGHT);
 504
 505         // >>>This is a fix for the moment, until a better solution is
 506         // found!!<<<
 507         // af.getFeatureRenderer().transferSettings(alignFrame.getFeatureRenderer());
 508
 509         // af.addSortByOrderMenuItem(ServiceName + " Ordering",
 510         // msaorder);
 511
 512         Desktop.addInternalFrame(af, MessageManager.formatMessage(
 513                 "label.original_data_for_params", new String[]
 514                 { this.title }), AlignFrame.DEFAULT_WIDTH,
 515                 AlignFrame.DEFAULT_HEIGHT);
 516       }
 517     }
 518   }
 519
 520   /**
 521    * DOCUMENT ME!
 522    *
 523    * @param e
 524    *          DOCUMENT ME!
 525    */
 526   public void fitToWindow_actionPerformed(ActionEvent e)
 527   {
 528     treeCanvas.fitToWindow = fitToWindow.isSelected();
 529     repaint();
 530   }
 531
 532   /**
 533    * sort the associated alignment view by the current tree.
 534    *
 535    * @param e
 536    */
 537   @Override
 538   public void sortByTree_actionPerformed()
 539   {
 540
 541     if (treeCanvas.applyToAllViews)
 542     {
 543       final ArrayList<CommandI> commands = new ArrayList<CommandI>();
 544       for (AlignmentPanel ap : PaintRefresher.getAssociatedPanels(av
 545               .getSequenceSetId()))
 546       {
 547         commands.add(sortAlignmentIn(ap.av.getAlignPanel()));
 548       }
 549       av.getAlignPanel().alignFrame.addHistoryItem(new CommandI()
 550       {
 551
 552         @Override
 553         public void undoCommand(AlignmentI[] views)
 554         {
 555           for (CommandI tsort : commands)
 556           {
 557             tsort.undoCommand(views);
 558           }
 559         }
 560
 561         @Override
 562         public int getSize()
 563         {
 564           return commands.size();
 565         }
 566
 567         @Override
 568         public String getDescription()
 569         {
 570           return "Tree Sort (many views)";
 571         }
 572
 573         @Override
 574         public void doCommand(AlignmentI[] views)
 575         {
 576
 577           for (CommandI tsort : commands)
 578           {
 579             tsort.doCommand(views);
 580           }
 581         }
 582       });
 583       for (AlignmentPanel ap : PaintRefresher.getAssociatedPanels(av
 584               .getSequenceSetId()))
 585       {
 586         // ensure all the alignFrames refresh their GI after adding an undo item
 587         ap.alignFrame.updateEditMenuBar();
 588       }
 589     }
 590     else
 591     {
 592       treeCanvas.ap.alignFrame
 593               .addHistoryItem(sortAlignmentIn(treeCanvas.ap));
 594     }
 595
 596   }
 597
 598   public CommandI sortAlignmentIn(AlignmentPanel ap)
 599   {
 600     AlignViewport av = ap.av;
 601     SequenceI[] oldOrder = av.getAlignment().getSequencesArray();
 602     AlignmentSorter.sortByTree(av.getAlignment(), tree);
 603     CommandI undo;
 604     undo = new OrderCommand("Tree Sort", oldOrder, av.getAlignment());
 605
 606     ap.paintAlignment(true);
 607     return undo;
 608   }
 609
 610   /**
 611    * DOCUMENT ME!
 612    *
 613    * @param e
 614    *          DOCUMENT ME!
 615    */
 616   public void font_actionPerformed(ActionEvent e)
 617   {
 618     if (treeCanvas == null)
 619     {
 620       return;
 621     }
 622
 623     new FontChooser(this);
 624   }
 625
 626   public Font getTreeFont()
 627   {
 628     return treeCanvas.font;
 629   }
 630
 631   public void setTreeFont(Font font)
 632   {
 633     if (treeCanvas != null)
 634     {
 635       treeCanvas.setFont(font);
 636     }
 637   }
 638
 639   /**
 640    * DOCUMENT ME!
 641    *
 642    * @param e
 643    *          DOCUMENT ME!
 644    */
 645   public void distanceMenu_actionPerformed(ActionEvent e)
 646   {
 647     treeCanvas.setShowDistances(distanceMenu.isSelected());
 648   }
 649
 650   /**
 651    * DOCUMENT ME!
 652    *
 653    * @param e
 654    *          DOCUMENT ME!
 655    */
 656   public void bootstrapMenu_actionPerformed(ActionEvent e)
 657   {
 658     treeCanvas.setShowBootstrap(bootstrapMenu.isSelected());
 659   }
 660
 661   /**
 662    * DOCUMENT ME!
 663    *
 664    * @param e
 665    *          DOCUMENT ME!
 666    */
 667   public void placeholdersMenu_actionPerformed(ActionEvent e)
 668   {
 669     treeCanvas.setMarkPlaceholders(placeholdersMenu.isSelected());
 670   }
 671
 672   /**
 673    * DOCUMENT ME!
 674    *
 675    * @param e
 676    *          DOCUMENT ME!
 677    */
 678   public void epsTree_actionPerformed(ActionEvent e)
 679   {
 680     boolean accurateText = true;
 681
 682     String renderStyle = jalview.bin.Cache.getDefault("EPS_RENDERING",
 683             "Prompt each time");
 684
 685     // If we need to prompt, and if the GUI is visible then
 686     // Prompt for EPS rendering style
 687     if (renderStyle.equalsIgnoreCase("Prompt each time")
 688             && !(System.getProperty("java.awt.headless") != null && System
 689                     .getProperty("java.awt.headless").equals("true")))
 690     {
 691       EPSOptions eps = new EPSOptions();
 692       renderStyle = eps.getValue();
 693
 694       if (renderStyle == null || eps.cancelled)
 695       {
 696         return;
 697       }
 698
 699     }
 700
 701     if (renderStyle.equalsIgnoreCase("text"))
 702     {
 703       accurateText = false;
 704     }
 705
 706     int width = treeCanvas.getWidth();
 707     int height = treeCanvas.getHeight();
 708
 709     try
 710     {
 711       jalview.io.JalviewFileChooser chooser = new jalview.io.JalviewFileChooser(
 712               jalview.bin.Cache.getProperty("LAST_DIRECTORY"), new String[]
 713               { "eps" }, new String[]
 714               { "Encapsulated Postscript" }, "Encapsulated Postscript");
 715       chooser.setFileView(new jalview.io.JalviewFileView());
 716       chooser.setDialogTitle(MessageManager.getString("label.create_eps_from_tree"));
 717       chooser.setToolTipText(MessageManager.getString("action.save"));
 718
 719       int value = chooser.showSaveDialog(this);
 720
 721       if (value != jalview.io.JalviewFileChooser.APPROVE_OPTION)
 722       {
 723         return;
 724       }
 725
 726       jalview.bin.Cache.setProperty("LAST_DIRECTORY", chooser
 727               .getSelectedFile().getParent());
 728
 729       FileOutputStream out = new FileOutputStream(chooser.getSelectedFile());
 730       EpsGraphics2D pg = new EpsGraphics2D("Tree", out, 0, 0, width, height);
 731
 732       pg.setAccurateTextMode(accurateText);
 733
 734       treeCanvas.draw(pg, width, height);
 735
 736       pg.flush();
 737       pg.close();
 738     } catch (Exception ex)
 739     {
 740       ex.printStackTrace();
 741     }
 742   }
 743
 744   /**
 745    * DOCUMENT ME!
 746    *
 747    * @param e
 748    *          DOCUMENT ME!
 749    */
 750   public void pngTree_actionPerformed(ActionEvent e)
 751   {
 752     int width = treeCanvas.getWidth();
 753     int height = treeCanvas.getHeight();
 754
 755     try
 756     {
 757       jalview.io.JalviewFileChooser chooser = new jalview.io.JalviewFileChooser(
 758               jalview.bin.Cache.getProperty("LAST_DIRECTORY"), new String[]
 759               { "png" }, new String[]
 760               { "Portable network graphics" }, "Portable network graphics");
 761
 762       chooser.setFileView(new jalview.io.JalviewFileView());
 763       chooser.setDialogTitle(MessageManager.getString("label.create_png_from_tree"));
 764       chooser.setToolTipText(MessageManager.getString("action.save"));
 765
 766       int value = chooser.showSaveDialog(this);
 767
 768       if (value != jalview.io.JalviewFileChooser.APPROVE_OPTION)
 769       {
 770         return;
 771       }
 772
 773       jalview.bin.Cache.setProperty("LAST_DIRECTORY", chooser
 774               .getSelectedFile().getParent());
 775
 776       FileOutputStream out = new FileOutputStream(chooser.getSelectedFile());
 777
 778       BufferedImage bi = new BufferedImage(width, height,
 779               BufferedImage.TYPE_INT_RGB);
 780       Graphics png = bi.getGraphics();
 781
 782       treeCanvas.draw(png, width, height);
 783
 784       ImageIO.write(bi, "png", out);
 785       out.close();
 786     } catch (Exception ex)
 787     {
 788       ex.printStackTrace();
 789     }
 790   }
 791
 792   /**
 793    * change node labels to the annotation referred to by labelClass TODO:
 794    * promote to a datamodel modification that can be undone TODO: make argument
 795    * one case of a generic transformation function ie { undoStep = apply(Tree,
 796    * TransformFunction)};
 797    *
 798    * @param labelClass
 799    */
 800   public void changeNames(final String labelClass)
 801   {
 802     tree.applyToNodes(new NodeTransformI()
 803     {
 804
 805       public void transform(BinaryNode node)
 806       {
 807         if (node instanceof SequenceNode
 808                 && !((SequenceNode) node).isPlaceholder()
 809                 && !((SequenceNode) node).isDummy())
 810         {
 811           String newname = null;
 812           SequenceI sq = (SequenceI) ((SequenceNode) node).element();
 813           if (sq != null)
 814           {
 815             // search dbrefs, features and annotation
 816             DBRefEntry[] refs = jalview.util.DBRefUtils.selectRefs(
 817                     sq.getDBRef(), new String[]
 818                     { labelClass.toUpperCase() });
 819             if (refs != null)
 820             {
 821               for (int i = 0; i < refs.length; i++)
 822               {
 823                 if (newname == null)
 824                 {
 825                   newname = new String(refs[i].getAccessionId());
 826                 }
 827                 else
 828                 {
 829                   newname = newname + "; " + refs[i].getAccessionId();
 830                 }
 831               }
 832             }
 833             if (newname == null)
 834             {
 835               SequenceFeature sf[] = sq.getSequenceFeatures();
 836               for (int i = 0; sf != null && i < sf.length; i++)
 837               {
 838                 if (sf[i].getType().equals(labelClass))
 839                 {
 840                   if (newname == null)
 841                   {
 842                     newname = new String(sf[i].getDescription());
 843                   }
 844                   else
 845                   {
 846                     newname = newname + "; " + sf[i].getDescription();
 847                   }
 848                 }
 849               }
 850             }
 851           }
 852           if (newname != null)
 853           {
 854             String oldname = ((SequenceNode) node).getName();
 855             // TODO : save in the undo object for this modification.
 856             ((SequenceNode) node).setName(newname);
 857           }
 858         }
 859       }
 860     });
 861   }
 862 }