src/jalview/gui/AlignFrame.java

   1 /*\r
   2  * Jalview - A Sequence Alignment Editor and Viewer\r
   3  * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
   4  *\r
   5  * This program is free software; you can redistribute it and/or\r
   6  * modify it under the terms of the GNU General Public License\r
   7  * as published by the Free Software Foundation; either version 2\r
   8  * of the License, or (at your option) any later version.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful,\r
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13  * GNU General Public License for more details.\r
  14  *\r
  15  * You should have received a copy of the GNU General Public License\r
  16  * along with this program; if not, write to the Free Softwarechang\r
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
  18  */\r
  19 package jalview.gui;\r
  20 \r
  21 import java.beans.*;\r
  22 import java.io.*;\r
  23 import java.util.*;\r
  24 \r
  25 import java.awt.*;\r
  26 import java.awt.datatransfer.*;\r
  27 import java.awt.event.*;\r
  28 import java.awt.print.*;\r
  29 import javax.swing.*;\r
  30 import javax.swing.event.*;\r
  31 \r
  32 import jalview.analysis.*;\r
  33 import jalview.datamodel.*;\r
  34 import jalview.io.*;\r
  35 import jalview.jbgui.*;\r
  36 import jalview.schemes.*;\r
  37 import jalview.ws.*;\r
  38 \r
  39 /**\r
  40  * DOCUMENT ME!\r
  41  *\r
  42  * @author $author$\r
  43  * @version $Revision$\r
  44  */\r
  45 public class AlignFrame\r
  46     extends GAlignFrame\r
  47 {\r
  48   /** DOCUMENT ME!! */\r
  49   public static final int NEW_WINDOW_WIDTH = 700;\r
  50 \r
  51   /** DOCUMENT ME!! */\r
  52   public static final int NEW_WINDOW_HEIGHT = 500;\r
  53   final AlignmentPanel alignPanel;\r
  54   final AlignViewport viewport;\r
  55 \r
  56   /** DOCUMENT ME!! */\r
  57   public String currentFileFormat = null;\r
  58   Stack historyList = new Stack();\r
  59   Stack redoList = new Stack();\r
  60   private int treeCount = 0;\r
  61 \r
  62   /**\r
  63    * Creates a new AlignFrame object.\r
  64    *\r
  65    * @param al DOCUMENT ME!\r
  66    */\r
  67   public AlignFrame(AlignmentI al)\r
  68   {\r
  69     viewport = new AlignViewport(al);\r
  70 \r
  71     if(viewport.vconsensus==null)\r
  72     {\r
  73       //Out of memory caluclating consensus.\r
  74       BLOSUM62Colour.setEnabled(false);\r
  75       PIDColour.setEnabled(false);\r
  76       conservationMenuItem.setEnabled(false);\r
  77       modifyConservation.setEnabled(false);\r
  78       abovePIDThreshold.setEnabled(false);\r
  79       modifyPID.setEnabled(false);\r
  80     }\r
  81 \r
  82     alignPanel = new AlignmentPanel(this, viewport);\r
  83     alignPanel.annotationPanel.adjustPanelHeight();\r
  84     alignPanel.annotationSpaceFillerHolder.setPreferredSize(alignPanel.\r
  85         annotationPanel.getPreferredSize());\r
  86     alignPanel.annotationScroller.setPreferredSize(alignPanel.annotationPanel.\r
  87         getPreferredSize());\r
  88     alignPanel.setAnnotationVisible(viewport.getShowAnnotation());\r
  89 \r
  90     String sortby = jalview.bin.Cache.getDefault("SORT_ALIGNMENT", "No sort");\r
  91 \r
  92     if(sortby.equals("Id"))\r
  93       sortIDMenuItem_actionPerformed(null);\r
  94     else if(sortby.equals("Pairwise Identity"))\r
  95       sortPairwiseMenuItem_actionPerformed(null);\r
  96 \r
  97     getContentPane().add(alignPanel, java.awt.BorderLayout.CENTER);\r
  98 \r
  99     viewport.addPropertyChangeListener(new PropertyChangeListener()\r
 100     {\r
 101      public void propertyChange(PropertyChangeEvent evt)\r
 102      {\r
 103        if (evt.getPropertyName().equals("alignment"))\r
 104        {\r
 105          alignmentChanged();\r
 106        }\r
 107      }\r
 108    });\r
 109 \r
 110         if(Desktop.desktop!=null)\r
 111     addServiceListeners();\r
 112   }\r
 113 \r
 114   /* Set up intrinsic listeners for dynamically generated GUI bits. */\r
 115   private void addServiceListeners()\r
 116   {\r
 117     final java.beans.PropertyChangeListener thisListener;\r
 118     // Do this once to get current state\r
 119     BuildWebServiceMenu();\r
 120     Desktop.discoverer.addPropertyChangeListener(\r
 121         thisListener = new java.beans.PropertyChangeListener()\r
 122     {\r
 123       public void propertyChange(PropertyChangeEvent evt)\r
 124       {\r
 125         // System.out.println("Discoverer property change.");\r
 126         if (evt.getPropertyName().equals("services"))\r
 127         {\r
 128           // System.out.println("Rebuilding web service menu");\r
 129           BuildWebServiceMenu();\r
 130         }\r
 131       }\r
 132     });\r
 133     addInternalFrameListener(new javax.swing.event.\r
 134                              InternalFrameAdapter()\r
 135     {\r
 136       public void internalFrameClosed(\r
 137           javax.swing.event.InternalFrameEvent evt)\r
 138       {\r
 139         // System.out.println("deregistering discoverer listener");\r
 140         Desktop.discoverer.removePropertyChangeListener(thisListener);\r
 141         closeMenuItem_actionPerformed(null);\r
 142       }\r
 143       ;\r
 144     });\r
 145 \r
 146   }\r
 147 \r
 148   /**\r
 149    * DOCUMENT ME!\r
 150    *\r
 151    * @param String DOCUMENT ME!\r
 152    */\r
 153 \r
 154   public void parseGroupsFile(String file)\r
 155   {\r
 156     try\r
 157     {\r
 158       BufferedReader in = new BufferedReader(new FileReader(file));\r
 159       SequenceI seq = null;\r
 160       String line, text, token;\r
 161       UserColourScheme ucs;\r
 162       int index, start, end;\r
 163       StringTokenizer st;\r
 164       SequenceGroup sg;\r
 165       while ( (line = in.readLine()) != null)\r
 166       {\r
 167         st = new StringTokenizer(line, "\t");\r
 168         if (st.countTokens() != 6)\r
 169         {\r
 170           System.out.println("Groups file " + file +\r
 171                              " is invalid. Read help file.");\r
 172           System.exit(1);\r
 173         }\r
 174 \r
 175         while (st.hasMoreElements())\r
 176         {\r
 177           text = st.nextToken();\r
 178           token = st.nextToken();\r
 179           if (!token.equals("ID_NOT_SPECIFIED"))\r
 180           {\r
 181             index = viewport.alignment.findIndex(viewport.alignment.findName(\r
 182                 token));\r
 183             st.nextToken();\r
 184           }\r
 185           else\r
 186           {\r
 187             index = Integer.parseInt(st.nextToken());\r
 188           }\r
 189 \r
 190           start = Integer.parseInt(st.nextToken());\r
 191           end = Integer.parseInt(st.nextToken());\r
 192           ucs = new UserColourScheme(st.nextToken());\r
 193 \r
 194           seq = viewport.alignment.getSequenceAt(index);\r
 195           start = seq.findIndex(start) - 1;\r
 196           end = seq.findIndex(end) - 1;\r
 197 \r
 198           sg = new SequenceGroup(text, ucs, true, true, false, start, end);\r
 199           sg.addSequence(seq, true);\r
 200 \r
 201           viewport.alignment.addGroup(sg);\r
 202         }\r
 203       }\r
 204 \r
 205     }\r
 206     catch (Exception ex)\r
 207     {\r
 208       System.out.println("Error parsing groups file: " + ex);\r
 209     }\r
 210   }\r
 211 \r
 212   /**\r
 213    * DOCUMENT ME!\r
 214    *\r
 215    * @param e DOCUMENT ME!\r
 216    */\r
 217   public void saveAlignmentMenu_actionPerformed(ActionEvent e)\r
 218   {\r
 219     JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache.\r
 220         getProperty(\r
 221             "LAST_DIRECTORY"),\r
 222         new String[]\r
 223         {\r
 224         "fa, fasta, fastq", "aln", "pfam", "msf", "pir", "blc",\r
 225         "jar"\r
 226     },\r
 227         new String[]\r
 228         {\r
 229         "Fasta", "Clustal", "PFAM", "MSF", "PIR", "BLC", "Jalview"\r
 230     }, currentFileFormat);\r
 231 \r
 232     chooser.setAcceptAllFileFilterUsed(false);\r
 233     chooser.setFileView(new JalviewFileView());\r
 234     chooser.setDialogTitle("Save Alignment to file");\r
 235     chooser.setToolTipText("Save");\r
 236 \r
 237     int value = chooser.showSaveDialog(this);\r
 238 \r
 239     if (value == JalviewFileChooser.APPROVE_OPTION)\r
 240     {\r
 241         currentFileFormat = chooser.getSelectedFormat();\r
 242 \r
 243         if (currentFileFormat == null)\r
 244         {\r
 245           JOptionPane.showInternalMessageDialog(Desktop.desktop,\r
 246                                                 "You must select a file format before saving!",\r
 247                                                 "File format not specified",\r
 248                                                 JOptionPane.WARNING_MESSAGE);\r
 249           value = chooser.showSaveDialog(this);\r
 250           return;\r
 251         }\r
 252 \r
 253       jalview.bin.Cache.setProperty("DEFAULT_FILE_FORMAT",\r
 254                                     currentFileFormat);\r
 255 \r
 256       String choice = chooser.getSelectedFile().getPath();\r
 257       jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice);\r
 258 \r
 259       saveAlignment(choice, currentFileFormat);\r
 260     }\r
 261   }\r
 262 \r
 263   public boolean saveAlignment(String file, String format)\r
 264   {\r
 265     if (format.equalsIgnoreCase("Jalview"))\r
 266     {\r
 267       String shortName = title;\r
 268 \r
 269       if (shortName.indexOf(java.io.File.separatorChar) > -1)\r
 270       {\r
 271         shortName = shortName.substring(shortName.lastIndexOf(\r
 272             java.io.File.separatorChar) + 1);\r
 273       }\r
 274 \r
 275       Jalview2XML.SaveAlignment(this, file, shortName);\r
 276 \r
 277       // USE Jalview2XML to save this file\r
 278       return true;\r
 279     }\r
 280     else\r
 281     {\r
 282       String output = new FormatAdapter().formatSequences(format,\r
 283           viewport.getAlignment().\r
 284           getSequences());\r
 285       if (output == null)\r
 286       {\r
 287         return false;\r
 288       }\r
 289 \r
 290       try\r
 291       {\r
 292         java.io.PrintWriter out = new java.io.PrintWriter(\r
 293             new java.io.FileWriter(file));\r
 294 \r
 295         out.print(output);\r
 296         out.close();\r
 297         return true;\r
 298       }\r
 299       catch (Exception ex)\r
 300       {\r
 301         ex.printStackTrace();\r
 302       }\r
 303     }\r
 304     return false;\r
 305   }\r
 306 \r
 307   /**\r
 308    * DOCUMENT ME!\r
 309    *\r
 310    * @param e DOCUMENT ME!\r
 311    */\r
 312   protected void outputText_actionPerformed(ActionEvent e)\r
 313   {\r
 314     CutAndPasteTransfer cap = new CutAndPasteTransfer();\r
 315     Desktop.addInternalFrame(cap,\r
 316                              "Alignment output - " + e.getActionCommand(), 600,\r
 317                              500);\r
 318     cap.setText(new FormatAdapter().formatSequences(e.getActionCommand(),\r
 319                                               viewport.getAlignment().\r
 320                                               getSequences()));\r
 321   }\r
 322 \r
 323   /**\r
 324    * DOCUMENT ME!\r
 325    *\r
 326    * @param e DOCUMENT ME!\r
 327    */\r
 328   protected void htmlMenuItem_actionPerformed(ActionEvent e)\r
 329   {\r
 330     new HTMLOutput(viewport);\r
 331   }\r
 332 \r
 333   public void createImageMap(File file, String image)\r
 334   {\r
 335     alignPanel.makePNGImageMap(file, image);\r
 336   }\r
 337 \r
 338   /**\r
 339    * DOCUMENT ME!\r
 340    *\r
 341    * @param e DOCUMENT ME!\r
 342    */\r
 343   public void createPNG(File f)\r
 344   {\r
 345     alignPanel.makePNG(f);\r
 346   }\r
 347 \r
 348   /**\r
 349    * DOCUMENT ME!\r
 350    *\r
 351    * @param e DOCUMENT ME!\r
 352    */\r
 353   public void createEPS(File f)\r
 354   {\r
 355     alignPanel.makeEPS(f);\r
 356   }\r
 357 \r
 358   /**\r
 359    * DOCUMENT ME!\r
 360    *\r
 361    * @param e DOCUMENT ME!\r
 362    */\r
 363   public void printMenuItem_actionPerformed(ActionEvent e)\r
 364   {\r
 365     //Putting in a thread avoids Swing painting problems\r
 366     PrintThread thread = new PrintThread();\r
 367     thread.start();\r
 368   }\r
 369 \r
 370   /**\r
 371    * DOCUMENT ME!\r
 372    *\r
 373    * @param e DOCUMENT ME!\r
 374    */\r
 375   public void closeMenuItem_actionPerformed(ActionEvent e)\r
 376   {\r
 377     try\r
 378     {\r
 379       PaintRefresher.components.remove(viewport.alignment);\r
 380       this.setClosed(true);\r
 381     }\r
 382     catch (Exception ex)\r
 383     {\r
 384     }\r
 385   }\r
 386 \r
 387   /**\r
 388    * DOCUMENT ME!\r
 389    */\r
 390   void updateEditMenuBar()\r
 391   {\r
 392     if (historyList.size() > 0)\r
 393     {\r
 394       undoMenuItem.setEnabled(true);\r
 395 \r
 396       HistoryItem hi = (HistoryItem) historyList.peek();\r
 397       undoMenuItem.setText("Undo " + hi.getDescription());\r
 398     }\r
 399     else\r
 400     {\r
 401       undoMenuItem.setEnabled(false);\r
 402       undoMenuItem.setText("Undo");\r
 403     }\r
 404 \r
 405     if (redoList.size() > 0)\r
 406     {\r
 407       redoMenuItem.setEnabled(true);\r
 408 \r
 409       HistoryItem hi = (HistoryItem) redoList.peek();\r
 410       redoMenuItem.setText("Redo " + hi.getDescription());\r
 411     }\r
 412     else\r
 413     {\r
 414       redoMenuItem.setEnabled(false);\r
 415       redoMenuItem.setText("Redo");\r
 416     }\r
 417   }\r
 418 \r
 419   /**\r
 420    * DOCUMENT ME!\r
 421    *\r
 422    * @param hi DOCUMENT ME!\r
 423    */\r
 424   public void addHistoryItem(HistoryItem hi)\r
 425   {\r
 426     historyList.push(hi);\r
 427     updateEditMenuBar();\r
 428   }\r
 429 \r
 430   /**\r
 431    * DOCUMENT ME!\r
 432    *\r
 433    * @param e DOCUMENT ME!\r
 434    */\r
 435   protected void undoMenuItem_actionPerformed(ActionEvent e)\r
 436   {\r
 437     HistoryItem hi = (HistoryItem) historyList.pop();\r
 438     redoList.push(new HistoryItem(hi.getDescription(), viewport.alignment,\r
 439                                   HistoryItem.HIDE));\r
 440     restoreHistoryItem(hi);\r
 441     viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());\r
 442   }\r
 443 \r
 444   /**\r
 445    * DOCUMENT ME!\r
 446    *\r
 447    * @param e DOCUMENT ME!\r
 448    */\r
 449   protected void redoMenuItem_actionPerformed(ActionEvent e)\r
 450   {\r
 451     HistoryItem hi = (HistoryItem) redoList.pop();\r
 452     restoreHistoryItem(hi);\r
 453     updateEditMenuBar();\r
 454     viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());\r
 455   }\r
 456 \r
 457   // used by undo and redo\r
 458   void restoreHistoryItem(HistoryItem hi)\r
 459   {\r
 460     if (hi.getType() == HistoryItem.SORT)\r
 461     {\r
 462       for (int i = 0; i < hi.getSequences().size(); i++)\r
 463       {\r
 464         viewport.alignment.getSequences().setElementAt(hi.getSequences()\r
 465             .elementAt(i),\r
 466             i);\r
 467       }\r
 468     }\r
 469     else\r
 470     {\r
 471       for (int i = 0; i < hi.getSequences().size(); i++)\r
 472       {\r
 473         SequenceI restore = (SequenceI) hi.getSequences().elementAt(i);\r
 474 \r
 475         if (restore.getLength() == 0)\r
 476         {\r
 477           restore.setSequence(hi.getHidden().elementAt(i).toString());\r
 478           viewport.alignment.getSequences().insertElementAt(restore,\r
 479               hi.getAlignIndex(i));\r
 480         }\r
 481         else\r
 482         {\r
 483           restore.setSequence(hi.getHidden().elementAt(i).toString());\r
 484         }\r
 485       }\r
 486 \r
 487       if (hi.getType() == HistoryItem.PASTE)\r
 488       {\r
 489         for (int i = viewport.alignment.getHeight() - 1;\r
 490              i > (hi.getSequences().size() - 1); i--)\r
 491         {\r
 492           viewport.alignment.deleteSequence(i);\r
 493         }\r
 494       }\r
 495     }\r
 496 \r
 497     updateEditMenuBar();\r
 498 \r
 499     viewport.firePropertyChange("alignment", null,\r
 500                                 viewport.getAlignment().getSequences());\r
 501   }\r
 502 \r
 503   /**\r
 504    * DOCUMENT ME!\r
 505    *\r
 506    * @param up DOCUMENT ME!\r
 507    */\r
 508   public void moveSelectedSequences(boolean up)\r
 509   {\r
 510     SequenceGroup sg = viewport.getSelectionGroup();\r
 511 \r
 512     if (sg == null)\r
 513     {\r
 514       return;\r
 515     }\r
 516 \r
 517     if (up)\r
 518     {\r
 519       for (int i = 1; i < viewport.alignment.getHeight(); i++)\r
 520       {\r
 521         SequenceI seq = viewport.alignment.getSequenceAt(i);\r
 522 \r
 523         if (!sg.sequences.contains(seq))\r
 524         {\r
 525           continue;\r
 526         }\r
 527 \r
 528         SequenceI temp = viewport.alignment.getSequenceAt(i - 1);\r
 529 \r
 530         if (sg.sequences.contains(temp))\r
 531         {\r
 532           continue;\r
 533         }\r
 534 \r
 535         viewport.alignment.getSequences().setElementAt(temp, i);\r
 536         viewport.alignment.getSequences().setElementAt(seq, i - 1);\r
 537       }\r
 538     }\r
 539     else\r
 540     {\r
 541       for (int i = viewport.alignment.getHeight() - 2; i > -1; i--)\r
 542       {\r
 543         SequenceI seq = viewport.alignment.getSequenceAt(i);\r
 544 \r
 545         if (!sg.sequences.contains(seq))\r
 546         {\r
 547           continue;\r
 548         }\r
 549 \r
 550         SequenceI temp = viewport.alignment.getSequenceAt(i + 1);\r
 551 \r
 552         if (sg.sequences.contains(temp))\r
 553         {\r
 554           continue;\r
 555         }\r
 556 \r
 557         viewport.alignment.getSequences().setElementAt(temp, i);\r
 558         viewport.alignment.getSequences().setElementAt(seq, i + 1);\r
 559       }\r
 560     }\r
 561 \r
 562     alignPanel.repaint();\r
 563   }\r
 564 \r
 565   /**\r
 566    * DOCUMENT ME!\r
 567    *\r
 568    * @param e DOCUMENT ME!\r
 569    */\r
 570   protected void copy_actionPerformed(ActionEvent e)\r
 571   {\r
 572     if (viewport.getSelectionGroup() == null)\r
 573     {\r
 574       System.out.println("null here");\r
 575       return;\r
 576     }\r
 577 \r
 578     SequenceGroup sg = viewport.getSelectionGroup();\r
 579 \r
 580     Clipboard c = Toolkit.getDefaultToolkit().getSystemClipboard();\r
 581 \r
 582     Hashtable orderedSeqs = new Hashtable();\r
 583     SequenceI [] seqs = new SequenceI[sg.getSize()];\r
 584 \r
 585     for (int i = 0; i < sg.getSize(); i++)\r
 586     {\r
 587       SequenceI seq = sg.getSequenceAt(i);\r
 588       int index = viewport.alignment.findIndex(seq);\r
 589       orderedSeqs.put(index + "", seq);\r
 590     }\r
 591 \r
 592     int index = 0, startRes, endRes;\r
 593     char ch;\r
 594 \r
 595     for (int i = 0; i < sg.getSize(); i++)\r
 596     {\r
 597       SequenceI seq = null;\r
 598 \r
 599       while (seq == null)\r
 600       {\r
 601         if (orderedSeqs.containsKey(index + ""))\r
 602         {\r
 603           seq = (SequenceI) orderedSeqs.get(index + "");\r
 604           index++;\r
 605 \r
 606           break;\r
 607         }\r
 608         else\r
 609         {\r
 610           index++;\r
 611         }\r
 612       }\r
 613 \r
 614 \r
 615       //FIND START RES\r
 616       //Returns residue following index if gap\r
 617       startRes = seq.findPosition(sg.getStartRes());\r
 618 \r
 619       //FIND END RES\r
 620       //Need to find the residue preceeding index if gap\r
 621       endRes = 0;\r
 622 \r
 623       for (int j = 0; j < sg.getEndRes() + 1 && j < seq.getLength(); j++)\r
 624       {\r
 625         ch = seq.getCharAt(j);\r
 626         if (!jalview.util.Comparison.isGap( (ch)))\r
 627         {\r
 628           endRes++;\r
 629         }\r
 630       }\r
 631 \r
 632       if (endRes > 0)\r
 633       {\r
 634         endRes += seq.getStart() - 1;\r
 635       }\r
 636 \r
 637       seqs[i] = new Sequence(seq.getName(),\r
 638                              seq.getSequence(sg.getStartRes(), sg.getEndRes()+1),\r
 639                              startRes,\r
 640                              endRes);\r
 641     }\r
 642 \r
 643     c.setContents(new StringSelection(FastaFile.print(seqs)), null);\r
 644   }\r
 645 \r
 646   /**\r
 647    * DOCUMENT ME!\r
 648    *\r
 649    * @param e DOCUMENT ME!\r
 650    */\r
 651   protected void pasteNew_actionPerformed(ActionEvent e)\r
 652   {\r
 653     paste(true);\r
 654   }\r
 655 \r
 656   /**\r
 657    * DOCUMENT ME!\r
 658    *\r
 659    * @param e DOCUMENT ME!\r
 660    */\r
 661   protected void pasteThis_actionPerformed(ActionEvent e)\r
 662   {\r
 663     addHistoryItem(new HistoryItem("Paste Sequences", viewport.alignment,\r
 664                                    HistoryItem.PASTE));\r
 665     paste(false);\r
 666   }\r
 667 \r
 668   /**\r
 669    * DOCUMENT ME!\r
 670    *\r
 671    * @param newAlignment DOCUMENT ME!\r
 672    */\r
 673   void paste(boolean newAlignment)\r
 674   {\r
 675     try\r
 676     {\r
 677       Clipboard c = Toolkit.getDefaultToolkit().getSystemClipboard();\r
 678       Transferable contents = c.getContents(this);\r
 679 \r
 680       if (contents == null)\r
 681       {\r
 682         return;\r
 683       }\r
 684 \r
 685       String str = (String) contents.getTransferData(DataFlavor.stringFlavor);\r
 686 \r
 687       String format = IdentifyFile.Identify(str, "Paste");\r
 688       SequenceI[] sequences = new FormatAdapter().readFile(str, "Paste", format);\r
 689 \r
 690 \r
 691       if (newAlignment)\r
 692       {\r
 693         AlignFrame af = new AlignFrame(new Alignment(sequences));\r
 694         String newtitle = new String("Copied sequences");\r
 695 \r
 696         if (title.startsWith("Copied sequences"))\r
 697         {\r
 698           newtitle = title;\r
 699         }\r
 700         else\r
 701         {\r
 702           newtitle = newtitle.concat("- from " + title);\r
 703         }\r
 704 \r
 705         Desktop.addInternalFrame(af, newtitle, NEW_WINDOW_WIDTH,\r
 706                                  NEW_WINDOW_HEIGHT);\r
 707       }\r
 708       else\r
 709       {\r
 710         //!newAlignment\r
 711         for (int i = 0; i < sequences.length; i++)\r
 712           viewport.alignment.addSequence(sequences[i]);\r
 713 \r
 714         viewport.setEndSeq(viewport.alignment.getHeight());\r
 715         viewport.alignment.getWidth();\r
 716         viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());\r
 717       }\r
 718     }\r
 719     catch (Exception ex)\r
 720     {\r
 721         // could be anything being pasted in here\r
 722     }\r
 723 \r
 724 \r
 725   }\r
 726 \r
 727   /**\r
 728    * DOCUMENT ME!\r
 729    *\r
 730    * @param e DOCUMENT ME!\r
 731    */\r
 732   protected void cut_actionPerformed(ActionEvent e)\r
 733   {\r
 734     copy_actionPerformed(null);\r
 735     delete_actionPerformed(null);\r
 736   }\r
 737 \r
 738   /**\r
 739    * DOCUMENT ME!\r
 740    *\r
 741    * @param e DOCUMENT ME!\r
 742    */\r
 743   protected void delete_actionPerformed(ActionEvent e)\r
 744   {\r
 745 \r
 746     if (viewport.getSelectionGroup() == null)\r
 747     {\r
 748       return;\r
 749     }\r
 750 \r
 751     addHistoryItem(new HistoryItem("Delete Sequences", viewport.alignment,\r
 752                                    HistoryItem.HIDE));\r
 753 \r
 754     SequenceGroup sg = viewport.getSelectionGroup();\r
 755     boolean allSequences = false;\r
 756     if (sg.sequences.size() == viewport.alignment.getHeight())\r
 757     {\r
 758       allSequences = true;\r
 759     }\r
 760 \r
 761     for (int i = 0; i < sg.sequences.size(); i++)\r
 762     {\r
 763       SequenceI seq = sg.getSequenceAt(i);\r
 764       int index = viewport.getAlignment().findIndex(seq);\r
 765       seq.deleteChars(sg.getStartRes(), sg.getEndRes() + 1);\r
 766 \r
 767       // If the cut affects all sequences, remove highlighted columns\r
 768       if (allSequences)\r
 769       {\r
 770         viewport.getColumnSelection().removeElements(sg.getStartRes(),\r
 771             sg.getEndRes() + 1);\r
 772       }\r
 773 \r
 774       if (seq.getSequence().length() < 1)\r
 775       {\r
 776         viewport.getAlignment().deleteSequence(seq);\r
 777       }\r
 778       else\r
 779       {\r
 780         viewport.getAlignment().getSequences().setElementAt(seq, index);\r
 781       }\r
 782     }\r
 783 \r
 784     viewport.setSelectionGroup(null);\r
 785     viewport.alignment.deleteGroup(sg);\r
 786 \r
 787     viewport.firePropertyChange("alignment", null,\r
 788                                   viewport.getAlignment().getSequences());\r
 789 \r
 790 \r
 791 \r
 792     if (viewport.getAlignment().getHeight() < 1)\r
 793     {\r
 794       try\r
 795       {\r
 796         this.setClosed(true);\r
 797       }\r
 798       catch (Exception ex)\r
 799       {\r
 800       }\r
 801     }\r
 802   }\r
 803 \r
 804   /**\r
 805    * DOCUMENT ME!\r
 806    *\r
 807    * @param e DOCUMENT ME!\r
 808    */\r
 809   protected void deleteGroups_actionPerformed(ActionEvent e)\r
 810   {\r
 811     viewport.alignment.deleteAllGroups();\r
 812     viewport.setSelectionGroup(null);\r
 813     alignPanel.repaint();\r
 814   }\r
 815 \r
 816   /**\r
 817    * DOCUMENT ME!\r
 818    *\r
 819    * @param e DOCUMENT ME!\r
 820    */\r
 821   public void selectAllSequenceMenuItem_actionPerformed(ActionEvent e)\r
 822   {\r
 823     SequenceGroup sg = new SequenceGroup();\r
 824 \r
 825     for (int i = 0; i < viewport.getAlignment().getSequences().size();\r
 826          i++)\r
 827     {\r
 828       sg.addSequence(viewport.getAlignment().getSequenceAt(i), false);\r
 829     }\r
 830 \r
 831     sg.setEndRes(viewport.alignment.getWidth() - 1);\r
 832     viewport.setSelectionGroup(sg);\r
 833     PaintRefresher.Refresh(null, viewport.alignment);\r
 834   }\r
 835 \r
 836   /**\r
 837    * DOCUMENT ME!\r
 838    *\r
 839    * @param e DOCUMENT ME!\r
 840    */\r
 841   public void deselectAllSequenceMenuItem_actionPerformed(ActionEvent e)\r
 842   {\r
 843     viewport.setSelectionGroup(null);\r
 844     viewport.getColumnSelection().clear();\r
 845     viewport.setSelectionGroup(null);\r
 846     alignPanel.annotationPanel.activeRes = null;\r
 847     PaintRefresher.Refresh(null, viewport.alignment);\r
 848   }\r
 849 \r
 850   /**\r
 851    * DOCUMENT ME!\r
 852    *\r
 853    * @param e DOCUMENT ME!\r
 854    */\r
 855   public void invertSequenceMenuItem_actionPerformed(ActionEvent e)\r
 856   {\r
 857     SequenceGroup sg = viewport.getSelectionGroup();\r
 858 \r
 859     if (sg == null)\r
 860     {\r
 861       selectAllSequenceMenuItem_actionPerformed(null);\r
 862 \r
 863       return;\r
 864     }\r
 865 \r
 866     for (int i = 0; i < viewport.getAlignment().getSequences().size();\r
 867          i++)\r
 868     {\r
 869       sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false);\r
 870     }\r
 871 \r
 872     PaintRefresher.Refresh(null, viewport.alignment);\r
 873   }\r
 874 \r
 875   /**\r
 876    * DOCUMENT ME!\r
 877    *\r
 878    * @param e DOCUMENT ME!\r
 879    */\r
 880   public void remove2LeftMenuItem_actionPerformed(ActionEvent e)\r
 881   {\r
 882     ColumnSelection colSel = viewport.getColumnSelection();\r
 883 \r
 884     if (colSel.size() > 0)\r
 885     {\r
 886       addHistoryItem(new HistoryItem("Remove Left", viewport.alignment,\r
 887                                      HistoryItem.HIDE));\r
 888 \r
 889       int min = colSel.getMin();\r
 890       viewport.getAlignment().trimLeft(min);\r
 891       colSel.compensateForEdit(0, min);\r
 892 \r
 893       if (viewport.getSelectionGroup() != null)\r
 894       {\r
 895         viewport.getSelectionGroup().adjustForRemoveLeft(min);\r
 896       }\r
 897 \r
 898       Vector groups = viewport.alignment.getGroups();\r
 899 \r
 900       for (int i = 0; i < groups.size(); i++)\r
 901       {\r
 902         SequenceGroup sg = (SequenceGroup) groups.get(i);\r
 903 \r
 904         if (!sg.adjustForRemoveLeft(min))\r
 905         {\r
 906           viewport.alignment.deleteGroup(sg);\r
 907         }\r
 908       }\r
 909 \r
 910       viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());\r
 911     }\r
 912   }\r
 913 \r
 914   /**\r
 915    * DOCUMENT ME!\r
 916    *\r
 917    * @param e DOCUMENT ME!\r
 918    */\r
 919   public void remove2RightMenuItem_actionPerformed(ActionEvent e)\r
 920   {\r
 921     ColumnSelection colSel = viewport.getColumnSelection();\r
 922 \r
 923     if (colSel.size() > 0)\r
 924     {\r
 925       addHistoryItem(new HistoryItem("Remove Right", viewport.alignment,\r
 926                                      HistoryItem.HIDE));\r
 927 \r
 928       int max = colSel.getMax();\r
 929       viewport.getAlignment().trimRight(max);\r
 930 \r
 931       if (viewport.getSelectionGroup() != null)\r
 932       {\r
 933         viewport.getSelectionGroup().adjustForRemoveRight(max);\r
 934       }\r
 935 \r
 936       Vector groups = viewport.alignment.getGroups();\r
 937 \r
 938       for (int i = 0; i < groups.size(); i++)\r
 939       {\r
 940         SequenceGroup sg = (SequenceGroup) groups.get(i);\r
 941 \r
 942         if (!sg.adjustForRemoveRight(max))\r
 943         {\r
 944           viewport.alignment.deleteGroup(sg);\r
 945         }\r
 946       }\r
 947 \r
 948       viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());\r
 949     }\r
 950   }\r
 951 \r
 952   /**\r
 953    * DOCUMENT ME!\r
 954    *\r
 955    * @param e DOCUMENT ME!\r
 956    */\r
 957   public void removeGappedColumnMenuItem_actionPerformed(ActionEvent e)\r
 958   {\r
 959     addHistoryItem(new HistoryItem("Remove Gapped Columns",\r
 960                                    viewport.alignment, HistoryItem.HIDE));\r
 961 \r
 962     //This is to maintain viewport position on first residue\r
 963     //of first sequence\r
 964     SequenceI seq = viewport.alignment.getSequenceAt(0);\r
 965     int startRes = seq.findPosition(viewport.startRes);\r
 966 \r
 967     viewport.getAlignment().removeGaps();\r
 968 \r
 969     viewport.setStartRes(seq.findIndex(startRes)-1);\r
 970 \r
 971    viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());\r
 972   }\r
 973 \r
 974   /**\r
 975    * DOCUMENT ME!\r
 976    *\r
 977    * @param e DOCUMENT ME!\r
 978    */\r
 979   public void removeAllGapsMenuItem_actionPerformed(ActionEvent e)\r
 980   {\r
 981     addHistoryItem(new HistoryItem("Remove Gaps", viewport.alignment,\r
 982                                    HistoryItem.HIDE));\r
 983 \r
 984     //This is to maintain viewport position on first residue\r
 985     //of first sequence\r
 986     SequenceI seq = viewport.alignment.getSequenceAt(0);\r
 987     int startRes = seq.findPosition(viewport.startRes);\r
 988 \r
 989 \r
 990     SequenceI current;\r
 991     int jSize;\r
 992 \r
 993     Vector seqs = null;\r
 994 \r
 995     int start = 0;\r
 996     int end = viewport.alignment.getWidth();\r
 997 \r
 998     if (viewport.getSelectionGroup() != null\r
 999         && viewport.getSelectionGroup().sequences != null\r
1000         && viewport.getSelectionGroup().sequences.size() > 0)\r
1001     {\r
1002       seqs = viewport.getSelectionGroup().sequences;\r
1003       start = viewport.getSelectionGroup().getStartRes();\r
1004       end = viewport.getSelectionGroup().getEndRes()+1;\r
1005     }\r
1006     else\r
1007     {\r
1008       seqs = viewport.alignment.getSequences();\r
1009     }\r
1010 \r
1011     for (int i = 0; i < seqs.size(); i++)\r
1012     {\r
1013       current = (SequenceI) seqs.elementAt(i);\r
1014       jSize = current.getLength();\r
1015 \r
1016       // Removing a range is much quicker than removing gaps\r
1017       // one by one for long sequences\r
1018       int j = start;\r
1019       int rangeStart=-1, rangeEnd=-1;\r
1020 \r
1021       do\r
1022       {\r
1023         if (jalview.util.Comparison.isGap(current.getCharAt(j)))\r
1024         {\r
1025           if(rangeStart==-1)\r
1026            {\r
1027              rangeStart = j;\r
1028              rangeEnd = j+1;\r
1029            }\r
1030            else\r
1031            {\r
1032              rangeEnd++;\r
1033            }\r
1034            j++;\r
1035         }\r
1036         else\r
1037         {\r
1038           if(rangeStart>-1)\r
1039           {\r
1040             current.deleteChars(rangeStart, rangeEnd);\r
1041             j-=rangeEnd-rangeStart;\r
1042             jSize-=rangeEnd-rangeStart;\r
1043             rangeStart = -1;\r
1044             rangeEnd = -1;\r
1045           }\r
1046           else\r
1047             j++;\r
1048         }\r
1049       }\r
1050       while (j < end && j < jSize);\r
1051       if(rangeStart>-1)\r
1052       {\r
1053        current.deleteChars(rangeStart, rangeEnd);\r
1054       }\r
1055     }\r
1056 \r
1057     viewport.setStartRes(seq.findIndex(startRes)-1);\r
1058 \r
1059     viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());\r
1060   }\r
1061 \r
1062  public void alignmentChanged()\r
1063  {\r
1064    if(viewport.vconsensus!=null)\r
1065    {\r
1066      viewport.updateConsensus();\r
1067      viewport.updateConservation();\r
1068    }\r
1069    resetAllColourSchemes();\r
1070    if(alignPanel.overviewPanel!=null)\r
1071      alignPanel.overviewPanel.updateOverviewImage();\r
1072 \r
1073    alignPanel.repaint();\r
1074  }\r
1075 \r
1076   void resetAllColourSchemes()\r
1077   {\r
1078     ColourSchemeI cs = viewport.globalColourScheme;\r
1079     if(cs!=null)\r
1080     {\r
1081       if (cs instanceof ClustalxColourScheme)\r
1082       {\r
1083         ( (ClustalxColourScheme) viewport.getGlobalColourScheme()).\r
1084             resetClustalX(viewport.alignment.getSequences(),\r
1085                           viewport.alignment.getWidth());\r
1086       }\r
1087 \r
1088       cs.setConsensus(viewport.vconsensus);\r
1089       if (cs.conservationApplied())\r
1090       {\r
1091         Alignment al = (Alignment) viewport.alignment;\r
1092         Conservation c = new Conservation("All",\r
1093                                           ResidueProperties.propHash, 3,\r
1094                                           al.getSequences(), 0,\r
1095                                           al.getWidth() - 1);\r
1096         c.calculate();\r
1097         c.verdict(false, viewport.ConsPercGaps);\r
1098 \r
1099         cs.setConservation(c);\r
1100       }\r
1101     }\r
1102 \r
1103     int s, sSize = viewport.alignment.getGroups().size();\r
1104     for(s=0; s<sSize; s++)\r
1105     {\r
1106       SequenceGroup sg = (SequenceGroup)viewport.alignment.getGroups().elementAt(s);\r
1107       if(sg.cs!=null && sg.cs instanceof ClustalxColourScheme)\r
1108       {\r
1109         ((ClustalxColourScheme)sg.cs).resetClustalX(sg.sequences, sg.getWidth());\r
1110       }\r
1111       sg.recalcConservation();\r
1112     }\r
1113   }\r
1114 \r
1115   /**\r
1116    * DOCUMENT ME!\r
1117    *\r
1118    * @param e DOCUMENT ME!\r
1119    */\r
1120   public void padGapsMenuitem_actionPerformed(ActionEvent e)\r
1121   {\r
1122     addHistoryItem(new HistoryItem("Pad Gaps", viewport.alignment,\r
1123                                    HistoryItem.HIDE));\r
1124 \r
1125     SequenceI current;\r
1126     int Width = viewport.getAlignment().getWidth();\r
1127 \r
1128     for (int i = 0; i < viewport.getAlignment().getSequences().size();\r
1129          i++)\r
1130     {\r
1131       current = viewport.getAlignment().getSequenceAt(i);\r
1132 \r
1133       if (current.getLength() < Width)\r
1134       {\r
1135         current.insertCharAt(Width - 1, viewport.getGapCharacter());\r
1136       }\r
1137     }\r
1138 \r
1139     alignmentChanged();\r
1140   }\r
1141 \r
1142   /**\r
1143    * DOCUMENT ME!\r
1144    *\r
1145    * @param e DOCUMENT ME!\r
1146    */\r
1147   public void findMenuItem_actionPerformed(ActionEvent e)\r
1148   {\r
1149     JInternalFrame frame = new JInternalFrame();\r
1150     Finder finder = new Finder(viewport, alignPanel, frame);\r
1151     frame.setContentPane(finder);\r
1152     Desktop.addInternalFrame(frame, "Find", 340, 110);\r
1153     frame.setLayer(JLayeredPane.PALETTE_LAYER);\r
1154   }\r
1155 \r
1156   /**\r
1157    * DOCUMENT ME!\r
1158    *\r
1159    * @param e DOCUMENT ME!\r
1160    */\r
1161   public void font_actionPerformed(ActionEvent e)\r
1162   {\r
1163     new FontChooser(alignPanel);\r
1164   }\r
1165 \r
1166   /**\r
1167    * DOCUMENT ME!\r
1168    *\r
1169    * @param e DOCUMENT ME!\r
1170    */\r
1171   protected void fullSeqId_actionPerformed(ActionEvent e)\r
1172   {\r
1173     viewport.setShowFullId(fullSeqId.isSelected());\r
1174 \r
1175     alignPanel.idPanel.idCanvas.setPreferredSize(alignPanel.calculateIdWidth());\r
1176     alignPanel.repaint();\r
1177   }\r
1178 \r
1179   /**\r
1180    * DOCUMENT ME!\r
1181    *\r
1182    * @param e DOCUMENT ME!\r
1183    */\r
1184   protected void colourTextMenuItem_actionPerformed(ActionEvent e)\r
1185   {\r
1186     viewport.setColourText(colourTextMenuItem.isSelected());\r
1187     alignPanel.repaint();\r
1188   }\r
1189 \r
1190   /**\r
1191    * DOCUMENT ME!\r
1192    *\r
1193    * @param e DOCUMENT ME!\r
1194    */\r
1195   protected void wrapMenuItem_actionPerformed(ActionEvent e)\r
1196   {\r
1197     viewport.setWrapAlignment(wrapMenuItem.isSelected());\r
1198     alignPanel.setWrapAlignment(wrapMenuItem.isSelected());\r
1199     scaleAbove.setVisible(wrapMenuItem.isSelected());\r
1200     scaleLeft.setVisible(wrapMenuItem.isSelected());\r
1201     scaleRight.setVisible(wrapMenuItem.isSelected());\r
1202     alignPanel.repaint();\r
1203   }\r
1204 \r
1205   /**\r
1206    * DOCUMENT ME!\r
1207    *\r
1208    * @param e DOCUMENT ME!\r
1209    */\r
1210   protected void scaleAbove_actionPerformed(ActionEvent e)\r
1211   {\r
1212     viewport.setScaleAboveWrapped(scaleAbove.isSelected());\r
1213     alignPanel.repaint();\r
1214   }\r
1215 \r
1216   /**\r
1217    * DOCUMENT ME!\r
1218    *\r
1219    * @param e DOCUMENT ME!\r
1220    */\r
1221   protected void scaleLeft_actionPerformed(ActionEvent e)\r
1222   {\r
1223     viewport.setScaleLeftWrapped(scaleLeft.isSelected());\r
1224     alignPanel.repaint();\r
1225   }\r
1226 \r
1227   /**\r
1228    * DOCUMENT ME!\r
1229    *\r
1230    * @param e DOCUMENT ME!\r
1231    */\r
1232   protected void scaleRight_actionPerformed(ActionEvent e)\r
1233   {\r
1234     viewport.setScaleRightWrapped(scaleRight.isSelected());\r
1235     alignPanel.repaint();\r
1236   }\r
1237 \r
1238   /**\r
1239    * DOCUMENT ME!\r
1240    *\r
1241    * @param e DOCUMENT ME!\r
1242    */\r
1243   public void viewBoxesMenuItem_actionPerformed(ActionEvent e)\r
1244   {\r
1245     viewport.setShowBoxes(viewBoxesMenuItem.isSelected());\r
1246     alignPanel.repaint();\r
1247   }\r
1248 \r
1249   /**\r
1250    * DOCUMENT ME!\r
1251    *\r
1252    * @param e DOCUMENT ME!\r
1253    */\r
1254   public void viewTextMenuItem_actionPerformed(ActionEvent e)\r
1255   {\r
1256     viewport.setShowText(viewTextMenuItem.isSelected());\r
1257     alignPanel.repaint();\r
1258   }\r
1259 \r
1260   /**\r
1261    * DOCUMENT ME!\r
1262    *\r
1263    * @param e DOCUMENT ME!\r
1264    */\r
1265   protected void renderGapsMenuItem_actionPerformed(ActionEvent e)\r
1266   {\r
1267     viewport.setRenderGaps(renderGapsMenuItem.isSelected());\r
1268     alignPanel.repaint();\r
1269   }\r
1270 \r
1271   /**\r
1272    * DOCUMENT ME!\r
1273    *\r
1274    * @param evt DOCUMENT ME!\r
1275    */\r
1276   public void sequenceFeatures_actionPerformed(ActionEvent evt)\r
1277   {\r
1278     viewport.showSequenceFeatures(sequenceFeatures.isSelected());\r
1279 \r
1280     if (viewport.showSequenceFeatures &&\r
1281         ! ( (Alignment) viewport.alignment).featuresAdded)\r
1282     {\r
1283       SequenceFeatureFetcher sft = new SequenceFeatureFetcher(viewport.\r
1284           alignment,\r
1285           alignPanel);\r
1286       ( (Alignment) viewport.alignment).featuresAdded = true;\r
1287     }\r
1288 \r
1289     alignPanel.repaint();\r
1290   }\r
1291 \r
1292   /**\r
1293    * DOCUMENT ME!\r
1294    *\r
1295    * @param e DOCUMENT ME!\r
1296    */\r
1297   public void annotationPanelMenuItem_actionPerformed(ActionEvent e)\r
1298   {\r
1299     viewport.setShowAnnotation(annotationPanelMenuItem.isSelected());\r
1300     alignPanel.setAnnotationVisible(annotationPanelMenuItem.isSelected());\r
1301   }\r
1302 \r
1303   /**\r
1304    * DOCUMENT ME!\r
1305    *\r
1306    * @param e DOCUMENT ME!\r
1307    */\r
1308   public void overviewMenuItem_actionPerformed(ActionEvent e)\r
1309   {\r
1310     if (alignPanel.overviewPanel != null)\r
1311     {\r
1312       return;\r
1313     }\r
1314 \r
1315     JInternalFrame frame = new JInternalFrame();\r
1316     OverviewPanel overview = new OverviewPanel(alignPanel);\r
1317     frame.setContentPane(overview);\r
1318     Desktop.addInternalFrame(frame, "Overview " + this.getTitle(),\r
1319                              frame.getWidth(), frame.getHeight());\r
1320     frame.pack();\r
1321     frame.setLayer(JLayeredPane.PALETTE_LAYER);\r
1322     frame.addInternalFrameListener(new javax.swing.event.InternalFrameAdapter()\r
1323     {\r
1324       public void internalFrameClosed(\r
1325           javax.swing.event.InternalFrameEvent evt)\r
1326       {\r
1327         alignPanel.setOverviewPanel(null);\r
1328       }\r
1329       ;\r
1330     });\r
1331 \r
1332     alignPanel.setOverviewPanel(overview);\r
1333   }\r
1334 \r
1335   /**\r
1336    * DOCUMENT ME!\r
1337    *\r
1338    * @param e DOCUMENT ME!\r
1339    */\r
1340   protected void noColourmenuItem_actionPerformed(ActionEvent e)\r
1341   {\r
1342     changeColour(null);\r
1343   }\r
1344 \r
1345   /**\r
1346    * DOCUMENT ME!\r
1347    *\r
1348    * @param e DOCUMENT ME!\r
1349    */\r
1350   public void clustalColour_actionPerformed(ActionEvent e)\r
1351   {\r
1352     changeColour(new ClustalxColourScheme(\r
1353         viewport.alignment.getSequences(), viewport.alignment.getWidth()));\r
1354   }\r
1355 \r
1356   /**\r
1357    * DOCUMENT ME!\r
1358    *\r
1359    * @param e DOCUMENT ME!\r
1360    */\r
1361   public void zappoColour_actionPerformed(ActionEvent e)\r
1362   {\r
1363     changeColour(new ZappoColourScheme());\r
1364   }\r
1365 \r
1366   /**\r
1367    * DOCUMENT ME!\r
1368    *\r
1369    * @param e DOCUMENT ME!\r
1370    */\r
1371   public void taylorColour_actionPerformed(ActionEvent e)\r
1372   {\r
1373     changeColour(new TaylorColourScheme());\r
1374   }\r
1375 \r
1376   /**\r
1377    * DOCUMENT ME!\r
1378    *\r
1379    * @param e DOCUMENT ME!\r
1380    */\r
1381   public void hydrophobicityColour_actionPerformed(ActionEvent e)\r
1382   {\r
1383     changeColour(new HydrophobicColourScheme());\r
1384   }\r
1385 \r
1386   /**\r
1387    * DOCUMENT ME!\r
1388    *\r
1389    * @param e DOCUMENT ME!\r
1390    */\r
1391   public void helixColour_actionPerformed(ActionEvent e)\r
1392   {\r
1393     changeColour(new HelixColourScheme());\r
1394   }\r
1395 \r
1396   /**\r
1397    * DOCUMENT ME!\r
1398    *\r
1399    * @param e DOCUMENT ME!\r
1400    */\r
1401   public void strandColour_actionPerformed(ActionEvent e)\r
1402   {\r
1403     changeColour(new StrandColourScheme());\r
1404   }\r
1405 \r
1406   /**\r
1407    * DOCUMENT ME!\r
1408    *\r
1409    * @param e DOCUMENT ME!\r
1410    */\r
1411   public void turnColour_actionPerformed(ActionEvent e)\r
1412   {\r
1413     changeColour(new TurnColourScheme());\r
1414   }\r
1415 \r
1416   /**\r
1417    * DOCUMENT ME!\r
1418    *\r
1419    * @param e DOCUMENT ME!\r
1420    */\r
1421   public void buriedColour_actionPerformed(ActionEvent e)\r
1422   {\r
1423     changeColour(new BuriedColourScheme());\r
1424   }\r
1425 \r
1426   /**\r
1427    * DOCUMENT ME!\r
1428    *\r
1429    * @param e DOCUMENT ME!\r
1430    */\r
1431   public void nucleotideColour_actionPerformed(ActionEvent e)\r
1432   {\r
1433     changeColour(new NucleotideColourScheme());\r
1434   }\r
1435 \r
1436   /**\r
1437    * DOCUMENT ME!\r
1438    *\r
1439    * @param e DOCUMENT ME!\r
1440    */\r
1441   protected void applyToAllGroups_actionPerformed(ActionEvent e)\r
1442   {\r
1443     viewport.setColourAppliesToAllGroups(applyToAllGroups.isSelected());\r
1444   }\r
1445 \r
1446   /**\r
1447    * DOCUMENT ME!\r
1448    *\r
1449    * @param cs DOCUMENT ME!\r
1450    */\r
1451   void changeColour(ColourSchemeI cs)\r
1452   {\r
1453     int threshold = 0;\r
1454 \r
1455     if(cs!=null)\r
1456     {\r
1457       if (viewport.getAbovePIDThreshold())\r
1458       {\r
1459         threshold = SliderPanel.setPIDSliderSource(alignPanel, cs,\r
1460                                                    "Background");\r
1461 \r
1462         cs.setThreshold(threshold,\r
1463                         viewport.getIgnoreGapsConsensus());\r
1464 \r
1465         viewport.setGlobalColourScheme(cs);\r
1466       }\r
1467       else\r
1468       {\r
1469         cs.setThreshold(0, viewport.getIgnoreGapsConsensus());\r
1470       }\r
1471 \r
1472       if (viewport.getConservationSelected())\r
1473       {\r
1474 \r
1475         Alignment al = (Alignment) viewport.alignment;\r
1476         Conservation c = new Conservation("All",\r
1477                                           ResidueProperties.propHash, 3,\r
1478                                           al.getSequences(), 0,\r
1479                                           al.getWidth() - 1);\r
1480 \r
1481         c.calculate();\r
1482         c.verdict(false, viewport.ConsPercGaps);\r
1483 \r
1484         cs.setConservation(c);\r
1485 \r
1486         cs.setConservationInc(SliderPanel.setConservationSlider(alignPanel, cs,\r
1487             "Background"));\r
1488       }\r
1489       else\r
1490       {\r
1491         cs.setConservation(null);\r
1492       }\r
1493 \r
1494       cs.setConsensus(viewport.vconsensus);\r
1495     }\r
1496 \r
1497     viewport.setGlobalColourScheme(cs);\r
1498 \r
1499     if (viewport.getColourAppliesToAllGroups())\r
1500     {\r
1501       Vector groups = viewport.alignment.getGroups();\r
1502 \r
1503       for (int i = 0; i < groups.size(); i++)\r
1504       {\r
1505         SequenceGroup sg = (SequenceGroup) groups.elementAt(i);\r
1506 \r
1507         if (cs == null)\r
1508         {\r
1509           sg.cs = null;\r
1510           continue;\r
1511         }\r
1512 \r
1513         if (cs instanceof ClustalxColourScheme)\r
1514         {\r
1515           sg.cs = new ClustalxColourScheme(sg.sequences, sg.getWidth());\r
1516         }\r
1517         else if (cs instanceof UserColourScheme)\r
1518         {\r
1519           sg.cs = new UserColourScheme( ( (UserColourScheme) cs).getColours());\r
1520         }\r
1521         else\r
1522         {\r
1523           try\r
1524           {\r
1525             sg.cs = (ColourSchemeI) cs.getClass().newInstance();\r
1526           }\r
1527           catch (Exception ex)\r
1528           {\r
1529           }\r
1530         }\r
1531 \r
1532         if (viewport.getAbovePIDThreshold()\r
1533             || cs instanceof PIDColourScheme\r
1534             || cs instanceof Blosum62ColourScheme)\r
1535         {\r
1536          sg.cs.setThreshold(threshold,\r
1537                 viewport.getIgnoreGapsConsensus());\r
1538 \r
1539           sg.cs.setConsensus(AAFrequency.calculate(sg.sequences, 0,\r
1540               sg.getWidth()));\r
1541         }\r
1542         else\r
1543           sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());\r
1544 \r
1545 \r
1546         if (viewport.getConservationSelected())\r
1547         {\r
1548           Conservation c = new Conservation("Group",\r
1549                                             ResidueProperties.propHash, 3,\r
1550                                             sg.sequences, 0,\r
1551                                             viewport.alignment.getWidth() - 1);\r
1552           c.calculate();\r
1553           c.verdict(false, viewport.ConsPercGaps);\r
1554           sg.cs.setConservation(c);\r
1555         }\r
1556         else\r
1557           sg.cs.setConservation(null);\r
1558       }\r
1559     }\r
1560 \r
1561     if (alignPanel.getOverviewPanel() != null)\r
1562     {\r
1563       alignPanel.getOverviewPanel().updateOverviewImage();\r
1564     }\r
1565 \r
1566     alignPanel.repaint();\r
1567   }\r
1568 \r
1569   /**\r
1570    * DOCUMENT ME!\r
1571    *\r
1572    * @param e DOCUMENT ME!\r
1573    */\r
1574   protected void modifyPID_actionPerformed(ActionEvent e)\r
1575   {\r
1576     if (viewport.getAbovePIDThreshold() && viewport.globalColourScheme!=null)\r
1577     {\r
1578       SliderPanel.setPIDSliderSource(alignPanel,\r
1579                                      viewport.getGlobalColourScheme(),\r
1580                                      "Background");\r
1581       SliderPanel.showPIDSlider();\r
1582     }\r
1583   }\r
1584 \r
1585   /**\r
1586    * DOCUMENT ME!\r
1587    *\r
1588    * @param e DOCUMENT ME!\r
1589    */\r
1590   protected void modifyConservation_actionPerformed(ActionEvent e)\r
1591   {\r
1592     if (viewport.getConservationSelected() && viewport.globalColourScheme!=null)\r
1593     {\r
1594       SliderPanel.setConservationSlider(alignPanel,\r
1595                                         viewport.globalColourScheme,\r
1596                                         "Background");\r
1597       SliderPanel.showConservationSlider();\r
1598     }\r
1599   }\r
1600 \r
1601   /**\r
1602    * DOCUMENT ME!\r
1603    *\r
1604    * @param e DOCUMENT ME!\r
1605    */\r
1606   protected void conservationMenuItem_actionPerformed(ActionEvent e)\r
1607   {\r
1608     viewport.setConservationSelected(conservationMenuItem.isSelected());\r
1609 \r
1610     viewport.setAbovePIDThreshold(false);\r
1611     abovePIDThreshold.setSelected(false);\r
1612 \r
1613     changeColour(viewport.getGlobalColourScheme());\r
1614 \r
1615     modifyConservation_actionPerformed(null);\r
1616   }\r
1617 \r
1618   /**\r
1619    * DOCUMENT ME!\r
1620    *\r
1621    * @param e DOCUMENT ME!\r
1622    */\r
1623   public void abovePIDThreshold_actionPerformed(ActionEvent e)\r
1624   {\r
1625     viewport.setAbovePIDThreshold(abovePIDThreshold.isSelected());\r
1626 \r
1627     conservationMenuItem.setSelected(false);\r
1628     viewport.setConservationSelected(false);\r
1629 \r
1630     ColourSchemeI cs = viewport.getGlobalColourScheme();\r
1631 \r
1632     changeColour(viewport.getGlobalColourScheme());\r
1633 \r
1634     modifyPID_actionPerformed(null);\r
1635   }\r
1636 \r
1637   /**\r
1638    * DOCUMENT ME!\r
1639    *\r
1640    * @param e DOCUMENT ME!\r
1641    */\r
1642   public void userDefinedColour_actionPerformed(ActionEvent e)\r
1643   {\r
1644     if (e.getActionCommand().equals("User Defined..."))\r
1645     {\r
1646       new UserDefinedColours(alignPanel, null);\r
1647     }\r
1648     else\r
1649     {\r
1650       UserColourScheme udc = (UserColourScheme) UserDefinedColours.\r
1651           getUserColourSchemes().get(e.getActionCommand());\r
1652 \r
1653       changeColour(udc);\r
1654     }\r
1655   }\r
1656 \r
1657   public void updateUserColourMenu()\r
1658   {\r
1659 \r
1660     Component[] menuItems = colourMenu.getMenuComponents();\r
1661     int i, iSize = menuItems.length;\r
1662     for (i = 0; i < iSize; i++)\r
1663     {\r
1664       if (menuItems[i].getName() != null &&\r
1665           menuItems[i].getName().equals("USER_DEFINED"))\r
1666       {\r
1667         colourMenu.remove(menuItems[i]);\r
1668         iSize--;\r
1669       }\r
1670     }\r
1671     if (jalview.gui.UserDefinedColours.getUserColourSchemes() != null)\r
1672     {\r
1673       java.util.Enumeration userColours = jalview.gui.UserDefinedColours.\r
1674           getUserColourSchemes().keys();\r
1675 \r
1676       while (userColours.hasMoreElements())\r
1677       {\r
1678         final JRadioButtonMenuItem radioItem = new JRadioButtonMenuItem(userColours.\r
1679             nextElement().toString());\r
1680         radioItem.setName("USER_DEFINED");\r
1681         radioItem.addMouseListener(new MouseAdapter()\r
1682             {\r
1683               public void mousePressed(MouseEvent evt)\r
1684               {\r
1685                 if(evt.isControlDown() || SwingUtilities.isRightMouseButton(evt))\r
1686                 {\r
1687                   radioItem.removeActionListener(radioItem.getActionListeners()[0]);\r
1688 \r
1689                   int option = JOptionPane.showInternalConfirmDialog(jalview.gui.Desktop.desktop,\r
1690                       "Remove from default list?",\r
1691                       "Remove user defined colour",\r
1692                       JOptionPane.YES_NO_OPTION);\r
1693                   if(option == JOptionPane.YES_OPTION)\r
1694                   {\r
1695                     jalview.gui.UserDefinedColours.removeColourFromDefaults(radioItem.getText());\r
1696                     colourMenu.remove(radioItem);\r
1697                   }\r
1698                   else\r
1699                     radioItem.addActionListener(new ActionListener()\r
1700                     {\r
1701                       public void actionPerformed(ActionEvent evt)\r
1702                       {\r
1703                         userDefinedColour_actionPerformed(evt);\r
1704                       }\r
1705                     });\r
1706                 }\r
1707               }\r
1708             });\r
1709         radioItem.addActionListener(new ActionListener()\r
1710         {\r
1711           public void actionPerformed(ActionEvent evt)\r
1712           {\r
1713             userDefinedColour_actionPerformed(evt);\r
1714           }\r
1715         });\r
1716 \r
1717         colourMenu.insert(radioItem, 15);\r
1718         colours.add(radioItem);\r
1719       }\r
1720     }\r
1721   }\r
1722 \r
1723   /**\r
1724    * DOCUMENT ME!\r
1725    *\r
1726    * @param e DOCUMENT ME!\r
1727    */\r
1728   public void PIDColour_actionPerformed(ActionEvent e)\r
1729   {\r
1730     changeColour(new PIDColourScheme());\r
1731   }\r
1732 \r
1733   /**\r
1734    * DOCUMENT ME!\r
1735    *\r
1736    * @param e DOCUMENT ME!\r
1737    */\r
1738   public void BLOSUM62Colour_actionPerformed(ActionEvent e)\r
1739   {\r
1740     changeColour(new Blosum62ColourScheme());\r
1741   }\r
1742 \r
1743   /**\r
1744    * DOCUMENT ME!\r
1745    *\r
1746    * @param e DOCUMENT ME!\r
1747    */\r
1748   public void sortPairwiseMenuItem_actionPerformed(ActionEvent e)\r
1749   {\r
1750     addHistoryItem(new HistoryItem("Pairwise Sort", viewport.alignment,\r
1751                                    HistoryItem.SORT));\r
1752     AlignmentSorter.sortByPID(viewport.getAlignment(),\r
1753                               viewport.getAlignment().getSequenceAt(0));\r
1754     alignPanel.repaint();\r
1755   }\r
1756 \r
1757   /**\r
1758    * DOCUMENT ME!\r
1759    *\r
1760    * @param e DOCUMENT ME!\r
1761    */\r
1762   public void sortIDMenuItem_actionPerformed(ActionEvent e)\r
1763   {\r
1764     addHistoryItem(new HistoryItem("ID Sort", viewport.alignment,\r
1765                                    HistoryItem.SORT));\r
1766     AlignmentSorter.sortByID(viewport.getAlignment());\r
1767     alignPanel.repaint();\r
1768   }\r
1769 \r
1770   /**\r
1771    * DOCUMENT ME!\r
1772    *\r
1773    * @param e DOCUMENT ME!\r
1774    */\r
1775   public void sortGroupMenuItem_actionPerformed(ActionEvent e)\r
1776   {\r
1777     addHistoryItem(new HistoryItem("Group Sort", viewport.alignment,\r
1778                                    HistoryItem.SORT));\r
1779 \r
1780     AlignmentSorter.sortByGroup(viewport.getAlignment());\r
1781     alignPanel.repaint();\r
1782   }\r
1783 \r
1784   /**\r
1785    * DOCUMENT ME!\r
1786    *\r
1787    * @param e DOCUMENT ME!\r
1788    */\r
1789   public void removeRedundancyMenuItem_actionPerformed(ActionEvent e)\r
1790   {\r
1791     RedundancyPanel sp = new RedundancyPanel(alignPanel, this);\r
1792     JInternalFrame frame = new JInternalFrame();\r
1793     frame.setContentPane(sp);\r
1794     Desktop.addInternalFrame(frame, "Redundancy threshold selection", 400,\r
1795                              100, false);\r
1796   }\r
1797 \r
1798   /**\r
1799    * DOCUMENT ME!\r
1800    *\r
1801    * @param e DOCUMENT ME!\r
1802    */\r
1803   public void pairwiseAlignmentMenuItem_actionPerformed(ActionEvent e)\r
1804   {\r
1805     if ( (viewport.getSelectionGroup() == null) ||\r
1806         (viewport.getSelectionGroup().getSize() < 2))\r
1807     {\r
1808       JOptionPane.showInternalMessageDialog(this,\r
1809                                             "You must select at least 2 sequences.",\r
1810                                             "Invalid Selection",\r
1811                                             JOptionPane.WARNING_MESSAGE);\r
1812     }\r
1813     else\r
1814     {\r
1815       JInternalFrame frame = new JInternalFrame();\r
1816       frame.setContentPane(new PairwiseAlignPanel(viewport));\r
1817       Desktop.addInternalFrame(frame, "Pairwise Alignment", 600, 500);\r
1818     }\r
1819   }\r
1820 \r
1821   /**\r
1822    * DOCUMENT ME!\r
1823    *\r
1824    * @param e DOCUMENT ME!\r
1825    */\r
1826   public void PCAMenuItem_actionPerformed(ActionEvent e)\r
1827   {\r
1828     if ( ( (viewport.getSelectionGroup() != null) &&\r
1829           (viewport.getSelectionGroup().getSize() < 4) &&\r
1830           (viewport.getSelectionGroup().getSize() > 0)) ||\r
1831         (viewport.getAlignment().getHeight() < 4))\r
1832     {\r
1833       JOptionPane.showInternalMessageDialog(this,\r
1834                                             "Principal component analysis must take\n" +\r
1835                                             "at least 4 input sequences.",\r
1836                                             "Sequence selection insufficient",\r
1837                                             JOptionPane.WARNING_MESSAGE);\r
1838 \r
1839       return;\r
1840     }\r
1841 \r
1842      new PCAPanel(viewport);\r
1843   }\r
1844 \r
1845   /**\r
1846    * DOCUMENT ME!\r
1847    *\r
1848    * @param e DOCUMENT ME!\r
1849    */\r
1850   public void averageDistanceTreeMenuItem_actionPerformed(ActionEvent e)\r
1851   {\r
1852     NewTreePanel("AV", "PID", "Average distance tree using PID");\r
1853   }\r
1854 \r
1855   /**\r
1856    * DOCUMENT ME!\r
1857    *\r
1858    * @param e DOCUMENT ME!\r
1859    */\r
1860   public void neighbourTreeMenuItem_actionPerformed(ActionEvent e)\r
1861   {\r
1862     NewTreePanel("NJ", "PID", "Neighbour joining tree using PID");\r
1863   }\r
1864 \r
1865   /**\r
1866    * DOCUMENT ME!\r
1867    *\r
1868    * @param e DOCUMENT ME!\r
1869    */\r
1870   protected void njTreeBlosumMenuItem_actionPerformed(ActionEvent e)\r
1871   {\r
1872     NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62");\r
1873   }\r
1874 \r
1875   /**\r
1876    * DOCUMENT ME!\r
1877    *\r
1878    * @param e DOCUMENT ME!\r
1879    */\r
1880   protected void avTreeBlosumMenuItem_actionPerformed(ActionEvent e)\r
1881   {\r
1882     NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62");\r
1883   }\r
1884 \r
1885   /**\r
1886    * DOCUMENT ME!\r
1887    *\r
1888    * @param type DOCUMENT ME!\r
1889    * @param pwType DOCUMENT ME!\r
1890    * @param title DOCUMENT ME!\r
1891    */\r
1892   void NewTreePanel(String type, String pwType, String title)\r
1893   {\r
1894     final TreePanel tp;\r
1895 \r
1896     if ( (viewport.getSelectionGroup() != null) &&\r
1897         (viewport.getSelectionGroup().getSize() > 3))\r
1898     {\r
1899       int s = 0;\r
1900       SequenceGroup sg = viewport.getSelectionGroup();\r
1901 \r
1902       /* Decide if the selection is a column region */\r
1903       while (s < sg.sequences.size())\r
1904       {\r
1905         if ( ( (SequenceI) sg.sequences.elementAt(s++)).getLength() <\r
1906             sg.getEndRes())\r
1907         {\r
1908           JOptionPane.showMessageDialog(Desktop.desktop,\r
1909                                         "The selected region to create a tree may\nonly contain residues or gaps.\n" +\r
1910                                         "Try using the Pad function in the edit menu,\n" +\r
1911                                         "or one of the multiple sequence alignment web services.",\r
1912                                         "Sequences in selection are not aligned",\r
1913                                         JOptionPane.WARNING_MESSAGE);\r
1914 \r
1915           return;\r
1916         }\r
1917       }\r
1918 \r
1919       title = title + " on region";\r
1920       tp = new TreePanel(viewport,\r
1921                          viewport.getSelectionGroup().sequences, type, pwType,\r
1922                          sg.getStartRes(), sg.getEndRes());\r
1923     }\r
1924     else\r
1925     {\r
1926       //are the sequences aligned?\r
1927       if (!viewport.alignment.isAligned())\r
1928       {\r
1929         JOptionPane.showMessageDialog(Desktop.desktop,\r
1930                                       "The sequences must be aligned before creating a tree.\n" +\r
1931                                       "Try using the Pad function in the edit menu,\n" +\r
1932                                       "or one of the multiple sequence alignment web services.",\r
1933                                       "Sequences not aligned",\r
1934                                       JOptionPane.WARNING_MESSAGE);\r
1935 \r
1936         return;\r
1937       }\r
1938 \r
1939       tp = new TreePanel(viewport,\r
1940                          viewport.getAlignment().getSequences(), type, pwType,\r
1941                          0,\r
1942                          viewport.alignment.getWidth());\r
1943     }\r
1944 \r
1945     addTreeMenuItem(tp, title);\r
1946     viewport.setCurrentTree(tp.getTree());\r
1947 \r
1948     Desktop.addInternalFrame(tp, title + " from " + this.title, 600, 500);\r
1949   }\r
1950 \r
1951   /**\r
1952    * DOCUMENT ME!\r
1953    *\r
1954    * @param title DOCUMENT ME!\r
1955    * @param order DOCUMENT ME!\r
1956    */\r
1957   public void addSortByOrderMenuItem(String title, final AlignmentOrder order)\r
1958   {\r
1959     final JMenuItem item = new JMenuItem("by " + title);\r
1960     sort.add(item);\r
1961     item.addActionListener(new java.awt.event.ActionListener()\r
1962     {\r
1963       public void actionPerformed(ActionEvent e)\r
1964       {\r
1965         addHistoryItem(new HistoryItem("Sort", viewport.alignment,\r
1966                                        HistoryItem.SORT));\r
1967 \r
1968         // TODO: JBPNote - have to map order entries to curent SequenceI pointers\r
1969         AlignmentSorter.sortBy(viewport.getAlignment(), order);\r
1970         alignPanel.repaint();\r
1971       }\r
1972     });\r
1973   }\r
1974 \r
1975   /**\r
1976    * Maintain the Order by->Displayed Tree menu.\r
1977    * Creates a new menu item for a TreePanel with an appropriate\r
1978    * <code>jalview.analysis.AlignmentSorter</code> call. Listeners are added\r
1979    * to remove the menu item when the treePanel is closed, and adjust\r
1980    * the tree leaf to sequence mapping when the alignment is modified.\r
1981    * @param treePanel Displayed tree window.\r
1982    * @param title SortBy menu item title.\r
1983    */\r
1984   void addTreeMenuItem(final TreePanel treePanel, String title)\r
1985   {\r
1986     final JMenuItem item = new JMenuItem(title);\r
1987 \r
1988     treeCount++;\r
1989 \r
1990     if (treeCount == 1)\r
1991     {\r
1992       sort.add(sortByTreeMenu);\r
1993     }\r
1994 \r
1995     sortByTreeMenu.add(item);\r
1996     item.addActionListener(new java.awt.event.ActionListener()\r
1997     {\r
1998       public void actionPerformed(ActionEvent e)\r
1999       {\r
2000         addHistoryItem(new HistoryItem("Tree Sort",\r
2001                                        viewport.alignment, HistoryItem.SORT));\r
2002         AlignmentSorter.sortByTree(viewport.getAlignment(),\r
2003                                    treePanel.getTree());\r
2004         alignPanel.repaint();\r
2005       }\r
2006     });\r
2007 \r
2008     treePanel.addInternalFrameListener(new javax.swing.event.\r
2009                                        InternalFrameAdapter()\r
2010     {\r
2011       public void internalFrameClosed(\r
2012           javax.swing.event.InternalFrameEvent evt)\r
2013       {\r
2014         treeCount--;\r
2015         sortByTreeMenu.remove(item);\r
2016 \r
2017         if (treeCount == 0)\r
2018         {\r
2019           sort.remove(sortByTreeMenu);\r
2020         }\r
2021       }\r
2022       ;\r
2023     });\r
2024   }\r
2025 \r
2026   /**\r
2027    * Work out whether the whole set of sequences\r
2028    * or just the selected set will be submitted for multiple alignment.\r
2029    *\r
2030    */\r
2031   private SequenceI[] gatherSequencesForAlignment()\r
2032   {\r
2033     // Now, check we have enough sequences\r
2034     SequenceI[] msa = null;\r
2035 \r
2036     if ( (viewport.getSelectionGroup() != null) &&\r
2037         (viewport.getSelectionGroup().getSize() > 1))\r
2038     {\r
2039       // JBPNote UGLY! To prettify, make SequenceGroup and Alignment conform to some common interface!\r
2040       SequenceGroup seqs = viewport.getSelectionGroup();\r
2041       int sz;\r
2042       msa = new SequenceI[sz = seqs.getSize()];\r
2043 \r
2044       for (int i = 0; i < sz; i++)\r
2045       {\r
2046         msa[i] = (SequenceI) seqs.getSequenceAt(i);\r
2047       }\r
2048     }\r
2049     else\r
2050     {\r
2051       Vector seqs = viewport.getAlignment().getSequences();\r
2052 \r
2053       if (seqs.size() > 1)\r
2054       {\r
2055         msa = new SequenceI[seqs.size()];\r
2056 \r
2057         for (int i = 0; i < seqs.size(); i++)\r
2058         {\r
2059           msa[i] = (SequenceI) seqs.elementAt(i);\r
2060         }\r
2061       }\r
2062     }\r
2063     return msa;\r
2064   }\r
2065 \r
2066   /**\r
2067    * Decides what is submitted to a secondary structure prediction service,\r
2068    * the currently selected sequence, or the currently selected alignment\r
2069    * (where the first sequence in the set is the one that the prediction\r
2070    * will be for).\r
2071    */\r
2072   SequenceI[] gatherSeqOrMsaForSecStrPrediction()\r
2073   {\r
2074     SequenceI seq = null;\r
2075     SequenceI[] msa = null;\r
2076 \r
2077     if ( (viewport.getSelectionGroup() != null) &&\r
2078         (viewport.getSelectionGroup().getSize() > 0))\r
2079     {\r
2080       // JBPNote UGLY! To prettify, make SequenceGroup and Alignment conform to some common interface!\r
2081       SequenceGroup seqs = viewport.getSelectionGroup();\r
2082 \r
2083       if ( (seqs.getSize() == 1) || !viewport.alignment.isAligned())\r
2084       {\r
2085         seq = (SequenceI) seqs.getSequenceAt(0);\r
2086       }\r
2087       else\r
2088       {\r
2089         int sz;\r
2090         msa = new SequenceI[sz = seqs.getSize()];\r
2091 \r
2092         for (int i = 0; i < sz; i++)\r
2093         {\r
2094           msa[i] = (SequenceI) seqs.getSequenceAt(i);\r
2095         }\r
2096       }\r
2097     }\r
2098     else\r
2099     {\r
2100       Vector seqs = viewport.getAlignment().getSequences();\r
2101 \r
2102       if ( (seqs.size() == 1) || !viewport.alignment.isAligned())\r
2103       {\r
2104         seq = (SequenceI) seqs.elementAt(0);\r
2105       }\r
2106       else\r
2107       {\r
2108         msa = new SequenceI[seqs.size()];\r
2109 \r
2110         for (int i = 0; i < seqs.size(); i++)\r
2111         {\r
2112           msa[i] = (SequenceI) seqs.elementAt(i);\r
2113         }\r
2114       }\r
2115     }\r
2116     if (msa != null)\r
2117     {\r
2118       return msa;\r
2119     }\r
2120     else\r
2121     {\r
2122       if (seq != null)\r
2123       {\r
2124         return new SequenceI[]\r
2125             {\r
2126             seq};\r
2127       }\r
2128     }\r
2129     return null;\r
2130   }\r
2131   /**\r
2132    * DOCUMENT ME!\r
2133    *\r
2134    * @param e DOCUMENT ME!\r
2135    */\r
2136   protected void LoadtreeMenuItem_actionPerformed(ActionEvent e)\r
2137   {\r
2138     // Pick the tree file\r
2139     JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache.\r
2140         getProperty(\r
2141             "LAST_DIRECTORY"));\r
2142     chooser.setFileView(new JalviewFileView());\r
2143     chooser.setDialogTitle("Select a newick-like tree file");\r
2144     chooser.setToolTipText("Load a tree file");\r
2145 \r
2146     int value = chooser.showOpenDialog(null);\r
2147 \r
2148     if (value == JalviewFileChooser.APPROVE_OPTION)\r
2149     {\r
2150       String choice = chooser.getSelectedFile().getPath();\r
2151       jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice);\r
2152 \r
2153       try\r
2154       {\r
2155         jalview.io.NewickFile fin = new jalview.io.NewickFile(choice,\r
2156             "File");\r
2157         viewport.setCurrentTree(ShowNewickTree(fin, choice).getTree());\r
2158       }\r
2159       catch (Exception ex)\r
2160       {\r
2161         JOptionPane.showMessageDialog(Desktop.desktop,\r
2162                                       "Problem reading tree file",\r
2163                                       ex.getMessage(),\r
2164                                       JOptionPane.WARNING_MESSAGE);\r
2165         ex.printStackTrace();\r
2166       }\r
2167     }\r
2168   }\r
2169 \r
2170 \r
2171   public TreePanel ShowNewickTree(NewickFile nf, String title)\r
2172   {\r
2173     return ShowNewickTree(nf,title,600,500,4,5);\r
2174   }\r
2175   /**\r
2176    * DOCUMENT ME!\r
2177    *\r
2178    * @param nf DOCUMENT ME!\r
2179    * @param title DOCUMENT ME!\r
2180    *\r
2181    * @return DOCUMENT ME!\r
2182    */\r
2183   public TreePanel ShowNewickTree(NewickFile nf, String title, int w,int h,int x, int y)\r
2184   {\r
2185     TreePanel tp = null;\r
2186 \r
2187     try\r
2188     {\r
2189       nf.parse();\r
2190 \r
2191       if (nf.getTree() != null)\r
2192       {\r
2193         tp = new TreePanel(viewport,\r
2194                            viewport.getAlignment().getSequences(), nf,\r
2195                            "FromFile",\r
2196                            title);\r
2197 \r
2198         tp.setSize(w,h);\r
2199 \r
2200         if(x>0 && y>0)\r
2201           tp.setLocation(x,y);\r
2202 \r
2203 \r
2204         Desktop.addInternalFrame(tp, title, w, h);\r
2205         addTreeMenuItem(tp, title);\r
2206       }\r
2207     }\r
2208     catch (Exception ex)\r
2209     {\r
2210       ex.printStackTrace();\r
2211     }\r
2212 \r
2213     return tp;\r
2214   }\r
2215 \r
2216   class PrintThread\r
2217       extends Thread\r
2218   {\r
2219     public void run()\r
2220     {\r
2221       PrinterJob printJob = PrinterJob.getPrinterJob();\r
2222       PageFormat pf = printJob.pageDialog(printJob.defaultPage());\r
2223       printJob.setPrintable(alignPanel, pf);\r
2224 \r
2225       if (printJob.printDialog())\r
2226       {\r
2227         try\r
2228         {\r
2229           printJob.print();\r
2230         }\r
2231         catch (Exception PrintException)\r
2232         {\r
2233           PrintException.printStackTrace();\r
2234         }\r
2235       }\r
2236     }\r
2237   }\r
2238 \r
2239   /**\r
2240    * Generates menu items and listener event actions for web service clients\r
2241    *\r
2242    */\r
2243   public void BuildWebServiceMenu()\r
2244   {\r
2245     if ( (Desktop.discoverer.services != null)\r
2246         && (Desktop.discoverer.services.size() > 0))\r
2247     {\r
2248       Vector msaws = (Vector) Desktop.discoverer.services.get("MsaWS");\r
2249       Vector secstrpr = (Vector) Desktop.discoverer.services.get("SecStrPred");\r
2250       Vector wsmenu = new Vector();\r
2251       if (msaws != null)\r
2252       {\r
2253         // Add any Multiple Sequence Alignment Services\r
2254         final JMenu msawsmenu = new JMenu("Alignment");\r
2255         for (int i = 0, j = msaws.size(); i < j; i++)\r
2256         {\r
2257           final ext.vamsas.ServiceHandle sh = (ext.vamsas.ServiceHandle) msaws.\r
2258               get(i);\r
2259           final JMenuItem method = new JMenuItem(sh.getName());\r
2260           method.addActionListener(new ActionListener()\r
2261           {\r
2262             public void actionPerformed(ActionEvent e)\r
2263             {\r
2264               SequenceI[] msa = gatherSequencesForAlignment();\r
2265               MsaWSClient ct = new jalview.ws.MsaWSClient(sh, title, msa,\r
2266                   false, true);\r
2267 \r
2268             }\r
2269 \r
2270           });\r
2271           msawsmenu.add(method);\r
2272           // Deal with services that we know accept partial alignments.\r
2273           if (sh.getName().indexOf("lustal") > -1)\r
2274           {\r
2275             // We know that ClustalWS can accept partial alignments for refinement.\r
2276             final JMenuItem methodR = new JMenuItem(sh.getName()+" Realign");\r
2277             methodR.addActionListener(new ActionListener()\r
2278             {\r
2279               public void actionPerformed(ActionEvent e)\r
2280               {\r
2281                 SequenceI[] msa = gatherSequencesForAlignment();\r
2282                 MsaWSClient ct = new jalview.ws.MsaWSClient(sh, title, msa,\r
2283                     true, true);\r
2284 \r
2285               }\r
2286 \r
2287             });\r
2288             msawsmenu.add(methodR);\r
2289 \r
2290           }\r
2291         }\r
2292         wsmenu.add(msawsmenu);\r
2293       }\r
2294       if (secstrpr != null)\r
2295       {\r
2296         // Add any secondary structure prediction services\r
2297         final JMenu secstrmenu = new JMenu("Secondary Structure Prediction");\r
2298         for (int i = 0, j = secstrpr.size(); i < j; i++)\r
2299         {\r
2300           final ext.vamsas.ServiceHandle sh = (ext.vamsas.ServiceHandle)\r
2301               secstrpr.get(i);\r
2302           final JMenuItem method = new JMenuItem(sh.getName());\r
2303           method.addActionListener(new ActionListener()\r
2304           {\r
2305             public void actionPerformed(ActionEvent e)\r
2306             {\r
2307               SequenceI[] msa = gatherSeqOrMsaForSecStrPrediction();\r
2308               if (msa.length == 1)\r
2309               {\r
2310                 // Single Sequence prediction\r
2311                 jalview.ws.JPredClient ct = new jalview.ws.JPredClient(sh,\r
2312                     title, msa[0]);\r
2313               }\r
2314               else\r
2315               {\r
2316                 if (msa.length > 1)\r
2317                 {\r
2318                   // Single Sequence prediction\r
2319                   jalview.ws.JPredClient ct = new jalview.ws.JPredClient(sh,\r
2320                       title, msa);\r
2321                 }\r
2322               }\r
2323             }\r
2324           });\r
2325           secstrmenu.add(method);\r
2326         }\r
2327         wsmenu.add(secstrmenu);\r
2328       }\r
2329       this.webService.removeAll();\r
2330       for (int i = 0, j = wsmenu.size(); i < j; i++)\r
2331       {\r
2332         webService.add( (JMenu) wsmenu.get(i));\r
2333       }\r
2334     }\r
2335     else\r
2336     {\r
2337       this.webService.removeAll();\r
2338       this.webService.add(this.webServiceNoServices);\r
2339     }\r
2340     // TODO: add in rediscovery function\r
2341     // TODO: reduce code redundancy.\r
2342     // TODO: group services by location as well as function.\r
2343   }\r
2344 \r
2345 }\r