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