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