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 import javax.swing.event.AncestorEvent;\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.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           viewport.alignment.addSequence(sequences[i]);\r
 832           if(sequences[i].getDatasetSequence()==null)\r
 833           {\r
 834              ////////////////////////////\r
 835             //Datset needs extension;\r
 836             /////////////////////////////\r
 837             Sequence ds = new Sequence(sequences[i].getName(),\r
 838                                        AlignSeq.extractGaps("-. ", sequences[i].getSequence()),\r
 839                                        sequences[i].getStart(),\r
 840                                        sequences[i].getEnd());\r
 841             sequences[i].setDatasetSequence(ds);\r
 842             viewport.alignment.getDataset().addSequence(ds);\r
 843 \r
 844 \r
 845           }\r
 846 \r
 847         }\r
 848         viewport.setEndSeq(viewport.alignment.getHeight());\r
 849         viewport.alignment.getWidth();\r
 850         viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());\r
 851       }\r
 852     }\r
 853     catch (Exception ex)\r
 854     {\r
 855         // could be anything being pasted in here\r
 856     }\r
 857 \r
 858 \r
 859   }\r
 860 \r
 861   /**\r
 862    * DOCUMENT ME!\r
 863    *\r
 864    * @param e DOCUMENT ME!\r
 865    */\r
 866   protected void cut_actionPerformed(ActionEvent e)\r
 867   {\r
 868     copy_actionPerformed(null);\r
 869     delete_actionPerformed(null);\r
 870   }\r
 871 \r
 872   /**\r
 873    * DOCUMENT ME!\r
 874    *\r
 875    * @param e DOCUMENT ME!\r
 876    */\r
 877   protected void delete_actionPerformed(ActionEvent e)\r
 878   {\r
 879 \r
 880     if (viewport.getSelectionGroup() == null)\r
 881     {\r
 882       return;\r
 883     }\r
 884 \r
 885     addHistoryItem(new HistoryItem("Delete Sequences", viewport.alignment,\r
 886                                    HistoryItem.HIDE));\r
 887 \r
 888     SequenceGroup sg = viewport.getSelectionGroup();\r
 889     boolean allSequences = false;\r
 890     if (sg.sequences.size() == viewport.alignment.getHeight())\r
 891     {\r
 892       allSequences = true;\r
 893     }\r
 894 \r
 895     for (int i = 0; i < sg.sequences.size(); i++)\r
 896     {\r
 897       SequenceI seq = sg.getSequenceAt(i);\r
 898       int index = viewport.getAlignment().findIndex(seq);\r
 899       seq.deleteChars(sg.getStartRes(), sg.getEndRes() + 1);\r
 900 \r
 901       // If the cut affects all sequences, remove highlighted columns\r
 902       if (allSequences)\r
 903       {\r
 904         viewport.getColumnSelection().removeElements(sg.getStartRes(),\r
 905             sg.getEndRes() + 1);\r
 906       }\r
 907 \r
 908       if (seq.getSequence().length() < 1)\r
 909       {\r
 910         viewport.getAlignment().deleteSequence(seq);\r
 911       }\r
 912       else\r
 913       {\r
 914         viewport.getAlignment().getSequences().setElementAt(seq, index);\r
 915       }\r
 916     }\r
 917 \r
 918     viewport.setSelectionGroup(null);\r
 919     viewport.alignment.deleteGroup(sg);\r
 920 \r
 921     viewport.firePropertyChange("alignment", null,\r
 922                                   viewport.getAlignment().getSequences());\r
 923 \r
 924 \r
 925 \r
 926     if (viewport.getAlignment().getHeight() < 1)\r
 927     {\r
 928       try\r
 929       {\r
 930         this.setClosed(true);\r
 931       }\r
 932       catch (Exception ex)\r
 933       {\r
 934       }\r
 935     }\r
 936   }\r
 937 \r
 938   /**\r
 939    * DOCUMENT ME!\r
 940    *\r
 941    * @param e DOCUMENT ME!\r
 942    */\r
 943   protected void deleteGroups_actionPerformed(ActionEvent e)\r
 944   {\r
 945     viewport.alignment.deleteAllGroups();\r
 946     viewport.setSelectionGroup(null);\r
 947     alignPanel.repaint();\r
 948   }\r
 949 \r
 950   /**\r
 951    * DOCUMENT ME!\r
 952    *\r
 953    * @param e DOCUMENT ME!\r
 954    */\r
 955   public void selectAllSequenceMenuItem_actionPerformed(ActionEvent e)\r
 956   {\r
 957     SequenceGroup sg = new SequenceGroup();\r
 958 \r
 959     for (int i = 0; i < viewport.getAlignment().getSequences().size();\r
 960          i++)\r
 961     {\r
 962       sg.addSequence(viewport.getAlignment().getSequenceAt(i), false);\r
 963     }\r
 964 \r
 965     sg.setEndRes(viewport.alignment.getWidth() - 1);\r
 966     viewport.setSelectionGroup(sg);\r
 967     PaintRefresher.Refresh(null, viewport.alignment);\r
 968   }\r
 969 \r
 970   /**\r
 971    * DOCUMENT ME!\r
 972    *\r
 973    * @param e DOCUMENT ME!\r
 974    */\r
 975   public void deselectAllSequenceMenuItem_actionPerformed(ActionEvent e)\r
 976   {\r
 977     viewport.setSelectionGroup(null);\r
 978     viewport.getColumnSelection().clear();\r
 979     viewport.setSelectionGroup(null);\r
 980     alignPanel.annotationPanel.activeRes = null;\r
 981     PaintRefresher.Refresh(null, viewport.alignment);\r
 982   }\r
 983 \r
 984   /**\r
 985    * DOCUMENT ME!\r
 986    *\r
 987    * @param e DOCUMENT ME!\r
 988    */\r
 989   public void invertSequenceMenuItem_actionPerformed(ActionEvent e)\r
 990   {\r
 991     SequenceGroup sg = viewport.getSelectionGroup();\r
 992 \r
 993     if (sg == null)\r
 994     {\r
 995       selectAllSequenceMenuItem_actionPerformed(null);\r
 996 \r
 997       return;\r
 998     }\r
 999 \r
1000     for (int i = 0; i < viewport.getAlignment().getSequences().size();\r
1001          i++)\r
1002     {\r
1003       sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false);\r
1004     }\r
1005 \r
1006     PaintRefresher.Refresh(null, viewport.alignment);\r
1007   }\r
1008 \r
1009   /**\r
1010    * DOCUMENT ME!\r
1011    *\r
1012    * @param e DOCUMENT ME!\r
1013    */\r
1014   public void remove2LeftMenuItem_actionPerformed(ActionEvent e)\r
1015   {\r
1016     ColumnSelection colSel = viewport.getColumnSelection();\r
1017 \r
1018     if (colSel.size() > 0)\r
1019     {\r
1020       addHistoryItem(new HistoryItem("Remove Left", viewport.alignment,\r
1021                                      HistoryItem.HIDE));\r
1022 \r
1023       int min = colSel.getMin();\r
1024       viewport.getAlignment().trimLeft(min);\r
1025       colSel.compensateForEdit(0, min);\r
1026 \r
1027       if (viewport.getSelectionGroup() != null)\r
1028       {\r
1029         viewport.getSelectionGroup().adjustForRemoveLeft(min);\r
1030       }\r
1031 \r
1032       Vector groups = viewport.alignment.getGroups();\r
1033 \r
1034       for (int i = 0; i < groups.size(); i++)\r
1035       {\r
1036         SequenceGroup sg = (SequenceGroup) groups.get(i);\r
1037 \r
1038         if (!sg.adjustForRemoveLeft(min))\r
1039         {\r
1040           viewport.alignment.deleteGroup(sg);\r
1041         }\r
1042       }\r
1043 \r
1044       viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());\r
1045     }\r
1046   }\r
1047 \r
1048   /**\r
1049    * DOCUMENT ME!\r
1050    *\r
1051    * @param e DOCUMENT ME!\r
1052    */\r
1053   public void remove2RightMenuItem_actionPerformed(ActionEvent e)\r
1054   {\r
1055     ColumnSelection colSel = viewport.getColumnSelection();\r
1056 \r
1057     if (colSel.size() > 0)\r
1058     {\r
1059       addHistoryItem(new HistoryItem("Remove Right", viewport.alignment,\r
1060                                      HistoryItem.HIDE));\r
1061 \r
1062       int max = colSel.getMax();\r
1063       viewport.getAlignment().trimRight(max);\r
1064 \r
1065       if (viewport.getSelectionGroup() != null)\r
1066       {\r
1067         viewport.getSelectionGroup().adjustForRemoveRight(max);\r
1068       }\r
1069 \r
1070       Vector groups = viewport.alignment.getGroups();\r
1071 \r
1072       for (int i = 0; i < groups.size(); i++)\r
1073       {\r
1074         SequenceGroup sg = (SequenceGroup) groups.get(i);\r
1075 \r
1076         if (!sg.adjustForRemoveRight(max))\r
1077         {\r
1078           viewport.alignment.deleteGroup(sg);\r
1079         }\r
1080       }\r
1081 \r
1082       viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());\r
1083     }\r
1084   }\r
1085 \r
1086   /**\r
1087    * DOCUMENT ME!\r
1088    *\r
1089    * @param e DOCUMENT ME!\r
1090    */\r
1091   public void removeGappedColumnMenuItem_actionPerformed(ActionEvent e)\r
1092   {\r
1093     addHistoryItem(new HistoryItem("Remove Gapped Columns",\r
1094                                    viewport.alignment, HistoryItem.HIDE));\r
1095 \r
1096     //This is to maintain viewport position on first residue\r
1097     //of first sequence\r
1098     SequenceI seq = viewport.alignment.getSequenceAt(0);\r
1099     int startRes = seq.findPosition(viewport.startRes);\r
1100 \r
1101     viewport.getAlignment().removeGaps();\r
1102 \r
1103     viewport.setStartRes(seq.findIndex(startRes)-1);\r
1104 \r
1105    viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());\r
1106   }\r
1107 \r
1108   /**\r
1109    * DOCUMENT ME!\r
1110    *\r
1111    * @param e DOCUMENT ME!\r
1112    */\r
1113   public void removeAllGapsMenuItem_actionPerformed(ActionEvent e)\r
1114   {\r
1115     addHistoryItem(new HistoryItem("Remove Gaps", viewport.alignment,\r
1116                                    HistoryItem.HIDE));\r
1117 \r
1118     //This is to maintain viewport position on first residue\r
1119     //of first sequence\r
1120     SequenceI seq = viewport.alignment.getSequenceAt(0);\r
1121     int startRes = seq.findPosition(viewport.startRes);\r
1122 \r
1123 \r
1124     SequenceI current;\r
1125     int jSize;\r
1126 \r
1127     Vector seqs = null;\r
1128 \r
1129     int start = 0;\r
1130     int end = viewport.alignment.getWidth();\r
1131 \r
1132     if (viewport.getSelectionGroup() != null\r
1133         && viewport.getSelectionGroup().sequences != null\r
1134         && viewport.getSelectionGroup().sequences.size() > 0)\r
1135     {\r
1136       seqs = viewport.getSelectionGroup().sequences;\r
1137       start = viewport.getSelectionGroup().getStartRes();\r
1138       end = viewport.getSelectionGroup().getEndRes()+1;\r
1139     }\r
1140     else\r
1141     {\r
1142       seqs = viewport.alignment.getSequences();\r
1143     }\r
1144 \r
1145     for (int i = 0; i < seqs.size(); i++)\r
1146     {\r
1147       current = (SequenceI) seqs.elementAt(i);\r
1148       jSize = current.getLength();\r
1149 \r
1150       // Removing a range is much quicker than removing gaps\r
1151       // one by one for long sequences\r
1152       int j = start;\r
1153       int rangeStart=-1, rangeEnd=-1;\r
1154 \r
1155       do\r
1156       {\r
1157         if (jalview.util.Comparison.isGap(current.getCharAt(j)))\r
1158         {\r
1159           if(rangeStart==-1)\r
1160            {\r
1161              rangeStart = j;\r
1162              rangeEnd = j+1;\r
1163            }\r
1164            else\r
1165            {\r
1166              rangeEnd++;\r
1167            }\r
1168            j++;\r
1169         }\r
1170         else\r
1171         {\r
1172           if(rangeStart>-1)\r
1173           {\r
1174             current.deleteChars(rangeStart, rangeEnd);\r
1175             j-=rangeEnd-rangeStart;\r
1176             jSize-=rangeEnd-rangeStart;\r
1177             rangeStart = -1;\r
1178             rangeEnd = -1;\r
1179           }\r
1180           else\r
1181             j++;\r
1182         }\r
1183       }\r
1184       while (j < end && j < jSize);\r
1185       if(rangeStart>-1)\r
1186       {\r
1187        current.deleteChars(rangeStart, rangeEnd);\r
1188       }\r
1189     }\r
1190 \r
1191     viewport.setStartRes(seq.findIndex(startRes)-1);\r
1192 \r
1193     viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());\r
1194   }\r
1195 \r
1196  public void alignmentChanged()\r
1197  {\r
1198    if(viewport.vconsensus!=null)\r
1199    {\r
1200      viewport.updateConsensus();\r
1201      viewport.updateConservation();\r
1202    }\r
1203    resetAllColourSchemes();\r
1204    if(alignPanel.overviewPanel!=null)\r
1205      alignPanel.overviewPanel.updateOverviewImage();\r
1206 \r
1207   Provenance prov = viewport.alignment.getProvenance();\r
1208   if(prov == null)\r
1209    {\r
1210      prov = new Provenance();\r
1211      viewport.alignment.setProvenance(prov);\r
1212    }\r
1213 \r
1214    prov.addEntry("Me",\r
1215        "Edited in Jalview", new java.util.Date(), "myID");\r
1216 \r
1217    alignPanel.repaint();\r
1218  }\r
1219 \r
1220   void resetAllColourSchemes()\r
1221   {\r
1222     ColourSchemeI cs = viewport.globalColourScheme;\r
1223     if(cs!=null)\r
1224     {\r
1225       if (cs instanceof ClustalxColourScheme)\r
1226       {\r
1227         ( (ClustalxColourScheme) viewport.getGlobalColourScheme()).\r
1228             resetClustalX(viewport.alignment.getSequences(),\r
1229                           viewport.alignment.getWidth());\r
1230       }\r
1231 \r
1232       cs.setConsensus(viewport.vconsensus);\r
1233       if (cs.conservationApplied())\r
1234       {\r
1235         Alignment al = (Alignment) viewport.alignment;\r
1236         Conservation c = new Conservation("All",\r
1237                                           ResidueProperties.propHash, 3,\r
1238                                           al.getSequences(), 0,\r
1239                                           al.getWidth() - 1);\r
1240         c.calculate();\r
1241         c.verdict(false, viewport.ConsPercGaps);\r
1242 \r
1243         cs.setConservation(c);\r
1244       }\r
1245     }\r
1246 \r
1247     int s, sSize = viewport.alignment.getGroups().size();\r
1248     for(s=0; s<sSize; s++)\r
1249     {\r
1250       SequenceGroup sg = (SequenceGroup)viewport.alignment.getGroups().elementAt(s);\r
1251       if(sg.cs!=null && sg.cs instanceof ClustalxColourScheme)\r
1252       {\r
1253         ((ClustalxColourScheme)sg.cs).resetClustalX(sg.sequences, sg.getWidth());\r
1254       }\r
1255       sg.recalcConservation();\r
1256     }\r
1257   }\r
1258 \r
1259   /**\r
1260    * DOCUMENT ME!\r
1261    *\r
1262    * @param e DOCUMENT ME!\r
1263    */\r
1264   public void padGapsMenuitem_actionPerformed(ActionEvent e)\r
1265   {\r
1266     addHistoryItem(new HistoryItem("Pad Gaps", viewport.alignment,\r
1267                                    HistoryItem.HIDE));\r
1268 \r
1269     SequenceI current;\r
1270     int Width = viewport.getAlignment().getWidth();\r
1271 \r
1272     for (int i = 0; i < viewport.getAlignment().getSequences().size();\r
1273          i++)\r
1274     {\r
1275       current = viewport.getAlignment().getSequenceAt(i);\r
1276 \r
1277       if (current.getLength() < Width)\r
1278       {\r
1279         current.insertCharAt(Width - 1, viewport.getGapCharacter());\r
1280       }\r
1281     }\r
1282 \r
1283     alignmentChanged();\r
1284   }\r
1285 \r
1286   /**\r
1287    * DOCUMENT ME!\r
1288    *\r
1289    * @param e DOCUMENT ME!\r
1290    */\r
1291   public void findMenuItem_actionPerformed(ActionEvent e)\r
1292   {\r
1293     JInternalFrame frame = new JInternalFrame();\r
1294     Finder finder = new Finder(viewport, alignPanel, frame);\r
1295     frame.setContentPane(finder);\r
1296     Desktop.addInternalFrame(frame, "Find", 340, 110);\r
1297     frame.setLayer(JLayeredPane.PALETTE_LAYER);\r
1298   }\r
1299 \r
1300   /**\r
1301    * DOCUMENT ME!\r
1302    *\r
1303    * @param e DOCUMENT ME!\r
1304    */\r
1305   public void font_actionPerformed(ActionEvent e)\r
1306   {\r
1307     new FontChooser(alignPanel);\r
1308   }\r
1309 \r
1310   /**\r
1311    * DOCUMENT ME!\r
1312    *\r
1313    * @param e DOCUMENT ME!\r
1314    */\r
1315   protected void seqLimit_actionPerformed(ActionEvent e)\r
1316   {\r
1317     viewport.setShowJVSuffix(seqLimits.isSelected());\r
1318 \r
1319     alignPanel.idPanel.idCanvas.setPreferredSize(alignPanel.calculateIdWidth());\r
1320     alignPanel.repaint();\r
1321   }\r
1322 \r
1323 \r
1324   /**\r
1325    * DOCUMENT ME!\r
1326    *\r
1327    * @param e DOCUMENT ME!\r
1328    */\r
1329   protected void colourTextMenuItem_actionPerformed(ActionEvent e)\r
1330   {\r
1331     viewport.setColourText(colourTextMenuItem.isSelected());\r
1332     alignPanel.repaint();\r
1333   }\r
1334 \r
1335   /**\r
1336    * DOCUMENT ME!\r
1337    *\r
1338    * @param e DOCUMENT ME!\r
1339    */\r
1340   protected void wrapMenuItem_actionPerformed(ActionEvent e)\r
1341   {\r
1342     viewport.setWrapAlignment(wrapMenuItem.isSelected());\r
1343     alignPanel.setWrapAlignment(wrapMenuItem.isSelected());\r
1344     scaleAbove.setVisible(wrapMenuItem.isSelected());\r
1345     scaleLeft.setVisible(wrapMenuItem.isSelected());\r
1346     scaleRight.setVisible(wrapMenuItem.isSelected());\r
1347     alignPanel.repaint();\r
1348   }\r
1349 \r
1350   /**\r
1351    * DOCUMENT ME!\r
1352    *\r
1353    * @param e DOCUMENT ME!\r
1354    */\r
1355   protected void scaleAbove_actionPerformed(ActionEvent e)\r
1356   {\r
1357     viewport.setScaleAboveWrapped(scaleAbove.isSelected());\r
1358     alignPanel.repaint();\r
1359   }\r
1360 \r
1361   /**\r
1362    * DOCUMENT ME!\r
1363    *\r
1364    * @param e DOCUMENT ME!\r
1365    */\r
1366   protected void scaleLeft_actionPerformed(ActionEvent e)\r
1367   {\r
1368     viewport.setScaleLeftWrapped(scaleLeft.isSelected());\r
1369     alignPanel.repaint();\r
1370   }\r
1371 \r
1372   /**\r
1373    * DOCUMENT ME!\r
1374    *\r
1375    * @param e DOCUMENT ME!\r
1376    */\r
1377   protected void scaleRight_actionPerformed(ActionEvent e)\r
1378   {\r
1379     viewport.setScaleRightWrapped(scaleRight.isSelected());\r
1380     alignPanel.repaint();\r
1381   }\r
1382 \r
1383   /**\r
1384    * DOCUMENT ME!\r
1385    *\r
1386    * @param e DOCUMENT ME!\r
1387    */\r
1388   public void viewBoxesMenuItem_actionPerformed(ActionEvent e)\r
1389   {\r
1390     viewport.setShowBoxes(viewBoxesMenuItem.isSelected());\r
1391     alignPanel.repaint();\r
1392   }\r
1393 \r
1394   /**\r
1395    * DOCUMENT ME!\r
1396    *\r
1397    * @param e DOCUMENT ME!\r
1398    */\r
1399   public void viewTextMenuItem_actionPerformed(ActionEvent e)\r
1400   {\r
1401     viewport.setShowText(viewTextMenuItem.isSelected());\r
1402     alignPanel.repaint();\r
1403   }\r
1404 \r
1405   /**\r
1406    * DOCUMENT ME!\r
1407    *\r
1408    * @param e DOCUMENT ME!\r
1409    */\r
1410   protected void renderGapsMenuItem_actionPerformed(ActionEvent e)\r
1411   {\r
1412     viewport.setRenderGaps(renderGapsMenuItem.isSelected());\r
1413     alignPanel.repaint();\r
1414   }\r
1415 \r
1416   /**\r
1417    * DOCUMENT ME!\r
1418    *\r
1419    * @param evt DOCUMENT ME!\r
1420    */\r
1421   public void sequenceFeatures_actionPerformed(ActionEvent evt)\r
1422   {\r
1423     viewport.showSequenceFeatures(sequenceFeatures.isSelected());\r
1424 \r
1425     if (viewport.showSequenceFeatures)\r
1426     {\r
1427       new SequenceFeatureFetcher(viewport.\r
1428          alignment,\r
1429           alignPanel);\r
1430     }\r
1431 \r
1432     featureSettings.setEnabled(true);\r
1433 \r
1434     alignPanel.repaint();\r
1435   }\r
1436 \r
1437   /**\r
1438    * DOCUMENT ME!\r
1439    *\r
1440    * @param e DOCUMENT ME!\r
1441    */\r
1442   public void annotationPanelMenuItem_actionPerformed(ActionEvent e)\r
1443   {\r
1444     viewport.setShowAnnotation(annotationPanelMenuItem.isSelected());\r
1445     alignPanel.setAnnotationVisible(annotationPanelMenuItem.isSelected());\r
1446   }\r
1447 \r
1448   /**\r
1449    * DOCUMENT ME!\r
1450    *\r
1451    * @param e DOCUMENT ME!\r
1452    */\r
1453   public void overviewMenuItem_actionPerformed(ActionEvent e)\r
1454   {\r
1455     if (alignPanel.overviewPanel != null)\r
1456     {\r
1457       return;\r
1458     }\r
1459 \r
1460     JInternalFrame frame = new JInternalFrame();\r
1461     OverviewPanel overview = new OverviewPanel(alignPanel);\r
1462     frame.setContentPane(overview);\r
1463     Desktop.addInternalFrame(frame, "Overview " + this.getTitle(),\r
1464                              frame.getWidth(), frame.getHeight());\r
1465     frame.pack();\r
1466     frame.setLayer(JLayeredPane.PALETTE_LAYER);\r
1467     frame.addInternalFrameListener(new javax.swing.event.InternalFrameAdapter()\r
1468     {\r
1469       public void internalFrameClosed(\r
1470           javax.swing.event.InternalFrameEvent evt)\r
1471       {\r
1472         alignPanel.setOverviewPanel(null);\r
1473       }\r
1474       ;\r
1475     });\r
1476 \r
1477     alignPanel.setOverviewPanel(overview);\r
1478   }\r
1479 \r
1480   /**\r
1481    * DOCUMENT ME!\r
1482    *\r
1483    * @param e DOCUMENT ME!\r
1484    */\r
1485   protected void noColourmenuItem_actionPerformed(ActionEvent e)\r
1486   {\r
1487     changeColour(null);\r
1488   }\r
1489 \r
1490   /**\r
1491    * DOCUMENT ME!\r
1492    *\r
1493    * @param e DOCUMENT ME!\r
1494    */\r
1495   public void clustalColour_actionPerformed(ActionEvent e)\r
1496   {\r
1497     changeColour(new ClustalxColourScheme(\r
1498         viewport.alignment.getSequences(), viewport.alignment.getWidth()));\r
1499   }\r
1500 \r
1501   /**\r
1502    * DOCUMENT ME!\r
1503    *\r
1504    * @param e DOCUMENT ME!\r
1505    */\r
1506   public void zappoColour_actionPerformed(ActionEvent e)\r
1507   {\r
1508     changeColour(new ZappoColourScheme());\r
1509   }\r
1510 \r
1511   /**\r
1512    * DOCUMENT ME!\r
1513    *\r
1514    * @param e DOCUMENT ME!\r
1515    */\r
1516   public void taylorColour_actionPerformed(ActionEvent e)\r
1517   {\r
1518     changeColour(new TaylorColourScheme());\r
1519   }\r
1520 \r
1521   /**\r
1522    * DOCUMENT ME!\r
1523    *\r
1524    * @param e DOCUMENT ME!\r
1525    */\r
1526   public void hydrophobicityColour_actionPerformed(ActionEvent e)\r
1527   {\r
1528     changeColour(new HydrophobicColourScheme());\r
1529   }\r
1530 \r
1531   /**\r
1532    * DOCUMENT ME!\r
1533    *\r
1534    * @param e DOCUMENT ME!\r
1535    */\r
1536   public void helixColour_actionPerformed(ActionEvent e)\r
1537   {\r
1538     changeColour(new HelixColourScheme());\r
1539   }\r
1540 \r
1541   /**\r
1542    * DOCUMENT ME!\r
1543    *\r
1544    * @param e DOCUMENT ME!\r
1545    */\r
1546   public void strandColour_actionPerformed(ActionEvent e)\r
1547   {\r
1548     changeColour(new StrandColourScheme());\r
1549   }\r
1550 \r
1551   /**\r
1552    * DOCUMENT ME!\r
1553    *\r
1554    * @param e DOCUMENT ME!\r
1555    */\r
1556   public void turnColour_actionPerformed(ActionEvent e)\r
1557   {\r
1558     changeColour(new TurnColourScheme());\r
1559   }\r
1560 \r
1561   /**\r
1562    * DOCUMENT ME!\r
1563    *\r
1564    * @param e DOCUMENT ME!\r
1565    */\r
1566   public void buriedColour_actionPerformed(ActionEvent e)\r
1567   {\r
1568     changeColour(new BuriedColourScheme());\r
1569   }\r
1570 \r
1571   /**\r
1572    * DOCUMENT ME!\r
1573    *\r
1574    * @param e DOCUMENT ME!\r
1575    */\r
1576   public void nucleotideColour_actionPerformed(ActionEvent e)\r
1577   {\r
1578     changeColour(new NucleotideColourScheme());\r
1579   }\r
1580 \r
1581   /**\r
1582    * DOCUMENT ME!\r
1583    *\r
1584    * @param e DOCUMENT ME!\r
1585    */\r
1586   protected void applyToAllGroups_actionPerformed(ActionEvent e)\r
1587   {\r
1588     viewport.setColourAppliesToAllGroups(applyToAllGroups.isSelected());\r
1589   }\r
1590 \r
1591   /**\r
1592    * DOCUMENT ME!\r
1593    *\r
1594    * @param cs DOCUMENT ME!\r
1595    */\r
1596   void changeColour(ColourSchemeI cs)\r
1597   {\r
1598     int threshold = 0;\r
1599 \r
1600     if(cs!=null)\r
1601     {\r
1602       if (viewport.getAbovePIDThreshold())\r
1603       {\r
1604         threshold = SliderPanel.setPIDSliderSource(alignPanel, cs,\r
1605                                                    "Background");\r
1606 \r
1607         cs.setThreshold(threshold,\r
1608                         viewport.getIgnoreGapsConsensus());\r
1609 \r
1610         viewport.setGlobalColourScheme(cs);\r
1611       }\r
1612       else\r
1613       {\r
1614         cs.setThreshold(0, viewport.getIgnoreGapsConsensus());\r
1615       }\r
1616 \r
1617       if (viewport.getConservationSelected())\r
1618       {\r
1619 \r
1620         Alignment al = (Alignment) viewport.alignment;\r
1621         Conservation c = new Conservation("All",\r
1622                                           ResidueProperties.propHash, 3,\r
1623                                           al.getSequences(), 0,\r
1624                                           al.getWidth() - 1);\r
1625 \r
1626         c.calculate();\r
1627         c.verdict(false, viewport.ConsPercGaps);\r
1628 \r
1629         cs.setConservation(c);\r
1630 \r
1631         cs.setConservationInc(SliderPanel.setConservationSlider(alignPanel, cs,\r
1632             "Background"));\r
1633       }\r
1634       else\r
1635       {\r
1636         cs.setConservation(null);\r
1637       }\r
1638 \r
1639       cs.setConsensus(viewport.vconsensus);\r
1640     }\r
1641 \r
1642     viewport.setGlobalColourScheme(cs);\r
1643 \r
1644     if (viewport.getColourAppliesToAllGroups())\r
1645     {\r
1646       Vector groups = viewport.alignment.getGroups();\r
1647 \r
1648       for (int i = 0; i < groups.size(); i++)\r
1649       {\r
1650         SequenceGroup sg = (SequenceGroup) groups.elementAt(i);\r
1651 \r
1652         if (cs == null)\r
1653         {\r
1654           sg.cs = null;\r
1655           continue;\r
1656         }\r
1657 \r
1658         if (cs instanceof ClustalxColourScheme)\r
1659         {\r
1660           sg.cs = new ClustalxColourScheme(sg.sequences, sg.getWidth());\r
1661         }\r
1662         else if (cs instanceof UserColourScheme)\r
1663         {\r
1664           sg.cs = new UserColourScheme( ( (UserColourScheme) cs).getColours());\r
1665         }\r
1666         else\r
1667         {\r
1668           try\r
1669           {\r
1670             sg.cs = (ColourSchemeI) cs.getClass().newInstance();\r
1671           }\r
1672           catch (Exception ex)\r
1673           {\r
1674           }\r
1675         }\r
1676 \r
1677         if (viewport.getAbovePIDThreshold()\r
1678             || cs instanceof PIDColourScheme\r
1679             || cs instanceof Blosum62ColourScheme)\r
1680         {\r
1681          sg.cs.setThreshold(threshold,\r
1682                 viewport.getIgnoreGapsConsensus());\r
1683 \r
1684           sg.cs.setConsensus(AAFrequency.calculate(sg.sequences, 0,\r
1685               sg.getWidth()));\r
1686         }\r
1687         else\r
1688           sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());\r
1689 \r
1690 \r
1691         if (viewport.getConservationSelected())\r
1692         {\r
1693           Conservation c = new Conservation("Group",\r
1694                                             ResidueProperties.propHash, 3,\r
1695                                             sg.sequences, 0,\r
1696                                             viewport.alignment.getWidth() - 1);\r
1697           c.calculate();\r
1698           c.verdict(false, viewport.ConsPercGaps);\r
1699           sg.cs.setConservation(c);\r
1700         }\r
1701         else\r
1702           sg.cs.setConservation(null);\r
1703       }\r
1704     }\r
1705 \r
1706     if (alignPanel.getOverviewPanel() != null)\r
1707     {\r
1708       alignPanel.getOverviewPanel().updateOverviewImage();\r
1709     }\r
1710 \r
1711     alignPanel.repaint();\r
1712   }\r
1713 \r
1714   /**\r
1715    * DOCUMENT ME!\r
1716    *\r
1717    * @param e DOCUMENT ME!\r
1718    */\r
1719   protected void modifyPID_actionPerformed(ActionEvent e)\r
1720   {\r
1721     if (viewport.getAbovePIDThreshold() && viewport.globalColourScheme!=null)\r
1722     {\r
1723       SliderPanel.setPIDSliderSource(alignPanel,\r
1724                                      viewport.getGlobalColourScheme(),\r
1725                                      "Background");\r
1726       SliderPanel.showPIDSlider();\r
1727     }\r
1728   }\r
1729 \r
1730   /**\r
1731    * DOCUMENT ME!\r
1732    *\r
1733    * @param e DOCUMENT ME!\r
1734    */\r
1735   protected void modifyConservation_actionPerformed(ActionEvent e)\r
1736   {\r
1737     if (viewport.getConservationSelected() && viewport.globalColourScheme!=null)\r
1738     {\r
1739       SliderPanel.setConservationSlider(alignPanel,\r
1740                                         viewport.globalColourScheme,\r
1741                                         "Background");\r
1742       SliderPanel.showConservationSlider();\r
1743     }\r
1744   }\r
1745 \r
1746   /**\r
1747    * DOCUMENT ME!\r
1748    *\r
1749    * @param e DOCUMENT ME!\r
1750    */\r
1751   protected void conservationMenuItem_actionPerformed(ActionEvent e)\r
1752   {\r
1753     viewport.setConservationSelected(conservationMenuItem.isSelected());\r
1754 \r
1755     viewport.setAbovePIDThreshold(false);\r
1756     abovePIDThreshold.setSelected(false);\r
1757 \r
1758     changeColour(viewport.getGlobalColourScheme());\r
1759 \r
1760     modifyConservation_actionPerformed(null);\r
1761   }\r
1762 \r
1763   /**\r
1764    * DOCUMENT ME!\r
1765    *\r
1766    * @param e DOCUMENT ME!\r
1767    */\r
1768   public void abovePIDThreshold_actionPerformed(ActionEvent e)\r
1769   {\r
1770     viewport.setAbovePIDThreshold(abovePIDThreshold.isSelected());\r
1771 \r
1772     conservationMenuItem.setSelected(false);\r
1773     viewport.setConservationSelected(false);\r
1774 \r
1775     changeColour(viewport.getGlobalColourScheme());\r
1776 \r
1777     modifyPID_actionPerformed(null);\r
1778   }\r
1779 \r
1780   /**\r
1781    * DOCUMENT ME!\r
1782    *\r
1783    * @param e DOCUMENT ME!\r
1784    */\r
1785   public void userDefinedColour_actionPerformed(ActionEvent e)\r
1786   {\r
1787     if (e.getActionCommand().equals("User Defined..."))\r
1788     {\r
1789       new UserDefinedColours(alignPanel, null);\r
1790     }\r
1791     else\r
1792     {\r
1793       UserColourScheme udc = (UserColourScheme) UserDefinedColours.\r
1794           getUserColourSchemes().get(e.getActionCommand());\r
1795 \r
1796       changeColour(udc);\r
1797     }\r
1798   }\r
1799 \r
1800   public void updateUserColourMenu()\r
1801   {\r
1802 \r
1803     Component[] menuItems = colourMenu.getMenuComponents();\r
1804     int i, iSize = menuItems.length;\r
1805     for (i = 0; i < iSize; i++)\r
1806     {\r
1807       if (menuItems[i].getName() != null &&\r
1808           menuItems[i].getName().equals("USER_DEFINED"))\r
1809       {\r
1810         colourMenu.remove(menuItems[i]);\r
1811         iSize--;\r
1812       }\r
1813     }\r
1814     if (jalview.gui.UserDefinedColours.getUserColourSchemes() != null)\r
1815     {\r
1816       java.util.Enumeration userColours = jalview.gui.UserDefinedColours.\r
1817           getUserColourSchemes().keys();\r
1818 \r
1819       while (userColours.hasMoreElements())\r
1820       {\r
1821         final JRadioButtonMenuItem radioItem = new JRadioButtonMenuItem(userColours.\r
1822             nextElement().toString());\r
1823         radioItem.setName("USER_DEFINED");\r
1824         radioItem.addMouseListener(new MouseAdapter()\r
1825             {\r
1826               public void mousePressed(MouseEvent evt)\r
1827               {\r
1828                 if(evt.isControlDown() || SwingUtilities.isRightMouseButton(evt))\r
1829                 {\r
1830                   radioItem.removeActionListener(radioItem.getActionListeners()[0]);\r
1831 \r
1832                   int option = JOptionPane.showInternalConfirmDialog(jalview.gui.Desktop.desktop,\r
1833                       "Remove from default list?",\r
1834                       "Remove user defined colour",\r
1835                       JOptionPane.YES_NO_OPTION);\r
1836                   if(option == JOptionPane.YES_OPTION)\r
1837                   {\r
1838                     jalview.gui.UserDefinedColours.removeColourFromDefaults(radioItem.getText());\r
1839                     colourMenu.remove(radioItem);\r
1840                   }\r
1841                   else\r
1842                     radioItem.addActionListener(new ActionListener()\r
1843                     {\r
1844                       public void actionPerformed(ActionEvent evt)\r
1845                       {\r
1846                         userDefinedColour_actionPerformed(evt);\r
1847                       }\r
1848                     });\r
1849                 }\r
1850               }\r
1851             });\r
1852         radioItem.addActionListener(new ActionListener()\r
1853         {\r
1854           public void actionPerformed(ActionEvent evt)\r
1855           {\r
1856             userDefinedColour_actionPerformed(evt);\r
1857           }\r
1858         });\r
1859 \r
1860         colourMenu.insert(radioItem, 15);\r
1861         colours.add(radioItem);\r
1862       }\r
1863     }\r
1864   }\r
1865 \r
1866   /**\r
1867    * DOCUMENT ME!\r
1868    *\r
1869    * @param e DOCUMENT ME!\r
1870    */\r
1871   public void PIDColour_actionPerformed(ActionEvent e)\r
1872   {\r
1873     changeColour(new PIDColourScheme());\r
1874   }\r
1875 \r
1876   /**\r
1877    * DOCUMENT ME!\r
1878    *\r
1879    * @param e DOCUMENT ME!\r
1880    */\r
1881   public void BLOSUM62Colour_actionPerformed(ActionEvent e)\r
1882   {\r
1883     changeColour(new Blosum62ColourScheme());\r
1884   }\r
1885 \r
1886   /**\r
1887    * DOCUMENT ME!\r
1888    *\r
1889    * @param e DOCUMENT ME!\r
1890    */\r
1891   public void sortPairwiseMenuItem_actionPerformed(ActionEvent e)\r
1892   {\r
1893     addHistoryItem(new HistoryItem("Pairwise Sort", viewport.alignment,\r
1894                                    HistoryItem.SORT));\r
1895     AlignmentSorter.sortByPID(viewport.getAlignment(),\r
1896                               viewport.getAlignment().getSequenceAt(0));\r
1897     alignPanel.repaint();\r
1898   }\r
1899 \r
1900   /**\r
1901    * DOCUMENT ME!\r
1902    *\r
1903    * @param e DOCUMENT ME!\r
1904    */\r
1905   public void sortIDMenuItem_actionPerformed(ActionEvent e)\r
1906   {\r
1907     addHistoryItem(new HistoryItem("ID Sort", viewport.alignment,\r
1908                                    HistoryItem.SORT));\r
1909     AlignmentSorter.sortByID(viewport.getAlignment());\r
1910     alignPanel.repaint();\r
1911   }\r
1912 \r
1913   /**\r
1914    * DOCUMENT ME!\r
1915    *\r
1916    * @param e DOCUMENT ME!\r
1917    */\r
1918   public void sortGroupMenuItem_actionPerformed(ActionEvent e)\r
1919   {\r
1920     addHistoryItem(new HistoryItem("Group Sort", viewport.alignment,\r
1921                                    HistoryItem.SORT));\r
1922 \r
1923     AlignmentSorter.sortByGroup(viewport.getAlignment());\r
1924     alignPanel.repaint();\r
1925   }\r
1926 \r
1927   /**\r
1928    * DOCUMENT ME!\r
1929    *\r
1930    * @param e DOCUMENT ME!\r
1931    */\r
1932   public void removeRedundancyMenuItem_actionPerformed(ActionEvent e)\r
1933   {\r
1934     RedundancyPanel sp = new RedundancyPanel(alignPanel, this);\r
1935     JInternalFrame frame = new JInternalFrame();\r
1936     frame.setContentPane(sp);\r
1937     Desktop.addInternalFrame(frame, "Redundancy threshold selection", 400,\r
1938                              100, false);\r
1939   }\r
1940 \r
1941   /**\r
1942    * DOCUMENT ME!\r
1943    *\r
1944    * @param e DOCUMENT ME!\r
1945    */\r
1946   public void pairwiseAlignmentMenuItem_actionPerformed(ActionEvent e)\r
1947   {\r
1948     if ( (viewport.getSelectionGroup() == null) ||\r
1949         (viewport.getSelectionGroup().getSize() < 2))\r
1950     {\r
1951       JOptionPane.showInternalMessageDialog(this,\r
1952                                             "You must select at least 2 sequences.",\r
1953                                             "Invalid Selection",\r
1954                                             JOptionPane.WARNING_MESSAGE);\r
1955     }\r
1956     else\r
1957     {\r
1958       JInternalFrame frame = new JInternalFrame();\r
1959       frame.setContentPane(new PairwiseAlignPanel(viewport));\r
1960       Desktop.addInternalFrame(frame, "Pairwise Alignment", 600, 500);\r
1961     }\r
1962   }\r
1963 \r
1964   /**\r
1965    * DOCUMENT ME!\r
1966    *\r
1967    * @param e DOCUMENT ME!\r
1968    */\r
1969   public void PCAMenuItem_actionPerformed(ActionEvent e)\r
1970   {\r
1971     if ( ( (viewport.getSelectionGroup() != null) &&\r
1972           (viewport.getSelectionGroup().getSize() < 4) &&\r
1973           (viewport.getSelectionGroup().getSize() > 0)) ||\r
1974         (viewport.getAlignment().getHeight() < 4))\r
1975     {\r
1976       JOptionPane.showInternalMessageDialog(this,\r
1977                                             "Principal component analysis must take\n" +\r
1978                                             "at least 4 input sequences.",\r
1979                                             "Sequence selection insufficient",\r
1980                                             JOptionPane.WARNING_MESSAGE);\r
1981 \r
1982       return;\r
1983     }\r
1984 \r
1985      new PCAPanel(viewport);\r
1986   }\r
1987 \r
1988   /**\r
1989    * DOCUMENT ME!\r
1990    *\r
1991    * @param e DOCUMENT ME!\r
1992    */\r
1993   public void averageDistanceTreeMenuItem_actionPerformed(ActionEvent e)\r
1994   {\r
1995     NewTreePanel("AV", "PID", "Average distance tree using PID");\r
1996   }\r
1997 \r
1998   /**\r
1999    * DOCUMENT ME!\r
2000    *\r
2001    * @param e DOCUMENT ME!\r
2002    */\r
2003   public void neighbourTreeMenuItem_actionPerformed(ActionEvent e)\r
2004   {\r
2005     NewTreePanel("NJ", "PID", "Neighbour joining tree using PID");\r
2006   }\r
2007 \r
2008   /**\r
2009    * DOCUMENT ME!\r
2010    *\r
2011    * @param e DOCUMENT ME!\r
2012    */\r
2013   protected void njTreeBlosumMenuItem_actionPerformed(ActionEvent e)\r
2014   {\r
2015     NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62");\r
2016   }\r
2017 \r
2018   /**\r
2019    * DOCUMENT ME!\r
2020    *\r
2021    * @param e DOCUMENT ME!\r
2022    */\r
2023   protected void avTreeBlosumMenuItem_actionPerformed(ActionEvent e)\r
2024   {\r
2025     NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62");\r
2026   }\r
2027 \r
2028   /**\r
2029    * DOCUMENT ME!\r
2030    *\r
2031    * @param type DOCUMENT ME!\r
2032    * @param pwType DOCUMENT ME!\r
2033    * @param title DOCUMENT ME!\r
2034    */\r
2035   void NewTreePanel(String type, String pwType, String title)\r
2036   {\r
2037     final TreePanel tp;\r
2038 \r
2039     if ( (viewport.getSelectionGroup() != null) &&\r
2040         (viewport.getSelectionGroup().getSize() > 3))\r
2041     {\r
2042       int s = 0;\r
2043       SequenceGroup sg = viewport.getSelectionGroup();\r
2044 \r
2045       /* Decide if the selection is a column region */\r
2046       while (s < sg.sequences.size())\r
2047       {\r
2048         if ( ( (SequenceI) sg.sequences.elementAt(s++)).getLength() <\r
2049             sg.getEndRes())\r
2050         {\r
2051           JOptionPane.showMessageDialog(Desktop.desktop,\r
2052                                         "The selected region to create a tree may\nonly contain residues or gaps.\n" +\r
2053                                         "Try using the Pad function in the edit menu,\n" +\r
2054                                         "or one of the multiple sequence alignment web services.",\r
2055                                         "Sequences in selection are not aligned",\r
2056                                         JOptionPane.WARNING_MESSAGE);\r
2057 \r
2058           return;\r
2059         }\r
2060       }\r
2061 \r
2062       title = title + " on region";\r
2063       tp = new TreePanel(viewport,\r
2064                          viewport.getSelectionGroup().sequences, type, pwType,\r
2065                          sg.getStartRes(), sg.getEndRes());\r
2066     }\r
2067     else\r
2068     {\r
2069       //are the sequences aligned?\r
2070       if (!viewport.alignment.isAligned())\r
2071       {\r
2072         JOptionPane.showMessageDialog(Desktop.desktop,\r
2073                                       "The sequences must be aligned before creating a tree.\n" +\r
2074                                       "Try using the Pad function in the edit menu,\n" +\r
2075                                       "or one of the multiple sequence alignment web services.",\r
2076                                       "Sequences not aligned",\r
2077                                       JOptionPane.WARNING_MESSAGE);\r
2078 \r
2079         return;\r
2080       }\r
2081 \r
2082       tp = new TreePanel(viewport,\r
2083                          viewport.getAlignment().getSequences(), type, pwType,\r
2084                          0,\r
2085                          viewport.alignment.getWidth());\r
2086     }\r
2087 \r
2088     addTreeMenuItem(tp, title);\r
2089     viewport.setCurrentTree(tp.getTree());\r
2090 \r
2091     Desktop.addInternalFrame(tp, title + " from " + this.title, 600, 500);\r
2092   }\r
2093 \r
2094   /**\r
2095    * DOCUMENT ME!\r
2096    *\r
2097    * @param title DOCUMENT ME!\r
2098    * @param order DOCUMENT ME!\r
2099    */\r
2100   public void addSortByOrderMenuItem(String title, final AlignmentOrder order)\r
2101   {\r
2102     final JMenuItem item = new JMenuItem("by " + title);\r
2103     sort.add(item);\r
2104     item.addActionListener(new java.awt.event.ActionListener()\r
2105     {\r
2106       public void actionPerformed(ActionEvent e)\r
2107       {\r
2108         addHistoryItem(new HistoryItem("Sort", viewport.alignment,\r
2109                                        HistoryItem.SORT));\r
2110 \r
2111         // TODO: JBPNote - have to map order entries to curent SequenceI pointers\r
2112         AlignmentSorter.sortBy(viewport.getAlignment(), order);\r
2113         alignPanel.repaint();\r
2114       }\r
2115     });\r
2116   }\r
2117 \r
2118   /**\r
2119    * Maintain the Order by->Displayed Tree menu.\r
2120    * Creates a new menu item for a TreePanel with an appropriate\r
2121    * <code>jalview.analysis.AlignmentSorter</code> call. Listeners are added\r
2122    * to remove the menu item when the treePanel is closed, and adjust\r
2123    * the tree leaf to sequence mapping when the alignment is modified.\r
2124    * @param treePanel Displayed tree window.\r
2125    * @param title SortBy menu item title.\r
2126    */\r
2127   void addTreeMenuItem(final TreePanel treePanel, String title)\r
2128   {\r
2129     final JMenuItem item = new JMenuItem(title);\r
2130 \r
2131     treeCount++;\r
2132 \r
2133     if (treeCount == 1)\r
2134     {\r
2135       sort.add(sortByTreeMenu);\r
2136     }\r
2137 \r
2138     sortByTreeMenu.add(item);\r
2139     item.addActionListener(new java.awt.event.ActionListener()\r
2140     {\r
2141       public void actionPerformed(ActionEvent e)\r
2142       {\r
2143         addHistoryItem(new HistoryItem("Tree Sort",\r
2144                                        viewport.alignment, HistoryItem.SORT));\r
2145         AlignmentSorter.sortByTree(viewport.getAlignment(),\r
2146                                    treePanel.getTree());\r
2147         alignPanel.repaint();\r
2148       }\r
2149     });\r
2150 \r
2151     treePanel.addInternalFrameListener(new javax.swing.event.\r
2152                                        InternalFrameAdapter()\r
2153     {\r
2154       public void internalFrameClosed(\r
2155           javax.swing.event.InternalFrameEvent evt)\r
2156       {\r
2157         treeCount--;\r
2158         sortByTreeMenu.remove(item);\r
2159 \r
2160         if (treeCount == 0)\r
2161         {\r
2162           sort.remove(sortByTreeMenu);\r
2163         }\r
2164       }\r
2165       ;\r
2166     });\r
2167   }\r
2168 \r
2169   /**\r
2170    * Work out whether the whole set of sequences\r
2171    * or just the selected set will be submitted for multiple alignment.\r
2172    *\r
2173    */\r
2174   private SequenceI[] gatherSequencesForAlignment()\r
2175   {\r
2176     // Now, check we have enough sequences\r
2177     SequenceI[] msa = null;\r
2178 \r
2179     if ( (viewport.getSelectionGroup() != null) &&\r
2180         (viewport.getSelectionGroup().getSize() > 1))\r
2181     {\r
2182       // JBPNote UGLY! To prettify, make SequenceGroup and Alignment conform to some common interface!\r
2183       SequenceGroup seqs = viewport.getSelectionGroup();\r
2184       int sz;\r
2185       msa = new SequenceI[sz = seqs.getSize()];\r
2186 \r
2187       for (int i = 0; i < sz; i++)\r
2188       {\r
2189         msa[i] = (SequenceI) seqs.getSequenceAt(i);\r
2190       }\r
2191     }\r
2192     else\r
2193     {\r
2194       Vector seqs = viewport.getAlignment().getSequences();\r
2195 \r
2196       if (seqs.size() > 1)\r
2197       {\r
2198         msa = new SequenceI[seqs.size()];\r
2199 \r
2200         for (int i = 0; i < seqs.size(); i++)\r
2201         {\r
2202           msa[i] = (SequenceI) seqs.elementAt(i);\r
2203         }\r
2204       }\r
2205     }\r
2206     return msa;\r
2207   }\r
2208 \r
2209   /**\r
2210    * Decides what is submitted to a secondary structure prediction service,\r
2211    * the currently selected sequence, or the currently selected alignment\r
2212    * (where the first sequence in the set is the one that the prediction\r
2213    * will be for).\r
2214    */\r
2215   SequenceI[] gatherSeqOrMsaForSecStrPrediction()\r
2216   {\r
2217     SequenceI seq = null;\r
2218     SequenceI[] msa = null;\r
2219 \r
2220     if ( (viewport.getSelectionGroup() != null) &&\r
2221         (viewport.getSelectionGroup().getSize() > 0))\r
2222     {\r
2223       // JBPNote UGLY! To prettify, make SequenceGroup and Alignment conform to some common interface!\r
2224       SequenceGroup seqs = viewport.getSelectionGroup();\r
2225 \r
2226       if ( (seqs.getSize() == 1) || !viewport.alignment.isAligned())\r
2227       {\r
2228         seq = (SequenceI) seqs.getSequenceAt(0);\r
2229       }\r
2230       else\r
2231       {\r
2232         int sz;\r
2233         msa = new SequenceI[sz = seqs.getSize()];\r
2234 \r
2235         for (int i = 0; i < sz; i++)\r
2236         {\r
2237           msa[i] = (SequenceI) seqs.getSequenceAt(i);\r
2238         }\r
2239       }\r
2240     }\r
2241     else\r
2242     {\r
2243       Vector seqs = viewport.getAlignment().getSequences();\r
2244 \r
2245       if ( (seqs.size() == 1) || !viewport.alignment.isAligned())\r
2246       {\r
2247         seq = (SequenceI) seqs.elementAt(0);\r
2248       }\r
2249       else\r
2250       {\r
2251         msa = new SequenceI[seqs.size()];\r
2252 \r
2253         for (int i = 0; i < seqs.size(); i++)\r
2254         {\r
2255           msa[i] = (SequenceI) seqs.elementAt(i);\r
2256         }\r
2257       }\r
2258     }\r
2259     if (msa != null)\r
2260     {\r
2261       return msa;\r
2262     }\r
2263     else\r
2264     {\r
2265       if (seq != null)\r
2266       {\r
2267         return new SequenceI[]\r
2268             {\r
2269             seq};\r
2270       }\r
2271     }\r
2272     return null;\r
2273   }\r
2274   /**\r
2275    * DOCUMENT ME!\r
2276    *\r
2277    * @param e DOCUMENT ME!\r
2278    */\r
2279   protected void LoadtreeMenuItem_actionPerformed(ActionEvent e)\r
2280   {\r
2281     // Pick the tree file\r
2282     JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache.\r
2283         getProperty(\r
2284             "LAST_DIRECTORY"));\r
2285     chooser.setFileView(new JalviewFileView());\r
2286     chooser.setDialogTitle("Select a newick-like tree file");\r
2287     chooser.setToolTipText("Load a tree file");\r
2288 \r
2289     int value = chooser.showOpenDialog(null);\r
2290 \r
2291     if (value == JalviewFileChooser.APPROVE_OPTION)\r
2292     {\r
2293       String choice = chooser.getSelectedFile().getPath();\r
2294       jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice);\r
2295 \r
2296       try\r
2297       {\r
2298         jalview.io.NewickFile fin = new jalview.io.NewickFile(choice,\r
2299             "File");\r
2300         viewport.setCurrentTree(ShowNewickTree(fin, choice).getTree());\r
2301       }\r
2302       catch (Exception ex)\r
2303       {\r
2304         JOptionPane.showMessageDialog(Desktop.desktop,\r
2305                                       "Problem reading tree file",\r
2306                                       ex.getMessage(),\r
2307                                       JOptionPane.WARNING_MESSAGE);\r
2308         ex.printStackTrace();\r
2309       }\r
2310     }\r
2311   }\r
2312 \r
2313 \r
2314   public TreePanel ShowNewickTree(NewickFile nf, String title)\r
2315   {\r
2316     return ShowNewickTree(nf,title,600,500,4,5);\r
2317   }\r
2318   /**\r
2319    * DOCUMENT ME!\r
2320    *\r
2321    * @param nf DOCUMENT ME!\r
2322    * @param title DOCUMENT ME!\r
2323    *\r
2324    * @return DOCUMENT ME!\r
2325    */\r
2326   public TreePanel ShowNewickTree(NewickFile nf, String title, int w,int h,int x, int y)\r
2327   {\r
2328     TreePanel tp = null;\r
2329 \r
2330     try\r
2331     {\r
2332       nf.parse();\r
2333 \r
2334       if (nf.getTree() != null)\r
2335       {\r
2336         tp = new TreePanel(viewport,\r
2337                            viewport.getAlignment().getSequences(), nf,\r
2338                            "FromFile",\r
2339                            title);\r
2340 \r
2341         tp.setSize(w,h);\r
2342 \r
2343         if(x>0 && y>0)\r
2344           tp.setLocation(x,y);\r
2345 \r
2346 \r
2347         Desktop.addInternalFrame(tp, title, w, h);\r
2348         addTreeMenuItem(tp, title);\r
2349       }\r
2350     }\r
2351     catch (Exception ex)\r
2352     {\r
2353       ex.printStackTrace();\r
2354     }\r
2355 \r
2356     return tp;\r
2357   }\r
2358 \r
2359   class PrintThread\r
2360       extends Thread\r
2361   {\r
2362     public void run()\r
2363     {\r
2364       PrinterJob printJob = PrinterJob.getPrinterJob();\r
2365       PageFormat pf = printJob.pageDialog(printJob.defaultPage());\r
2366       printJob.setPrintable(alignPanel, pf);\r
2367 \r
2368       if (printJob.printDialog())\r
2369       {\r
2370         try\r
2371         {\r
2372           printJob.print();\r
2373         }\r
2374         catch (Exception PrintException)\r
2375         {\r
2376           PrintException.printStackTrace();\r
2377         }\r
2378       }\r
2379     }\r
2380   }\r
2381 \r
2382   /**\r
2383    * Generates menu items and listener event actions for web service clients\r
2384    *\r
2385    */\r
2386   public void BuildWebServiceMenu()\r
2387   {\r
2388     if ( (Discoverer.services != null)\r
2389         && (Discoverer.services.size() > 0))\r
2390     {\r
2391       Vector msaws = (Vector) Discoverer.services.get("MsaWS");\r
2392       Vector secstrpr = (Vector) Discoverer.services.get("SecStrPred");\r
2393       Vector wsmenu = new Vector();\r
2394       if (msaws != null)\r
2395       {\r
2396         // Add any Multiple Sequence Alignment Services\r
2397         final JMenu msawsmenu = new JMenu("Alignment");\r
2398         for (int i = 0, j = msaws.size(); i < j; i++)\r
2399         {\r
2400           final ext.vamsas.ServiceHandle sh = (ext.vamsas.ServiceHandle) msaws.\r
2401               get(i);\r
2402           final JMenuItem method = new JMenuItem(sh.getName());\r
2403           method.addActionListener(new ActionListener()\r
2404           {\r
2405             public void actionPerformed(ActionEvent e)\r
2406             {\r
2407               SequenceI[] msa = gatherSequencesForAlignment();\r
2408               new jalview.ws.MsaWSClient(sh, title, msa,\r
2409                   false, true, viewport.getAlignment().getDataset());\r
2410 \r
2411             }\r
2412 \r
2413           });\r
2414           msawsmenu.add(method);\r
2415           // Deal with services that we know accept partial alignments.\r
2416           if (sh.getName().indexOf("lustal") > -1)\r
2417           {\r
2418             // We know that ClustalWS can accept partial alignments for refinement.\r
2419             final JMenuItem methodR = new JMenuItem(sh.getName()+" Realign");\r
2420             methodR.addActionListener(new ActionListener()\r
2421             {\r
2422               public void actionPerformed(ActionEvent e)\r
2423               {\r
2424                 SequenceI[] msa = gatherSequencesForAlignment();\r
2425                 new jalview.ws.MsaWSClient(sh, title, msa,\r
2426                     true, true, viewport.getAlignment().getDataset());\r
2427 \r
2428               }\r
2429 \r
2430             });\r
2431             msawsmenu.add(methodR);\r
2432 \r
2433           }\r
2434         }\r
2435         wsmenu.add(msawsmenu);\r
2436       }\r
2437       if (secstrpr != null)\r
2438       {\r
2439         // Add any secondary structure prediction services\r
2440         final JMenu secstrmenu = new JMenu("Secondary Structure Prediction");\r
2441         for (int i = 0, j = secstrpr.size(); i < j; i++)\r
2442         {\r
2443           final ext.vamsas.ServiceHandle sh = (ext.vamsas.ServiceHandle)\r
2444               secstrpr.get(i);\r
2445           final JMenuItem method = new JMenuItem(sh.getName());\r
2446           method.addActionListener(new ActionListener()\r
2447           {\r
2448             public void actionPerformed(ActionEvent e)\r
2449             {\r
2450               SequenceI[] msa = gatherSeqOrMsaForSecStrPrediction();\r
2451               if (msa.length == 1)\r
2452               {\r
2453                 // Single Sequence prediction\r
2454                 new jalview.ws.JPredClient(sh,title, msa[0]);\r
2455               }\r
2456               else\r
2457               {\r
2458                 if (msa.length > 1)\r
2459                 {\r
2460                   // Single Sequence prediction\r
2461                   jalview.ws.JPredClient ct = new jalview.ws.JPredClient(sh,\r
2462                       title, msa);\r
2463                 }\r
2464               }\r
2465             }\r
2466           });\r
2467           secstrmenu.add(method);\r
2468         }\r
2469         wsmenu.add(secstrmenu);\r
2470       }\r
2471       this.webService.removeAll();\r
2472       for (int i = 0, j = wsmenu.size(); i < j; i++)\r
2473       {\r
2474         webService.add( (JMenu) wsmenu.get(i));\r
2475       }\r
2476     }\r
2477     else\r
2478     {\r
2479       this.webService.removeAll();\r
2480       this.webService.add(this.webServiceNoServices);\r
2481     }\r
2482     // TODO: add in rediscovery function\r
2483     // TODO: reduce code redundancy.\r
2484     // TODO: group services by location as well as function.\r
2485   }\r
2486 \r
2487  /* public void vamsasStore_actionPerformed(ActionEvent e)\r
2488   {\r
2489     JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache.\r
2490         getProperty("LAST_DIRECTORY"));\r
2491 \r
2492     chooser.setFileView(new JalviewFileView());\r
2493     chooser.setDialogTitle("Export to Vamsas file");\r
2494     chooser.setToolTipText("Export");\r
2495 \r
2496     int value = chooser.showSaveDialog(this);\r
2497 \r
2498     if (value == JalviewFileChooser.APPROVE_OPTION)\r
2499     {\r
2500       jalview.io.VamsasDatastore vs = new jalview.io.VamsasDatastore(viewport);\r
2501       //vs.store(chooser.getSelectedFile().getAbsolutePath()   );\r
2502       vs.storeJalview( chooser.getSelectedFile().getAbsolutePath(), this);\r
2503     }\r
2504   }*/\r
2505 \r
2506   public void featureSettings_actionPerformed(ActionEvent e)\r
2507   {\r
2508     new FeatureSettings(viewport, alignPanel);\r
2509   }\r
2510 \r
2511 \r
2512 \r
2513 public void showTranslation_actionPerformed(ActionEvent e)\r
2514 {\r
2515   int s, sSize = viewport.alignment.getHeight();\r
2516   SequenceI [] newSeq = new SequenceI[sSize];\r
2517 \r
2518   int res, resSize;\r
2519   StringBuffer protein;\r
2520   String seq;\r
2521   for(s=0; s<sSize; s++)\r
2522   {\r
2523     protein = new StringBuffer();\r
2524     seq = AlignSeq.extractGaps("-. ", viewport.alignment.getSequenceAt(s).getSequence());\r
2525     resSize = seq.length();\r
2526     for(res = 0; res < resSize; res+=3)\r
2527     {\r
2528       String codon = seq.substring(res, res+3);\r
2529       codon = codon.replace('U', 'T');\r
2530       String aa = ResidueProperties.codonTranslate(codon);\r
2531       if(aa==null)\r
2532         protein.append(viewport.getGapCharacter());\r
2533       else if(aa.equals("STOP"))\r
2534         protein.append("X");\r
2535       else\r
2536         protein.append( aa );\r
2537     }\r
2538     newSeq[s] = new Sequence(viewport.alignment.getSequenceAt(s).getName(), protein.toString());\r
2539   }\r
2540 \r
2541 \r
2542   AlignmentI al = new Alignment(newSeq);\r
2543   al.setDataset(null);\r
2544 \r
2545 \r
2546   ////////////////////////////////\r
2547   // Copy annotations across\r
2548   jalview.datamodel.AlignmentAnnotation[] annotations\r
2549       = viewport.alignment.getAlignmentAnnotation();\r
2550   int a, aSize;\r
2551   for (int i = 0; i < annotations.length; i++)\r
2552   {\r
2553 \r
2554     if (annotations[i].label.equals("Quality") ||\r
2555         annotations[i].label.equals("Conservation") ||\r
2556         annotations[i].label.equals("Consensus"))\r
2557     {\r
2558       continue;\r
2559     }\r
2560 \r
2561 \r
2562     aSize = viewport.alignment.getWidth()/3;\r
2563     jalview.datamodel.Annotation [] anots =\r
2564         new jalview.datamodel.Annotation[aSize];\r
2565 \r
2566     for(a=0; a<viewport.alignment.getWidth(); a++)\r
2567     {\r
2568      if( annotations[i].annotations[a]==null\r
2569       || annotations[i].annotations[a]==null)\r
2570        continue;\r
2571 \r
2572       anots[a/3] = new Annotation(\r
2573      annotations[i].annotations[a].displayCharacter,\r
2574      annotations[i].annotations[a].description,\r
2575      annotations[i].annotations[a].secondaryStructure,\r
2576      annotations[i].annotations[a].value,\r
2577      annotations[i].annotations[a].colour);\r
2578     }\r
2579 \r
2580     jalview.datamodel.AlignmentAnnotation aa\r
2581           = new jalview.datamodel.AlignmentAnnotation(annotations[i].label,\r
2582        annotations[i].description, anots );\r
2583      al.addAnnotation(aa);\r
2584   }\r
2585 \r
2586 \r
2587     AlignFrame af = new AlignFrame(al);\r
2588     Desktop.addInternalFrame(af, "Translation of "+this.getTitle(),\r
2589                              NEW_WINDOW_WIDTH,\r
2590                              NEW_WINDOW_HEIGHT);\r
2591 \r
2592 \r
2593    // AlignViewport newViewport = new AlignViewport(al);\r
2594    // AlignmentPanel ap = new AlignmentPanel(this, newViewport);\r
2595    // tabbedPane.add("Protein", ap);\r
2596    // viewports.add(newViewport);\r
2597   //  alignPanels.add(ap);\r
2598 \r
2599     ///Dataset tab\r
2600   /////////////////////////\r
2601 \r
2602   //  AlignViewport ds = new AlignViewport(al.getDataset());\r
2603   //  ds.setDataset(true);\r
2604   //  AlignmentPanel dap = new AlignmentPanel(this, ds);\r
2605   //  tabbedPane.add("Dataset", dap);\r
2606   //  viewports.add(ds);\r
2607   //  alignPanels.add(dap);\r
2608   /////////////////////////\r
2609 \r
2610 \r
2611 }\r
2612 \r
2613 /*public void tabSelected()\r
2614  {\r
2615   int index = tabbedPane.getSelectedIndex();\r
2616   viewport = (AlignViewport)viewports.elementAt(index);\r
2617   alignPanel = (AlignmentPanel)alignPanels.elementAt(index);\r
2618  }*/\r
2619 }\r