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