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