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