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