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