src/jalview/gui/AlignFrame.java

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