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