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