src/jalview/gui/TreePanel.java

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