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