src/jalview/gui/AlignFrame.java

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