src/jalview/gui/TreePanel.java

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