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
  62 import java.awt.BorderLayout;
  63 import java.awt.Canvas;
  64 import java.awt.CheckboxMenuItem;
  65 import java.awt.Color;
  66 import java.awt.Font;
  67 import java.awt.FontMetrics;
  68 import java.awt.Frame;
  69 import java.awt.Graphics;
  70 import java.awt.Label;
  71 import java.awt.Menu;
  72 import java.awt.MenuBar;
  73 import java.awt.MenuItem;
  74 import java.awt.event.ActionEvent;
  75 import java.awt.event.ActionListener;
  76 import java.awt.event.FocusEvent;
  77 import java.awt.event.FocusListener;
  78 import java.awt.event.ItemEvent;
  79 import java.awt.event.ItemListener;
  80 import java.awt.event.KeyEvent;
  81 import java.awt.event.KeyListener;
  82 import java.awt.event.WindowAdapter;
  83 import java.awt.event.WindowEvent;
  84 import java.io.IOException;
  85 import java.net.URL;
  86 import java.net.URLEncoder;
  87 import java.util.Enumeration;
  88 import java.util.Hashtable;
  89 import java.util.List;
  90 import java.util.StringTokenizer;
  91 import java.util.Vector;
  92
  93 public class AlignFrame extends EmbmenuFrame implements ActionListener,
  94         ItemListener, KeyListener
  95 {
  96   public AlignViewControllerI avc;
  97   public AlignmentPanel alignPanel;
  98
  99   public AlignViewport viewport;
 100
 101   int DEFAULT_WIDTH = 700;
 102
 103   int DEFAULT_HEIGHT = 500;
 104
 105   String jalviewServletURL;
 106
 107   public AlignFrame(AlignmentI al, jalview.bin.JalviewLite applet,
 108           String title, boolean embedded)
 109   {
 110     if (applet != null)
 111     {
 112       jalviewServletURL = applet.getParameter("APPLICATION_URL");
 113     }
 114
 115     try
 116     {
 117       jbInit();
 118     } catch (Exception ex)
 119     {
 120       ex.printStackTrace();
 121     }
 122
 123     viewport = new AlignViewport(al, applet);
 124     alignPanel = new AlignmentPanel(this, viewport);
 125     avc = new jalview.controller.AlignViewController(viewport, alignPanel);
 126     viewport.updateConservation(alignPanel);
 127     viewport.updateConsensus(alignPanel);
 128
 129     annotationPanelMenuItem.setState(viewport.showAnnotation);
 130     displayNonconservedMenuItem.setState(viewport.getShowUnconserved());
 131     followMouseOverFlag.setState(viewport.getFollowHighlight());
 132     showGroupConsensus.setState(viewport.isShowGroupConsensus());
 133     showGroupConservation.setState(viewport.isShowGroupConservation());
 134     showConsensusHistogram.setState(viewport.isShowConsensusHistogram());
 135     showSequenceLogo.setState(viewport.isShowSequenceLogo());
 136     normSequenceLogo.setState(viewport.isNormaliseSequenceLogo());
 137
 138     seqLimits.setState(viewport.showJVSuffix);
 139
 140     if (applet != null)
 141     {
 142       String param = applet.getParameter("sortBy");
 143       if (param != null)
 144       {
 145         if (param.equalsIgnoreCase("Id"))
 146         {
 147           sortIDMenuItem_actionPerformed();
 148         }
 149         else if (param.equalsIgnoreCase("Pairwise Identity"))
 150         {
 151           sortPairwiseMenuItem_actionPerformed();
 152         }
 153         else if (param.equalsIgnoreCase("Length"))
 154         {
 155           sortLengthMenuItem_actionPerformed();
 156         }
 157       }
 158
 159       param = applet.getParameter("wrap");
 160       if (param != null)
 161       {
 162         if (param.equalsIgnoreCase("true"))
 163         {
 164           wrapMenuItem.setState(true);
 165           wrapMenuItem_actionPerformed();
 166         }
 167       }
 168       param = applet.getParameter("centrecolumnlabels");
 169       if (param != null)
 170       {
 171         centreColumnLabelFlag.setState(true);
 172         centreColumnLabelFlag_stateChanged();
 173       }
 174       try
 175       {
 176         param = applet.getParameter("windowWidth");
 177         if (param != null)
 178         {
 179           int width = Integer.parseInt(param);
 180           DEFAULT_WIDTH = width;
 181         }
 182         param = applet.getParameter("windowHeight");
 183         if (param != null)
 184         {
 185           int height = Integer.parseInt(param);
 186           DEFAULT_HEIGHT = height;
 187         }
 188       } catch (Exception ex)
 189       {
 190       }
 191
 192     }
 193     if (viewport.getAlignment().isNucleotide())
 194     {
 195       viewport.updateStrucConsensus(alignPanel);
 196       if (viewport.getAlignment().hasRNAStructure())
 197       {
 198         RNAHelixColour.setEnabled(true);
 199       }
 200       else
 201       {
 202         RNAHelixColour.setEnabled(false);
 203       }
 204     }
 205     else
 206     {
 207       RNAHelixColour.setEnabled(false);
 208       purinePyrimidineColour.setEnabled(false);
 209     }
 210     // Some JVMS send keyevents to Top frame or lowest panel,
 211     // Havent worked out why yet. So add to both this frame and seqCanvas for
 212     // now
 213     this.addKeyListener(this);
 214     alignPanel.seqPanel.seqCanvas.addKeyListener(this);
 215     alignPanel.idPanel.idCanvas.addKeyListener(this);
 216     alignPanel.scalePanel.addKeyListener(this);
 217     alignPanel.annotationPanel.addKeyListener(this);
 218     alignPanel.annotationPanelHolder.addKeyListener(this);
 219     alignPanel.annotationSpaceFillerHolder.addKeyListener(this);
 220     alignPanel.alabels.addKeyListener(this);
 221     createAlignFrameWindow(embedded, title);
 222
 223     validate();
 224     alignPanel.adjustAnnotationHeight();
 225     alignPanel.paintAlignment(true);
 226   }
 227
 228   public AlignViewport getAlignViewport()
 229   {
 230     return viewport;
 231   }
 232
 233   public SeqCanvas getSeqcanvas()
 234   {
 235     return alignPanel.seqPanel.seqCanvas;
 236   }
 237
 238   /**
 239    * Load a features file onto the alignment
 240    *
 241    * @param file
 242    *          file URL, content, or other resolvable path
 243    * @param type
 244    *          is protocol for accessing data referred to by file
 245    */
 246
 247   public boolean parseFeaturesFile(String file, String type)
 248   {
 249     return parseFeaturesFile(file, type, true);
 250   }
 251
 252   /**
 253    * Load a features file onto the alignment
 254    *
 255    * @param file
 256    *          file URL, content, or other resolvable path
 257    * @param type
 258    *          is protocol for accessing data referred to by file
 259    * @param autoenabledisplay
 260    *          when true, display features flag will be automatically enabled if
 261    *          features are loaded
 262    * @return true if data parsed as a features file
 263    */
 264   public boolean parseFeaturesFile(String file, String type,
 265           boolean autoenabledisplay)
 266   {
 267     // TODO: test if importing a features file onto an alignment which already
 268     // has features with links overwrites the original links.
 269
 270     Hashtable featureLinks = new Hashtable();
 271     boolean featuresFile = false;
 272     try
 273     {
 274       featuresFile = new jalview.io.FeaturesFile(file, type)
 275               .parse(viewport.getAlignment(), alignPanel.seqPanel.seqCanvas
 276                       .getFeatureRenderer().featureColours, featureLinks,
 277                       true, viewport.applet.getDefaultParameter(
 278                               "relaxedidmatch", false));
 279     } catch (Exception ex)
 280     {
 281       ex.printStackTrace();
 282     }
 283
 284     if (featuresFile)
 285     {
 286       if (featureLinks.size() > 0)
 287       {
 288         alignPanel.seqPanel.seqCanvas.getFeatureRenderer().featureLinks = featureLinks;
 289       }
 290       if (autoenabledisplay)
 291       {
 292         viewport.showSequenceFeatures = true;
 293         sequenceFeatures.setState(true);
 294       }
 295       if (viewport.featureSettings != null)
 296       {
 297         viewport.featureSettings.refreshTable();
 298       }
 299       alignPanel.paintAlignment(true);
 300       statusBar.setText("Successfully added features to alignment.");
 301     }
 302     return featuresFile;
 303   }
 304
 305   @Override
 306   public void keyPressed(KeyEvent evt)
 307   {
 308     if (viewport.cursorMode
 309             && ((evt.getKeyCode() >= KeyEvent.VK_0 && evt.getKeyCode() <= KeyEvent.VK_9) || (evt
 310                     .getKeyCode() >= KeyEvent.VK_NUMPAD0 && evt
 311                     .getKeyCode() <= KeyEvent.VK_NUMPAD9))
 312             && Character.isDigit(evt.getKeyChar()))
 313       alignPanel.seqPanel.numberPressed(evt.getKeyChar());
 314
 315     switch (evt.getKeyCode())
 316     {
 317     case 27: // escape key
 318       deselectAllSequenceMenuItem_actionPerformed();
 319
 320       alignPanel.alabels.cancelDrag();
 321       break;
 322     case KeyEvent.VK_X:
 323       if (evt.isControlDown() || evt.isMetaDown())
 324       {
 325         cut_actionPerformed();
 326       }
 327       break;
 328     case KeyEvent.VK_C:
 329       if (viewport.cursorMode && !evt.isControlDown())
 330       {
 331         alignPanel.seqPanel.setCursorColumn();
 332       }
 333       if (evt.isControlDown() || evt.isMetaDown())
 334       {
 335         copy_actionPerformed();
 336       }
 337       break;
 338     case KeyEvent.VK_V:
 339       if (evt.isControlDown())
 340       {
 341         paste(evt.isShiftDown());
 342       }
 343       break;
 344     case KeyEvent.VK_A:
 345       if (evt.isControlDown() || evt.isMetaDown())
 346       {
 347         selectAllSequenceMenuItem_actionPerformed();
 348       }
 349       break;
 350     case KeyEvent.VK_DOWN:
 351       if (viewport.cursorMode)
 352       {
 353         alignPanel.seqPanel.moveCursor(0, 1);
 354       }
 355       else
 356       {
 357         moveSelectedSequences(false);
 358       }
 359       break;
 360
 361     case KeyEvent.VK_UP:
 362       if (viewport.cursorMode)
 363       {
 364         alignPanel.seqPanel.moveCursor(0, -1);
 365       }
 366       else
 367       {
 368         moveSelectedSequences(true);
 369       }
 370       break;
 371
 372     case KeyEvent.VK_LEFT:
 373       if (evt.isAltDown() || !viewport.cursorMode)
 374         slideSequences(false, alignPanel.seqPanel.getKeyboardNo1());
 375       else
 376         alignPanel.seqPanel.moveCursor(-1, 0);
 377       break;
 378
 379     case KeyEvent.VK_RIGHT:
 380       if (evt.isAltDown() || !viewport.cursorMode)
 381         slideSequences(true, alignPanel.seqPanel.getKeyboardNo1());
 382       else
 383         alignPanel.seqPanel.moveCursor(1, 0);
 384       break;
 385
 386     case KeyEvent.VK_SPACE:
 387       if (viewport.cursorMode)
 388       {
 389         alignPanel.seqPanel.insertGapAtCursor(evt.isControlDown()
 390                 || evt.isShiftDown() || evt.isAltDown());
 391       }
 392       break;
 393
 394     case KeyEvent.VK_DELETE:
 395     case KeyEvent.VK_BACK_SPACE:
 396       if (viewport.cursorMode)
 397       {
 398         alignPanel.seqPanel.deleteGapAtCursor(evt.isControlDown()
 399                 || evt.isShiftDown() || evt.isAltDown());
 400       }
 401       else
 402       {
 403         cut_actionPerformed();
 404         alignPanel.seqPanel.seqCanvas.repaint();
 405       }
 406       break;
 407
 408     case KeyEvent.VK_S:
 409       if (viewport.cursorMode)
 410       {
 411         alignPanel.seqPanel.setCursorRow();
 412       }
 413       break;
 414     case KeyEvent.VK_P:
 415       if (viewport.cursorMode)
 416       {
 417         alignPanel.seqPanel.setCursorPosition();
 418       }
 419       break;
 420
 421     case KeyEvent.VK_ENTER:
 422     case KeyEvent.VK_COMMA:
 423       if (viewport.cursorMode)
 424       {
 425         alignPanel.seqPanel.setCursorRowAndColumn();
 426       }
 427       break;
 428
 429     case KeyEvent.VK_Q:
 430       if (viewport.cursorMode)
 431       {
 432         alignPanel.seqPanel.setSelectionAreaAtCursor(true);
 433       }
 434       break;
 435     case KeyEvent.VK_M:
 436       if (viewport.cursorMode)
 437       {
 438         alignPanel.seqPanel.setSelectionAreaAtCursor(false);
 439       }
 440       break;
 441
 442     case KeyEvent.VK_F2:
 443       viewport.cursorMode = !viewport.cursorMode;
 444       statusBar.setText("Keyboard editing mode is "
 445               + (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, "Alignment Properties: "
 990               + getTitle(), 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, "Cut & Paste Input", 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             "Alignment output - " + 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("Paste your features / annotations / T-coffee score file here.");
1152     cap.setAnnotationImport();
1153     Frame frame = new Frame();
1154     frame.add(cap);
1155     jalview.bin.JalviewLite.addFrame(frame, "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, "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, "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("Undo " + command.getDescription());
1367     }
1368     else
1369     {
1370       undoMenuItem.setEnabled(false);
1371       undoMenuItem.setLabel("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("Redo " + command.getDescription());
1380     }
1381     else
1382     {
1383       redoMenuItem.setEnabled(false);
1384       redoMenuItem.setLabel("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("Removed " + trimRegion.getSize() + " columns.");
2028
2029       addHistoryItem(trimRegion);
2030
2031       for (SequenceGroup sg : viewport.getAlignment().getGroups())
2032       {
2033         if ((trimLeft && !sg.adjustForRemoveLeft(column))
2034                 || (!trimLeft && !sg.adjustForRemoveRight(column)))
2035         {
2036           viewport.getAlignment().deleteGroup(sg);
2037         }
2038       }
2039
2040       viewport.firePropertyChange("alignment", null, viewport
2041               .getAlignment().getSequences());
2042     }
2043   }
2044
2045   public void removeGappedColumnMenuItem_actionPerformed()
2046   {
2047     int start = 0, end = viewport.getAlignment().getWidth() - 1;
2048
2049     SequenceI[] seqs;
2050     if (viewport.getSelectionGroup() != null)
2051     {
2052       seqs = viewport.getSelectionGroup().getSequencesAsArray(
2053               viewport.getHiddenRepSequences());
2054       start = viewport.getSelectionGroup().getStartRes();
2055       end = viewport.getSelectionGroup().getEndRes();
2056     }
2057     else
2058     {
2059       seqs = viewport.getAlignment().getSequencesArray();
2060     }
2061
2062     RemoveGapColCommand removeGapCols = new RemoveGapColCommand(
2063             "Remove Gapped Columns", seqs, start, end,
2064             viewport.getAlignment());
2065
2066     addHistoryItem(removeGapCols);
2067
2068     statusBar.setText("Removed " + removeGapCols.getSize()
2069             + " empty columns.");
2070
2071     // This is to maintain viewport position on first residue
2072     // of first sequence
2073     SequenceI seq = viewport.getAlignment().getSequenceAt(0);
2074     int startRes = seq.findPosition(viewport.startRes);
2075     // ShiftList shifts;
2076     // viewport.getAlignment().removeGaps(shifts=new ShiftList());
2077     // edit.alColumnChanges=shifts.getInverse();
2078     // if (viewport.hasHiddenColumns)
2079     // viewport.getColumnSelection().compensateForEdits(shifts);
2080     viewport.setStartRes(seq.findIndex(startRes) - 1);
2081     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
2082             .getSequences());
2083
2084   }
2085
2086   public void removeAllGapsMenuItem_actionPerformed()
2087   {
2088     int start = 0, end = viewport.getAlignment().getWidth() - 1;
2089
2090     SequenceI[] seqs;
2091     if (viewport.getSelectionGroup() != null)
2092     {
2093       seqs = viewport.getSelectionGroup().getSequencesAsArray(
2094               viewport.getHiddenRepSequences());
2095       start = viewport.getSelectionGroup().getStartRes();
2096       end = viewport.getSelectionGroup().getEndRes();
2097     }
2098     else
2099     {
2100       seqs = viewport.getAlignment().getSequencesArray();
2101     }
2102
2103     // This is to maintain viewport position on first residue
2104     // of first sequence
2105     SequenceI seq = viewport.getAlignment().getSequenceAt(0);
2106     int startRes = seq.findPosition(viewport.startRes);
2107
2108     addHistoryItem(new RemoveGapsCommand("Remove Gaps", seqs, start, end,
2109             viewport.getAlignment()));
2110
2111     viewport.setStartRes(seq.findIndex(startRes) - 1);
2112
2113     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
2114             .getSequences());
2115
2116   }
2117
2118   public void findMenuItem_actionPerformed()
2119   {
2120     new Finder(alignPanel);
2121   }
2122
2123   /**
2124    * create a new view derived from the current view
2125    *
2126    * @param viewtitle
2127    * @return frame for the new view
2128    */
2129   public AlignFrame newView(String viewtitle)
2130   {
2131     AlignmentI newal;
2132     if (viewport.hasHiddenRows())
2133     {
2134       newal = new Alignment(viewport.getAlignment().getHiddenSequences()
2135               .getFullAlignment().getSequencesArray());
2136     }
2137     else
2138     {
2139       newal = new Alignment(viewport.getAlignment().getSequencesArray());
2140     }
2141
2142     if (viewport.getAlignment().getAlignmentAnnotation() != null)
2143     {
2144       for (int i = 0; i < viewport.getAlignment().getAlignmentAnnotation().length; i++)
2145       {
2146         if (!viewport.getAlignment().getAlignmentAnnotation()[i].autoCalculated)
2147         {
2148           newal.addAnnotation(viewport.getAlignment()
2149                   .getAlignmentAnnotation()[i]);
2150         }
2151       }
2152     }
2153
2154     AlignFrame newaf = new AlignFrame(newal, viewport.applet, "", false);
2155
2156     newaf.viewport.setSequenceSetId(alignPanel.av.getSequenceSetId());
2157     PaintRefresher.Register(alignPanel, alignPanel.av.getSequenceSetId());
2158     PaintRefresher.Register(newaf.alignPanel,
2159             newaf.alignPanel.av.getSequenceSetId());
2160
2161     PaintRefresher.Register(newaf.alignPanel.idPanel.idCanvas,
2162             newaf.alignPanel.av.getSequenceSetId());
2163     PaintRefresher.Register(newaf.alignPanel.seqPanel.seqCanvas,
2164             newaf.alignPanel.av.getSequenceSetId());
2165
2166     Vector comps = (Vector) PaintRefresher.components.get(viewport
2167             .getSequenceSetId());
2168     int viewSize = -1;
2169     for (int i = 0; i < comps.size(); i++)
2170     {
2171       if (comps.elementAt(i) instanceof AlignmentPanel)
2172       {
2173         viewSize++;
2174       }
2175     }
2176
2177     String title = new String(this.getTitle());
2178     if (viewtitle != null)
2179     {
2180       title = viewtitle + " ( " + title + ")";
2181     }
2182     else
2183     {
2184       if (title.indexOf("(View") > -1)
2185       {
2186         title = title.substring(0, title.indexOf("(View"));
2187       }
2188       title += "(View " + viewSize + ")";
2189     }
2190
2191     newaf.setTitle(title.toString());
2192
2193     newaf.viewport.historyList = viewport.historyList;
2194     newaf.viewport.redoList = viewport.redoList;
2195     return newaf;
2196   }
2197
2198   /**
2199    *
2200    * @return list of feature groups on the view
2201    */
2202   public String[] getFeatureGroups()
2203   {
2204     FeatureRenderer fr = null;
2205     if (alignPanel != null
2206             && (fr = alignPanel.getFeatureRenderer()) != null)
2207     {
2208       return fr.getGroups();
2209     }
2210     return null;
2211   }
2212
2213   /**
2214    * get sequence feature groups that are hidden or shown
2215    *
2216    * @param visible
2217    *          true is visible
2218    * @return list
2219    */
2220   public String[] getFeatureGroupsOfState(boolean visible)
2221   {
2222     FeatureRenderer fr = null;
2223     if (alignPanel != null
2224             && (fr = alignPanel.getFeatureRenderer()) != null)
2225     {
2226       return fr.getGroups(visible);
2227     }
2228     return null;
2229   }
2230
2231   /**
2232    * Change the display state for the given feature groups
2233    *
2234    * @param groups
2235    *          list of group strings
2236    * @param state
2237    *          visible or invisible
2238    */
2239   public void setFeatureGroupState(String[] groups, boolean state)
2240   {
2241     FeatureRenderer fr = null;
2242     this.sequenceFeatures.setState(true);
2243     viewport.showSequenceFeatures(true);
2244     if (alignPanel != null
2245             && (fr = alignPanel.getFeatureRenderer()) != null)
2246     {
2247       fr.setGroupState(groups, state);
2248       alignPanel.seqPanel.seqCanvas.repaint();
2249       if (alignPanel.overviewPanel != null)
2250       {
2251         alignPanel.overviewPanel.updateOverviewImage();
2252       }
2253     }
2254   }
2255
2256   public void seqLimits_itemStateChanged()
2257   {
2258     viewport.setShowJVSuffix(seqLimits.getState());
2259     alignPanel.fontChanged();
2260     alignPanel.paintAlignment(true);
2261   }
2262
2263   protected void colourTextMenuItem_actionPerformed()
2264   {
2265     viewport.setColourText(colourTextMenuItem.getState());
2266     alignPanel.paintAlignment(true);
2267   }
2268
2269   protected void displayNonconservedMenuItem_actionPerformed()
2270   {
2271     viewport.setShowunconserved(displayNonconservedMenuItem.getState());
2272     alignPanel.paintAlignment(true);
2273   }
2274
2275   protected void wrapMenuItem_actionPerformed()
2276   {
2277     viewport.setWrapAlignment(wrapMenuItem.getState());
2278     alignPanel.setWrapAlignment(wrapMenuItem.getState());
2279     scaleAbove.setEnabled(wrapMenuItem.getState());
2280     scaleLeft.setEnabled(wrapMenuItem.getState());
2281     scaleRight.setEnabled(wrapMenuItem.getState());
2282     alignPanel.paintAlignment(true);
2283   }
2284
2285   public void overviewMenuItem_actionPerformed()
2286   {
2287     if (alignPanel.overviewPanel != null)
2288     {
2289       return;
2290     }
2291
2292     Frame frame = new Frame();
2293     OverviewPanel overview = new OverviewPanel(alignPanel);
2294     frame.add(overview);
2295     // +50 must allow for applet frame window
2296     jalview.bin.JalviewLite.addFrame(frame, "Overview " + this.getTitle(),
2297             overview.getPreferredSize().width,
2298             overview.getPreferredSize().height + 50);
2299
2300     frame.pack();
2301     final AlignmentPanel ap = alignPanel;
2302     frame.addWindowListener(new WindowAdapter()
2303     {
2304       @Override
2305       public void windowClosing(WindowEvent e)
2306       {
2307         if (ap != null)
2308         {
2309           ap.setOverviewPanel(null);
2310         }
2311       };
2312     });
2313
2314     alignPanel.setOverviewPanel(overview);
2315
2316   }
2317
2318   void changeColour(ColourSchemeI cs)
2319   {
2320     int threshold = 0;
2321
2322     if (cs != null)
2323     {
2324       if (viewport.getAbovePIDThreshold())
2325       {
2326         threshold = SliderPanel.setPIDSliderSource(alignPanel, cs,
2327                 "Background");
2328
2329         cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
2330
2331         viewport.setGlobalColourScheme(cs);
2332       }
2333       else
2334       {
2335         cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
2336       }
2337
2338       if (viewport.getConservationSelected())
2339       {
2340
2341         Alignment al = (Alignment) viewport.getAlignment();
2342         Conservation c = new Conservation("All",
2343                 ResidueProperties.propHash, 3, al.getSequences(), 0,
2344                 al.getWidth() - 1);
2345
2346         c.calculate();
2347         c.verdict(false, viewport.getConsPercGaps());
2348
2349         cs.setConservation(c);
2350
2351         cs.setConservationInc(SliderPanel.setConservationSlider(alignPanel,
2352                 cs, "Background"));
2353
2354       }
2355       else
2356       {
2357         cs.setConservation(null);
2358       }
2359
2360       cs.setConsensus(viewport.getSequenceConsensusHash());
2361
2362     }
2363     viewport.setGlobalColourScheme(cs);
2364
2365     if (alignPanel.getOverviewPanel() != null)
2366     {
2367       alignPanel.getOverviewPanel().updateOverviewImage();
2368     }
2369
2370     jalview.structure.StructureSelectionManager
2371             .getStructureSelectionManager(viewport.applet)
2372             .sequenceColoursChanged(alignPanel);
2373
2374     alignPanel.paintAlignment(true);
2375   }
2376
2377   protected void modifyPID_actionPerformed()
2378   {
2379     if (viewport.getAbovePIDThreshold()
2380             && viewport.getGlobalColourScheme() != null)
2381     {
2382       SliderPanel.setPIDSliderSource(alignPanel,
2383               viewport.getGlobalColourScheme(), "Background");
2384       SliderPanel.showPIDSlider();
2385     }
2386   }
2387
2388   protected void modifyConservation_actionPerformed()
2389   {
2390     if (viewport.getConservationSelected()
2391             && viewport.getGlobalColourScheme() != null)
2392     {
2393       SliderPanel.setConservationSlider(alignPanel,
2394               viewport.getGlobalColourScheme(), "Background");
2395       SliderPanel.showConservationSlider();
2396     }
2397   }
2398
2399   protected void conservationMenuItem_actionPerformed()
2400   {
2401     viewport.setConservationSelected(conservationMenuItem.getState());
2402
2403     viewport.setAbovePIDThreshold(false);
2404     abovePIDThreshold.setState(false);
2405
2406     changeColour(viewport.getGlobalColourScheme());
2407
2408     modifyConservation_actionPerformed();
2409   }
2410
2411   public void abovePIDThreshold_actionPerformed()
2412   {
2413     viewport.setAbovePIDThreshold(abovePIDThreshold.getState());
2414
2415     conservationMenuItem.setState(false);
2416     viewport.setConservationSelected(false);
2417
2418     changeColour(viewport.getGlobalColourScheme());
2419
2420     modifyPID_actionPerformed();
2421   }
2422
2423   public void sortPairwiseMenuItem_actionPerformed()
2424   {
2425     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2426     AlignmentSorter.sortByPID(viewport.getAlignment(), viewport
2427             .getAlignment().getSequenceAt(0), null);
2428
2429     addHistoryItem(new OrderCommand("Pairwise Sort", oldOrder,
2430             viewport.getAlignment()));
2431     alignPanel.paintAlignment(true);
2432   }
2433
2434   public void sortIDMenuItem_actionPerformed()
2435   {
2436     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2437     AlignmentSorter.sortByID(viewport.getAlignment());
2438     addHistoryItem(new OrderCommand("ID Sort", oldOrder,
2439             viewport.getAlignment()));
2440     alignPanel.paintAlignment(true);
2441   }
2442
2443   public void sortLengthMenuItem_actionPerformed()
2444   {
2445     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2446     AlignmentSorter.sortByLength(viewport.getAlignment());
2447     addHistoryItem(new OrderCommand("Length Sort", oldOrder,
2448             viewport.getAlignment()));
2449     alignPanel.paintAlignment(true);
2450   }
2451
2452   public void sortGroupMenuItem_actionPerformed()
2453   {
2454     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2455     AlignmentSorter.sortByGroup(viewport.getAlignment());
2456     addHistoryItem(new OrderCommand("Group Sort", oldOrder,
2457             viewport.getAlignment()));
2458     alignPanel.paintAlignment(true);
2459
2460   }
2461
2462   public void removeRedundancyMenuItem_actionPerformed()
2463   {
2464     new RedundancyPanel(alignPanel);
2465   }
2466
2467   public void pairwiseAlignmentMenuItem_actionPerformed()
2468   {
2469     if (viewport.getSelectionGroup() != null
2470             && viewport.getSelectionGroup().getSize() > 1)
2471     {
2472       Frame frame = new Frame();
2473       frame.add(new PairwiseAlignPanel(alignPanel));
2474       jalview.bin.JalviewLite.addFrame(frame, "Pairwise Alignment", 600,
2475               500);
2476     }
2477   }
2478
2479   public void PCAMenuItem_actionPerformed()
2480   {
2481     // are the sequences aligned?
2482     if (!viewport.getAlignment().isAligned(false))
2483     {
2484       SequenceI current;
2485       int Width = viewport.getAlignment().getWidth();
2486
2487       for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
2488       {
2489         current = viewport.getAlignment().getSequenceAt(i);
2490
2491         if (current.getLength() < Width)
2492         {
2493           current.insertCharAt(Width - 1, viewport.getGapCharacter());
2494         }
2495       }
2496       alignPanel.paintAlignment(true);
2497     }
2498
2499     if ((viewport.getSelectionGroup() != null
2500             && viewport.getSelectionGroup().getSize() < 4 && viewport
2501             .getSelectionGroup().getSize() > 0)
2502             || viewport.getAlignment().getHeight() < 4)
2503     {
2504       return;
2505     }
2506
2507     try
2508     {
2509       new PCAPanel(viewport);
2510     } catch (java.lang.OutOfMemoryError ex)
2511     {
2512     }
2513
2514   }
2515
2516   public void averageDistanceTreeMenuItem_actionPerformed()
2517   {
2518     NewTreePanel("AV", "PID", "Average distance tree using PID");
2519   }
2520
2521   public void neighbourTreeMenuItem_actionPerformed()
2522   {
2523     NewTreePanel("NJ", "PID", "Neighbour joining tree using PID");
2524   }
2525
2526   protected void njTreeBlosumMenuItem_actionPerformed()
2527   {
2528     NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62");
2529   }
2530
2531   protected void avTreeBlosumMenuItem_actionPerformed()
2532   {
2533     NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62");
2534   }
2535
2536   void NewTreePanel(String type, String pwType, String title)
2537   {
2538     // are the sequences aligned?
2539     if (!viewport.getAlignment().isAligned(false))
2540     {
2541       SequenceI current;
2542       int Width = viewport.getAlignment().getWidth();
2543
2544       for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
2545       {
2546         current = viewport.getAlignment().getSequenceAt(i);
2547
2548         if (current.getLength() < Width)
2549         {
2550           current.insertCharAt(Width - 1, viewport.getGapCharacter());
2551         }
2552       }
2553       alignPanel.paintAlignment(true);
2554
2555     }
2556
2557     if ((viewport.getSelectionGroup() != null && viewport
2558             .getSelectionGroup().getSize() > 1)
2559             || (viewport.getAlignment().getHeight() > 1))
2560     {
2561       final TreePanel tp = new TreePanel(alignPanel, type, pwType);
2562
2563       addTreeMenuItem(tp, title);
2564
2565       jalview.bin.JalviewLite.addFrame(tp, title, 600, 500);
2566     }
2567   }
2568
2569   void loadTree_actionPerformed()
2570   {
2571     CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
2572     cap.setText("Paste your Newick tree file here.");
2573     cap.setTreeImport();
2574     Frame frame = new Frame();
2575     frame.add(cap);
2576     jalview.bin.JalviewLite.addFrame(frame, "Paste Newick file ", 400, 300);
2577   }
2578
2579   public void loadTree(jalview.io.NewickFile tree, String treeFile)
2580   {
2581     TreePanel tp = new TreePanel(alignPanel, treeFile, "From File - ", tree);
2582     jalview.bin.JalviewLite.addFrame(tp, treeFile, 600, 500);
2583     addTreeMenuItem(tp, treeFile);
2584   }
2585
2586   /**
2587    * sort the alignment using the given treePanel
2588    *
2589    * @param treePanel
2590    *          tree used to sort view
2591    * @param title
2592    *          string used for undo event name
2593    */
2594   public void sortByTree(TreePanel treePanel, String title)
2595   {
2596     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2597     AlignmentSorter
2598             .sortByTree(viewport.getAlignment(), treePanel.getTree());
2599     // addHistoryItem(new HistoryItem("Sort", viewport.alignment,
2600     // HistoryItem.SORT));
2601     addHistoryItem(new OrderCommand("Order by " + title, oldOrder,
2602             viewport.getAlignment()));
2603     alignPanel.paintAlignment(true);
2604   }
2605
2606   /**
2607    * Do any automatic reordering of the alignment and add the necessary bits to
2608    * the menu structure for the new tree
2609    *
2610    * @param treePanel
2611    * @param title
2612    */
2613   protected void addTreeMenuItem(final TreePanel treePanel,
2614           final String title)
2615   {
2616     final MenuItem item = new MenuItem(title);
2617     sortByTreeMenu.add(item);
2618     item.addActionListener(new java.awt.event.ActionListener()
2619     {
2620       @Override
2621       public void actionPerformed(ActionEvent evt)
2622       {
2623         sortByTree(treePanel, title); // treePanel.getTitle());
2624       }
2625     });
2626
2627     treePanel.addWindowListener(new WindowAdapter()
2628     {
2629       @Override
2630       public void windowOpened(WindowEvent e)
2631       {
2632         if (viewport.sortByTree)
2633         {
2634           sortByTree(treePanel, title);
2635         }
2636         super.windowOpened(e);
2637       }
2638
2639       @Override
2640       public void windowClosing(WindowEvent e)
2641       {
2642         sortByTreeMenu.remove(item);
2643       };
2644     });
2645   }
2646
2647   public boolean sortBy(AlignmentOrder alorder, String undoname)
2648   {
2649     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2650     if (viewport.applet.debug)
2651     {
2652       System.err.println("Sorting " + alorder.getOrder().size()
2653               + " in alignment '" + getTitle() + "'");
2654     }
2655     AlignmentSorter.sortBy(viewport.getAlignment(), alorder);
2656     if (undoname != null)
2657     {
2658       addHistoryItem(new OrderCommand(undoname, oldOrder,
2659               viewport.getAlignment()));
2660     }
2661     alignPanel.paintAlignment(true);
2662     return true;
2663   }
2664
2665   protected void documentation_actionPerformed()
2666   {
2667     alignPanel.av.applet.openJalviewHelpUrl();
2668   }
2669
2670   protected void about_actionPerformed()
2671   {
2672
2673     class AboutPanel extends Canvas
2674     {
2675       String version;
2676
2677       String builddate;
2678
2679       public AboutPanel(String version, String builddate)
2680       {
2681         this.version = version;
2682         this.builddate = builddate;
2683       }
2684
2685       @Override
2686       public void paint(Graphics g)
2687       {
2688         g.setColor(Color.white);
2689         g.fillRect(0, 0, getSize().width, getSize().height);
2690         g.setFont(new Font("Helvetica", Font.PLAIN, 12));
2691         FontMetrics fm = g.getFontMetrics();
2692         int fh = fm.getHeight();
2693         int y = 5, x = 7;
2694         g.setColor(Color.black);
2695         // TODO: update this text for each release or centrally store it for
2696         // lite and application
2697         g.setFont(new Font("Helvetica", Font.BOLD, 14));
2698         g.drawString("JalviewLite - Release " + version, x, y += fh);
2699         g.setFont(new Font("Helvetica", Font.BOLD, 12));
2700         g.drawString("Build date: " + builddate, x, y += fh);
2701         g.setFont(new Font("Helvetica", Font.PLAIN, 12));
2702         g.drawString(
2703                 "Authors:  Jim Procter, Andrew Waterhouse, Jan Engelhardt, Lauren Lui,",
2704                 x, y += fh * 1.5);
2705         g.drawString("Michele Clamp, James Cuff, Steve Searle, David Martin & Geoff Barton.", x + 50, y += fh+8);
2706         g.drawString(
2707                 "Development managed by The Barton Group, University of Dundee, Scotland, UK.",
2708                 x, y += fh);
2709         g.drawString(
2710                 "For help, see the FAQ at www.jalview.org and/or join the jalview-discuss@jalview.org mailing list",
2711                 x, y += fh);
2712         g.drawString("If  you use Jalview, please cite:", x, y += fh + 8);
2713         g.drawString(
2714                 "Waterhouse, A.M., Procter, J.B., Martin, D.M.A, Clamp, M. and Barton, G. J. (2009)",
2715                 x, y += fh);
2716         g.drawString(
2717                 "Jalview Version 2 - a multiple sequence alignment editor and analysis workbench",
2718                 x, y += fh);
2719         g.drawString("Bioinformatics doi: 10.1093/bioinformatics/btp033",
2720                 x, y += fh);
2721       }
2722     }
2723
2724     Frame frame = new Frame();
2725     frame.add(new AboutPanel(JalviewLite.getVersion(), JalviewLite
2726             .getBuildDate()));
2727     jalview.bin.JalviewLite.addFrame(frame, "Jalview", 580, 220);
2728
2729   }
2730
2731   public void showURL(String url, String target)
2732   {
2733     if (viewport.applet == null)
2734     {
2735       System.out.println("Not running as applet - no browser available.");
2736     }
2737     else
2738     {
2739       viewport.applet.showURL(url, target);
2740     }
2741   }
2742
2743   // ////////////////////////////////////////////////////////////////////////////////
2744   // JBuilder Graphics here
2745
2746   MenuBar alignFrameMenuBar = new MenuBar();
2747
2748   Menu fileMenu = new Menu("File");
2749
2750   MenuItem loadApplication = new MenuItem("View in Full Application");
2751
2752   MenuItem loadTree = new MenuItem("Load Associated Tree ...");
2753
2754   MenuItem loadAnnotations = new MenuItem("Load Features/Annotations ...");
2755
2756   MenuItem outputFeatures = new MenuItem("Export Features ...");
2757
2758   MenuItem outputAnnotations = new MenuItem("Export Annotations ...");
2759
2760   MenuItem closeMenuItem = new MenuItem("Close");
2761
2762   Menu editMenu = new Menu("Edit");
2763
2764   Menu viewMenu = new Menu("View");
2765
2766   Menu colourMenu = new Menu("Colour");
2767
2768   Menu calculateMenu = new Menu("Calculate");
2769
2770   MenuItem selectAllSequenceMenuItem = new MenuItem("Select all");
2771
2772   MenuItem deselectAllSequenceMenuItem = new MenuItem("Deselect All");
2773
2774   MenuItem invertSequenceMenuItem = new MenuItem("Invert Selection");
2775
2776   MenuItem remove2LeftMenuItem = new MenuItem();
2777
2778   MenuItem remove2RightMenuItem = new MenuItem();
2779
2780   MenuItem removeGappedColumnMenuItem = new MenuItem();
2781
2782   MenuItem removeAllGapsMenuItem = new MenuItem();
2783
2784   CheckboxMenuItem viewBoxesMenuItem = new CheckboxMenuItem();
2785
2786   CheckboxMenuItem viewTextMenuItem = new CheckboxMenuItem();
2787
2788   MenuItem sortPairwiseMenuItem = new MenuItem();
2789
2790   MenuItem sortIDMenuItem = new MenuItem();
2791
2792   MenuItem sortLengthMenuItem = new MenuItem();
2793
2794   MenuItem sortGroupMenuItem = new MenuItem();
2795
2796   MenuItem removeRedundancyMenuItem = new MenuItem();
2797
2798   MenuItem pairwiseAlignmentMenuItem = new MenuItem();
2799
2800   MenuItem PCAMenuItem = new MenuItem();
2801
2802   MenuItem averageDistanceTreeMenuItem = new MenuItem();
2803
2804   MenuItem neighbourTreeMenuItem = new MenuItem();
2805
2806   BorderLayout borderLayout1 = new BorderLayout();
2807
2808   public Label statusBar = new Label();
2809
2810   Menu outputTextboxMenu = new Menu();
2811
2812   MenuItem clustalColour = new MenuItem();
2813
2814   MenuItem zappoColour = new MenuItem();
2815
2816   MenuItem taylorColour = new MenuItem();
2817
2818   MenuItem hydrophobicityColour = new MenuItem();
2819
2820   MenuItem helixColour = new MenuItem();
2821
2822   MenuItem strandColour = new MenuItem();
2823
2824   MenuItem turnColour = new MenuItem();
2825
2826   MenuItem buriedColour = new MenuItem();
2827
2828   MenuItem purinePyrimidineColour = new MenuItem();
2829
2830   MenuItem RNAHelixColour = new MenuItem();
2831
2832   MenuItem userDefinedColour = new MenuItem();
2833
2834   MenuItem PIDColour = new MenuItem();
2835
2836   MenuItem BLOSUM62Colour = new MenuItem();
2837
2838   MenuItem tcoffeeColour = new MenuItem();
2839
2840   MenuItem njTreeBlosumMenuItem = new MenuItem();
2841
2842   MenuItem avDistanceTreeBlosumMenuItem = new MenuItem();
2843
2844   CheckboxMenuItem annotationPanelMenuItem = new CheckboxMenuItem();
2845
2846   CheckboxMenuItem colourTextMenuItem = new CheckboxMenuItem();
2847
2848   CheckboxMenuItem displayNonconservedMenuItem = new CheckboxMenuItem();
2849
2850   MenuItem alProperties = new MenuItem("Alignment Properties...");
2851
2852   MenuItem overviewMenuItem = new MenuItem();
2853
2854   MenuItem undoMenuItem = new MenuItem();
2855
2856   MenuItem redoMenuItem = new MenuItem();
2857
2858   CheckboxMenuItem conservationMenuItem = new CheckboxMenuItem();
2859
2860   MenuItem noColourmenuItem = new MenuItem();
2861
2862   CheckboxMenuItem wrapMenuItem = new CheckboxMenuItem();
2863
2864   CheckboxMenuItem renderGapsMenuItem = new CheckboxMenuItem();
2865
2866   MenuItem findMenuItem = new MenuItem();
2867
2868   CheckboxMenuItem abovePIDThreshold = new CheckboxMenuItem();
2869
2870   MenuItem nucleotideColour = new MenuItem();
2871
2872   MenuItem deleteGroups = new MenuItem();
2873
2874   MenuItem grpsFromSelection = new MenuItem();
2875
2876   MenuItem createGroup = new MenuItem();
2877
2878   MenuItem unGroup = new MenuItem();
2879
2880   MenuItem delete = new MenuItem();
2881
2882   MenuItem copy = new MenuItem();
2883
2884   MenuItem cut = new MenuItem();
2885
2886   Menu pasteMenu = new Menu();
2887
2888   MenuItem pasteNew = new MenuItem();
2889
2890   MenuItem pasteThis = new MenuItem();
2891
2892   CheckboxMenuItem applyToAllGroups = new CheckboxMenuItem();
2893
2894   MenuItem font = new MenuItem();
2895
2896   CheckboxMenuItem scaleAbove = new CheckboxMenuItem();
2897
2898   CheckboxMenuItem scaleLeft = new CheckboxMenuItem();
2899
2900   CheckboxMenuItem scaleRight = new CheckboxMenuItem();
2901
2902   MenuItem modifyPID = new MenuItem();
2903
2904   MenuItem modifyConservation = new MenuItem();
2905
2906   CheckboxMenuItem autoCalculate = new CheckboxMenuItem(
2907           "Autocalculate Consensus", true);
2908
2909   CheckboxMenuItem sortByTree = new CheckboxMenuItem(
2910           "Sort Alignment With New Tree", true);
2911
2912   Menu sortByTreeMenu = new Menu();
2913
2914   Menu sort = new Menu();
2915
2916   Menu calculate = new Menu();
2917
2918   MenuItem inputText = new MenuItem();
2919
2920   Menu helpMenu = new Menu();
2921
2922   MenuItem documentation = new MenuItem();
2923
2924   MenuItem about = new MenuItem();
2925
2926   CheckboxMenuItem seqLimits = new CheckboxMenuItem();
2927
2928   CheckboxMenuItem centreColumnLabelFlag = new CheckboxMenuItem();
2929
2930   CheckboxMenuItem followMouseOverFlag = new CheckboxMenuItem();
2931
2932   Menu autoAnnMenu = new Menu();
2933
2934   CheckboxMenuItem showSequenceLogo = new CheckboxMenuItem();
2935
2936   CheckboxMenuItem applyAutoAnnotationSettings = new CheckboxMenuItem();
2937
2938   CheckboxMenuItem showConsensusHistogram = new CheckboxMenuItem();
2939
2940   CheckboxMenuItem showGroupConsensus = new CheckboxMenuItem();
2941
2942   CheckboxMenuItem showGroupConservation = new CheckboxMenuItem();
2943
2944   CheckboxMenuItem normSequenceLogo = new CheckboxMenuItem();
2945
2946   private void jbInit() throws Exception
2947   {
2948
2949     setMenuBar(alignFrameMenuBar);
2950
2951     MenuItem item;
2952
2953     // dynamically fill save as menu with available formats
2954     for (int i = 0; i < jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS.length; i++)
2955     {
2956
2957       item = new MenuItem(
2958               jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS[i]);
2959
2960       item.addActionListener(new java.awt.event.ActionListener()
2961       {
2962         @Override
2963         public void actionPerformed(ActionEvent e)
2964         {
2965           outputText_actionPerformed(e);
2966         }
2967       });
2968
2969       outputTextboxMenu.add(item);
2970     }
2971     closeMenuItem.addActionListener(this);
2972     loadApplication.addActionListener(this);
2973
2974     loadTree.addActionListener(this);
2975     loadAnnotations.addActionListener(this);
2976     outputFeatures.addActionListener(this);
2977     outputAnnotations.addActionListener(this);
2978     selectAllSequenceMenuItem.addActionListener(this);
2979     deselectAllSequenceMenuItem.addActionListener(this);
2980     invertSequenceMenuItem.addActionListener(this);
2981     remove2LeftMenuItem.setLabel("Remove Left");
2982     remove2LeftMenuItem.addActionListener(this);
2983     remove2RightMenuItem.setLabel("Remove Right");
2984     remove2RightMenuItem.addActionListener(this);
2985     removeGappedColumnMenuItem.setLabel("Remove Empty Columns");
2986     removeGappedColumnMenuItem.addActionListener(this);
2987     removeAllGapsMenuItem.setLabel("Remove All Gaps");
2988     removeAllGapsMenuItem.addActionListener(this);
2989     viewBoxesMenuItem.setLabel("Boxes");
2990     viewBoxesMenuItem.setState(true);
2991     viewBoxesMenuItem.addItemListener(this);
2992     viewTextMenuItem.setLabel("Text");
2993     viewTextMenuItem.setState(true);
2994     viewTextMenuItem.addItemListener(this);
2995     sortPairwiseMenuItem.setLabel("by Pairwise Identity");
2996     sortPairwiseMenuItem.addActionListener(this);
2997     sortIDMenuItem.setLabel("by ID");
2998     sortIDMenuItem.addActionListener(this);
2999     sortLengthMenuItem.setLabel("by Length");
3000     sortLengthMenuItem.addActionListener(this);
3001     sortGroupMenuItem.setLabel("by Group");
3002     sortGroupMenuItem.addActionListener(this);
3003     removeRedundancyMenuItem.setLabel("Remove Redundancy...");
3004     removeRedundancyMenuItem.addActionListener(this);
3005     pairwiseAlignmentMenuItem.setLabel("Pairwise Alignments...");
3006     pairwiseAlignmentMenuItem.addActionListener(this);
3007     PCAMenuItem.setLabel("Principal Component Analysis");
3008     PCAMenuItem.addActionListener(this);
3009     averageDistanceTreeMenuItem
3010             .setLabel("Average Distance Using % Identity");
3011     averageDistanceTreeMenuItem.addActionListener(this);
3012     neighbourTreeMenuItem.setLabel("Neighbour Joining Using % Identity");
3013     neighbourTreeMenuItem.addActionListener(this);
3014     statusBar.setBackground(Color.white);
3015     statusBar.setFont(new java.awt.Font("Verdana", 0, 11));
3016     statusBar.setText("Status bar");
3017     outputTextboxMenu.setLabel("Output to Textbox");
3018     clustalColour.setLabel("Clustalx");
3019
3020     clustalColour.addActionListener(this);
3021     zappoColour.setLabel("Zappo");
3022     zappoColour.addActionListener(this);
3023     taylorColour.setLabel("Taylor");
3024     taylorColour.addActionListener(this);
3025     hydrophobicityColour.setLabel("Hydrophobicity");
3026     hydrophobicityColour.addActionListener(this);
3027     helixColour.setLabel("Helix Propensity");
3028     helixColour.addActionListener(this);
3029     strandColour.setLabel("Strand Propensity");
3030     strandColour.addActionListener(this);
3031     turnColour.setLabel("Turn Propensity");
3032     turnColour.addActionListener(this);
3033     buriedColour.setLabel("Buried Index");
3034     buriedColour.addActionListener(this);
3035     purinePyrimidineColour.setLabel("Purine/Pyrimidine");
3036     purinePyrimidineColour.addActionListener(this);
3037     RNAHelixColour.setLabel("by RNA Helices");
3038     RNAHelixColour.addActionListener(this);
3039     userDefinedColour.setLabel("User Defined...");
3040     userDefinedColour.addActionListener(this);
3041     PIDColour.setLabel("Percentage Identity");
3042     PIDColour.addActionListener(this);
3043     BLOSUM62Colour.setLabel("BLOSUM62 Score");
3044     BLOSUM62Colour.addActionListener(this);
3045     tcoffeeColour.setLabel("T-Coffee Scores");
3046     tcoffeeColour.setEnabled(false); // it will enabled only if a score file is
3047                                      // provided
3048     tcoffeeColour.addActionListener(this);
3049     avDistanceTreeBlosumMenuItem
3050             .setLabel("Average Distance Using BLOSUM62");
3051     avDistanceTreeBlosumMenuItem.addActionListener(this);
3052     njTreeBlosumMenuItem.setLabel("Neighbour Joining Using BLOSUM62");
3053     njTreeBlosumMenuItem.addActionListener(this);
3054     annotationPanelMenuItem.setLabel("Show Annotations");
3055     annotationPanelMenuItem.addItemListener(this);
3056     colourTextMenuItem.setLabel("Colour Text");
3057     colourTextMenuItem.addItemListener(this);
3058     displayNonconservedMenuItem.setLabel("Show nonconserved");
3059     displayNonconservedMenuItem.addItemListener(this);
3060     alProperties.addActionListener(this);
3061     overviewMenuItem.setLabel("Overview Window");
3062     overviewMenuItem.addActionListener(this);
3063     undoMenuItem.setEnabled(false);
3064     undoMenuItem.setLabel("Undo");
3065     undoMenuItem.addActionListener(this);
3066     redoMenuItem.setEnabled(false);
3067     redoMenuItem.setLabel("Redo");
3068     redoMenuItem.addActionListener(this);
3069     conservationMenuItem.setLabel("by Conservation");
3070     conservationMenuItem.addItemListener(this);
3071     noColourmenuItem.setLabel("None");
3072     noColourmenuItem.addActionListener(this);
3073     wrapMenuItem.setLabel("Wrap");
3074     wrapMenuItem.addItemListener(this);
3075     renderGapsMenuItem.setLabel("Show Gaps");
3076     renderGapsMenuItem.setState(true);
3077     renderGapsMenuItem.addItemListener(this);
3078     findMenuItem.setLabel("Find...");
3079     findMenuItem.addActionListener(this);
3080     abovePIDThreshold.setLabel("Above Identity Threshold");
3081     abovePIDThreshold.addItemListener(this);
3082     nucleotideColour.setLabel("Nucleotide");
3083     nucleotideColour.addActionListener(this);
3084     deleteGroups.setLabel("Undefine Groups");
3085     deleteGroups.addActionListener(this);
3086     grpsFromSelection.setLabel("Make Groups For Selection");
3087     grpsFromSelection.addActionListener(this);
3088     createGroup.setLabel("Create Group");
3089     unGroup.setLabel("Remove Group");
3090     copy.setLabel("Copy");
3091     copy.addActionListener(this);
3092     cut.setLabel("Cut");
3093     cut.addActionListener(this);
3094     delete.setLabel("Delete");
3095     delete.addActionListener(this);
3096     pasteMenu.setLabel("Paste");
3097     pasteNew.setLabel("To New Alignment");
3098     pasteNew.addActionListener(this);
3099     pasteThis.setLabel("Add To This Alignment");
3100     pasteThis.addActionListener(this);
3101     applyToAllGroups.setLabel("Apply Colour To All Groups");
3102     applyToAllGroups.setState(true);
3103     applyToAllGroups.addItemListener(this);
3104     font.setLabel("Font...");
3105     font.addActionListener(this);
3106     scaleAbove.setLabel("Scale Above");
3107     scaleAbove.setState(true);
3108     scaleAbove.setEnabled(false);
3109     scaleAbove.addItemListener(this);
3110     scaleLeft.setEnabled(false);
3111     scaleLeft.setState(true);
3112     scaleLeft.setLabel("Scale Left");
3113     scaleLeft.addItemListener(this);
3114     scaleRight.setEnabled(false);
3115     scaleRight.setState(true);
3116     scaleRight.setLabel("Scale Right");
3117     scaleRight.addItemListener(this);
3118     modifyPID.setLabel("Modify Identity Threshold...");
3119     modifyPID.addActionListener(this);
3120     modifyConservation.setLabel("Modify Conservation Threshold...");
3121     modifyConservation.addActionListener(this);
3122     sortByTreeMenu.setLabel("By Tree Order");
3123     sort.setLabel("Sort");
3124     calculate.setLabel("Calculate Tree");
3125     autoCalculate.addItemListener(this);
3126     sortByTree.addItemListener(this);
3127     inputText.setLabel("Input from textbox");
3128     inputText.addActionListener(this);
3129     centreColumnLabelFlag.setLabel("Centre column labels");
3130     centreColumnLabelFlag.addItemListener(this);
3131     followMouseOverFlag.setLabel("Automatic Scrolling");
3132     followMouseOverFlag.addItemListener(this);
3133     helpMenu.setLabel("Help");
3134     documentation.setLabel("Documentation");
3135     documentation.addActionListener(this);
3136
3137     about.setLabel("About...");
3138     about.addActionListener(this);
3139     seqLimits.setState(true);
3140     seqLimits.setLabel("Show Sequence Limits");
3141     seqLimits.addItemListener(this);
3142     featureSettings.setLabel("Feature Settings...");
3143     featureSettings.addActionListener(this);
3144     sequenceFeatures.setLabel("Sequence Features");
3145     sequenceFeatures.addItemListener(this);
3146     sequenceFeatures.setState(false);
3147     annotationColour.setLabel("by Annotation...");
3148     annotationColour.addActionListener(this);
3149     invertSequenceMenuItem.setLabel("Invert Sequence Selection");
3150     invertColSel.setLabel("Invert Column Selection");
3151     menu1.setLabel("Show");
3152     showColumns.setLabel("All Columns ");
3153     showSeqs.setLabel("All Sequences");
3154     menu2.setLabel("Hide");
3155     hideColumns.setLabel("Selected Columns");
3156     hideSequences.setLabel("Selected Sequences");
3157     hideAllButSelection.setLabel("All but Selected Region (Shift+Ctrl+H)");
3158     hideAllSelection.setLabel("Selected Region");
3159     showAllHidden.setLabel("All Sequences and Columns");
3160     showGroupConsensus.setLabel("Group Consensus");
3161     showGroupConservation.setLabel("Group Conservation");
3162     showConsensusHistogram.setLabel("Show Consensus Histogram");
3163     showSequenceLogo.setLabel("Show Consensus Logo");
3164     normSequenceLogo.setLabel("Normalise Consensus Logo");
3165     applyAutoAnnotationSettings.setLabel("Apply to all groups");
3166     applyAutoAnnotationSettings.setState(true);
3167     autoAnnMenu.setLabel("Autocalculated Annotation");
3168
3169     invertColSel.addActionListener(this);
3170     showColumns.addActionListener(this);
3171     showSeqs.addActionListener(this);
3172     hideColumns.addActionListener(this);
3173     hideSequences.addActionListener(this);
3174     hideAllButSelection.addActionListener(this);
3175     hideAllSelection.addActionListener(this);
3176     showAllHidden.addActionListener(this);
3177     showGroupConsensus.addItemListener(this);
3178     showGroupConservation.addItemListener(this);
3179     showConsensusHistogram.addItemListener(this);
3180     showSequenceLogo.addItemListener(this);
3181     normSequenceLogo.addItemListener(this);
3182
3183     applyAutoAnnotationSettings.addItemListener(this);
3184     formatMenu.setLabel("Format");
3185     selectMenu.setLabel("Select");
3186     newView.setLabel("New View");
3187     newView.addActionListener(this);
3188     alignFrameMenuBar.add(fileMenu);
3189     alignFrameMenuBar.add(editMenu);
3190     alignFrameMenuBar.add(selectMenu);
3191     alignFrameMenuBar.add(viewMenu);
3192     alignFrameMenuBar.add(formatMenu);
3193     alignFrameMenuBar.add(colourMenu);
3194     alignFrameMenuBar.add(calculateMenu);
3195     alignFrameMenuBar.add(helpMenu);
3196
3197     fileMenu.add(inputText);
3198     fileMenu.add(loadTree);
3199     fileMenu.add(loadAnnotations);
3200
3201     fileMenu.addSeparator();
3202     fileMenu.add(outputTextboxMenu);
3203     fileMenu.add(outputFeatures);
3204     fileMenu.add(outputAnnotations);
3205
3206     if (jalviewServletURL != null)
3207     {
3208       fileMenu.add(loadApplication);
3209     }
3210
3211     fileMenu.addSeparator();
3212     fileMenu.add(closeMenuItem);
3213
3214     editMenu.add(undoMenuItem);
3215     editMenu.add(redoMenuItem);
3216     editMenu.add(cut);
3217     editMenu.add(copy);
3218     editMenu.add(pasteMenu);
3219     editMenu.add(delete);
3220     editMenu.addSeparator();
3221     editMenu.add(remove2LeftMenuItem);
3222     editMenu.add(remove2RightMenuItem);
3223     editMenu.add(removeGappedColumnMenuItem);
3224     editMenu.add(removeAllGapsMenuItem);
3225     editMenu.add(removeRedundancyMenuItem);
3226     viewMenu.add(newView);
3227     viewMenu.addSeparator();
3228     viewMenu.add(menu1);
3229     viewMenu.add(menu2);
3230     viewMenu.addSeparator();
3231     viewMenu.add(followMouseOverFlag);
3232     viewMenu.add(annotationPanelMenuItem);
3233     autoAnnMenu.add(applyAutoAnnotationSettings);
3234     autoAnnMenu.add(showConsensusHistogram);
3235     autoAnnMenu.add(showSequenceLogo);
3236     autoAnnMenu.add(normSequenceLogo);
3237     autoAnnMenu.addSeparator();
3238     autoAnnMenu.add(showGroupConservation);
3239     autoAnnMenu.add(showGroupConsensus);
3240     viewMenu.add(autoAnnMenu);
3241     viewMenu.addSeparator();
3242     viewMenu.add(sequenceFeatures);
3243     viewMenu.add(featureSettings);
3244     viewMenu.addSeparator();
3245     viewMenu.add(alProperties);
3246     viewMenu.addSeparator();
3247     viewMenu.add(overviewMenuItem);
3248     colourMenu.add(applyToAllGroups);
3249     colourMenu.addSeparator();
3250     colourMenu.add(noColourmenuItem);
3251     colourMenu.add(clustalColour);
3252     colourMenu.add(BLOSUM62Colour);
3253     colourMenu.add(PIDColour);
3254     colourMenu.add(zappoColour);
3255     colourMenu.add(taylorColour);
3256     colourMenu.add(hydrophobicityColour);
3257     colourMenu.add(helixColour);
3258     colourMenu.add(strandColour);
3259     colourMenu.add(turnColour);
3260     colourMenu.add(buriedColour);
3261     colourMenu.add(nucleotideColour);
3262     colourMenu.add(purinePyrimidineColour);
3263     colourMenu.add(tcoffeeColour);
3264     colourMenu.add(userDefinedColour);
3265     colourMenu.addSeparator();
3266     colourMenu.add(conservationMenuItem);
3267     colourMenu.add(modifyConservation);
3268     colourMenu.add(abovePIDThreshold);
3269     colourMenu.add(modifyPID);
3270     colourMenu.add(annotationColour);
3271     colourMenu.add(RNAHelixColour);
3272     calculateMenu.add(sort);
3273     calculateMenu.add(calculate);
3274     calculateMenu.addSeparator();
3275     calculateMenu.add(pairwiseAlignmentMenuItem);
3276     calculateMenu.add(PCAMenuItem);
3277     calculateMenu.add(autoCalculate);
3278     calculateMenu.add(sortByTree);
3279     this.add(statusBar, BorderLayout.SOUTH);
3280     pasteMenu.add(pasteNew);
3281     pasteMenu.add(pasteThis);
3282     sort.add(sortIDMenuItem);
3283     sort.add(sortLengthMenuItem);
3284     sort.add(sortByTreeMenu);
3285     sort.add(sortGroupMenuItem);
3286     sort.add(sortPairwiseMenuItem);
3287     calculate.add(averageDistanceTreeMenuItem);
3288     calculate.add(neighbourTreeMenuItem);
3289     calculate.add(avDistanceTreeBlosumMenuItem);
3290     calculate.add(njTreeBlosumMenuItem);
3291     helpMenu.add(documentation);
3292     helpMenu.add(about);
3293     menu1.add(showColumns);
3294     menu1.add(showSeqs);
3295     menu1.add(showAllHidden);
3296     menu2.add(hideColumns);
3297     menu2.add(hideSequences);
3298     menu2.add(hideAllSelection);
3299     menu2.add(hideAllButSelection);
3300     formatMenu.add(font);
3301     formatMenu.add(seqLimits);
3302     formatMenu.add(wrapMenuItem);
3303     formatMenu.add(scaleAbove);
3304     formatMenu.add(scaleLeft);
3305     formatMenu.add(scaleRight);
3306     formatMenu.add(viewBoxesMenuItem);
3307     formatMenu.add(viewTextMenuItem);
3308     formatMenu.add(colourTextMenuItem);
3309     formatMenu.add(displayNonconservedMenuItem);
3310     formatMenu.add(renderGapsMenuItem);
3311     formatMenu.add(centreColumnLabelFlag);
3312     selectMenu.add(findMenuItem);
3313     selectMenu.addSeparator();
3314     selectMenu.add(selectAllSequenceMenuItem);
3315     selectMenu.add(deselectAllSequenceMenuItem);
3316     selectMenu.add(invertSequenceMenuItem);
3317     selectMenu.add(invertColSel);
3318     selectMenu.add(createGroup);
3319     selectMenu.add(unGroup);
3320     selectMenu.add(grpsFromSelection);
3321     selectMenu.add(deleteGroups);
3322
3323   }
3324
3325   MenuItem featureSettings = new MenuItem();
3326
3327   CheckboxMenuItem sequenceFeatures = new CheckboxMenuItem();
3328
3329   MenuItem annotationColour = new MenuItem();
3330
3331   MenuItem invertColSel = new MenuItem();
3332
3333   Menu menu1 = new Menu();
3334
3335   MenuItem showColumns = new MenuItem();
3336
3337   MenuItem showSeqs = new MenuItem();
3338
3339   Menu menu2 = new Menu();
3340
3341   MenuItem hideColumns = new MenuItem();
3342
3343   MenuItem hideSequences = new MenuItem();
3344
3345   MenuItem hideAllButSelection = new MenuItem();
3346
3347   MenuItem hideAllSelection = new MenuItem();
3348
3349   MenuItem showAllHidden = new MenuItem();
3350
3351   Menu formatMenu = new Menu();
3352
3353   Menu selectMenu = new Menu();
3354
3355   MenuItem newView = new MenuItem();
3356
3357   /**
3358    * Attach the alignFrame panels after embedding menus, if necessary. This used
3359    * to be called setEmbedded, but is now creates the dropdown menus in a
3360    * platform independent manner to avoid OSX/Mac menu appendage daftness.
3361    *
3362    * @param reallyEmbedded
3363    *          true to attach the view to the applet area on the page rather than
3364    *          in a new window
3365    */
3366   public void createAlignFrameWindow(boolean reallyEmbedded, String title)
3367   {
3368     if (reallyEmbedded)
3369     {
3370       // ////
3371       // Explicly build the embedded menu panel for the on-page applet
3372       //
3373       // view cannot be closed if its actually on the page
3374       fileMenu.remove(closeMenuItem);
3375       fileMenu.remove(3); // Remove Seperator
3376       embeddedMenu = makeEmbeddedPopupMenu(alignFrameMenuBar, "Arial",
3377               Font.PLAIN, 10, false); // use our own fonts.
3378       // and actually add the components to the applet area
3379       viewport.applet.setLayout(new BorderLayout());
3380       viewport.applet.add(embeddedMenu, BorderLayout.NORTH);
3381       viewport.applet.add(statusBar, BorderLayout.SOUTH);
3382       alignPanel.setSize(viewport.applet.getSize().width,
3383               viewport.applet.getSize().height - embeddedMenu.HEIGHT
3384                       - statusBar.HEIGHT);
3385       viewport.applet.add(alignPanel, BorderLayout.CENTER);
3386       final AlignFrame me = this;
3387       viewport.applet.addFocusListener(new FocusListener()
3388       {
3389
3390         @Override
3391         public void focusLost(FocusEvent e)
3392         {
3393           if (me.viewport.applet.currentAlignFrame == me)
3394           {
3395             me.viewport.applet.currentAlignFrame = null;
3396           }
3397         }
3398
3399         @Override
3400         public void focusGained(FocusEvent e)
3401         {
3402           me.viewport.applet.currentAlignFrame = me;
3403         }
3404       });
3405       viewport.applet.validate();
3406     }
3407     else
3408     {
3409       // //////
3410       // test and embed menu bar if necessary.
3411       //
3412       if (embedMenuIfNeeded(alignPanel))
3413       {
3414         // adjust for status bar height too
3415         alignPanel.setSize(getSize().width, getSize().height
3416                 - statusBar.HEIGHT);
3417       }
3418       add(statusBar, BorderLayout.SOUTH);
3419       add(alignPanel, BorderLayout.CENTER);
3420       // and register with the applet so it can pass external API calls to us
3421       jalview.bin.JalviewLite.addFrame(this, title, DEFAULT_WIDTH,
3422               DEFAULT_HEIGHT);
3423     }
3424   }
3425
3426   /**
3427    * create a new binding between structures in an existing jmol viewer instance
3428    * and an alignpanel with sequences that have existing PDBFile entries. Note,
3429    * this does not open a new Jmol window, or modify the display of the
3430    * structures in the original jmol window. Note This method doesn't work
3431    * without an additional javascript library to exchange messages between the
3432    * distinct applets. See http://issues.jalview.org/browse/JAL-621
3433    *
3434    * @param viewer
3435    *          JmolViewer instance
3436    * @param sequenceIds
3437    *          - sequence Ids to search for associations
3438    */
3439   public SequenceStructureBinding addStructureViewInstance(
3440           Object jmolviewer, String[] sequenceIds)
3441   {
3442     org.jmol.api.JmolViewer viewer = null;
3443     try
3444     {
3445       viewer = (org.jmol.api.JmolViewer) jmolviewer;
3446     } catch (ClassCastException ex)
3447     {
3448       System.err.println("Unsupported viewer object :"
3449               + jmolviewer.getClass());
3450     }
3451     if (viewer == null)
3452     {
3453       System.err.println("Can't use this object as a structure viewer:"
3454               + jmolviewer.getClass());
3455       return null;
3456     }
3457     SequenceI[] seqs = null;
3458     if (sequenceIds == null || sequenceIds.length == 0)
3459     {
3460       seqs = viewport.getAlignment().getSequencesArray();
3461     }
3462     else
3463     {
3464       Vector sqi = new Vector();
3465       AlignmentI al = viewport.getAlignment();
3466       for (int sid = 0; sid < sequenceIds.length; sid++)
3467       {
3468         SequenceI sq = al.findName(sequenceIds[sid]);
3469         if (sq != null)
3470         {
3471           sqi.addElement(sq);
3472         }
3473       }
3474       if (sqi.size() > 0)
3475       {
3476         seqs = new SequenceI[sqi.size()];
3477         for (int sid = 0, sSize = sqi.size(); sid < sSize; sid++)
3478         {
3479           seqs[sid] = (SequenceI) sqi.elementAt(sid);
3480         }
3481       }
3482       else
3483       {
3484         return null;
3485       }
3486     }
3487     ExtJmol jmv = null;
3488     // TODO: search for a jmv that involves viewer
3489     if (jmv == null)
3490     { // create a new viewer/jalview binding.
3491       jmv = new ExtJmol(viewer, alignPanel, new SequenceI[][]
3492       { seqs });
3493     }
3494     return jmv;
3495
3496   }
3497
3498   /**
3499    * bind a pdb file to a sequence in the current view
3500    *
3501    * @param sequenceId
3502    *          - sequenceId within the dataset.
3503    * @param pdbEntryString
3504    *          - the short name for the PDB file
3505    * @param pdbFile
3506    *          - pdb file - either a URL or a valid PDB file.
3507    * @return true if binding was as success TODO: consider making an exception
3508    *         structure for indicating when PDB parsing or sequenceId location
3509    *         fails.
3510    */
3511   public boolean addPdbFile(String sequenceId, String pdbEntryString,
3512           String pdbFile)
3513   {
3514     SequenceI toaddpdb = viewport.getAlignment().findName(sequenceId);
3515     boolean needtoadd = false;
3516     if (toaddpdb != null)
3517     {
3518       Vector pdbe = toaddpdb.getPDBId();
3519       PDBEntry pdbentry = null;
3520       if (pdbe != null && pdbe.size() > 0)
3521       {
3522         for (int pe = 0, peSize = pdbe.size(); pe < peSize; pe++)
3523         {
3524           pdbentry = (PDBEntry) pdbe.elementAt(pe);
3525           if (!pdbentry.getId().equals(pdbEntryString)
3526                   && !pdbentry.getFile().equals(pdbFile))
3527           {
3528             pdbentry = null;
3529           }
3530           else
3531           {
3532             continue;
3533           }
3534         }
3535       }
3536       if (pdbentry == null)
3537       {
3538         pdbentry = new PDBEntry();
3539         pdbentry.setId(pdbEntryString);
3540         pdbentry.setFile(pdbFile);
3541         needtoadd = true; // add this new entry to sequence.
3542       }
3543       // resolve data source
3544       // TODO: this code should be a refactored to an io package
3545       String protocol = AppletFormatAdapter.resolveProtocol(pdbFile, "PDB");
3546       if (protocol == null)
3547       {
3548         return false;
3549       }
3550       if (needtoadd)
3551       {
3552         // make a note of the access mode and add
3553         if (pdbentry.getProperty() == null)
3554         {
3555           pdbentry.setProperty(new Hashtable());
3556         }
3557         pdbentry.getProperty().put("protocol", protocol);
3558         toaddpdb.addPDBId(pdbentry);
3559       }
3560     }
3561     return true;
3562   }
3563
3564   private Object[] cleanSeqChainArrays(SequenceI[] seqs, String[] chains)
3565   {
3566     if (seqs != null)
3567     {
3568       Vector sequences = new Vector();
3569       for (int i = 0; i < seqs.length; i++)
3570       {
3571         if (seqs[i] != null)
3572         {
3573           sequences.addElement(new Object[]
3574           { seqs[i], (chains != null) ? chains[i] : null });
3575         }
3576       }
3577       seqs = new SequenceI[sequences.size()];
3578       chains = new String[sequences.size()];
3579       for (int i = 0, isize = sequences.size(); i < isize; i++)
3580       {
3581         Object[] oj = (Object[]) sequences.elementAt(i);
3582
3583         seqs[i] = (SequenceI) oj[0];
3584         chains[i] = (String) oj[1];
3585       }
3586     }
3587     return new Object[]
3588     { seqs, chains };
3589
3590   }
3591
3592   public void newStructureView(JalviewLite applet, PDBEntry pdb,
3593           SequenceI[] seqs, String[] chains, String protocol)
3594   {
3595     // Scrub any null sequences from the array
3596     Object[] sqch = cleanSeqChainArrays(seqs, chains);
3597     seqs = (SequenceI[]) sqch[0];
3598     chains = (String[]) sqch[1];
3599     if (seqs == null || seqs.length == 0)
3600     {
3601       System.err
3602               .println("JalviewLite.AlignFrame:newStructureView: No sequence to bind structure to.");
3603     }
3604     if (protocol == null || protocol.trim().length() == 0
3605             || protocol.equals("null"))
3606     {
3607       protocol = (String) pdb.getProperty().get("protocol");
3608       if (protocol == null)
3609       {
3610         System.err.println("Couldn't work out protocol to open structure: "
3611                 + pdb.getId());
3612         return;
3613       }
3614     }
3615     if (applet.useXtrnalSviewer)
3616     {
3617       // register the association(s) and quit, don't create any windows.
3618       if (StructureSelectionManager.getStructureSelectionManager(applet)
3619               .setMapping(seqs, chains, pdb.getFile(), protocol) == null)
3620       {
3621         System.err.println("Failed to map " + pdb.getFile() + " ("
3622                 + protocol + ") to any sequences");
3623       }
3624       return;
3625     }
3626     if (applet.isAlignPdbStructures() && applet.jmolAvailable)
3627     {
3628       // can only do alignments with Jmol
3629       // find the last jmol window assigned to this alignment
3630       jalview.appletgui.AppletJmol ajm = null, tajm;
3631       Vector jmols = applet
3632               .getAppletWindow(jalview.appletgui.AppletJmol.class);
3633       for (int i = 0, iSize = jmols.size(); i < iSize; i++)
3634       {
3635         tajm = (jalview.appletgui.AppletJmol) jmols.elementAt(i);
3636         if (tajm.ap.alignFrame == this)
3637         {
3638           ajm = tajm;
3639           break;
3640         }
3641       }
3642       if (ajm != null)
3643       {
3644         System.err
3645                 .println("Incremental adding and aligning structure to existing Jmol view not yet implemented.");
3646         // try and add the pdb structure
3647         // ajm.addS
3648         ajm = null;
3649       }
3650     }
3651     // otherwise, create a new window
3652     if (applet.jmolAvailable)
3653     {
3654       new jalview.appletgui.AppletJmol(pdb, seqs, chains, alignPanel,
3655               protocol);
3656       applet.lastFrameX += 40;
3657       applet.lastFrameY += 40;
3658     }
3659     else
3660     {
3661       new MCview.AppletPDBViewer(pdb, seqs, chains, alignPanel, protocol);
3662     }
3663
3664   }
3665
3666   public void alignedStructureView(JalviewLite applet, PDBEntry[] pdb,
3667           SequenceI[][] seqs, String[][] chains, String[] protocols)
3668   {
3669     // TODO Auto-generated method stub
3670     System.err.println("Aligned Structure View: Not yet implemented.");
3671   }
3672
3673   /**
3674    * modify the current selection, providing the user has not made a selection
3675    * already.
3676    *
3677    * @param sel
3678    *          - sequences from this alignment
3679    * @param csel
3680    *          - columns to be selected on the alignment
3681    */
3682   public void select(SequenceGroup sel, ColumnSelection csel)
3683   {
3684     alignPanel.seqPanel.selection(sel, csel, null);
3685   }
3686
3687   public void scrollTo(int row, int column)
3688   {
3689     alignPanel.seqPanel.scrollTo(row, column);
3690   }
3691
3692   public void scrollToRow(int row)
3693   {
3694     alignPanel.seqPanel.scrollToRow(row);
3695   }
3696
3697   public void scrollToColumn(int column)
3698   {
3699     alignPanel.seqPanel.scrollToColumn(column);
3700   }
3701
3702   /**
3703    * @return the alignments unique ID.
3704    */
3705   public String getSequenceSetId()
3706   {
3707     return viewport.getSequenceSetId();
3708   }
3709
3710   /**
3711    * Load the (T-Coffee) score file from the specified url
3712    *
3713    * @param source
3714    *          File/URL/T-COFFEE score file contents
3715    * @throws IOException
3716    * @return true if alignment was annotated with data from source
3717    */
3718   public boolean loadScoreFile(String source) throws IOException
3719   {
3720
3721     TCoffeeScoreFile file = new TCoffeeScoreFile(source,
3722             AppletFormatAdapter.checkProtocol(source));
3723     if (!file.isValid())
3724     {
3725       // TODO: raise dialog for gui
3726       System.err.println("Problems parsing T-Coffee scores: "
3727               + file.getWarningMessage());
3728       System.err.println("Origin was:\n" + source);
3729       return false;
3730     }
3731
3732     /*
3733      * check that the score matrix matches the alignment dimensions
3734      */
3735     AlignmentI aln;
3736     if ((aln = viewport.getAlignment()) != null
3737             && (aln.getHeight() != file.getHeight() || aln.getWidth() != file
3738                     .getWidth()))
3739     {
3740       // TODO: raise a dialog box here rather than bomb out.
3741       System.err
3742               .println("The scores matrix does not match the alignment dimensions");
3743
3744     }
3745
3746     // TODO add parameter to indicate if matching should be done
3747     if (file.annotateAlignment(alignPanel.getAlignment(), false))
3748     {
3749       alignPanel.fontChanged();
3750       tcoffeeColour.setEnabled(true);
3751       // switch to this color
3752       changeColour(new TCoffeeColourScheme(alignPanel.getAlignment()));
3753       return true;
3754     }
3755     else
3756     {
3757       System.err.println("Problems resolving T-Coffee scores:");
3758       if (file.getWarningMessage() != null)
3759       {
3760         System.err.println(file.getWarningMessage());
3761       }
3762     }
3763     return false;
3764   }
3765
3766 }