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