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