src/jalview/appletgui/AlignFrame.java

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