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