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