src/jalview/appletgui/AlignFrame.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.appletgui;
  22
  23 import java.awt.BorderLayout;
  24 import java.awt.Canvas;
  25 import java.awt.CheckboxMenuItem;
  26 import java.awt.Color;
  27 import java.awt.Font;
  28 import java.awt.FontMetrics;
  29 import java.awt.Frame;
  30 import java.awt.Graphics;
  31 import java.awt.Label;
  32 import java.awt.Menu;
  33 import java.awt.MenuBar;
  34 import java.awt.MenuItem;
  35 import java.awt.event.ActionEvent;
  36 import java.awt.event.ActionListener;
  37 import java.awt.event.FocusEvent;
  38 import java.awt.event.FocusListener;
  39 import java.awt.event.ItemEvent;
  40 import java.awt.event.ItemListener;
  41 import java.awt.event.KeyEvent;
  42 import java.awt.event.KeyListener;
  43 import java.awt.event.WindowAdapter;
  44 import java.awt.event.WindowEvent;
  45 import java.io.IOException;
  46 import java.net.URL;
  47 import java.net.URLEncoder;
  48 import java.util.Arrays;
  49 import java.util.Deque;
  50 import java.util.HashMap;
  51 import java.util.Hashtable;
  52 import java.util.List;
  53 import java.util.Map;
  54 import java.util.StringTokenizer;
  55 import java.util.Vector;
  56
  57 import jalview.analysis.AlignmentSorter;
  58 import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
  59 import jalview.api.AlignViewControllerGuiI;
  60 import jalview.api.AlignViewControllerI;
  61 import jalview.api.AlignViewportI;
  62 import jalview.api.FeatureRenderer;
  63 import jalview.api.SequenceStructureBinding;
  64 import jalview.bin.JalviewLite;
  65 import jalview.commands.CommandI;
  66 import jalview.commands.EditCommand;
  67 import jalview.commands.EditCommand.Action;
  68 import jalview.commands.OrderCommand;
  69 import jalview.commands.RemoveGapColCommand;
  70 import jalview.commands.RemoveGapsCommand;
  71 import jalview.commands.SlideSequencesCommand;
  72 import jalview.commands.TrimRegionCommand;
  73 import jalview.datamodel.Alignment;
  74 import jalview.datamodel.AlignmentAnnotation;
  75 import jalview.datamodel.AlignmentI;
  76 import jalview.datamodel.AlignmentOrder;
  77 import jalview.datamodel.ColumnSelection;
  78 import jalview.datamodel.PDBEntry;
  79 import jalview.datamodel.Sequence;
  80 import jalview.datamodel.SequenceGroup;
  81 import jalview.datamodel.SequenceI;
  82 import jalview.io.AnnotationFile;
  83 import jalview.io.AppletFormatAdapter;
  84 import jalview.io.FeaturesFile;
  85 import jalview.io.TCoffeeScoreFile;
  86 import jalview.schemes.Blosum62ColourScheme;
  87 import jalview.schemes.BuriedColourScheme;
  88 import jalview.schemes.ClustalxColourScheme;
  89 import jalview.schemes.ColourSchemeI;
  90 import jalview.schemes.HelixColourScheme;
  91 import jalview.schemes.HydrophobicColourScheme;
  92 import jalview.schemes.NucleotideColourScheme;
  93 import jalview.schemes.PIDColourScheme;
  94 import jalview.schemes.PurinePyrimidineColourScheme;
  95 import jalview.schemes.RNAHelicesColourChooser;
  96 import jalview.schemes.RNAInteractionColourScheme;
  97 import jalview.schemes.StrandColourScheme;
  98 import jalview.schemes.TCoffeeColourScheme;
  99 import jalview.schemes.TaylorColourScheme;
 100 import jalview.schemes.TurnColourScheme;
 101 import jalview.schemes.ZappoColourScheme;
 102 import jalview.structure.StructureSelectionManager;
 103 import jalview.structures.models.AAStructureBindingModel;
 104 import jalview.util.MappingUtils;
 105 import jalview.util.MessageManager;
 106
 107 public class AlignFrame extends EmbmenuFrame implements ActionListener,
 108         ItemListener, KeyListener, AlignViewControllerGuiI
 109 {
 110   public AlignViewControllerI avc;
 111
 112   public AlignmentPanel alignPanel;
 113
 114   public AlignViewport viewport;
 115
 116   // width and height may be overridden by applet parameters
 117   int frameWidth = 700;
 118
 119   int frameHeight = 500;
 120
 121   String jalviewServletURL;
 122
 123   /*
 124    * Flag for showing autocalculated consensus above or below other consensus
 125    * rows
 126    */
 127   private boolean showAutoCalculatedAbove;
 128
 129   private SequenceAnnotationOrder annotationSortOrder;
 130
 131   /**
 132    * Constructor that creates the frame and adds it to the display.
 133    *
 134    * @param al
 135    * @param applet
 136    * @param title
 137    * @param embedded
 138    */
 139   public AlignFrame(AlignmentI al, JalviewLite applet,
 140           String title, boolean embedded)
 141   {
 142     this(al, applet, title, embedded, true);
 143   }
 144
 145   /**
 146    * Constructor that optionally allows the frame to be displayed or only
 147    * created.
 148    *
 149    * @param al
 150    * @param applet
 151    * @param title
 152    * @param embedded
 153    * @param addToDisplay
 154    */
 155   public AlignFrame(AlignmentI al, JalviewLite applet,
 156           String title, boolean embedded, boolean addToDisplay)
 157   {
 158     if (applet != null)
 159     {
 160       jalviewServletURL = applet.getParameter("APPLICATION_URL");
 161     }
 162
 163     try
 164     {
 165       jbInit();
 166     } catch (Exception ex)
 167     {
 168       ex.printStackTrace();
 169     }
 170     // need to get window geometry before we calculate alignment layout
 171     if (applet != null)
 172     {
 173       String param;
 174       try
 175       {
 176         param = applet.getParameter("windowWidth");
 177         if (param != null)
 178         {
 179           int width = Integer.parseInt(param);
 180           frameWidth = width;
 181         }
 182         param = applet.getParameter("windowHeight");
 183         if (param != null)
 184         {
 185           int height = Integer.parseInt(param);
 186           frameHeight = height;
 187         }
 188       } catch (Exception ex)
 189       {
 190       }
 191     }
 192     viewport = new AlignViewport(al, applet);
 193     alignPanel = new AlignmentPanel(this, viewport);
 194     avc = new jalview.controller.AlignViewController(this, viewport,
 195             alignPanel);
 196     viewport.updateConservation(alignPanel);
 197     viewport.updateConsensus(alignPanel);
 198
 199     displayNonconservedMenuItem.setState(viewport.getShowUnconserved());
 200     followMouseOverFlag.setState(viewport.getFollowHighlight());
 201     showGroupConsensus.setState(viewport.isShowGroupConsensus());
 202     showGroupConservation.setState(viewport.isShowGroupConservation());
 203     showConsensusHistogram.setState(viewport.isShowConsensusHistogram());
 204     showSequenceLogo.setState(viewport.isShowSequenceLogo());
 205     normSequenceLogo.setState(viewport.isNormaliseSequenceLogo());
 206     applyToAllGroups.setState(viewport.getColourAppliesToAllGroups());
 207     annotationPanelMenuItem.setState(viewport.isShowAnnotation());
 208     showAlignmentAnnotations.setState(viewport.isShowAnnotation());
 209     showSequenceAnnotations.setState(viewport.isShowAnnotation());
 210
 211     seqLimits.setState(viewport.getShowJVSuffix());
 212
 213     if (applet != null)
 214     {
 215       String param = applet.getParameter("sortBy");
 216       if (param != null)
 217       {
 218         if (param.equalsIgnoreCase("Id"))
 219         {
 220           sortIDMenuItem_actionPerformed();
 221         }
 222         else if (param.equalsIgnoreCase("Pairwise Identity"))
 223         {
 224           sortPairwiseMenuItem_actionPerformed();
 225         }
 226         else if (param.equalsIgnoreCase("Length"))
 227         {
 228           sortLengthMenuItem_actionPerformed();
 229         }
 230       }
 231
 232       param = applet.getParameter("wrap");
 233       if (param != null)
 234       {
 235         if (param.equalsIgnoreCase("true"))
 236         {
 237           wrapMenuItem.setState(true);
 238           wrapMenuItem_actionPerformed();
 239         }
 240       }
 241       param = applet.getParameter("centrecolumnlabels");
 242       if (param != null)
 243       {
 244         centreColumnLabelFlag.setState(true);
 245         centreColumnLabelFlag_stateChanged();
 246       }
 247
 248     }
 249     if (viewport.getAlignment().isNucleotide())
 250     {
 251       viewport.updateStrucConsensus(alignPanel);
 252       if (viewport.getAlignment().hasRNAStructure())
 253       {
 254         RNAHelixColour.setEnabled(true);
 255       }
 256       else
 257       {
 258         RNAHelixColour.setEnabled(false);
 259       }
 260     }
 261     else
 262     {
 263       RNAHelixColour.setEnabled(false);
 264       purinePyrimidineColour.setEnabled(false);
 265     }
 266     // Some JVMS send keyevents to Top frame or lowest panel,
 267     // Havent worked out why yet. So add to both this frame and seqCanvas for
 268     // now
 269     this.addKeyListener(this);
 270     alignPanel.seqPanel.seqCanvas.addKeyListener(this);
 271     alignPanel.idPanel.idCanvas.addKeyListener(this);
 272     alignPanel.scalePanel.addKeyListener(this);
 273     alignPanel.annotationPanel.addKeyListener(this);
 274     alignPanel.annotationPanelHolder.addKeyListener(this);
 275     alignPanel.annotationSpaceFillerHolder.addKeyListener(this);
 276     alignPanel.alabels.addKeyListener(this);
 277
 278     if (addToDisplay)
 279     {
 280       addToDisplay(embedded);
 281     }
 282   }
 283
 284   /**
 285    * @param embedded
 286    */
 287   public void addToDisplay(boolean embedded)
 288   {
 289     createAlignFrameWindow(embedded);
 290     validate();
 291     alignPanel.adjustAnnotationHeight();
 292     alignPanel.paintAlignment(true);
 293   }
 294
 295   public AlignViewport getAlignViewport()
 296   {
 297     return viewport;
 298   }
 299
 300   public SeqCanvas getSeqcanvas()
 301   {
 302     return alignPanel.seqPanel.seqCanvas;
 303   }
 304
 305   /**
 306    * Load a features file onto the alignment
 307    *
 308    * @param file
 309    *          file URL, content, or other resolvable path
 310    * @param type
 311    *          is protocol for accessing data referred to by file
 312    */
 313
 314   public boolean parseFeaturesFile(String file, String type)
 315   {
 316     return parseFeaturesFile(file, type, true);
 317   }
 318
 319   /**
 320    * Load a features file onto the alignment
 321    *
 322    * @param file
 323    *          file URL, content, or other resolvable path
 324    * @param type
 325    *          is protocol for accessing data referred to by file
 326    * @param autoenabledisplay
 327    *          when true, display features flag will be automatically enabled if
 328    *          features are loaded
 329    * @return true if data parsed as a features file
 330    */
 331   public boolean parseFeaturesFile(String file, String type,
 332           boolean autoenabledisplay)
 333   {
 334     // TODO: test if importing a features file onto an alignment which already
 335     // has features with links overwrites the original links.
 336
 337     Hashtable featureLinks = new Hashtable();
 338     boolean featuresFile = false;
 339     try
 340     {
 341       featuresFile = new jalview.io.FeaturesFile(file, type)
 342               .parse(viewport.getAlignment(), alignPanel.seqPanel.seqCanvas
 343                       .getFeatureRenderer().getFeatureColours(), featureLinks,
 344                       true, viewport.applet.getDefaultParameter(
 345                               "relaxedidmatch", false));
 346     } catch (Exception ex)
 347     {
 348       ex.printStackTrace();
 349     }
 350
 351     if (featuresFile)
 352     {
 353       if (featureLinks.size() > 0)
 354       {
 355         alignPanel.seqPanel.seqCanvas.getFeatureRenderer().featureLinks = featureLinks;
 356       }
 357       if (autoenabledisplay)
 358       {
 359         viewport.setShowSequenceFeatures(true);
 360         sequenceFeatures.setState(true);
 361       }
 362       if (alignPanel.seqPanel.seqCanvas.fr != null)
 363       {
 364         // update the min/max ranges where necessary
 365         alignPanel.seqPanel.seqCanvas.fr.findAllFeatures(true);
 366       }
 367       if (viewport.featureSettings != null)
 368       {
 369         viewport.featureSettings.refreshTable();
 370       }
 371       alignPanel.paintAlignment(true);
 372       statusBar.setText(MessageManager
 373               .getString("label.successfully_added_features_alignment"));
 374     }
 375     return featuresFile;
 376   }
 377
 378   @Override
 379   public void keyPressed(KeyEvent evt)
 380   {
 381     if (viewport.cursorMode
 382             && ((evt.getKeyCode() >= KeyEvent.VK_0 && evt.getKeyCode() <= KeyEvent.VK_9) || (evt
 383                     .getKeyCode() >= KeyEvent.VK_NUMPAD0 && evt
 384                     .getKeyCode() <= KeyEvent.VK_NUMPAD9))
 385             && Character.isDigit(evt.getKeyChar()))
 386     {
 387       alignPanel.seqPanel.numberPressed(evt.getKeyChar());
 388     }
 389
 390     switch (evt.getKeyCode())
 391     {
 392     case 27: // escape key
 393       deselectAllSequenceMenuItem_actionPerformed();
 394
 395       alignPanel.alabels.cancelDrag();
 396       break;
 397     case KeyEvent.VK_X:
 398       if (evt.isControlDown() || evt.isMetaDown())
 399       {
 400         cut_actionPerformed();
 401       }
 402       break;
 403     case KeyEvent.VK_C:
 404       if (viewport.cursorMode && !evt.isControlDown())
 405       {
 406         alignPanel.seqPanel.setCursorColumn();
 407       }
 408       if (evt.isControlDown() || evt.isMetaDown())
 409       {
 410         copy_actionPerformed();
 411       }
 412       break;
 413     case KeyEvent.VK_V:
 414       if (evt.isControlDown())
 415       {
 416         paste(evt.isShiftDown());
 417       }
 418       break;
 419     case KeyEvent.VK_A:
 420       if (evt.isControlDown() || evt.isMetaDown())
 421       {
 422         selectAllSequenceMenuItem_actionPerformed();
 423       }
 424       break;
 425     case KeyEvent.VK_DOWN:
 426       if (viewport.cursorMode)
 427       {
 428         alignPanel.seqPanel.moveCursor(0, 1);
 429       }
 430       else
 431       {
 432         moveSelectedSequences(false);
 433       }
 434       break;
 435
 436     case KeyEvent.VK_UP:
 437       if (viewport.cursorMode)
 438       {
 439         alignPanel.seqPanel.moveCursor(0, -1);
 440       }
 441       else
 442       {
 443         moveSelectedSequences(true);
 444       }
 445       break;
 446
 447     case KeyEvent.VK_LEFT:
 448       if (evt.isAltDown() || !viewport.cursorMode)
 449       {
 450         slideSequences(false, alignPanel.seqPanel.getKeyboardNo1());
 451       }
 452       else
 453       {
 454         alignPanel.seqPanel.moveCursor(-1, 0);
 455       }
 456       break;
 457
 458     case KeyEvent.VK_RIGHT:
 459       if (evt.isAltDown() || !viewport.cursorMode)
 460       {
 461         slideSequences(true, alignPanel.seqPanel.getKeyboardNo1());
 462       }
 463       else
 464       {
 465         alignPanel.seqPanel.moveCursor(1, 0);
 466       }
 467       break;
 468
 469     case KeyEvent.VK_SPACE:
 470       if (viewport.cursorMode)
 471       {
 472         alignPanel.seqPanel.insertGapAtCursor(evt.isControlDown()
 473                 || evt.isShiftDown() || evt.isAltDown());
 474       }
 475       break;
 476
 477     case KeyEvent.VK_DELETE:
 478     case KeyEvent.VK_BACK_SPACE:
 479       if (viewport.cursorMode)
 480       {
 481         alignPanel.seqPanel.deleteGapAtCursor(evt.isControlDown()
 482                 || evt.isShiftDown() || evt.isAltDown());
 483       }
 484       else
 485       {
 486         cut_actionPerformed();
 487         alignPanel.seqPanel.seqCanvas.repaint();
 488       }
 489       break;
 490
 491     case KeyEvent.VK_S:
 492       if (viewport.cursorMode)
 493       {
 494         alignPanel.seqPanel.setCursorRow();
 495       }
 496       break;
 497     case KeyEvent.VK_P:
 498       if (viewport.cursorMode)
 499       {
 500         alignPanel.seqPanel.setCursorPosition();
 501       }
 502       break;
 503
 504     case KeyEvent.VK_ENTER:
 505     case KeyEvent.VK_COMMA:
 506       if (viewport.cursorMode)
 507       {
 508         alignPanel.seqPanel.setCursorRowAndColumn();
 509       }
 510       break;
 511
 512     case KeyEvent.VK_Q:
 513       if (viewport.cursorMode)
 514       {
 515         alignPanel.seqPanel.setSelectionAreaAtCursor(true);
 516       }
 517       break;
 518     case KeyEvent.VK_M:
 519       if (viewport.cursorMode)
 520       {
 521         alignPanel.seqPanel.setSelectionAreaAtCursor(false);
 522       }
 523       break;
 524
 525     case KeyEvent.VK_F2:
 526       viewport.cursorMode = !viewport.cursorMode;
 527       statusBar.setText(MessageManager.formatMessage(
 528               "label.keyboard_editing_mode", new String[]
 529               { (viewport.cursorMode ? "on" : "off") }));
 530       if (viewport.cursorMode)
 531       {
 532         alignPanel.seqPanel.seqCanvas.cursorX = viewport.startRes;
 533         alignPanel.seqPanel.seqCanvas.cursorY = viewport.startSeq;
 534       }
 535       break;
 536
 537     case KeyEvent.VK_F:
 538       if (evt.isControlDown())
 539       {
 540         findMenuItem_actionPerformed();
 541       }
 542       break;
 543
 544     case KeyEvent.VK_H:
 545     {
 546       boolean toggleSeqs = !evt.isControlDown();
 547       boolean toggleCols = !evt.isShiftDown();
 548       toggleHiddenRegions(toggleSeqs, toggleCols);
 549       break;
 550     }
 551
 552     case KeyEvent.VK_PAGE_UP:
 553       if (viewport.getWrapAlignment())
 554       {
 555         alignPanel.scrollUp(true);
 556       }
 557       else
 558       {
 559         alignPanel.setScrollValues(viewport.startRes, viewport.startSeq
 560                 - viewport.endSeq + viewport.startSeq);
 561       }
 562       break;
 563
 564     case KeyEvent.VK_PAGE_DOWN:
 565       if (viewport.getWrapAlignment())
 566       {
 567         alignPanel.scrollUp(false);
 568       }
 569       else
 570       {
 571         alignPanel.setScrollValues(viewport.startRes, viewport.startSeq
 572                 + viewport.endSeq - viewport.startSeq);
 573       }
 574       break;
 575
 576     case KeyEvent.VK_Z:
 577       if (evt.isControlDown())
 578       {
 579         undoMenuItem_actionPerformed();
 580       }
 581       break;
 582
 583     case KeyEvent.VK_Y:
 584       if (evt.isControlDown())
 585       {
 586         redoMenuItem_actionPerformed();
 587       }
 588       break;
 589
 590     case KeyEvent.VK_L:
 591       if (evt.isControlDown())
 592       {
 593         trimAlignment(true);
 594       }
 595       break;
 596
 597     case KeyEvent.VK_R:
 598       if (evt.isControlDown())
 599       {
 600         trimAlignment(false);
 601       }
 602       break;
 603
 604     case KeyEvent.VK_E:
 605       if (evt.isControlDown())
 606       {
 607         if (evt.isShiftDown())
 608         {
 609           this.removeAllGapsMenuItem_actionPerformed();
 610         }
 611         else
 612         {
 613           removeGappedColumnMenuItem_actionPerformed();
 614         }
 615       }
 616       break;
 617     case KeyEvent.VK_I:
 618       if (evt.isControlDown())
 619       {
 620         if (evt.isAltDown())
 621         {
 622           invertColSel_actionPerformed();
 623         }
 624         else
 625         {
 626           invertSequenceMenuItem_actionPerformed();
 627         }
 628       }
 629       break;
 630
 631     case KeyEvent.VK_G:
 632       if (evt.isControlDown())
 633       {
 634         if (evt.isShiftDown())
 635         {
 636           this.unGroup_actionPerformed();
 637         }
 638         else
 639         {
 640           this.createGroup_actionPerformed();
 641         }
 642       }
 643       break;
 644
 645     case KeyEvent.VK_U:
 646       if (evt.isControlDown())
 647       {
 648         this.deleteGroups_actionPerformed();
 649       }
 650       break;
 651
 652     case KeyEvent.VK_T:
 653       if (evt.isControlDown())
 654       {
 655         newView(null);
 656       }
 657       break;
 658
 659     }
 660     alignPanel.paintAlignment(true);
 661   }
 662
 663   /**
 664    * called by key handler and the hide all/show all menu items
 665    *
 666    * @param toggleSeqs
 667    * @param toggleCols
 668    */
 669   private void toggleHiddenRegions(boolean toggleSeqs, boolean toggleCols)
 670   {
 671     boolean hide = false;
 672     SequenceGroup sg = viewport.getSelectionGroup();
 673     if (!toggleSeqs && !toggleCols)
 674     {
 675       // Hide everything by the current selection - this is a hack - we do the
 676       // invert and then hide
 677       // first check that there will be visible columns after the invert.
 678       if ((viewport.getColumnSelection() != null
 679               && viewport.getColumnSelection().getSelected() != null && viewport
 680               .getColumnSelection().getSelected().size() > 0)
 681               || (sg != null && sg.getSize() > 0 && sg.getStartRes() <= sg
 682                       .getEndRes()))
 683       {
 684         // now invert the sequence set, if required - empty selection implies
 685         // that no hiding is required.
 686         if (sg != null)
 687         {
 688           invertSequenceMenuItem_actionPerformed();
 689           sg = viewport.getSelectionGroup();
 690           toggleSeqs = true;
 691
 692         }
 693         viewport.expandColSelection(sg, true);
 694         // finally invert the column selection and get the new sequence
 695         // selection and indicate it should be hidden.
 696         invertColSel_actionPerformed();
 697         toggleCols = true;
 698       }
 699     }
 700
 701     if (toggleSeqs)
 702     {
 703       if (sg != null && sg.getSize() != viewport.getAlignment().getHeight())
 704       {
 705         hide = true;
 706         viewport.hideAllSelectedSeqs();
 707       }
 708       else if (!(toggleCols && viewport.getColumnSelection().getSelected()
 709               .size() > 0))
 710       {
 711         viewport.showAllHiddenSeqs();
 712       }
 713     }
 714
 715     if (toggleCols)
 716     {
 717       if (viewport.getColumnSelection().getSelected().size() > 0)
 718       {
 719         viewport.hideSelectedColumns();
 720         if (!toggleSeqs)
 721         {
 722           viewport.setSelectionGroup(sg);
 723         }
 724       }
 725       else if (!hide)
 726       {
 727         viewport.showAllHiddenColumns();
 728       }
 729     }
 730   }
 731
 732   @Override
 733   public void keyReleased(KeyEvent evt)
 734   {
 735   }
 736
 737   @Override
 738   public void keyTyped(KeyEvent evt)
 739   {
 740   }
 741
 742   @Override
 743   public void itemStateChanged(ItemEvent evt)
 744   {
 745     final Object source = evt.getSource();
 746     if (source == displayNonconservedMenuItem)
 747     {
 748       displayNonconservedMenuItem_actionPerformed();
 749     }
 750     else if (source == colourTextMenuItem)
 751     {
 752       colourTextMenuItem_actionPerformed();
 753     }
 754     else if (source == wrapMenuItem)
 755     {
 756       wrapMenuItem_actionPerformed();
 757     }
 758     else if (source == scaleAbove)
 759     {
 760       viewport.setScaleAboveWrapped(scaleAbove.getState());
 761     }
 762     else if (source == scaleLeft)
 763     {
 764       viewport.setScaleLeftWrapped(scaleLeft.getState());
 765     }
 766     else if (source == scaleRight)
 767     {
 768       viewport.setScaleRightWrapped(scaleRight.getState());
 769     }
 770     else if (source == seqLimits)
 771     {
 772       seqLimits_itemStateChanged();
 773     }
 774     else if (source == viewBoxesMenuItem)
 775     {
 776       viewport.setShowBoxes(viewBoxesMenuItem.getState());
 777     }
 778     else if (source == viewTextMenuItem)
 779     {
 780       viewport.setShowText(viewTextMenuItem.getState());
 781     }
 782     else if (source == renderGapsMenuItem)
 783     {
 784       viewport.setRenderGaps(renderGapsMenuItem.getState());
 785     }
 786     else if (source == annotationPanelMenuItem)
 787     {
 788       viewport.setShowAnnotation(annotationPanelMenuItem.getState());
 789       alignPanel.setAnnotationVisible(annotationPanelMenuItem.getState());
 790     }
 791     else if (source == sequenceFeatures)
 792     {
 793       viewport.setShowSequenceFeatures(sequenceFeatures.getState());
 794       alignPanel.seqPanel.seqCanvas.repaint();
 795     }
 796     else if (source == showAlignmentAnnotations)
 797     {
 798       setAnnotationsVisibility();
 799     }
 800     else if (source == showSequenceAnnotations)
 801     {
 802       setAnnotationsVisibility();
 803     }
 804     else if (source == sortAnnBySequence)
 805     {
 806       boolean newState = sortAnnBySequence.getState();
 807       sortAnnByLabel.setState(false);
 808       setAnnotationSortOrder(newState ? SequenceAnnotationOrder.SEQUENCE_AND_LABEL
 809               : SequenceAnnotationOrder.NONE);
 810       setViewportAnnotationOrder();
 811     }
 812     else if (source == sortAnnByLabel)
 813     {
 814       boolean newState = sortAnnByLabel.getState();
 815       sortAnnBySequence.setState(false);
 816       setAnnotationSortOrder(newState ? SequenceAnnotationOrder.LABEL_AND_SEQUENCE
 817               : SequenceAnnotationOrder.NONE);
 818       setViewportAnnotationOrder();
 819     }
 820     else if (source == showAutoFirst)
 821     {
 822       showAutoLast.setState(!showAutoFirst.getState());
 823       setShowAutoCalculatedAbove(showAutoFirst.getState());
 824       setViewportAnnotationOrder();
 825     }
 826     else if (source == showAutoLast)
 827     {
 828       showAutoFirst.setState(!showAutoLast.getState());
 829       setShowAutoCalculatedAbove(showAutoFirst.getState());
 830       setViewportAnnotationOrder();
 831     }
 832     else if (source == conservationMenuItem)
 833     {
 834       conservationMenuItem_actionPerformed();
 835     }
 836     else if (source == abovePIDThreshold)
 837     {
 838       abovePIDThreshold_actionPerformed();
 839     }
 840     else if (source == applyToAllGroups)
 841     {
 842       viewport.setColourAppliesToAllGroups(applyToAllGroups.getState());
 843     }
 844     else if (source == autoCalculate)
 845     {
 846       viewport.autoCalculateConsensus = autoCalculate.getState();
 847     }
 848     else if (source == sortByTree)
 849     {
 850       viewport.sortByTree = sortByTree.getState();
 851     }
 852     else if (source == this.centreColumnLabelFlag)
 853     {
 854       centreColumnLabelFlag_stateChanged();
 855     }
 856     else if (source == this.followMouseOverFlag)
 857     {
 858       mouseOverFlag_stateChanged();
 859     }
 860     else if (source == showGroupConsensus)
 861     {
 862       showGroupConsensus_actionPerformed();
 863     }
 864     else if (source == showGroupConservation)
 865     {
 866       showGroupConservation_actionPerformed();
 867     }
 868     else if (source == showSequenceLogo)
 869     {
 870       showSequenceLogo_actionPerformed();
 871     }
 872     else if (source == normSequenceLogo)
 873     {
 874       normSequenceLogo_actionPerformed();
 875     }
 876     else if (source == showConsensusHistogram)
 877     {
 878       showConsensusHistogram_actionPerformed();
 879     }
 880     else if (source == applyAutoAnnotationSettings)
 881     {
 882       applyAutoAnnotationSettings_actionPerformed();
 883     }
 884     alignPanel.paintAlignment(true);
 885   }
 886
 887   /**
 888    * Set the visibility state of sequence-related and/or alignment-related
 889    * annotations depending on checkbox selections. Repaint after calling.
 890    *
 891    * @param visible
 892    */
 893   private void setAnnotationsVisibility()
 894   {
 895     boolean showForAlignment = showAlignmentAnnotations.getState();
 896     boolean showForSequences = showSequenceAnnotations.getState();
 897     for (AlignmentAnnotation aa : alignPanel.getAlignment()
 898             .getAlignmentAnnotation())
 899     {
 900       boolean visible = (aa.sequenceRef == null ? showForAlignment
 901               : showForSequences);
 902         aa.visible = visible;
 903     }
 904     alignPanel.validateAnnotationDimensions(false);
 905   }
 906
 907   private void setAnnotationSortOrder(SequenceAnnotationOrder order)
 908   {
 909     this.annotationSortOrder = order;
 910   }
 911
 912   /**
 913    * Set flags on the viewport that control annotation ordering
 914    */
 915   private void setViewportAnnotationOrder()
 916   {
 917     this.alignPanel.av.setSortAnnotationsBy(this.annotationSortOrder);
 918     this.alignPanel.av
 919             .setShowAutocalculatedAbove(this.showAutoCalculatedAbove);
 920   }
 921
 922   private void setShowAutoCalculatedAbove(boolean showAbove)
 923   {
 924     this.showAutoCalculatedAbove = showAbove;
 925   }
 926
 927   private void mouseOverFlag_stateChanged()
 928   {
 929     viewport.followHighlight = followMouseOverFlag.getState();
 930     // TODO: could kick the scrollTo mechanism to reset view for current
 931     // searchresults.
 932   }
 933
 934   private void centreColumnLabelFlag_stateChanged()
 935   {
 936     viewport.centreColumnLabels = centreColumnLabelFlag.getState();
 937     this.alignPanel.annotationPanel.repaint();
 938   }
 939
 940   @Override
 941   public void actionPerformed(ActionEvent evt)
 942   {
 943     Object source = evt.getSource();
 944
 945     if (source == inputText)
 946     {
 947       inputText_actionPerformed();
 948     }
 949     else if (source == loadTree)
 950     {
 951       loadTree_actionPerformed();
 952     }
 953     else if (source == loadApplication)
 954     {
 955       launchFullApplication();
 956     }
 957     else if (source == loadAnnotations)
 958     {
 959       loadAnnotations();
 960     }
 961     else if (source == outputAnnotations)
 962     {
 963       outputAnnotations(true);
 964     }
 965     else if (source == outputFeatures)
 966     {
 967       outputFeatures(true, "Jalview");
 968     }
 969     else if (source == closeMenuItem)
 970     {
 971       closeMenuItem_actionPerformed();
 972     }
 973     else if (source == copy)
 974     {
 975       copy_actionPerformed();
 976     }
 977     else if (source == undoMenuItem)
 978     {
 979       undoMenuItem_actionPerformed();
 980     }
 981     else if (source == redoMenuItem)
 982     {
 983       redoMenuItem_actionPerformed();
 984     }
 985     else if (source == inputText)
 986     {
 987       inputText_actionPerformed();
 988     }
 989     else if (source == closeMenuItem)
 990     {
 991       closeMenuItem_actionPerformed();
 992     }
 993     else if (source == undoMenuItem)
 994     {
 995       undoMenuItem_actionPerformed();
 996     }
 997     else if (source == redoMenuItem)
 998     {
 999       redoMenuItem_actionPerformed();
1000     }
1001     else if (source == copy)
1002     {
1003       copy_actionPerformed();
1004     }
1005     else if (source == pasteNew)
1006     {
1007       pasteNew_actionPerformed();
1008     }
1009     else if (source == pasteThis)
1010     {
1011       pasteThis_actionPerformed();
1012     }
1013     else if (source == cut)
1014     {
1015       cut_actionPerformed();
1016     }
1017     else if (source == delete)
1018     {
1019       delete_actionPerformed();
1020     }
1021     else if (source == grpsFromSelection)
1022     {
1023       makeGrpsFromSelection_actionPerformed();
1024     }
1025     else if (source == deleteGroups)
1026     {
1027       deleteGroups_actionPerformed();
1028     }
1029     else if (source == selectAllSequenceMenuItem)
1030     {
1031       selectAllSequenceMenuItem_actionPerformed();
1032     }
1033     else if (source == deselectAllSequenceMenuItem)
1034     {
1035       deselectAllSequenceMenuItem_actionPerformed();
1036     }
1037     else if (source == invertSequenceMenuItem)
1038     {
1039       invertSequenceMenuItem_actionPerformed();
1040     }
1041     else if (source == invertColSel)
1042     {
1043       viewport.invertColumnSelection();
1044       alignPanel.paintAlignment(true);
1045     }
1046     else if (source == remove2LeftMenuItem)
1047     {
1048       trimAlignment(true);
1049     }
1050     else if (source == remove2RightMenuItem)
1051     {
1052       trimAlignment(false);
1053     }
1054     else if (source == removeGappedColumnMenuItem)
1055     {
1056       removeGappedColumnMenuItem_actionPerformed();
1057     }
1058     else if (source == removeAllGapsMenuItem)
1059     {
1060       removeAllGapsMenuItem_actionPerformed();
1061     }
1062     else if (source == findMenuItem)
1063     {
1064       findMenuItem_actionPerformed();
1065     }
1066     else if (source == font)
1067     {
1068       new FontChooser(alignPanel);
1069     }
1070     else if (source == newView)
1071     {
1072       newView(null);
1073     }
1074     else if (source == showColumns)
1075     {
1076       viewport.showAllHiddenColumns();
1077       alignPanel.paintAlignment(true);
1078     }
1079     else if (source == showSeqs)
1080     {
1081       viewport.showAllHiddenSeqs();
1082       alignPanel.paintAlignment(true);
1083     }
1084     else if (source == hideColumns)
1085     {
1086       viewport.hideSelectedColumns();
1087       alignPanel.paintAlignment(true);
1088     }
1089     else if (source == hideSequences
1090             && viewport.getSelectionGroup() != null)
1091     {
1092       viewport.hideAllSelectedSeqs();
1093       alignPanel.paintAlignment(true);
1094     }
1095     else if (source == hideAllButSelection)
1096     {
1097       toggleHiddenRegions(false, false);
1098       alignPanel.paintAlignment(true);
1099     }
1100     else if (source == hideAllSelection)
1101     {
1102       SequenceGroup sg = viewport.getSelectionGroup();
1103       viewport.expandColSelection(sg, false);
1104       viewport.hideAllSelectedSeqs();
1105       viewport.hideSelectedColumns();
1106       alignPanel.paintAlignment(true);
1107     }
1108     else if (source == showAllHidden)
1109     {
1110       viewport.showAllHiddenColumns();
1111       viewport.showAllHiddenSeqs();
1112       alignPanel.paintAlignment(true);
1113     }
1114     else if (source == showGroupConsensus)
1115     {
1116       showGroupConsensus_actionPerformed();
1117     }
1118     else if (source == showGroupConservation)
1119     {
1120       showGroupConservation_actionPerformed();
1121     }
1122     else if (source == showSequenceLogo)
1123     {
1124       showSequenceLogo_actionPerformed();
1125     }
1126     else if (source == normSequenceLogo)
1127     {
1128       normSequenceLogo_actionPerformed();
1129     }
1130     else if (source == showConsensusHistogram)
1131     {
1132       showConsensusHistogram_actionPerformed();
1133     }
1134     else if (source == applyAutoAnnotationSettings)
1135     {
1136       applyAutoAnnotationSettings_actionPerformed();
1137     }
1138     else if (source == featureSettings)
1139     {
1140       new FeatureSettings(alignPanel);
1141     }
1142     else if (source == alProperties)
1143     {
1144       StringBuffer contents = new jalview.io.AlignmentProperties(
1145               viewport.getAlignment()).formatAsString();
1146       CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
1147       cap.setText(contents.toString());
1148       Frame frame = new Frame();
1149       frame.add(cap);
1150       jalview.bin.JalviewLite.addFrame(frame, MessageManager.formatMessage(
1151               "label.alignment_properties", new String[]
1152               { getTitle() }), 400, 250);
1153     }
1154     else if (source == overviewMenuItem)
1155     {
1156       overviewMenuItem_actionPerformed();
1157     }
1158     else if (source == noColourmenuItem)
1159     {
1160       changeColour(null);
1161     }
1162     else if (source == clustalColour)
1163     {
1164       abovePIDThreshold.setState(false);
1165       changeColour(new ClustalxColourScheme(viewport.getAlignment(), null));
1166     }
1167     else if (source == zappoColour)
1168     {
1169       changeColour(new ZappoColourScheme());
1170     }
1171     else if (source == taylorColour)
1172     {
1173       changeColour(new TaylorColourScheme());
1174     }
1175     else if (source == hydrophobicityColour)
1176     {
1177       changeColour(new HydrophobicColourScheme());
1178     }
1179     else if (source == helixColour)
1180     {
1181       changeColour(new HelixColourScheme());
1182     }
1183     else if (source == strandColour)
1184     {
1185       changeColour(new StrandColourScheme());
1186     }
1187     else if (source == turnColour)
1188     {
1189       changeColour(new TurnColourScheme());
1190     }
1191     else if (source == buriedColour)
1192     {
1193       changeColour(new BuriedColourScheme());
1194     }
1195     else if (source == nucleotideColour)
1196     {
1197       changeColour(new NucleotideColourScheme());
1198     }
1199     else if (source == purinePyrimidineColour)
1200     {
1201       changeColour(new PurinePyrimidineColourScheme());
1202     }
1203     else if (source == RNAInteractionColour)
1204     {
1205       changeColour(new RNAInteractionColourScheme());
1206     }
1207     else if (source == RNAHelixColour)
1208     {
1209       new RNAHelicesColourChooser(viewport, alignPanel);
1210     }
1211     else if (source == modifyPID)
1212     {
1213       modifyPID_actionPerformed();
1214     }
1215     else if (source == modifyConservation)
1216     {
1217       modifyConservation_actionPerformed();
1218     }
1219     else if (source == userDefinedColour)
1220     {
1221       new UserDefinedColours(alignPanel, null);
1222     }
1223     else if (source == PIDColour)
1224     {
1225       changeColour(new PIDColourScheme());
1226     }
1227     else if (source == BLOSUM62Colour)
1228     {
1229       changeColour(new Blosum62ColourScheme());
1230     }
1231     else if (source == tcoffeeColour)
1232     {
1233       changeColour(new TCoffeeColourScheme(alignPanel.getAlignment()));
1234     }
1235     else if (source == annotationColour)
1236     {
1237       new AnnotationColourChooser(viewport, alignPanel);
1238     }
1239     else if (source == annotationColumnSelection)
1240     {
1241       new AnnotationColumnChooser(viewport, alignPanel);
1242     }
1243     else if (source == sortPairwiseMenuItem)
1244     {
1245       sortPairwiseMenuItem_actionPerformed();
1246     }
1247     else if (source == sortIDMenuItem)
1248     {
1249       sortIDMenuItem_actionPerformed();
1250     }
1251     else if (source == sortLengthMenuItem)
1252     {
1253       sortLengthMenuItem_actionPerformed();
1254     }
1255     else if (source == sortGroupMenuItem)
1256     {
1257       sortGroupMenuItem_actionPerformed();
1258     }
1259     else if (source == removeRedundancyMenuItem)
1260     {
1261       removeRedundancyMenuItem_actionPerformed();
1262     }
1263     else if (source == pairwiseAlignmentMenuItem)
1264     {
1265       pairwiseAlignmentMenuItem_actionPerformed();
1266     }
1267     else if (source == PCAMenuItem)
1268     {
1269       PCAMenuItem_actionPerformed();
1270     }
1271     else if (source == averageDistanceTreeMenuItem)
1272     {
1273       averageDistanceTreeMenuItem_actionPerformed();
1274     }
1275     else if (source == neighbourTreeMenuItem)
1276     {
1277       neighbourTreeMenuItem_actionPerformed();
1278     }
1279     else if (source == njTreeBlosumMenuItem)
1280     {
1281       njTreeBlosumMenuItem_actionPerformed();
1282     }
1283     else if (source == avDistanceTreeBlosumMenuItem)
1284     {
1285       avTreeBlosumMenuItem_actionPerformed();
1286     }
1287     else if (source == documentation)
1288     {
1289       documentation_actionPerformed();
1290     }
1291     else if (source == about)
1292     {
1293       about_actionPerformed();
1294     }
1295
1296   }
1297
1298   public void inputText_actionPerformed()
1299   {
1300     CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
1301     Frame frame = new Frame();
1302     frame.add(cap);
1303     jalview.bin.JalviewLite.addFrame(frame,
1304             MessageManager.getString("label.input_cut_paste"), 500, 500);
1305   }
1306
1307   protected void outputText_actionPerformed(ActionEvent e)
1308   {
1309     CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
1310     Frame frame = new Frame();
1311     frame.add(cap);
1312     jalview.bin.JalviewLite.addFrame(frame, MessageManager.formatMessage(
1313             "label.alignment_output_command", new Object[]
1314             { e.getActionCommand() }), 600, 500);
1315     cap.setText(new AppletFormatAdapter().formatSequences(
1316             e.getActionCommand(), viewport.getAlignment(),
1317             viewport.getShowJVSuffix()));
1318   }
1319
1320   public void loadAnnotations()
1321   {
1322     CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
1323     cap.setText(MessageManager
1324             .getString("label.paste_features_annotations_Tcoffee_here"));
1325     cap.setAnnotationImport();
1326     Frame frame = new Frame();
1327     frame.add(cap);
1328     jalview.bin.JalviewLite.addFrame(frame,
1329             MessageManager.getString("action.paste_annotations"), 400, 300);
1330
1331   }
1332
1333   public String outputAnnotations(boolean displayTextbox)
1334   {
1335     String annotation = new AnnotationFile()
1336             .printAnnotationsForView(viewport);
1337
1338     if (displayTextbox)
1339     {
1340       CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
1341       Frame frame = new Frame();
1342       frame.add(cap);
1343       jalview.bin.JalviewLite.addFrame(frame,
1344               MessageManager.getString("label.annotations"), 600, 500);
1345       cap.setText(annotation);
1346     }
1347
1348     return annotation;
1349   }
1350
1351   private Map<String,Object> getDisplayedFeatureCols()
1352   {
1353     if (alignPanel.getFeatureRenderer() != null
1354             && viewport.getFeaturesDisplayed()!= null)
1355     {
1356       return alignPanel.getFeatureRenderer().getDisplayedFeatureCols();
1357
1358     }
1359     return null;
1360   }
1361
1362   public String outputFeatures(boolean displayTextbox, String format)
1363   {
1364     String features;
1365     if (format.equalsIgnoreCase("Jalview"))
1366     {
1367       features = new FeaturesFile().printJalviewFormat(viewport
1368               .getAlignment().getSequencesArray(),
1369               getDisplayedFeatureCols());
1370     }
1371     else
1372     {
1373       features = new FeaturesFile().printGFFFormat(viewport.getAlignment()
1374               .getSequencesArray(), getDisplayedFeatureCols());
1375     }
1376
1377     if (displayTextbox)
1378     {
1379       boolean frimport = false;
1380       if (features == null || features.equals("No Features Visible"))
1381       {
1382         features = "# No features visible - paste some and import them here.";
1383         frimport = true;
1384       }
1385
1386       CutAndPasteTransfer cap = new CutAndPasteTransfer(frimport, this);
1387       if (frimport)
1388       {
1389         cap.setAnnotationImport();
1390       }
1391       Frame frame = new Frame();
1392       frame.add(cap);
1393       jalview.bin.JalviewLite.addFrame(frame,
1394               MessageManager.getString("label.features"), 600, 500);
1395       cap.setText(features);
1396     }
1397     else
1398     {
1399       if (features == null)
1400       {
1401         features = "";
1402       }
1403     }
1404
1405     return features;
1406   }
1407
1408   void launchFullApplication()
1409   {
1410     StringBuffer url = new StringBuffer(jalviewServletURL);
1411
1412     // allow servlet parameters to be passed in applet parameter
1413     String firstSep = url.lastIndexOf("?") > url.lastIndexOf("/") ? "&"
1414             : "?";
1415     url.append(firstSep);
1416
1417     url.append("open="
1418             + appendProtocol(viewport.applet.getParameter("file")));
1419
1420     if (viewport.applet.getParameter("features") != null)
1421     {
1422       url.append("&features=");
1423       url.append(appendProtocol(viewport.applet.getParameter("features")));
1424     }
1425
1426     if (viewport.applet.getParameter("annotations") != null)
1427     {
1428       url.append("&annotations=");
1429       url.append(appendProtocol(viewport.applet.getParameter("annotations")));
1430     }
1431
1432     if (viewport.applet.getParameter("jnetfile") != null)
1433     {
1434       url.append("&annotations=");
1435       url.append(appendProtocol(viewport.applet.getParameter("jnetfile")));
1436     }
1437
1438     if (viewport.applet.getParameter("defaultColour") != null)
1439     {
1440       url.append("&colour="
1441               + removeWhiteSpace(viewport.applet
1442                       .getParameter("defaultColour")));
1443     }
1444
1445     if (viewport.applet.getParameter("userDefinedColour") != null)
1446     {
1447       url.append("&colour="
1448               + removeWhiteSpace(viewport.applet
1449                       .getParameter("userDefinedColour")));
1450     }
1451     if (viewport.applet.getParameter("tree") != null)
1452     {
1453       url.append("&tree="
1454               + appendProtocol(viewport.applet.getParameter("tree")));
1455     }
1456     if (viewport.applet.getParameter("treeFile") != null)
1457     {
1458       url.append("&tree="
1459               + appendProtocol(viewport.applet.getParameter("treeFile")));
1460     }
1461
1462     showURL(url.toString(), "FULL_APP");
1463   }
1464
1465   String removeWhiteSpace(String colour)
1466   {
1467     StringBuffer sb = new StringBuffer();
1468     for (int i = 0; i < colour.length(); i++)
1469     {
1470       if (Character.isWhitespace(colour.charAt(i)))
1471       {
1472         sb.append("%20");
1473       }
1474       else
1475       {
1476         sb.append(colour.charAt(i));
1477       }
1478     }
1479
1480     return sb.toString();
1481   }
1482
1483   String appendProtocol(String url)
1484   {
1485     try
1486     {
1487       new URL(url);
1488       url = URLEncoder.encode(url);
1489     }
1490     /*
1491      * When we finally deprecate 1.1 compatibility, we can start to use
1492      * URLEncoder.encode(url,"UTF-8") and then we'll need this catch: catch
1493      * (UnsupportedEncodingException ex) { System.err.println("WARNING -
1494      * IMPLEMENTATION ERROR - UNSUPPORTED ENCODING EXCEPTION FOR "+url);
1495      * ex.printStackTrace(); }
1496      */
1497     catch (java.net.MalformedURLException ex)
1498     {
1499       url = viewport.applet.getCodeBase() + url;
1500     }
1501     return url;
1502   }
1503
1504   public void closeMenuItem_actionPerformed()
1505   {
1506     PaintRefresher.RemoveComponent(alignPanel);
1507     if (alignPanel.seqPanel != null
1508             && alignPanel.seqPanel.seqCanvas != null)
1509     {
1510       PaintRefresher.RemoveComponent(alignPanel.seqPanel.seqCanvas);
1511     }
1512     if (alignPanel.idPanel != null && alignPanel.idPanel.idCanvas != null)
1513     {
1514       PaintRefresher.RemoveComponent(alignPanel.idPanel.idCanvas);
1515     }
1516
1517     if (PaintRefresher.components.size() == 0 && viewport.applet == null)
1518     {
1519       System.exit(0);
1520     }
1521     else
1522     {
1523     }
1524     viewport = null;
1525     alignPanel = null;
1526     this.dispose();
1527   }
1528
1529   /**
1530    * TODO: JAL-1104
1531    */
1532   void updateEditMenuBar()
1533   {
1534
1535     if (viewport.getHistoryList().size() > 0)
1536     {
1537       undoMenuItem.setEnabled(true);
1538       CommandI command = viewport.getHistoryList().peek();
1539       undoMenuItem.setLabel(MessageManager.formatMessage(
1540               "label.undo_command", new Object[]
1541               { command.getDescription() }));
1542     }
1543     else
1544     {
1545       undoMenuItem.setEnabled(false);
1546       undoMenuItem.setLabel(MessageManager.getString("action.undo"));
1547     }
1548
1549     if (viewport.getRedoList().size() > 0)
1550     {
1551       redoMenuItem.setEnabled(true);
1552
1553       CommandI command = viewport.getRedoList().peek();
1554       redoMenuItem.setLabel(MessageManager.formatMessage(
1555               "label.redo_command", new Object[]
1556               { command.getDescription() }));
1557     }
1558     else
1559     {
1560       redoMenuItem.setEnabled(false);
1561       redoMenuItem.setLabel(MessageManager.getString("action.redo"));
1562     }
1563   }
1564
1565   /**
1566    * TODO: JAL-1104
1567    */
1568   @Override
1569   public void addHistoryItem(CommandI command)
1570   {
1571     if (command.getSize() > 0)
1572     {
1573       viewport.addToHistoryList(command);
1574       viewport.clearRedoList();
1575       updateEditMenuBar();
1576       viewport.updateHiddenColumns();
1577     }
1578   }
1579
1580   /**
1581    * TODO: JAL-1104 DOCUMENT ME!
1582    *
1583    * @param e
1584    *          DOCUMENT ME!
1585    */
1586   protected void undoMenuItem_actionPerformed()
1587   {
1588     if (viewport.getHistoryList().isEmpty())
1589     {
1590       return;
1591     }
1592
1593     CommandI command = viewport.getHistoryList().pop();
1594     viewport.addToRedoList(command);
1595     command.undoCommand(null);
1596
1597     AlignViewport originalSource = getOriginatingSource(command);
1598     // JBPNote Test
1599     if (originalSource != viewport)
1600     {
1601       System.err
1602               .println("Warning: Viewport object mismatch whilst undoing");
1603     }
1604     originalSource.updateHiddenColumns(); // originalSource.hasHiddenColumns =
1605                                           // viewport.getColumnSelection().getHiddenColumns()
1606                                           // != null;
1607     updateEditMenuBar();
1608     originalSource.firePropertyChange("alignment", null, originalSource
1609             .getAlignment().getSequences());
1610   }
1611
1612   /**
1613    * TODO: JAL-1104 DOCUMENT ME!
1614    *
1615    * @param e
1616    *          DOCUMENT ME!
1617    */
1618   protected void redoMenuItem_actionPerformed()
1619   {
1620     if (viewport.getRedoList().isEmpty())
1621     {
1622       return;
1623     }
1624
1625     CommandI command = viewport.getRedoList().pop();
1626     viewport.addToHistoryList(command);
1627     command.doCommand(null);
1628
1629     AlignViewport originalSource = getOriginatingSource(command);
1630     // JBPNote Test
1631     if (originalSource != viewport)
1632     {
1633       System.err
1634               .println("Warning: Viewport object mismatch whilst re-doing");
1635     }
1636     originalSource.updateHiddenColumns(); // sethasHiddenColumns(); =
1637                                           // viewport.getColumnSelection().getHiddenColumns()
1638                                           // != null;
1639
1640     updateEditMenuBar();
1641     originalSource.firePropertyChange("alignment", null, originalSource
1642             .getAlignment().getSequences());
1643   }
1644
1645   AlignViewport getOriginatingSource(CommandI command)
1646   {
1647     AlignViewport originalSource = null;
1648     // For sequence removal and addition, we need to fire
1649     // the property change event FROM the viewport where the
1650     // original alignment was altered
1651     AlignmentI al = null;
1652     if (command instanceof EditCommand)
1653     {
1654       EditCommand editCommand = (EditCommand) command;
1655       al = editCommand.getAlignment();
1656       Vector comps = (Vector) PaintRefresher.components.get(viewport
1657               .getSequenceSetId());
1658       for (int i = 0; i < comps.size(); i++)
1659       {
1660         if (comps.elementAt(i) instanceof AlignmentPanel)
1661         {
1662           if (al == ((AlignmentPanel) comps.elementAt(i)).av.getAlignment())
1663           {
1664             originalSource = ((AlignmentPanel) comps.elementAt(i)).av;
1665             break;
1666           }
1667         }
1668       }
1669     }
1670
1671     if (originalSource == null)
1672     {
1673       // The original view is closed, we must validate
1674       // the current view against the closed view first
1675       if (al != null)
1676       {
1677         PaintRefresher.validateSequences(al, viewport.getAlignment());
1678       }
1679
1680       originalSource = viewport;
1681     }
1682
1683     return originalSource;
1684   }
1685
1686   /**
1687    * Move the currently selected sequences up or down one position in the
1688    * alignment
1689    *
1690    * @param up
1691    */
1692   public void moveSelectedSequences(boolean up)
1693   {
1694     SequenceGroup sg = viewport.getSelectionGroup();
1695     if (sg == null)
1696     {
1697       return;
1698     }
1699     viewport.getAlignment().moveSelectedSequencesByOne(sg,
1700             up ? null : viewport.getHiddenRepSequences(), up);
1701     alignPanel.paintAlignment(true);
1702
1703     /*
1704      * Also move cDNA/protein complement sequences
1705      */
1706     AlignViewportI complement = viewport.getCodingComplement();
1707     if (complement != null)
1708     {
1709       SequenceGroup mappedSelection = MappingUtils.mapSequenceGroup(sg,
1710               viewport, complement);
1711       complement.getAlignment().moveSelectedSequencesByOne(mappedSelection,
1712               up ? null : complement.getHiddenRepSequences(), up);
1713       // TODO need to trigger a repaint of the complementary panel - how?
1714       // would prefer to handle in SplitFrame but it is not overriding key
1715       // listener chiz
1716     }
1717   }
1718
1719   synchronized void slideSequences(boolean right, int size)
1720   {
1721     List<SequenceI> sg = new Vector<SequenceI>();
1722     if (viewport.cursorMode)
1723     {
1724       sg.add(viewport.getAlignment().getSequenceAt(
1725               alignPanel.seqPanel.seqCanvas.cursorY));
1726     }
1727     else if (viewport.getSelectionGroup() != null
1728             && viewport.getSelectionGroup().getSize() != viewport
1729                     .getAlignment().getHeight())
1730     {
1731       sg = viewport.getSelectionGroup().getSequences(
1732               viewport.getHiddenRepSequences());
1733     }
1734
1735     if (sg.size() < 1)
1736     {
1737       return;
1738     }
1739
1740     Vector<SequenceI> invertGroup = new Vector();
1741
1742     for (int i = 0; i < viewport.getAlignment().getHeight(); i++)
1743     {
1744       if (!sg.contains(viewport.getAlignment().getSequenceAt(i)))
1745       {
1746         invertGroup.addElement(viewport.getAlignment().getSequenceAt(i));
1747       }
1748     }
1749
1750     SequenceI[] seqs1 = sg.toArray(new SequenceI[sg.size()]);
1751
1752     SequenceI[] seqs2 = invertGroup.toArray(new SequenceI[invertGroup
1753             .size()]);
1754     for (int i = 0; i < invertGroup.size(); i++)
1755     {
1756       seqs2[i] = invertGroup.elementAt(i);
1757     }
1758
1759     SlideSequencesCommand ssc;
1760     if (right)
1761     {
1762       ssc = new SlideSequencesCommand("Slide Sequences", seqs2, seqs1,
1763               size, viewport.getGapCharacter());
1764     }
1765     else
1766     {
1767       ssc = new SlideSequencesCommand("Slide Sequences", seqs1, seqs2,
1768               size, viewport.getGapCharacter());
1769     }
1770
1771     int groupAdjustment = 0;
1772     if (ssc.getGapsInsertedBegin() && right)
1773     {
1774       if (viewport.cursorMode)
1775       {
1776         alignPanel.seqPanel.moveCursor(size, 0);
1777       }
1778       else
1779       {
1780         groupAdjustment = size;
1781       }
1782     }
1783     else if (!ssc.getGapsInsertedBegin() && !right)
1784     {
1785       if (viewport.cursorMode)
1786       {
1787         alignPanel.seqPanel.moveCursor(-size, 0);
1788       }
1789       else
1790       {
1791         groupAdjustment = -size;
1792       }
1793     }
1794
1795     if (groupAdjustment != 0)
1796     {
1797       viewport.getSelectionGroup().setStartRes(
1798               viewport.getSelectionGroup().getStartRes() + groupAdjustment);
1799       viewport.getSelectionGroup().setEndRes(
1800               viewport.getSelectionGroup().getEndRes() + groupAdjustment);
1801     }
1802
1803     boolean appendHistoryItem = false;
1804     Deque<CommandI> historyList = viewport.getHistoryList();
1805     if (historyList != null && historyList.size() > 0
1806             && historyList.peek() instanceof SlideSequencesCommand)
1807     {
1808       appendHistoryItem = ssc
1809               .appendSlideCommand((SlideSequencesCommand) historyList
1810                       .peek());
1811     }
1812
1813     if (!appendHistoryItem)
1814     {
1815       addHistoryItem(ssc);
1816     }
1817
1818     repaint();
1819   }
1820
1821   static StringBuffer copiedSequences;
1822
1823   static Vector copiedHiddenColumns;
1824
1825   protected void copy_actionPerformed()
1826   {
1827     if (viewport.getSelectionGroup() == null)
1828     {
1829       return;
1830     }
1831
1832     SequenceGroup sg = viewport.getSelectionGroup();
1833     copiedSequences = new StringBuffer();
1834     Map<Integer, SequenceI> orderedSeqs = new HashMap<Integer, SequenceI>();
1835     for (int i = 0; i < sg.getSize(); i++)
1836     {
1837       SequenceI seq = sg.getSequenceAt(i);
1838       int index = viewport.getAlignment().findIndex(seq);
1839       orderedSeqs.put(index, seq);
1840     }
1841
1842     int index = 0, startRes, endRes;
1843     char ch;
1844
1845     if (viewport.hasHiddenColumns() && viewport.getSelectionGroup() != null)
1846     {
1847       copiedHiddenColumns = new Vector();
1848       int hiddenOffset = viewport.getSelectionGroup().getStartRes();
1849       for (int[] region : viewport.getColumnSelection().getHiddenColumns())
1850       {
1851         copiedHiddenColumns.addElement(new int[]
1852         { region[0] - hiddenOffset, region[1] - hiddenOffset });
1853       }
1854     }
1855     else
1856     {
1857       copiedHiddenColumns = null;
1858     }
1859
1860     for (int i = 0; i < sg.getSize(); i++)
1861     {
1862       SequenceI seq = null;
1863
1864       while (seq == null)
1865       {
1866         if (orderedSeqs.containsKey(index))
1867         {
1868           seq = orderedSeqs.get(index);
1869           index++;
1870           break;
1871         }
1872         else
1873         {
1874           index++;
1875         }
1876       }
1877
1878       // FIND START RES
1879       // Returns residue following index if gap
1880       startRes = seq.findPosition(sg.getStartRes());
1881
1882       // FIND END RES
1883       // Need to find the residue preceeding index if gap
1884       endRes = 0;
1885
1886       for (int j = 0; j < sg.getEndRes() + 1 && j < seq.getLength(); j++)
1887       {
1888         ch = seq.getCharAt(j);
1889         if (!jalview.util.Comparison.isGap((ch)))
1890         {
1891           endRes++;
1892         }
1893       }
1894
1895       if (endRes > 0)
1896       {
1897         endRes += seq.getStart() - 1;
1898       }
1899
1900       copiedSequences.append(seq.getName()
1901               + "\t"
1902               + startRes
1903               + "\t"
1904               + endRes
1905               + "\t"
1906               + seq.getSequenceAsString(sg.getStartRes(),
1907                       sg.getEndRes() + 1) + "\n");
1908     }
1909
1910   }
1911
1912   protected void pasteNew_actionPerformed()
1913   {
1914     paste(true);
1915   }
1916
1917   protected void pasteThis_actionPerformed()
1918   {
1919     paste(false);
1920   }
1921
1922   void paste(boolean newAlignment)
1923   {
1924     try
1925     {
1926
1927       if (copiedSequences == null)
1928       {
1929         return;
1930       }
1931
1932       StringTokenizer st = new StringTokenizer(copiedSequences.toString());
1933       Vector seqs = new Vector();
1934       while (st.hasMoreElements())
1935       {
1936         String name = st.nextToken();
1937         int start = Integer.parseInt(st.nextToken());
1938         int end = Integer.parseInt(st.nextToken());
1939         seqs.addElement(new Sequence(name, st.nextToken(), start, end));
1940       }
1941       SequenceI[] newSeqs = new SequenceI[seqs.size()];
1942       for (int i = 0; i < seqs.size(); i++)
1943       {
1944         newSeqs[i] = (SequenceI) seqs.elementAt(i);
1945       }
1946
1947       if (newAlignment)
1948       {
1949         String newtitle = MessageManager.getString("label.copied_sequences");
1950         if (getTitle().startsWith(MessageManager.getString("label.copied_sequences")))
1951         {
1952           newtitle = getTitle();
1953         }
1954         else
1955         {
1956           newtitle = newtitle.concat(MessageManager.formatMessage("label.from_msname", new String[]{getTitle()}));
1957         }
1958         AlignFrame af = new AlignFrame(new Alignment(newSeqs),
1959                 viewport.applet, newtitle, false);
1960         if (copiedHiddenColumns != null)
1961         {
1962           for (int i = 0; i < copiedHiddenColumns.size(); i++)
1963           {
1964             int[] region = (int[]) copiedHiddenColumns.elementAt(i);
1965             af.viewport.hideColumns(region[0], region[1]);
1966           }
1967         }
1968
1969         jalview.bin.JalviewLite.addFrame(af, newtitle, frameWidth,
1970                 frameHeight);
1971       }
1972       else
1973       {
1974         addSequences(newSeqs);
1975       }
1976
1977     } catch (Exception ex)
1978     {
1979     } // could be anything being pasted in here
1980
1981   }
1982
1983   void addSequences(SequenceI[] seqs)
1984   {
1985     for (int i = 0; i < seqs.length; i++)
1986     {
1987       viewport.getAlignment().addSequence(seqs[i]);
1988     }
1989
1990     // !newAlignment
1991     addHistoryItem(new EditCommand(
1992             MessageManager.getString("label.add_sequences"), Action.PASTE,
1993             seqs, 0, viewport.getAlignment().getWidth(),
1994             viewport.getAlignment()));
1995
1996     viewport.setEndSeq(viewport.getAlignment().getHeight());
1997     viewport.getAlignment().getWidth();
1998     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
1999             .getSequences());
2000
2001   }
2002
2003   protected void cut_actionPerformed()
2004   {
2005     copy_actionPerformed();
2006     delete_actionPerformed();
2007   }
2008
2009   protected void delete_actionPerformed()
2010   {
2011
2012     SequenceGroup sg = viewport.getSelectionGroup();
2013     if (sg == null)
2014     {
2015       return;
2016     }
2017
2018     Vector seqs = new Vector();
2019     SequenceI seq;
2020     for (int i = 0; i < sg.getSize(); i++)
2021     {
2022       seq = sg.getSequenceAt(i);
2023       seqs.addElement(seq);
2024     }
2025
2026     // If the cut affects all sequences, remove highlighted columns
2027     if (sg.getSize() == viewport.getAlignment().getHeight())
2028     {
2029       viewport.getColumnSelection().removeElements(sg.getStartRes(),
2030               sg.getEndRes() + 1);
2031     }
2032
2033     SequenceI[] cut = new SequenceI[seqs.size()];
2034     for (int i = 0; i < seqs.size(); i++)
2035     {
2036       cut[i] = (SequenceI) seqs.elementAt(i);
2037     }
2038
2039     /*
2040      * //ADD HISTORY ITEM
2041      */
2042     addHistoryItem(new EditCommand(
2043             MessageManager.getString("label.cut_sequences"), Action.CUT,
2044             cut, sg.getStartRes(), sg.getEndRes() - sg.getStartRes() + 1,
2045             viewport.getAlignment()));
2046
2047     viewport.setSelectionGroup(null);
2048     viewport.getAlignment().deleteGroup(sg);
2049
2050     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
2051             .getSequences());
2052
2053     if (viewport.getAlignment().getHeight() < 1)
2054     {
2055       this.setVisible(false);
2056     }
2057     viewport.sendSelection();
2058   }
2059
2060   /**
2061    * group consensus toggled
2062    *
2063    */
2064   protected void showGroupConsensus_actionPerformed()
2065   {
2066     viewport.setShowGroupConsensus(showGroupConsensus.getState());
2067     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
2068
2069   }
2070
2071   /**
2072    * group conservation toggled.
2073    */
2074   protected void showGroupConservation_actionPerformed()
2075   {
2076     viewport.setShowGroupConservation(showGroupConservation.getState());
2077     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
2078   }
2079
2080   /*
2081    * (non-Javadoc)
2082    *
2083    * @see
2084    * jalview.jbgui.GAlignFrame#showConsensusHistogram_actionPerformed(java.awt
2085    * .event.ActionEvent)
2086    */
2087   protected void showConsensusHistogram_actionPerformed()
2088   {
2089     viewport.setShowConsensusHistogram(showConsensusHistogram.getState());
2090     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
2091   }
2092
2093   /*
2094    * (non-Javadoc)
2095    *
2096    * @see
2097    * jalview.jbgui.GAlignFrame#showConsensusProfile_actionPerformed(java.awt
2098    * .event.ActionEvent)
2099    */
2100   protected void showSequenceLogo_actionPerformed()
2101   {
2102     viewport.setShowSequenceLogo(showSequenceLogo.getState());
2103     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
2104   }
2105
2106   protected void normSequenceLogo_actionPerformed()
2107   {
2108     showSequenceLogo.setState(true);
2109     viewport.setShowSequenceLogo(true);
2110     viewport.setNormaliseSequenceLogo(normSequenceLogo.getState());
2111     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
2112   }
2113
2114   protected void applyAutoAnnotationSettings_actionPerformed()
2115   {
2116     alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
2117   }
2118
2119   protected void makeGrpsFromSelection_actionPerformed()
2120   {
2121     if (avc.makeGroupsFromSelection())
2122     {
2123       PaintRefresher.Refresh(this, viewport.getSequenceSetId());
2124       alignPanel.updateAnnotation();
2125       alignPanel.paintAlignment(true);
2126     }
2127   }
2128
2129   protected void createGroup_actionPerformed()
2130   {
2131     avc.createGroup();
2132   }
2133
2134   protected void unGroup_actionPerformed()
2135   {
2136     if (avc.unGroup())
2137     {
2138       alignPanel.alignmentChanged();
2139     }
2140   }
2141
2142   protected void deleteGroups_actionPerformed()
2143   {
2144     if (avc.deleteGroups())
2145     {
2146       alignPanel.alignmentChanged();
2147     }
2148   }
2149
2150   public void selectAllSequenceMenuItem_actionPerformed()
2151   {
2152     SequenceGroup sg = new SequenceGroup();
2153     for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
2154     {
2155       sg.addSequence(viewport.getAlignment().getSequenceAt(i), false);
2156     }
2157     sg.setEndRes(viewport.getAlignment().getWidth() - 1);
2158     viewport.setSelectionGroup(sg);
2159     alignPanel.paintAlignment(true);
2160     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
2161     viewport.sendSelection();
2162   }
2163
2164   public void deselectAllSequenceMenuItem_actionPerformed()
2165   {
2166     if (viewport.cursorMode)
2167     {
2168       alignPanel.seqPanel.keyboardNo1 = null;
2169       alignPanel.seqPanel.keyboardNo2 = null;
2170     }
2171     viewport.setSelectionGroup(null);
2172     viewport.getColumnSelection().clear();
2173     viewport.setSelectionGroup(null);
2174     alignPanel.idPanel.idCanvas.searchResults = null;
2175     alignPanel.seqPanel.seqCanvas.highlightSearchResults(null);
2176     alignPanel.paintAlignment(true);
2177     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
2178     viewport.sendSelection();
2179   }
2180
2181   public void invertSequenceMenuItem_actionPerformed()
2182   {
2183     SequenceGroup sg = viewport.getSelectionGroup();
2184     for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
2185     {
2186       sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false);
2187     }
2188
2189     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
2190     viewport.sendSelection();
2191   }
2192
2193   public void invertColSel_actionPerformed()
2194   {
2195     viewport.invertColumnSelection();
2196     alignPanel.paintAlignment(true);
2197     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
2198     viewport.sendSelection();
2199   }
2200
2201   void trimAlignment(boolean trimLeft)
2202   {
2203     ColumnSelection colSel = viewport.getColumnSelection();
2204     int column;
2205
2206     if (colSel.size() > 0)
2207     {
2208       if (trimLeft)
2209       {
2210         column = colSel.getMin();
2211       }
2212       else
2213       {
2214         column = colSel.getMax();
2215       }
2216
2217       SequenceI[] seqs;
2218       if (viewport.getSelectionGroup() != null)
2219       {
2220         seqs = viewport.getSelectionGroup().getSequencesAsArray(
2221                 viewport.getHiddenRepSequences());
2222       }
2223       else
2224       {
2225         seqs = viewport.getAlignment().getSequencesArray();
2226       }
2227
2228       TrimRegionCommand trimRegion;
2229       if (trimLeft)
2230       {
2231         trimRegion = new TrimRegionCommand("Remove Left",
2232                 TrimRegionCommand.TRIM_LEFT, seqs, column,
2233                 viewport.getAlignment(), viewport.getColumnSelection(),
2234                 viewport.getSelectionGroup());
2235         viewport.setStartRes(0);
2236       }
2237       else
2238       {
2239         trimRegion = new TrimRegionCommand("Remove Right",
2240                 TrimRegionCommand.TRIM_RIGHT, seqs, column,
2241                 viewport.getAlignment(), viewport.getColumnSelection(),
2242                 viewport.getSelectionGroup());
2243       }
2244
2245       statusBar.setText(MessageManager.formatMessage(
2246               "label.removed_columns", new String[]
2247               { Integer.valueOf(trimRegion.getSize()).toString() }));
2248       addHistoryItem(trimRegion);
2249
2250       for (SequenceGroup sg : viewport.getAlignment().getGroups())
2251       {
2252         if ((trimLeft && !sg.adjustForRemoveLeft(column))
2253                 || (!trimLeft && !sg.adjustForRemoveRight(column)))
2254         {
2255           viewport.getAlignment().deleteGroup(sg);
2256         }
2257       }
2258
2259       viewport.firePropertyChange("alignment", null, viewport
2260               .getAlignment().getSequences());
2261     }
2262   }
2263
2264   public void removeGappedColumnMenuItem_actionPerformed()
2265   {
2266     int start = 0, end = viewport.getAlignment().getWidth() - 1;
2267
2268     SequenceI[] seqs;
2269     if (viewport.getSelectionGroup() != null)
2270     {
2271       seqs = viewport.getSelectionGroup().getSequencesAsArray(
2272               viewport.getHiddenRepSequences());
2273       start = viewport.getSelectionGroup().getStartRes();
2274       end = viewport.getSelectionGroup().getEndRes();
2275     }
2276     else
2277     {
2278       seqs = viewport.getAlignment().getSequencesArray();
2279     }
2280
2281     RemoveGapColCommand removeGapCols = new RemoveGapColCommand(
2282             "Remove Gapped Columns", seqs, start, end,
2283             viewport.getAlignment());
2284
2285     addHistoryItem(removeGapCols);
2286
2287     statusBar.setText(MessageManager.formatMessage(
2288             "label.removed_empty_columns", new String[]
2289             { Integer.valueOf(removeGapCols.getSize()).toString() }));
2290
2291     // This is to maintain viewport position on first residue
2292     // of first sequence
2293     SequenceI seq = viewport.getAlignment().getSequenceAt(0);
2294     int startRes = seq.findPosition(viewport.startRes);
2295     // ShiftList shifts;
2296     // viewport.getAlignment().removeGaps(shifts=new ShiftList());
2297     // edit.alColumnChanges=shifts.getInverse();
2298     // if (viewport.hasHiddenColumns)
2299     // viewport.getColumnSelection().compensateForEdits(shifts);
2300     viewport.setStartRes(seq.findIndex(startRes) - 1);
2301     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
2302             .getSequences());
2303
2304   }
2305
2306   public void removeAllGapsMenuItem_actionPerformed()
2307   {
2308     int start = 0, end = viewport.getAlignment().getWidth() - 1;
2309
2310     SequenceI[] seqs;
2311     if (viewport.getSelectionGroup() != null)
2312     {
2313       seqs = viewport.getSelectionGroup().getSequencesAsArray(
2314               viewport.getHiddenRepSequences());
2315       start = viewport.getSelectionGroup().getStartRes();
2316       end = viewport.getSelectionGroup().getEndRes();
2317     }
2318     else
2319     {
2320       seqs = viewport.getAlignment().getSequencesArray();
2321     }
2322
2323     // This is to maintain viewport position on first residue
2324     // of first sequence
2325     SequenceI seq = viewport.getAlignment().getSequenceAt(0);
2326     int startRes = seq.findPosition(viewport.startRes);
2327
2328     addHistoryItem(new RemoveGapsCommand("Remove Gaps", seqs, start, end,
2329             viewport.getAlignment()));
2330
2331     viewport.setStartRes(seq.findIndex(startRes) - 1);
2332
2333     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
2334             .getSequences());
2335
2336   }
2337
2338   public void findMenuItem_actionPerformed()
2339   {
2340     new Finder(alignPanel);
2341   }
2342
2343   /**
2344    * create a new view derived from the current view
2345    *
2346    * @param viewtitle
2347    * @return frame for the new view
2348    */
2349   public AlignFrame newView(String viewtitle)
2350   {
2351     AlignmentI newal;
2352     if (viewport.hasHiddenRows())
2353     {
2354       newal = new Alignment(viewport.getAlignment().getHiddenSequences()
2355               .getFullAlignment().getSequencesArray());
2356     }
2357     else
2358     {
2359       newal = new Alignment(viewport.getAlignment().getSequencesArray());
2360     }
2361
2362     if (viewport.getAlignment().getAlignmentAnnotation() != null)
2363     {
2364       for (int i = 0; i < viewport.getAlignment().getAlignmentAnnotation().length; i++)
2365       {
2366         if (!viewport.getAlignment().getAlignmentAnnotation()[i].autoCalculated)
2367         {
2368           newal.addAnnotation(viewport.getAlignment()
2369                   .getAlignmentAnnotation()[i]);
2370         }
2371       }
2372     }
2373
2374     AlignFrame newaf = new AlignFrame(newal, viewport.applet, "", false);
2375
2376     newaf.viewport.setSequenceSetId(alignPanel.av.getSequenceSetId());
2377     PaintRefresher.Register(alignPanel, alignPanel.av.getSequenceSetId());
2378     PaintRefresher.Register(newaf.alignPanel,
2379             newaf.alignPanel.av.getSequenceSetId());
2380
2381     PaintRefresher.Register(newaf.alignPanel.idPanel.idCanvas,
2382             newaf.alignPanel.av.getSequenceSetId());
2383     PaintRefresher.Register(newaf.alignPanel.seqPanel.seqCanvas,
2384             newaf.alignPanel.av.getSequenceSetId());
2385
2386     Vector comps = (Vector) PaintRefresher.components.get(viewport
2387             .getSequenceSetId());
2388     int viewSize = -1;
2389     for (int i = 0; i < comps.size(); i++)
2390     {
2391       if (comps.elementAt(i) instanceof AlignmentPanel)
2392       {
2393         viewSize++;
2394       }
2395     }
2396
2397     String title = new String(this.getTitle());
2398     if (viewtitle != null)
2399     {
2400       title = viewtitle + " ( " + title + ")";
2401     }
2402     else
2403     {
2404       if (title.indexOf("(View") > -1)
2405       {
2406         title = title.substring(0, title.indexOf("(View"));
2407       }
2408       title += "(View " + viewSize + ")";
2409     }
2410
2411     newaf.setTitle(title.toString());
2412
2413     newaf.viewport.setHistoryList(viewport.getHistoryList());
2414     newaf.viewport.setRedoList(viewport.getRedoList());
2415     return newaf;
2416   }
2417
2418   /**
2419    *
2420    * @return list of feature groups on the view
2421    */
2422   public String[] getFeatureGroups()
2423   {
2424     FeatureRenderer fr = null;
2425     if (alignPanel != null
2426             && (fr = alignPanel.getFeatureRenderer()) != null)
2427     {
2428       List<String> gps = fr.getFeatureGroups();
2429       String[] _gps = gps.toArray(new String[gps.size()]);
2430       return _gps;
2431     }
2432     return null;
2433   }
2434
2435   /**
2436    * get sequence feature groups that are hidden or shown
2437    *
2438    * @param visible
2439    *          true is visible
2440    * @return list
2441    */
2442   public String[] getFeatureGroupsOfState(boolean visible)
2443   {
2444     FeatureRenderer fr = null;
2445     if (alignPanel != null
2446             && (fr = alignPanel.getFeatureRenderer()) != null)
2447     {
2448       List<String> gps = fr.getGroups(visible);
2449       String[] _gps = gps.toArray(new String[gps.size()]);
2450       return _gps;
2451     }
2452     return null;
2453   }
2454
2455   /**
2456    * Change the display state for the given feature groups
2457    *
2458    * @param groups
2459    *          list of group strings
2460    * @param state
2461    *          visible or invisible
2462    */
2463   public void setFeatureGroupState(String[] groups, boolean state)
2464   {
2465     FeatureRenderer fr = null;
2466     this.sequenceFeatures.setState(true);
2467     viewport.setShowSequenceFeatures(true);
2468     if (alignPanel != null
2469             && (fr = alignPanel.getFeatureRenderer()) != null)
2470     {
2471
2472       fr.setGroupVisibility(Arrays.asList(groups), state);
2473       alignPanel.seqPanel.seqCanvas.repaint();
2474       if (alignPanel.overviewPanel != null)
2475       {
2476         alignPanel.overviewPanel.updateOverviewImage();
2477       }
2478     }
2479   }
2480
2481   public void seqLimits_itemStateChanged()
2482   {
2483     viewport.setShowJVSuffix(seqLimits.getState());
2484     alignPanel.fontChanged();
2485     alignPanel.paintAlignment(true);
2486   }
2487
2488   protected void colourTextMenuItem_actionPerformed()
2489   {
2490     viewport.setColourText(colourTextMenuItem.getState());
2491     alignPanel.paintAlignment(true);
2492   }
2493
2494   protected void displayNonconservedMenuItem_actionPerformed()
2495   {
2496     viewport.setShowUnconserved(displayNonconservedMenuItem.getState());
2497     alignPanel.paintAlignment(true);
2498   }
2499
2500   protected void wrapMenuItem_actionPerformed()
2501   {
2502     viewport.setWrapAlignment(wrapMenuItem.getState());
2503     alignPanel.setWrapAlignment(wrapMenuItem.getState());
2504     scaleAbove.setEnabled(wrapMenuItem.getState());
2505     scaleLeft.setEnabled(wrapMenuItem.getState());
2506     scaleRight.setEnabled(wrapMenuItem.getState());
2507     alignPanel.paintAlignment(true);
2508   }
2509
2510   public void overviewMenuItem_actionPerformed()
2511   {
2512     if (alignPanel.overviewPanel != null)
2513     {
2514       return;
2515     }
2516
2517     Frame frame = new Frame();
2518     OverviewPanel overview = new OverviewPanel(alignPanel);
2519     frame.add(overview);
2520     // +50 must allow for applet frame window
2521     jalview.bin.JalviewLite.addFrame(frame, MessageManager.formatMessage(
2522             "label.overview_params", new String[]
2523             { this.getTitle() }), overview.getPreferredSize().width,
2524             overview.getPreferredSize().height + 50);
2525
2526     frame.pack();
2527     final AlignmentPanel ap = alignPanel;
2528     frame.addWindowListener(new WindowAdapter()
2529     {
2530       @Override
2531       public void windowClosing(WindowEvent e)
2532       {
2533         if (ap != null)
2534         {
2535           ap.setOverviewPanel(null);
2536         }
2537       };
2538     });
2539
2540     alignPanel.setOverviewPanel(overview);
2541
2542   }
2543
2544   void changeColour(ColourSchemeI cs)
2545   {
2546     int threshold = 0;
2547
2548     if (cs != null)
2549     {
2550       if (viewport.getAbovePIDThreshold())
2551       {
2552         viewport.setThreshold(SliderPanel.setPIDSliderSource(alignPanel,
2553                 cs, "Background"));
2554       }
2555
2556       if (viewport.getConservationSelected())
2557       {
2558         cs.setConservationApplied(true);
2559         viewport.setIncrement(SliderPanel.setConservationSlider(alignPanel,
2560                 cs, "Background"));
2561       }
2562       else
2563       {
2564         cs.setConservationApplied(false);
2565       }
2566     }
2567     viewport.setGlobalColourScheme(cs);
2568
2569     if (alignPanel.getOverviewPanel() != null)
2570     {
2571       alignPanel.getOverviewPanel().updateOverviewImage();
2572     }
2573
2574     jalview.structure.StructureSelectionManager
2575             .getStructureSelectionManager(viewport.applet)
2576             .sequenceColoursChanged(alignPanel);
2577
2578     alignPanel.paintAlignment(true);
2579   }
2580
2581   protected void modifyPID_actionPerformed()
2582   {
2583     if (viewport.getAbovePIDThreshold()
2584             && viewport.getGlobalColourScheme() != null)
2585     {
2586       SliderPanel.setPIDSliderSource(alignPanel,
2587               viewport.getGlobalColourScheme(), "Background");
2588       SliderPanel.showPIDSlider();
2589     }
2590   }
2591
2592   protected void modifyConservation_actionPerformed()
2593   {
2594     if (viewport.getConservationSelected()
2595             && viewport.getGlobalColourScheme() != null)
2596     {
2597       SliderPanel.setConservationSlider(alignPanel,
2598               viewport.getGlobalColourScheme(), "Background");
2599       SliderPanel.showConservationSlider();
2600     }
2601   }
2602
2603   protected void conservationMenuItem_actionPerformed()
2604   {
2605     viewport.setConservationSelected(conservationMenuItem.getState());
2606
2607     viewport.setAbovePIDThreshold(false);
2608     abovePIDThreshold.setState(false);
2609
2610     changeColour(viewport.getGlobalColourScheme());
2611
2612     modifyConservation_actionPerformed();
2613   }
2614
2615   public void abovePIDThreshold_actionPerformed()
2616   {
2617     viewport.setAbovePIDThreshold(abovePIDThreshold.getState());
2618
2619     conservationMenuItem.setState(false);
2620     viewport.setConservationSelected(false);
2621
2622     changeColour(viewport.getGlobalColourScheme());
2623
2624     modifyPID_actionPerformed();
2625   }
2626
2627   public void sortPairwiseMenuItem_actionPerformed()
2628   {
2629     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2630     AlignmentSorter.sortByPID(viewport.getAlignment(), viewport
2631             .getAlignment().getSequenceAt(0), null);
2632
2633     addHistoryItem(new OrderCommand("Pairwise Sort", oldOrder,
2634             viewport.getAlignment()));
2635     alignPanel.paintAlignment(true);
2636   }
2637
2638   public void sortIDMenuItem_actionPerformed()
2639   {
2640     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2641     AlignmentSorter.sortByID(viewport.getAlignment());
2642     addHistoryItem(new OrderCommand("ID Sort", oldOrder,
2643             viewport.getAlignment()));
2644     alignPanel.paintAlignment(true);
2645   }
2646
2647   public void sortLengthMenuItem_actionPerformed()
2648   {
2649     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2650     AlignmentSorter.sortByLength(viewport.getAlignment());
2651     addHistoryItem(new OrderCommand("Length Sort", oldOrder,
2652             viewport.getAlignment()));
2653     alignPanel.paintAlignment(true);
2654   }
2655
2656   public void sortGroupMenuItem_actionPerformed()
2657   {
2658     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2659     AlignmentSorter.sortByGroup(viewport.getAlignment());
2660     addHistoryItem(new OrderCommand("Group Sort", oldOrder,
2661             viewport.getAlignment()));
2662     alignPanel.paintAlignment(true);
2663
2664   }
2665
2666   public void removeRedundancyMenuItem_actionPerformed()
2667   {
2668     new RedundancyPanel(alignPanel);
2669   }
2670
2671   public void pairwiseAlignmentMenuItem_actionPerformed()
2672   {
2673     if (viewport.getSelectionGroup() != null
2674             && viewport.getSelectionGroup().getSize() > 1)
2675     {
2676       Frame frame = new Frame();
2677       frame.add(new PairwiseAlignPanel(alignPanel));
2678       jalview.bin.JalviewLite.addFrame(frame,
2679               MessageManager.getString("action.pairwise_alignment"), 600,
2680               500);
2681     }
2682   }
2683
2684   public void PCAMenuItem_actionPerformed()
2685   {
2686     // are the sequences aligned?
2687     if (!viewport.getAlignment().isAligned(false))
2688     {
2689       SequenceI current;
2690       int Width = viewport.getAlignment().getWidth();
2691
2692       for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
2693       {
2694         current = viewport.getAlignment().getSequenceAt(i);
2695
2696         if (current.getLength() < Width)
2697         {
2698           current.insertCharAt(Width - 1, viewport.getGapCharacter());
2699         }
2700       }
2701       alignPanel.paintAlignment(true);
2702     }
2703
2704     if ((viewport.getSelectionGroup() != null
2705             && viewport.getSelectionGroup().getSize() < 4 && viewport
2706             .getSelectionGroup().getSize() > 0)
2707             || viewport.getAlignment().getHeight() < 4)
2708     {
2709       return;
2710     }
2711
2712     try
2713     {
2714       new PCAPanel(viewport);
2715     } catch (java.lang.OutOfMemoryError ex)
2716     {
2717     }
2718
2719   }
2720
2721   public void averageDistanceTreeMenuItem_actionPerformed()
2722   {
2723     NewTreePanel("AV", "PID", "Average distance tree using PID");
2724   }
2725
2726   public void neighbourTreeMenuItem_actionPerformed()
2727   {
2728     NewTreePanel("NJ", "PID", "Neighbour joining tree using PID");
2729   }
2730
2731   protected void njTreeBlosumMenuItem_actionPerformed()
2732   {
2733     NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62");
2734   }
2735
2736   protected void avTreeBlosumMenuItem_actionPerformed()
2737   {
2738     NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62");
2739   }
2740
2741   void NewTreePanel(String type, String pwType, String title)
2742   {
2743     // are the sequences aligned?
2744     if (!viewport.getAlignment().isAligned(false))
2745     {
2746       SequenceI current;
2747       int Width = viewport.getAlignment().getWidth();
2748
2749       for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
2750       {
2751         current = viewport.getAlignment().getSequenceAt(i);
2752
2753         if (current.getLength() < Width)
2754         {
2755           current.insertCharAt(Width - 1, viewport.getGapCharacter());
2756         }
2757       }
2758       alignPanel.paintAlignment(true);
2759
2760     }
2761
2762     if ((viewport.getSelectionGroup() != null && viewport
2763             .getSelectionGroup().getSize() > 1)
2764             || (viewport.getAlignment().getHeight() > 1))
2765     {
2766       final TreePanel tp = new TreePanel(alignPanel, type, pwType);
2767
2768       addTreeMenuItem(tp, title);
2769
2770       jalview.bin.JalviewLite.addFrame(tp, title, 600, 500);
2771     }
2772   }
2773
2774   void loadTree_actionPerformed()
2775   {
2776     CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
2777     cap.setText(MessageManager.getString("label.paste_newick_tree_file"));
2778     cap.setTreeImport();
2779     Frame frame = new Frame();
2780     frame.add(cap);
2781     jalview.bin.JalviewLite.addFrame(frame,
2782             MessageManager.getString("label.paste_newick_file"), 400, 300);
2783   }
2784
2785   public void loadTree(jalview.io.NewickFile tree, String treeFile)
2786   {
2787     TreePanel tp = new TreePanel(alignPanel, treeFile,
2788             MessageManager.getString("label.load_tree_from_file"), tree);
2789     jalview.bin.JalviewLite.addFrame(tp, treeFile, 600, 500);
2790     addTreeMenuItem(tp, treeFile);
2791   }
2792
2793   /**
2794    * sort the alignment using the given treePanel
2795    *
2796    * @param treePanel
2797    *          tree used to sort view
2798    * @param title
2799    *          string used for undo event name
2800    */
2801   public void sortByTree(TreePanel treePanel, String title)
2802   {
2803     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2804     AlignmentSorter
2805             .sortByTree(viewport.getAlignment(), treePanel.getTree());
2806     // addHistoryItem(new HistoryItem("Sort", viewport.alignment,
2807     // HistoryItem.SORT));
2808     addHistoryItem(new OrderCommand(MessageManager.formatMessage(
2809             "label.order_by_params", new String[]
2810             { title }), oldOrder, viewport.getAlignment()));
2811     alignPanel.paintAlignment(true);
2812   }
2813
2814   /**
2815    * Do any automatic reordering of the alignment and add the necessary bits to
2816    * the menu structure for the new tree
2817    *
2818    * @param treePanel
2819    * @param title
2820    */
2821   protected void addTreeMenuItem(final TreePanel treePanel,
2822           final String title)
2823   {
2824     final MenuItem item = new MenuItem(title);
2825     sortByTreeMenu.add(item);
2826     item.addActionListener(new java.awt.event.ActionListener()
2827     {
2828       @Override
2829       public void actionPerformed(ActionEvent evt)
2830       {
2831         sortByTree(treePanel, title); // treePanel.getTitle());
2832       }
2833     });
2834
2835     treePanel.addWindowListener(new WindowAdapter()
2836     {
2837       @Override
2838       public void windowOpened(WindowEvent e)
2839       {
2840         if (viewport.sortByTree)
2841         {
2842           sortByTree(treePanel, title);
2843         }
2844         super.windowOpened(e);
2845       }
2846
2847       @Override
2848       public void windowClosing(WindowEvent e)
2849       {
2850         sortByTreeMenu.remove(item);
2851       };
2852     });
2853   }
2854
2855   public boolean sortBy(AlignmentOrder alorder, String undoname)
2856   {
2857     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2858     if (viewport.applet.debug)
2859     {
2860       System.err.println("Sorting " + alorder.getOrder().size()
2861               + " in alignment '" + getTitle() + "'");
2862     }
2863     AlignmentSorter.sortBy(viewport.getAlignment(), alorder);
2864     if (undoname != null)
2865     {
2866       addHistoryItem(new OrderCommand(undoname, oldOrder,
2867               viewport.getAlignment()));
2868     }
2869     alignPanel.paintAlignment(true);
2870     return true;
2871   }
2872
2873   protected void documentation_actionPerformed()
2874   {
2875     alignPanel.av.applet.openJalviewHelpUrl();
2876   }
2877
2878   protected void about_actionPerformed()
2879   {
2880
2881     class AboutPanel extends Canvas
2882     {
2883       String version;
2884
2885       String builddate;
2886
2887       public AboutPanel(String version, String builddate)
2888       {
2889         this.version = version;
2890         this.builddate = builddate;
2891       }
2892
2893       @Override
2894       public void paint(Graphics g)
2895       {
2896         g.setColor(Color.white);
2897         g.fillRect(0, 0, getSize().width, getSize().height);
2898         g.setFont(new Font("Helvetica", Font.PLAIN, 12));
2899         FontMetrics fm = g.getFontMetrics();
2900         int fh = fm.getHeight();
2901         int y = 5, x = 7;
2902         g.setColor(Color.black);
2903         // TODO: update this text for each release or centrally store it for
2904         // lite and application
2905         g.setFont(new Font("Helvetica", Font.BOLD, 14));
2906         g.drawString(MessageManager.formatMessage(
2907                 "label.jalviewLite_release", new String[]
2908                 { version }), x, y += fh);
2909         g.setFont(new Font("Helvetica", Font.BOLD, 12));
2910         g.drawString(MessageManager.formatMessage(
2911                 "label.jaview_build_date", new String[]
2912                 { builddate }), x, y += fh);
2913         g.setFont(new Font("Helvetica", Font.PLAIN, 12));
2914         g.drawString(MessageManager.getString("label.jalview_authors_1"),
2915                 x, y += fh * 1.5);
2916         g.drawString(MessageManager.getString("label.jalview_authors_2"),
2917                 x + 50, y += fh + 8);
2918         g.drawString(
2919                 MessageManager.getString("label.jalview_dev_managers"), x,
2920                 y += fh);
2921         g.drawString(MessageManager
2922                 .getString("label.jalview_distribution_lists"), x, y += fh);
2923         g.drawString(MessageManager.getString("label.jalview_please_cite"),
2924                 x, y += fh + 8);
2925         g.drawString(
2926                 MessageManager.getString("label.jalview_cite_1_authors"),
2927                 x, y += fh);
2928         g.drawString(
2929                 MessageManager.getString("label.jalview_cite_1_title"), x,
2930                 y += fh);
2931         g.drawString(MessageManager.getString("label.jalview_cite_1_ref"),
2932                 x, y += fh);
2933       }
2934     }
2935
2936     Frame frame = new Frame();
2937     frame.add(new AboutPanel(JalviewLite.getVersion(), JalviewLite
2938             .getBuildDate()));
2939     jalview.bin.JalviewLite.addFrame(frame,
2940             MessageManager.getString("label.jalview"), 580, 220);
2941
2942   }
2943
2944   public void showURL(String url, String target)
2945   {
2946     if (viewport.applet == null)
2947     {
2948       System.out.println("Not running as applet - no browser available.");
2949     }
2950     else
2951     {
2952       viewport.applet.showURL(url, target);
2953     }
2954   }
2955
2956   // ////////////////////////////////////////////////////////////////////////////////
2957   // JBuilder Graphics here
2958
2959   MenuBar alignFrameMenuBar = new MenuBar();
2960
2961   Menu fileMenu = new Menu(MessageManager.getString("action.file"));
2962
2963   MenuItem loadApplication = new MenuItem(
2964           MessageManager.getString("label.view_full_application"));
2965
2966   MenuItem loadTree = new MenuItem(
2967           MessageManager.getString("label.load_associated_tree"));
2968
2969   MenuItem loadAnnotations = new MenuItem(
2970           MessageManager.getString("label.load_features_annotations"));
2971
2972   MenuItem outputFeatures = new MenuItem(
2973           MessageManager.getString("label.export_features").concat("..."));
2974
2975   MenuItem outputAnnotations = new MenuItem(
2976           MessageManager.getString("label.export_annotations").concat("..."));
2977
2978   MenuItem closeMenuItem = new MenuItem(
2979           MessageManager.getString("action.close"));
2980
2981   MenuItem selectAllSequenceMenuItem = new MenuItem(
2982           MessageManager.getString("action.select_all"));
2983
2984   MenuItem deselectAllSequenceMenuItem = new MenuItem(
2985           MessageManager.getString("action.deselect_all"));
2986
2987   MenuItem invertSequenceMenuItem = new MenuItem(
2988           MessageManager.getString("action.invert_selection"));
2989
2990   MenuItem remove2LeftMenuItem = new MenuItem();
2991
2992   MenuItem remove2RightMenuItem = new MenuItem();
2993
2994   MenuItem removeGappedColumnMenuItem = new MenuItem();
2995
2996   MenuItem removeAllGapsMenuItem = new MenuItem();
2997
2998   CheckboxMenuItem viewBoxesMenuItem = new CheckboxMenuItem();
2999
3000   CheckboxMenuItem viewTextMenuItem = new CheckboxMenuItem();
3001
3002   MenuItem sortPairwiseMenuItem = new MenuItem();
3003
3004   MenuItem sortIDMenuItem = new MenuItem();
3005
3006   MenuItem sortLengthMenuItem = new MenuItem();
3007
3008   MenuItem sortGroupMenuItem = new MenuItem();
3009
3010   MenuItem removeRedundancyMenuItem = new MenuItem();
3011
3012   MenuItem pairwiseAlignmentMenuItem = new MenuItem();
3013
3014   MenuItem PCAMenuItem = new MenuItem();
3015
3016   MenuItem averageDistanceTreeMenuItem = new MenuItem();
3017
3018   MenuItem neighbourTreeMenuItem = new MenuItem();
3019
3020   BorderLayout borderLayout1 = new BorderLayout();
3021
3022   public Label statusBar = new Label();
3023
3024   MenuItem clustalColour = new MenuItem();
3025
3026   MenuItem zappoColour = new MenuItem();
3027
3028   MenuItem taylorColour = new MenuItem();
3029
3030   MenuItem hydrophobicityColour = new MenuItem();
3031
3032   MenuItem helixColour = new MenuItem();
3033
3034   MenuItem strandColour = new MenuItem();
3035
3036   MenuItem turnColour = new MenuItem();
3037
3038   MenuItem buriedColour = new MenuItem();
3039
3040   MenuItem purinePyrimidineColour = new MenuItem();
3041
3042   MenuItem RNAInteractionColour = new MenuItem();
3043
3044   MenuItem RNAHelixColour = new MenuItem();
3045
3046   MenuItem userDefinedColour = new MenuItem();
3047
3048   MenuItem PIDColour = new MenuItem();
3049
3050   MenuItem BLOSUM62Colour = new MenuItem();
3051
3052   MenuItem tcoffeeColour = new MenuItem();
3053
3054   MenuItem njTreeBlosumMenuItem = new MenuItem();
3055
3056   MenuItem avDistanceTreeBlosumMenuItem = new MenuItem();
3057
3058   CheckboxMenuItem annotationPanelMenuItem = new CheckboxMenuItem();
3059
3060   CheckboxMenuItem colourTextMenuItem = new CheckboxMenuItem();
3061
3062   CheckboxMenuItem displayNonconservedMenuItem = new CheckboxMenuItem();
3063
3064   MenuItem alProperties = new MenuItem(
3065           MessageManager.getString("label.alignment_props"));
3066
3067   MenuItem overviewMenuItem = new MenuItem();
3068
3069   MenuItem undoMenuItem = new MenuItem();
3070
3071   MenuItem redoMenuItem = new MenuItem();
3072
3073   CheckboxMenuItem conservationMenuItem = new CheckboxMenuItem();
3074
3075   MenuItem noColourmenuItem = new MenuItem();
3076
3077   CheckboxMenuItem wrapMenuItem = new CheckboxMenuItem();
3078
3079   CheckboxMenuItem renderGapsMenuItem = new CheckboxMenuItem();
3080
3081   MenuItem findMenuItem = new MenuItem();
3082
3083   CheckboxMenuItem abovePIDThreshold = new CheckboxMenuItem();
3084
3085   MenuItem nucleotideColour = new MenuItem();
3086
3087   MenuItem deleteGroups = new MenuItem();
3088
3089   MenuItem grpsFromSelection = new MenuItem();
3090
3091   MenuItem createGroup = new MenuItem();
3092
3093   MenuItem unGroup = new MenuItem();
3094
3095   MenuItem delete = new MenuItem();
3096
3097   MenuItem copy = new MenuItem();
3098
3099   MenuItem cut = new MenuItem();
3100
3101   Menu pasteMenu = new Menu();
3102
3103   MenuItem pasteNew = new MenuItem();
3104
3105   MenuItem pasteThis = new MenuItem();
3106
3107   CheckboxMenuItem applyToAllGroups = new CheckboxMenuItem();
3108
3109   MenuItem font = new MenuItem();
3110
3111   CheckboxMenuItem scaleAbove = new CheckboxMenuItem();
3112
3113   CheckboxMenuItem scaleLeft = new CheckboxMenuItem();
3114
3115   CheckboxMenuItem scaleRight = new CheckboxMenuItem();
3116
3117   MenuItem modifyPID = new MenuItem();
3118
3119   MenuItem modifyConservation = new MenuItem();
3120
3121   CheckboxMenuItem autoCalculate = null;
3122
3123   CheckboxMenuItem sortByTree = new CheckboxMenuItem(
3124           "Sort Alignment With New Tree", true);
3125
3126   Menu sortByTreeMenu = new Menu();
3127
3128   MenuItem inputText = new MenuItem();
3129
3130   MenuItem documentation = new MenuItem();
3131
3132   MenuItem about = new MenuItem();
3133
3134   CheckboxMenuItem seqLimits = new CheckboxMenuItem();
3135
3136   CheckboxMenuItem centreColumnLabelFlag = new CheckboxMenuItem();
3137
3138   CheckboxMenuItem followMouseOverFlag = new CheckboxMenuItem();
3139
3140   CheckboxMenuItem showSequenceLogo = new CheckboxMenuItem();
3141
3142   CheckboxMenuItem applyAutoAnnotationSettings = new CheckboxMenuItem();
3143
3144   CheckboxMenuItem showConsensusHistogram = new CheckboxMenuItem();
3145
3146   CheckboxMenuItem showGroupConsensus = new CheckboxMenuItem();
3147
3148   CheckboxMenuItem showGroupConservation = new CheckboxMenuItem();
3149
3150   CheckboxMenuItem normSequenceLogo = new CheckboxMenuItem();
3151
3152   /**
3153    * Initialise menus and other items
3154    *
3155    * @throws Exception
3156    */
3157   private void jbInit() throws Exception
3158   {
3159     setMenuBar(alignFrameMenuBar);
3160
3161     /*
3162      * Configure File menu items and actions
3163      */
3164     inputText
3165             .setLabel(MessageManager.getString("label.input_from_textbox"));
3166     inputText.addActionListener(this);
3167     Menu outputTextboxMenu = new Menu(
3168             MessageManager.getString("label.out_to_textbox"));
3169     for (int i = 0; i < jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS.length; i++)
3170     {
3171
3172       MenuItem item = new MenuItem(
3173               jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS[i]);
3174
3175       item.addActionListener(new java.awt.event.ActionListener()
3176       {
3177         @Override
3178         public void actionPerformed(ActionEvent e)
3179         {
3180           outputText_actionPerformed(e);
3181         }
3182       });
3183
3184       outputTextboxMenu.add(item);
3185     }
3186     closeMenuItem.addActionListener(this);
3187     loadApplication.addActionListener(this);
3188     loadTree.addActionListener(this);
3189     loadAnnotations.addActionListener(this);
3190     outputFeatures.addActionListener(this);
3191     outputAnnotations.addActionListener(this);
3192
3193     /*
3194      * Configure Edit menu items and actions
3195      */
3196     undoMenuItem.setEnabled(false);
3197     undoMenuItem.setLabel(MessageManager.getString("action.undo"));
3198     undoMenuItem.addActionListener(this);
3199     redoMenuItem.setEnabled(false);
3200     redoMenuItem.setLabel(MessageManager.getString("action.redo"));
3201     redoMenuItem.addActionListener(this);
3202     copy.setLabel(MessageManager.getString("action.copy"));
3203     copy.addActionListener(this);
3204     cut.setLabel(MessageManager.getString("action.cut"));
3205     cut.addActionListener(this);
3206     delete.setLabel(MessageManager.getString("action.delete"));
3207     delete.addActionListener(this);
3208     pasteMenu.setLabel(MessageManager.getString("action.paste"));
3209     pasteNew.setLabel(MessageManager.getString("label.to_new_alignment"));
3210     pasteNew.addActionListener(this);
3211     pasteThis.setLabel(MessageManager.getString("label.to_this_alignment"));
3212     pasteThis.addActionListener(this);
3213     remove2LeftMenuItem.setLabel(MessageManager
3214             .getString("action.remove_left"));
3215     remove2LeftMenuItem.addActionListener(this);
3216     remove2RightMenuItem.setLabel(MessageManager
3217             .getString("action.remove_right"));
3218     remove2RightMenuItem.addActionListener(this);
3219     removeGappedColumnMenuItem.setLabel(MessageManager
3220             .getString("action.remove_empty_columns"));
3221     removeGappedColumnMenuItem.addActionListener(this);
3222     removeAllGapsMenuItem.setLabel(MessageManager
3223             .getString("action.remove_all_gaps"));
3224     removeAllGapsMenuItem.addActionListener(this);
3225     removeRedundancyMenuItem.setLabel(MessageManager.getString(
3226             "action.remove_redundancy").concat("..."));
3227     removeRedundancyMenuItem.addActionListener(this);
3228
3229     /*
3230      * Configure Select menu items and actions
3231      */
3232     findMenuItem.setLabel(MessageManager.getString("action.find"));
3233     findMenuItem.addActionListener(this);
3234     selectAllSequenceMenuItem.addActionListener(this);
3235     deselectAllSequenceMenuItem.addActionListener(this);
3236     invertSequenceMenuItem.setLabel(MessageManager
3237             .getString("action.invert_sequence_selection"));
3238     invertSequenceMenuItem.addActionListener(this);
3239     invertColSel.setLabel(MessageManager
3240             .getString("action.invert_column_selection"));
3241     invertColSel.addActionListener(this);
3242     deleteGroups.setLabel(MessageManager
3243             .getString("action.undefine_groups"));
3244     deleteGroups.addActionListener(this);
3245     grpsFromSelection.setLabel(MessageManager
3246             .getString("action.make_groups_selection"));
3247     grpsFromSelection.addActionListener(this);
3248     createGroup.setLabel(MessageManager.getString("action.create_group"));
3249     unGroup.setLabel(MessageManager.getString("action.remove_group"));
3250     annotationColumnSelection.setLabel("Select by Annotation");
3251     annotationColumnSelection.addActionListener(this);
3252
3253     /*
3254      * Configure View menu items and actions
3255      */
3256     newView.setLabel(MessageManager.getString("action.new_view"));
3257     newView.addActionListener(this);
3258     Menu showMenu = new Menu(MessageManager.getString("action.show"));
3259     showColumns.setLabel(MessageManager.getString("label.all_columns"));
3260     showSeqs.setLabel(MessageManager.getString("label.all_sequences"));
3261     Menu hideMenu = new Menu(MessageManager.getString("action.hide"));
3262     hideColumns
3263             .setLabel(MessageManager.getString("label.selected_columns"));
3264     hideSequences.setLabel(MessageManager
3265             .getString("label.selected_sequences"));
3266     hideAllButSelection.setLabel(MessageManager
3267             .getString("label.all_but_selected_region"));
3268     hideAllSelection.setLabel(MessageManager
3269             .getString("label.selected_region"));
3270     showAllHidden.setLabel(MessageManager
3271             .getString("label.all_sequences_columns"));
3272     showColumns.addActionListener(this);
3273     showSeqs.addActionListener(this);
3274     hideColumns.addActionListener(this);
3275     hideSequences.addActionListener(this);
3276     hideAllButSelection.addActionListener(this);
3277     hideAllSelection.addActionListener(this);
3278     showAllHidden.addActionListener(this);
3279     featureSettings.setLabel(MessageManager
3280             .getString("label.feature_settings"));
3281     featureSettings.addActionListener(this);
3282     sequenceFeatures.setLabel(MessageManager
3283             .getString("label.show_sequence_features"));
3284     sequenceFeatures.addItemListener(this);
3285     sequenceFeatures.setState(false);
3286     followMouseOverFlag.setLabel(MessageManager
3287             .getString("label.automatic_scrolling"));
3288     followMouseOverFlag.addItemListener(this);
3289     alProperties.addActionListener(this);
3290     overviewMenuItem.setLabel(MessageManager
3291             .getString("label.overview_window"));
3292     overviewMenuItem.addActionListener(this);
3293
3294     /*
3295      * Configure Annotations menu items and actions
3296      */
3297     annotationPanelMenuItem.setLabel(MessageManager
3298             .getString("label.show_annotations"));
3299     annotationPanelMenuItem.addItemListener(this);
3300     showGroupConsensus.setLabel(MessageManager
3301             .getString("label.group_consensus"));
3302     showGroupConservation.setLabel(MessageManager
3303             .getString("label.group_conservation"));
3304     showConsensusHistogram.setLabel(MessageManager
3305             .getString("label.show_consensus_histogram"));
3306     showSequenceLogo.setLabel(MessageManager
3307             .getString("label.show_consensus_logo"));
3308     normSequenceLogo.setLabel(MessageManager
3309             .getString("label.norm_consensus_logo"));
3310     applyAutoAnnotationSettings.setLabel(MessageManager
3311             .getString("label.apply_all_groups"));
3312     applyAutoAnnotationSettings.setState(true);
3313     Menu autoAnnMenu = new Menu(
3314             MessageManager.getString("label.autocalculated_annotation"));
3315     showGroupConsensus.addItemListener(this);
3316     showGroupConservation.addItemListener(this);
3317     showConsensusHistogram.addItemListener(this);
3318     showSequenceLogo.addItemListener(this);
3319     normSequenceLogo.addItemListener(this);
3320     applyAutoAnnotationSettings.addItemListener(this);
3321     showAlignmentAnnotations = new CheckboxMenuItem(
3322             MessageManager.getString("label.show_all_al_annotations"));
3323     showSequenceAnnotations = new CheckboxMenuItem(
3324             MessageManager.getString("label.show_all_seq_annotations"));
3325     sortAnnBySequence = new CheckboxMenuItem(
3326             MessageManager.getString("label.sort_annotations_by_sequence"));
3327     sortAnnByLabel = new CheckboxMenuItem(
3328             MessageManager.getString("label.sort_annotations_by_label"));
3329     showAutoFirst = new CheckboxMenuItem(
3330             MessageManager.getString("label.show_first"));
3331     showAutoLast = new CheckboxMenuItem(
3332             MessageManager.getString("label.show_last"));
3333     showAlignmentAnnotations.addItemListener(this);
3334     showSequenceAnnotations.addItemListener(this);
3335     sortAnnBySequence.addItemListener(this);
3336     sortAnnByLabel.addItemListener(this);
3337     showAutoFirst.addItemListener(this);
3338     showAutoLast.addItemListener(this);
3339
3340     /*
3341      * Configure Format menu items and actions
3342      */
3343     font.setLabel(MessageManager.getString("action.font"));
3344     font.addActionListener(this);
3345     scaleAbove.setLabel(MessageManager.getString("action.scale_above"));
3346     scaleAbove.setState(true);
3347     scaleAbove.setEnabled(false);
3348     scaleAbove.addItemListener(this);
3349     scaleLeft.setEnabled(false);
3350     scaleLeft.setState(true);
3351     scaleLeft.setLabel(MessageManager.getString("action.scale_left"));
3352     scaleLeft.addItemListener(this);
3353     scaleRight.setEnabled(false);
3354     scaleRight.setState(true);
3355     scaleRight.setLabel(MessageManager.getString("action.scale_right"));
3356     scaleRight.addItemListener(this);
3357     viewBoxesMenuItem.setLabel(MessageManager.getString("action.boxes"));
3358     viewBoxesMenuItem.setState(true);
3359     viewBoxesMenuItem.addItemListener(this);
3360     viewTextMenuItem.setLabel(MessageManager.getString("action.text"));
3361     viewTextMenuItem.setState(true);
3362     viewTextMenuItem.addItemListener(this);
3363     colourTextMenuItem.setLabel(MessageManager
3364             .getString("label.colour_text"));
3365     colourTextMenuItem.addItemListener(this);
3366     displayNonconservedMenuItem.setLabel(MessageManager
3367             .getString("label.show_non_conversed"));
3368     displayNonconservedMenuItem.addItemListener(this);
3369     wrapMenuItem.setLabel(MessageManager.getString("action.wrap"));
3370     wrapMenuItem.addItemListener(this);
3371     renderGapsMenuItem.setLabel(MessageManager
3372             .getString("action.show_gaps"));
3373     renderGapsMenuItem.setState(true);
3374     renderGapsMenuItem.addItemListener(this);
3375     centreColumnLabelFlag.setLabel(MessageManager
3376             .getString("label.centre_column_labels"));
3377     centreColumnLabelFlag.addItemListener(this);
3378     seqLimits.setState(true);
3379     seqLimits.setLabel(MessageManager
3380             .getString("label.show_sequence_limits"));
3381     seqLimits.addItemListener(this);
3382
3383     /*
3384      * Configure Colour menu items and actions
3385      */
3386     applyToAllGroups.setLabel(MessageManager
3387             .getString("label.apply_colour_to_all_groups"));
3388     applyToAllGroups.setState(true);
3389     applyToAllGroups.addItemListener(this);
3390     clustalColour.setLabel(MessageManager.getString("label.clustalx"));
3391     clustalColour.addActionListener(this);
3392     zappoColour.setLabel(MessageManager.getString("label.zappo"));
3393     zappoColour.addActionListener(this);
3394     taylorColour.setLabel(MessageManager.getString("label.taylor"));
3395     taylorColour.addActionListener(this);
3396     hydrophobicityColour.setLabel(MessageManager
3397             .getString("label.hydrophobicity"));
3398     hydrophobicityColour.addActionListener(this);
3399     helixColour
3400             .setLabel(MessageManager.getString("label.helix_propensity"));
3401     helixColour.addActionListener(this);
3402     strandColour.setLabel(MessageManager
3403             .getString("label.strand_propensity"));
3404     strandColour.addActionListener(this);
3405     turnColour.setLabel(MessageManager.getString("label.turn_propensity"));
3406     turnColour.addActionListener(this);
3407     buriedColour.setLabel(MessageManager.getString("label.buried_index"));
3408     buriedColour.addActionListener(this);
3409     purinePyrimidineColour.setLabel(MessageManager
3410             .getString("label.purine_pyrimidine"));
3411     purinePyrimidineColour.addActionListener(this);
3412     RNAInteractionColour.setLabel(MessageManager
3413             .getString("label.rna_interaction"));
3414     RNAInteractionColour.addActionListener(this);
3415     RNAHelixColour.setLabel(MessageManager
3416             .getString("action.by_rna_helixes"));
3417     RNAHelixColour.addActionListener(this);
3418     userDefinedColour.setLabel(MessageManager
3419             .getString("action.user_defined"));
3420     userDefinedColour.addActionListener(this);
3421     PIDColour.setLabel(MessageManager
3422             .getString("label.percentage_identity"));
3423     PIDColour.addActionListener(this);
3424     BLOSUM62Colour.setLabel(MessageManager
3425             .getString("label.blosum62_score"));
3426     BLOSUM62Colour.addActionListener(this);
3427     tcoffeeColour
3428             .setLabel(MessageManager.getString("label.tcoffee_scores"));
3429     // it will be enabled only if a score file is provided
3430     tcoffeeColour.setEnabled(false);
3431     tcoffeeColour.addActionListener(this);
3432     conservationMenuItem.setLabel(MessageManager
3433             .getString("action.by_conservation"));
3434     conservationMenuItem.addItemListener(this);
3435     noColourmenuItem.setLabel(MessageManager.getString("label.none"));
3436     noColourmenuItem.addActionListener(this);
3437     abovePIDThreshold.setLabel(MessageManager
3438             .getString("label.above_identity_threshold"));
3439     abovePIDThreshold.addItemListener(this);
3440     nucleotideColour.setLabel(MessageManager.getString("label.nucleotide"));
3441     nucleotideColour.addActionListener(this);
3442     modifyPID.setLabel(MessageManager
3443             .getString("label.modify_identity_thereshold"));
3444     modifyPID.addActionListener(this);
3445     modifyConservation.setLabel(MessageManager
3446             .getString("label.modify_conservation_thereshold"));
3447     modifyConservation.addActionListener(this);
3448     annotationColour.setLabel(MessageManager
3449             .getString("action.by_annotation"));
3450     annotationColour.addActionListener(this);
3451
3452     /*
3453      * Configure Calculate menu items and actions
3454      */
3455     sortPairwiseMenuItem.setLabel(MessageManager
3456             .getString("action.by_pairwise_id"));
3457     sortPairwiseMenuItem.addActionListener(this);
3458     sortIDMenuItem.setLabel(MessageManager.getString("action.by_id"));
3459     sortIDMenuItem.addActionListener(this);
3460     sortLengthMenuItem.setLabel(MessageManager
3461             .getString("action.by_length"));
3462     sortLengthMenuItem.addActionListener(this);
3463     sortGroupMenuItem.setLabel(MessageManager.getString("action.by_group"));
3464     sortGroupMenuItem.addActionListener(this);
3465     pairwiseAlignmentMenuItem.setLabel(MessageManager
3466             .getString("action.pairwise_alignment"));
3467     pairwiseAlignmentMenuItem.addActionListener(this);
3468     PCAMenuItem.setLabel(MessageManager
3469             .getString("label.principal_component_analysis"));
3470     PCAMenuItem.addActionListener(this);
3471     autoCalculate = new CheckboxMenuItem(
3472             MessageManager.getString("label.autocalculate_consensus"), true);
3473     averageDistanceTreeMenuItem.setLabel(MessageManager
3474             .getString("label.average_distance_identity"));
3475     averageDistanceTreeMenuItem.addActionListener(this);
3476     neighbourTreeMenuItem.setLabel(MessageManager
3477             .getString("label.neighbour_joining_identity"));
3478     neighbourTreeMenuItem.addActionListener(this);
3479     avDistanceTreeBlosumMenuItem.setLabel(MessageManager
3480             .getString("label.average_distance_bloslum62"));
3481     avDistanceTreeBlosumMenuItem.addActionListener(this);
3482     njTreeBlosumMenuItem.setLabel(MessageManager
3483             .getString("label.neighbour_blosum62"));
3484     njTreeBlosumMenuItem.addActionListener(this);
3485     sortByTreeMenu.setLabel(MessageManager
3486             .getString("action.by_tree_order"));
3487     Menu sortMenu = new Menu(MessageManager.getString("action.sort"));
3488     Menu calculateTreeMenu = new Menu(
3489             MessageManager.getString("action.calculate_tree"));
3490     autoCalculate.addItemListener(this);
3491     sortByTree.addItemListener(this);
3492
3493     /*
3494      * Configure Help menu items and actions
3495      */
3496     Menu helpMenu = new Menu(MessageManager.getString("action.help"));
3497     documentation.setLabel(MessageManager.getString("label.documentation"));
3498     documentation.addActionListener(this);
3499     about.setLabel(MessageManager.getString("label.about"));
3500     about.addActionListener(this);
3501
3502     /*
3503      * Add top level menus to frame
3504      */
3505     alignFrameMenuBar.add(fileMenu);
3506     Menu editMenu = new Menu(MessageManager.getString("action.edit"));
3507     alignFrameMenuBar.add(editMenu);
3508     Menu selectMenu = new Menu(MessageManager.getString("action.select"));
3509     alignFrameMenuBar.add(selectMenu);
3510     Menu viewMenu = new Menu(MessageManager.getString("action.view"));
3511     alignFrameMenuBar.add(viewMenu);
3512     Menu annotationsMenu = new Menu(
3513             MessageManager.getString("action.annotations"));
3514     alignFrameMenuBar.add(annotationsMenu);
3515     Menu formatMenu = new Menu(MessageManager.getString("action.format"));
3516     alignFrameMenuBar.add(formatMenu);
3517     Menu colourMenu = new Menu(MessageManager.getString("action.colour"));
3518     alignFrameMenuBar.add(colourMenu);
3519     Menu calculateMenu = new Menu(
3520             MessageManager.getString("action.calculate"));
3521     alignFrameMenuBar.add(calculateMenu);
3522     alignFrameMenuBar.add(helpMenu);
3523
3524     /*
3525      * File menu
3526      */
3527     fileMenu.add(inputText);
3528     fileMenu.add(loadTree);
3529     fileMenu.add(loadAnnotations);
3530     fileMenu.addSeparator();
3531     fileMenu.add(outputTextboxMenu);
3532     fileMenu.add(outputFeatures);
3533     fileMenu.add(outputAnnotations);
3534     if (jalviewServletURL != null)
3535     {
3536       fileMenu.add(loadApplication);
3537     }
3538     fileMenu.addSeparator();
3539     fileMenu.add(closeMenuItem);
3540
3541     /*
3542      * Edit menu
3543      */
3544     editMenu.add(undoMenuItem);
3545     editMenu.add(redoMenuItem);
3546     editMenu.add(cut);
3547     editMenu.add(copy);
3548     pasteMenu.add(pasteNew);
3549     pasteMenu.add(pasteThis);
3550     editMenu.add(pasteMenu);
3551     editMenu.add(delete);
3552     editMenu.addSeparator();
3553     editMenu.add(remove2LeftMenuItem);
3554     editMenu.add(remove2RightMenuItem);
3555     editMenu.add(removeGappedColumnMenuItem);
3556     editMenu.add(removeAllGapsMenuItem);
3557     editMenu.add(removeRedundancyMenuItem);
3558
3559     /*
3560      * Select menu
3561      */
3562     selectMenu.add(findMenuItem);
3563     selectMenu.addSeparator();
3564     selectMenu.add(selectAllSequenceMenuItem);
3565     selectMenu.add(deselectAllSequenceMenuItem);
3566     selectMenu.add(invertSequenceMenuItem);
3567     selectMenu.add(invertColSel);
3568     selectMenu.add(createGroup);
3569     selectMenu.add(unGroup);
3570     selectMenu.add(grpsFromSelection);
3571     selectMenu.add(deleteGroups);
3572     selectMenu.add(annotationColumnSelection);
3573
3574     /*
3575      * View menu
3576      */
3577     viewMenu.add(newView);
3578     viewMenu.addSeparator();
3579     showMenu.add(showColumns);
3580     showMenu.add(showSeqs);
3581     showMenu.add(showAllHidden);
3582     viewMenu.add(showMenu);
3583     hideMenu.add(hideColumns);
3584     hideMenu.add(hideSequences);
3585     hideMenu.add(hideAllSelection);
3586     hideMenu.add(hideAllButSelection);
3587     viewMenu.add(hideMenu);
3588     viewMenu.addSeparator();
3589     viewMenu.add(followMouseOverFlag);
3590     viewMenu.addSeparator();
3591     viewMenu.add(sequenceFeatures);
3592     viewMenu.add(featureSettings);
3593     viewMenu.addSeparator();
3594     viewMenu.add(alProperties);
3595     viewMenu.addSeparator();
3596     viewMenu.add(overviewMenuItem);
3597
3598     /*
3599      * Annotations menu
3600      */
3601     annotationsMenu.add(annotationPanelMenuItem);
3602     annotationsMenu.addSeparator();
3603     annotationsMenu.add(showAlignmentAnnotations);
3604     annotationsMenu.add(showSequenceAnnotations);
3605     annotationsMenu.add(sortAnnBySequence);
3606     annotationsMenu.add(sortAnnByLabel);
3607     annotationsMenu.addSeparator();
3608     autoAnnMenu.add(showAutoFirst);
3609     autoAnnMenu.add(showAutoLast);
3610     autoAnnMenu.addSeparator();
3611     autoAnnMenu.add(applyAutoAnnotationSettings);
3612     autoAnnMenu.add(showConsensusHistogram);
3613     autoAnnMenu.add(showSequenceLogo);
3614     autoAnnMenu.add(normSequenceLogo);
3615     autoAnnMenu.addSeparator();
3616     autoAnnMenu.add(showGroupConservation);
3617     autoAnnMenu.add(showGroupConsensus);
3618     annotationsMenu.add(autoAnnMenu);
3619
3620     /*
3621      * Format menu
3622      */
3623     formatMenu.add(font);
3624     formatMenu.add(seqLimits);
3625     formatMenu.add(wrapMenuItem);
3626     formatMenu.add(scaleAbove);
3627     formatMenu.add(scaleLeft);
3628     formatMenu.add(scaleRight);
3629     formatMenu.add(viewBoxesMenuItem);
3630     formatMenu.add(viewTextMenuItem);
3631     formatMenu.add(colourTextMenuItem);
3632     formatMenu.add(displayNonconservedMenuItem);
3633     formatMenu.add(renderGapsMenuItem);
3634     formatMenu.add(centreColumnLabelFlag);
3635
3636     /*
3637      * Colour menu
3638      */
3639     colourMenu.add(applyToAllGroups);
3640     colourMenu.addSeparator();
3641     colourMenu.add(noColourmenuItem);
3642     colourMenu.add(clustalColour);
3643     colourMenu.add(BLOSUM62Colour);
3644     colourMenu.add(PIDColour);
3645     colourMenu.add(zappoColour);
3646     colourMenu.add(taylorColour);
3647     colourMenu.add(hydrophobicityColour);
3648     colourMenu.add(helixColour);
3649     colourMenu.add(strandColour);
3650     colourMenu.add(turnColour);
3651     colourMenu.add(buriedColour);
3652     colourMenu.add(nucleotideColour);
3653     colourMenu.add(purinePyrimidineColour);
3654     // colourMenu.add(RNAInteractionColour);
3655     colourMenu.add(tcoffeeColour);
3656     colourMenu.add(userDefinedColour);
3657     colourMenu.addSeparator();
3658     colourMenu.add(conservationMenuItem);
3659     colourMenu.add(modifyConservation);
3660     colourMenu.add(abovePIDThreshold);
3661     colourMenu.add(modifyPID);
3662     colourMenu.add(annotationColour);
3663     colourMenu.add(RNAHelixColour);
3664
3665     /*
3666      * Calculate menu
3667      */
3668     sortMenu.add(sortIDMenuItem);
3669     sortMenu.add(sortLengthMenuItem);
3670     sortMenu.add(sortByTreeMenu);
3671     sortMenu.add(sortGroupMenuItem);
3672     sortMenu.add(sortPairwiseMenuItem);
3673     calculateMenu.add(sortMenu);
3674     calculateTreeMenu.add(averageDistanceTreeMenuItem);
3675     calculateTreeMenu.add(neighbourTreeMenuItem);
3676     calculateTreeMenu.add(avDistanceTreeBlosumMenuItem);
3677     calculateTreeMenu.add(njTreeBlosumMenuItem);
3678     calculateMenu.add(calculateTreeMenu);
3679     calculateMenu.addSeparator();
3680     calculateMenu.add(pairwiseAlignmentMenuItem);
3681     calculateMenu.add(PCAMenuItem);
3682     calculateMenu.add(autoCalculate);
3683     calculateMenu.add(sortByTree);
3684
3685     /*
3686      * Help menu
3687      */
3688     helpMenu.add(documentation);
3689     helpMenu.add(about);
3690
3691     /*
3692      * Status bar
3693      */
3694     statusBar.setBackground(Color.white);
3695     statusBar.setFont(new java.awt.Font("Verdana", 0, 11));
3696     statusBar.setText(MessageManager.getString("label.status_bar"));
3697     this.add(statusBar, BorderLayout.SOUTH);
3698   }
3699
3700   public void setStatus(String string)
3701   {
3702     statusBar.setText(string);
3703   };
3704
3705   MenuItem featureSettings = new MenuItem();
3706
3707   CheckboxMenuItem sequenceFeatures = new CheckboxMenuItem();
3708
3709   MenuItem annotationColour = new MenuItem();
3710
3711   MenuItem annotationColumnSelection = new MenuItem();
3712
3713   MenuItem invertColSel = new MenuItem();
3714
3715   MenuItem showColumns = new MenuItem();
3716
3717   MenuItem showSeqs = new MenuItem();
3718
3719   MenuItem hideColumns = new MenuItem();
3720
3721   MenuItem hideSequences = new MenuItem();
3722
3723   MenuItem hideAllButSelection = new MenuItem();
3724
3725   MenuItem hideAllSelection = new MenuItem();
3726
3727   MenuItem showAllHidden = new MenuItem();
3728
3729   MenuItem newView = new MenuItem();
3730
3731   private CheckboxMenuItem showAlignmentAnnotations;
3732
3733   private CheckboxMenuItem showSequenceAnnotations;
3734
3735   private CheckboxMenuItem sortAnnBySequence;
3736
3737   private CheckboxMenuItem sortAnnByLabel;
3738
3739   private CheckboxMenuItem showAutoFirst;
3740
3741   private CheckboxMenuItem showAutoLast;
3742
3743   /**
3744    * Attach the alignFrame panels after embedding menus, if necessary. This used
3745    * to be called setEmbedded, but is now creates the dropdown menus in a
3746    * platform independent manner to avoid OSX/Mac menu appendage daftness.
3747    *
3748    * @param reallyEmbedded
3749    *          true to attach the view to the applet area on the page rather than
3750    *          in a new window
3751    */
3752   public void createAlignFrameWindow(boolean reallyEmbedded)
3753   {
3754     if (reallyEmbedded)
3755     {
3756       embedAlignFrameInApplet(viewport.applet);
3757     }
3758     else
3759     {
3760       // //////
3761       // test and embed menu bar if necessary.
3762       //
3763       if (embedMenuIfNeeded(alignPanel))
3764       {
3765         /*
3766          * adjust for status bar height too. ? pointless as overridden by layout
3767          * manager
3768          */
3769         alignPanel.setSize(getSize().width,
3770                 getSize().height - statusBar.getHeight());
3771       }
3772       add(statusBar, BorderLayout.SOUTH);
3773       add(alignPanel, BorderLayout.CENTER);
3774       // and register with the applet so it can pass external API calls to us
3775       jalview.bin.JalviewLite.addFrame(this, this.getTitle(),
3776               frameWidth,
3777               frameHeight);
3778     }
3779   }
3780
3781   /**
3782    * Add the components of this AlignFrame to the applet container.
3783    *
3784    * @param theApplet
3785    */
3786   public void embedAlignFrameInApplet(final JalviewLite theApplet)
3787   {
3788     // ////
3789     // Explicitly build the embedded menu panel for the on-page applet
3790     //
3791     // view cannot be closed if its actually on the page
3792     fileMenu.remove(closeMenuItem);
3793     fileMenu.remove(3); // Remove Separator
3794     // construct embedded menu, using default font
3795     embeddedMenu = makeEmbeddedPopupMenu(alignFrameMenuBar, false, false);
3796     // and actually add the components to the applet area
3797     theApplet.setLayout(new BorderLayout());
3798     theApplet.add(embeddedMenu, BorderLayout.NORTH);
3799     theApplet.add(statusBar, BorderLayout.SOUTH);
3800     // TODO should size be left to the layout manager?
3801     alignPanel.setSize(theApplet.getSize().width,
3802             theApplet.getSize().height - embeddedMenu.getHeight()
3803                     - statusBar.getHeight());
3804     theApplet.add(alignPanel, BorderLayout.CENTER);
3805     final AlignFrame me = this;
3806     theApplet.addFocusListener(new FocusListener()
3807     {
3808
3809       @Override
3810       public void focusLost(FocusEvent e)
3811       {
3812         if (theApplet.currentAlignFrame == me)
3813         {
3814           theApplet.currentAlignFrame = null;
3815         }
3816       }
3817
3818       @Override
3819       public void focusGained(FocusEvent e)
3820       {
3821         theApplet.currentAlignFrame = me;
3822       }
3823     });
3824     theApplet.validate();
3825   }
3826
3827   /**
3828    * create a new binding between structures in an existing jmol viewer instance
3829    * and an alignpanel with sequences that have existing PDBFile entries. Note,
3830    * this does not open a new Jmol window, or modify the display of the
3831    * structures in the original jmol window. Note This method doesn't work
3832    * without an additional javascript library to exchange messages between the
3833    * distinct applets. See http://issues.jalview.org/browse/JAL-621
3834    *
3835    * @param viewer
3836    *          JmolViewer instance
3837    * @param sequenceIds
3838    *          - sequence Ids to search for associations
3839    */
3840   public SequenceStructureBinding addStructureViewInstance(
3841           Object jmolviewer, String[] sequenceIds)
3842   {
3843     org.jmol.api.JmolViewer viewer = null;
3844     try
3845     {
3846       viewer = (org.jmol.api.JmolViewer) jmolviewer;
3847     } catch (ClassCastException ex)
3848     {
3849       System.err.println("Unsupported viewer object :"
3850               + jmolviewer.getClass());
3851     }
3852     if (viewer == null)
3853     {
3854       System.err.println("Can't use this object as a structure viewer:"
3855               + jmolviewer.getClass());
3856       return null;
3857     }
3858     SequenceI[] seqs = null;
3859     if (sequenceIds == null || sequenceIds.length == 0)
3860     {
3861       seqs = viewport.getAlignment().getSequencesArray();
3862     }
3863     else
3864     {
3865       Vector sqi = new Vector();
3866       AlignmentI al = viewport.getAlignment();
3867       for (int sid = 0; sid < sequenceIds.length; sid++)
3868       {
3869         SequenceI sq = al.findName(sequenceIds[sid]);
3870         if (sq != null)
3871         {
3872           sqi.addElement(sq);
3873         }
3874       }
3875       if (sqi.size() > 0)
3876       {
3877         seqs = new SequenceI[sqi.size()];
3878         for (int sid = 0, sSize = sqi.size(); sid < sSize; sid++)
3879         {
3880           seqs[sid] = (SequenceI) sqi.elementAt(sid);
3881         }
3882       }
3883       else
3884       {
3885         return null;
3886       }
3887     }
3888     AAStructureBindingModel jmv = null;
3889     // TODO: search for a jmv that involves viewer
3890     if (jmv == null)
3891     { // create a new viewer/jalview binding.
3892       jmv = new ExtJmol(viewer, alignPanel, new SequenceI[][]
3893       { seqs });
3894     }
3895     return jmv;
3896
3897   }
3898
3899   /**
3900    * bind a pdb file to a sequence in the current view
3901    *
3902    * @param sequenceId
3903    *          - sequenceId within the dataset.
3904    * @param pdbEntryString
3905    *          - the short name for the PDB file
3906    * @param pdbFile
3907    *          - pdb file - either a URL or a valid PDB file.
3908    * @return true if binding was as success TODO: consider making an exception
3909    *         structure for indicating when PDB parsing or sequenceId location
3910    *         fails.
3911    */
3912   public boolean addPdbFile(String sequenceId, String pdbEntryString,
3913           String pdbFile)
3914   {
3915     SequenceI toaddpdb = viewport.getAlignment().findName(sequenceId);
3916     boolean needtoadd = false;
3917     if (toaddpdb != null)
3918     {
3919       Vector pdbe = toaddpdb.getPDBId();
3920       PDBEntry pdbentry = null;
3921       if (pdbe != null && pdbe.size() > 0)
3922       {
3923         for (int pe = 0, peSize = pdbe.size(); pe < peSize; pe++)
3924         {
3925           pdbentry = (PDBEntry) pdbe.elementAt(pe);
3926           if (!pdbentry.getId().equals(pdbEntryString)
3927                   && !pdbentry.getFile().equals(pdbFile))
3928           {
3929             pdbentry = null;
3930           }
3931           else
3932           {
3933             continue;
3934           }
3935         }
3936       }
3937       if (pdbentry == null)
3938       {
3939         pdbentry = new PDBEntry();
3940         pdbentry.setId(pdbEntryString);
3941         pdbentry.setFile(pdbFile);
3942         needtoadd = true; // add this new entry to sequence.
3943       }
3944       // resolve data source
3945       // TODO: this code should be a refactored to an io package
3946       String protocol = AppletFormatAdapter.resolveProtocol(pdbFile, "PDB");
3947       if (protocol == null)
3948       {
3949         return false;
3950       }
3951       if (needtoadd)
3952       {
3953         // make a note of the access mode and add
3954         if (pdbentry.getProperty() == null)
3955         {
3956           pdbentry.setProperty(new Hashtable());
3957         }
3958         pdbentry.getProperty().put("protocol", protocol);
3959         toaddpdb.addPDBId(pdbentry);
3960         alignPanel.getStructureSelectionManager()
3961                 .registerPDBEntry(pdbentry);
3962       }
3963     }
3964     return true;
3965   }
3966
3967   private Object[] cleanSeqChainArrays(SequenceI[] seqs, String[] chains)
3968   {
3969     if (seqs != null)
3970     {
3971       Vector sequences = new Vector();
3972       for (int i = 0; i < seqs.length; i++)
3973       {
3974         if (seqs[i] != null)
3975         {
3976           sequences.addElement(new Object[]
3977           { seqs[i], (chains != null) ? chains[i] : null });
3978         }
3979       }
3980       seqs = new SequenceI[sequences.size()];
3981       chains = new String[sequences.size()];
3982       for (int i = 0, isize = sequences.size(); i < isize; i++)
3983       {
3984         Object[] oj = (Object[]) sequences.elementAt(i);
3985
3986         seqs[i] = (SequenceI) oj[0];
3987         chains[i] = (String) oj[1];
3988       }
3989     }
3990     return new Object[]
3991     { seqs, chains };
3992
3993   }
3994
3995   public void newStructureView(JalviewLite applet, PDBEntry pdb,
3996           SequenceI[] seqs, String[] chains, String protocol)
3997   {
3998     // Scrub any null sequences from the array
3999     Object[] sqch = cleanSeqChainArrays(seqs, chains);
4000     seqs = (SequenceI[]) sqch[0];
4001     chains = (String[]) sqch[1];
4002     if (seqs == null || seqs.length == 0)
4003     {
4004       System.err
4005               .println("JalviewLite.AlignFrame:newStructureView: No sequence to bind structure to.");
4006     }
4007     if (protocol == null || protocol.trim().length() == 0
4008             || protocol.equals("null"))
4009     {
4010       protocol = (String) pdb.getProperty().get("protocol");
4011       if (protocol == null)
4012       {
4013         System.err.println("Couldn't work out protocol to open structure: "
4014                 + pdb.getId());
4015         return;
4016       }
4017     }
4018     if (applet.useXtrnalSviewer)
4019     {
4020       // register the association(s) and quit, don't create any windows.
4021       if (StructureSelectionManager.getStructureSelectionManager(applet)
4022               .setMapping(seqs, chains, pdb.getFile(), protocol) == null)
4023       {
4024         System.err.println("Failed to map " + pdb.getFile() + " ("
4025                 + protocol + ") to any sequences");
4026       }
4027       return;
4028     }
4029     if (applet.isAlignPdbStructures() && applet.jmolAvailable)
4030     {
4031       // can only do alignments with Jmol
4032       // find the last jmol window assigned to this alignment
4033       jalview.appletgui.AppletJmol ajm = null, tajm;
4034       Vector jmols = applet
4035               .getAppletWindow(jalview.appletgui.AppletJmol.class);
4036       for (int i = 0, iSize = jmols.size(); i < iSize; i++)
4037       {
4038         tajm = (jalview.appletgui.AppletJmol) jmols.elementAt(i);
4039         if (tajm.ap.alignFrame == this)
4040         {
4041           ajm = tajm;
4042           break;
4043         }
4044       }
4045       if (ajm != null)
4046       {
4047         System.err
4048                 .println("Incremental adding and aligning structure to existing Jmol view not yet implemented.");
4049         // try and add the pdb structure
4050         // ajm.addS
4051         ajm = null;
4052       }
4053     }
4054     // otherwise, create a new window
4055     if (applet.jmolAvailable)
4056     {
4057       new jalview.appletgui.AppletJmol(pdb, seqs, chains, alignPanel,
4058               protocol);
4059       applet.lastFrameX += 40;
4060       applet.lastFrameY += 40;
4061     }
4062     else
4063     {
4064       new MCview.AppletPDBViewer(pdb, seqs, chains, alignPanel, protocol);
4065     }
4066
4067   }
4068
4069   public void alignedStructureView(JalviewLite applet, PDBEntry[] pdb,
4070           SequenceI[][] seqs, String[][] chains, String[] protocols)
4071   {
4072     // TODO Auto-generated method stub
4073     System.err.println("Aligned Structure View: Not yet implemented.");
4074   }
4075
4076   /**
4077    * modify the current selection, providing the user has not made a selection
4078    * already.
4079    *
4080    * @param sel
4081    *          - sequences from this alignment
4082    * @param csel
4083    *          - columns to be selected on the alignment
4084    */
4085   public void select(SequenceGroup sel, ColumnSelection csel)
4086   {
4087     alignPanel.seqPanel.selection(sel, csel, null);
4088   }
4089
4090   public void scrollTo(int row, int column)
4091   {
4092     alignPanel.seqPanel.scrollTo(row, column);
4093   }
4094
4095   public void scrollToRow(int row)
4096   {
4097     alignPanel.seqPanel.scrollToRow(row);
4098   }
4099
4100   public void scrollToColumn(int column)
4101   {
4102     alignPanel.seqPanel.scrollToColumn(column);
4103   }
4104
4105   /**
4106    * @return the alignments unique ID.
4107    */
4108   public String getSequenceSetId()
4109   {
4110     return viewport.getSequenceSetId();
4111   }
4112
4113   /**
4114    * Load the (T-Coffee) score file from the specified url
4115    *
4116    * @param source
4117    *          File/URL/T-COFFEE score file contents
4118    * @throws IOException
4119    * @return true if alignment was annotated with data from source
4120    */
4121   public boolean loadScoreFile(String source) throws IOException
4122   {
4123
4124     TCoffeeScoreFile file = new TCoffeeScoreFile(source,
4125             AppletFormatAdapter.checkProtocol(source));
4126     if (!file.isValid())
4127     {
4128       // TODO: raise dialog for gui
4129       System.err.println("Problems parsing T-Coffee scores: "
4130               + file.getWarningMessage());
4131       System.err.println("Origin was:\n" + source);
4132       return false;
4133     }
4134
4135     /*
4136      * check that the score matrix matches the alignment dimensions
4137      */
4138     AlignmentI aln;
4139     if ((aln = viewport.getAlignment()) != null
4140             && (aln.getHeight() != file.getHeight() || aln.getWidth() != file
4141                     .getWidth()))
4142     {
4143       // TODO: raise a dialog box here rather than bomb out.
4144       System.err
4145               .println("The scores matrix does not match the alignment dimensions");
4146
4147     }
4148
4149     // TODO add parameter to indicate if matching should be done
4150     if (file.annotateAlignment(alignPanel.getAlignment(), false))
4151     {
4152       alignPanel.fontChanged();
4153       tcoffeeColour.setEnabled(true);
4154       // switch to this color
4155       changeColour(new TCoffeeColourScheme(alignPanel.getAlignment()));
4156       return true;
4157     }
4158     else
4159     {
4160       System.err.println("Problems resolving T-Coffee scores:");
4161       if (file.getWarningMessage() != null)
4162       {
4163         System.err.println(file.getWarningMessage());
4164       }
4165     }
4166     return false;
4167   }
4168
4169 }