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