src/jalview/appletgui/AlignFrame.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1)
   3  * Copyright (C) 2009 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18  */
  19 package jalview.appletgui;
  20
  21 import java.io.*;
  22 import java.net.*;
  23 import java.util.*;
  24
  25 import java.awt.*;
  26 import java.awt.event.*;
  27
  28 import jalview.analysis.*;
  29 import jalview.commands.*;
  30 import jalview.datamodel.*;
  31 import jalview.io.*;
  32 import jalview.schemes.*;
  33
  34 public class AlignFrame extends EmbmenuFrame implements ActionListener,
  35         ItemListener, KeyListener
  36 {
  37   public AlignmentPanel alignPanel;
  38
  39   public AlignViewport viewport;
  40
  41   int DEFAULT_WIDTH = 700;
  42
  43   int DEFAULT_HEIGHT = 500;
  44
  45   String jalviewServletURL;
  46
  47   public AlignFrame(AlignmentI al, jalview.bin.JalviewLite applet,
  48           String title, boolean embedded)
  49   {
  50
  51     if (applet != null)
  52     {
  53       jalviewServletURL = applet.getParameter("APPLICATION_URL");
  54     }
  55
  56     try
  57     {
  58       jbInit();
  59     } catch (Exception ex)
  60     {
  61       ex.printStackTrace();
  62     }
  63
  64     viewport = new AlignViewport(al, applet);
  65     alignPanel = new AlignmentPanel(this, viewport);
  66
  67     viewport.updateConservation(alignPanel);
  68     viewport.updateConsensus(alignPanel);
  69
  70     annotationPanelMenuItem.setState(viewport.showAnnotation);
  71     displayNonconservedMenuItem.setState(viewport.getShowunconserved());
  72
  73     seqLimits.setState(viewport.showJVSuffix);
  74
  75     if (applet != null)
  76     {
  77       String param = applet.getParameter("sortBy");
  78       if (param != null)
  79       {
  80         if (param.equalsIgnoreCase("Id"))
  81         {
  82           sortIDMenuItem_actionPerformed();
  83         }
  84         else if (param.equalsIgnoreCase("Pairwise Identity"))
  85         {
  86           sortPairwiseMenuItem_actionPerformed();
  87         }
  88       }
  89
  90       param = applet.getParameter("wrap");
  91       if (param != null)
  92       {
  93         if (param.equalsIgnoreCase("true"))
  94         {
  95           wrapMenuItem.setState(true);
  96           wrapMenuItem_actionPerformed();
  97         }
  98       }
  99       param = applet.getParameter("centrecolumnlabels");
 100       if (param != null)
 101       {
 102         centreColumnLabelFlag.setState(true);
 103         centreColumnLabelFlag_stateChanged();
 104       }
 105       try
 106       {
 107         param = applet.getParameter("windowWidth");
 108         if (param != null)
 109         {
 110           int width = Integer.parseInt(param);
 111           DEFAULT_WIDTH = width;
 112         }
 113         param = applet.getParameter("windowHeight");
 114         if (param != null)
 115         {
 116           int height = Integer.parseInt(param);
 117           DEFAULT_HEIGHT = height;
 118         }
 119       } catch (Exception ex)
 120       {
 121       }
 122
 123     }
 124
 125     // Some JVMS send keyevents to Top frame or lowest panel,
 126     // Havent worked out why yet. So add to both this frame and seqCanvas for
 127     // now
 128     this.addKeyListener(this);
 129     alignPanel.seqPanel.seqCanvas.addKeyListener(this);
 130     alignPanel.idPanel.idCanvas.addKeyListener(this);
 131     alignPanel.scalePanel.addKeyListener(this);
 132     alignPanel.annotationPanel.addKeyListener(this);
 133     createAlignFrameWindow(embedded, title);
 134     alignPanel.validate();
 135     alignPanel.paintAlignment(true);
 136   }
 137
 138   public AlignViewport getAlignViewport()
 139   {
 140     return viewport;
 141   }
 142
 143   public SeqCanvas getSeqcanvas()
 144   {
 145     return alignPanel.seqPanel.seqCanvas;
 146   }
 147
 148   /**
 149    * DOCUMENT ME!
 150    *
 151    * @param String
 152    *                DOCUMENT ME!
 153    */
 154
 155   public void parseFeaturesFile(String file, String type)
 156   {
 157     Hashtable featureLinks = new Hashtable();
 158     boolean featuresFile = false;
 159     try
 160     {
 161       featuresFile = new jalview.io.FeaturesFile(file, type).parse(
 162               viewport.alignment, alignPanel.seqPanel.seqCanvas
 163                       .getFeatureRenderer().featureColours, featureLinks,
 164               true);
 165     } catch (Exception ex)
 166     {
 167       ex.printStackTrace();
 168     }
 169
 170     if (featuresFile)
 171     {
 172       if (featureLinks.size() > 0)
 173       {
 174         alignPanel.seqPanel.seqCanvas.getFeatureRenderer().featureLinks = featureLinks;
 175       }
 176       viewport.showSequenceFeatures = true;
 177       sequenceFeatures.setState(true);
 178       alignPanel.paintAlignment(true);
 179     }
 180
 181   }
 182
 183   public void keyPressed(KeyEvent evt)
 184   {
 185     if (viewport.cursorMode
 186             && ((evt.getKeyCode() >= KeyEvent.VK_0 && evt.getKeyCode() <= KeyEvent.VK_9) || (evt
 187                     .getKeyCode() >= KeyEvent.VK_NUMPAD0 && evt
 188                     .getKeyCode() <= KeyEvent.VK_NUMPAD9))
 189             && Character.isDigit(evt.getKeyChar()))
 190       alignPanel.seqPanel.numberPressed(evt.getKeyChar());
 191
 192     switch (evt.getKeyCode())
 193     {
 194     case 27: // escape key
 195       deselectAllSequenceMenuItem_actionPerformed();
 196       break;
 197     case KeyEvent.VK_X:
 198       if (evt.isControlDown() || evt.isMetaDown())
 199       {
 200         cut_actionPerformed();
 201       }
 202       break;
 203     case KeyEvent.VK_C:
 204       if (viewport.cursorMode && !evt.isControlDown())
 205       {
 206         alignPanel.seqPanel.setCursorColumn();
 207       }
 208       if (evt.isControlDown() || evt.isMetaDown())
 209       {
 210         copy_actionPerformed();
 211       }
 212       break;
 213     case KeyEvent.VK_V:
 214       if (evt.isControlDown())
 215       {
 216         paste(evt.isShiftDown());
 217       }
 218       break;
 219     case KeyEvent.VK_A:
 220       if (evt.isControlDown() || evt.isMetaDown())
 221       {
 222         selectAllSequenceMenuItem_actionPerformed();
 223       }
 224       break;
 225     case KeyEvent.VK_DOWN:
 226       if (viewport.cursorMode)
 227       {
 228         alignPanel.seqPanel.moveCursor(0, 1);
 229       }
 230       else
 231       {
 232         moveSelectedSequences(false);
 233       }
 234       break;
 235
 236     case KeyEvent.VK_UP:
 237       if (viewport.cursorMode)
 238       {
 239         alignPanel.seqPanel.moveCursor(0, -1);
 240       }
 241       else
 242       {
 243         moveSelectedSequences(true);
 244       }
 245       break;
 246
 247     case KeyEvent.VK_LEFT:
 248       if (evt.isAltDown() || !viewport.cursorMode)
 249         slideSequences(false, alignPanel.seqPanel.getKeyboardNo1());
 250       else
 251         alignPanel.seqPanel.moveCursor(-1, 0);
 252       break;
 253
 254     case KeyEvent.VK_RIGHT:
 255       if (evt.isAltDown() || !viewport.cursorMode)
 256         slideSequences(true, alignPanel.seqPanel.getKeyboardNo1());
 257       else
 258         alignPanel.seqPanel.moveCursor(1, 0);
 259       break;
 260
 261     case KeyEvent.VK_SPACE:
 262       if (viewport.cursorMode)
 263       {
 264         alignPanel.seqPanel.insertGapAtCursor(evt.isControlDown()
 265                 || evt.isShiftDown() || evt.isAltDown());
 266       }
 267       break;
 268
 269     case KeyEvent.VK_DELETE:
 270     case KeyEvent.VK_BACK_SPACE:
 271       if (viewport.cursorMode)
 272       {
 273         alignPanel.seqPanel.deleteGapAtCursor(evt.isControlDown()
 274                 || evt.isShiftDown() || evt.isAltDown());
 275       }
 276       else
 277       {
 278         cut_actionPerformed();
 279         alignPanel.seqPanel.seqCanvas.repaint();
 280       }
 281       break;
 282
 283     case KeyEvent.VK_S:
 284       if (viewport.cursorMode)
 285       {
 286         alignPanel.seqPanel.setCursorRow();
 287       }
 288       break;
 289     case KeyEvent.VK_P:
 290       if (viewport.cursorMode)
 291       {
 292         alignPanel.seqPanel.setCursorPosition();
 293       }
 294       break;
 295
 296     case KeyEvent.VK_ENTER:
 297     case KeyEvent.VK_COMMA:
 298       if (viewport.cursorMode)
 299       {
 300         alignPanel.seqPanel.setCursorRowAndColumn();
 301       }
 302       break;
 303
 304     case KeyEvent.VK_Q:
 305       if (viewport.cursorMode)
 306       {
 307         alignPanel.seqPanel.setSelectionAreaAtCursor(true);
 308       }
 309       break;
 310     case KeyEvent.VK_M:
 311       if (viewport.cursorMode)
 312       {
 313         alignPanel.seqPanel.setSelectionAreaAtCursor(false);
 314       }
 315       break;
 316
 317     case KeyEvent.VK_F2:
 318       viewport.cursorMode = !viewport.cursorMode;
 319       statusBar.setText("Keyboard editing mode is "
 320               + (viewport.cursorMode ? "on" : "off"));
 321       if (viewport.cursorMode)
 322       {
 323         alignPanel.seqPanel.seqCanvas.cursorX = viewport.startRes;
 324         alignPanel.seqPanel.seqCanvas.cursorY = viewport.startSeq;
 325       }
 326       break;
 327
 328     case KeyEvent.VK_F:
 329       if (evt.isControlDown())
 330       {
 331         findMenuItem_actionPerformed();
 332       }
 333       break;
 334
 335     case KeyEvent.VK_H:
 336     {
 337       boolean toggleSeqs = !evt.isControlDown();
 338       boolean toggleCols = !evt.isShiftDown();
 339       boolean hide = false;
 340       SequenceGroup sg = viewport.getSelectionGroup();
 341
 342       if (toggleSeqs)
 343       {
 344         if (sg != null && sg.getSize() != viewport.alignment.getHeight())
 345         {
 346           hide = true;
 347           viewport.hideAllSelectedSeqs();
 348         }
 349         else if (!(toggleCols && viewport.colSel.getSelected().size() > 0))
 350         {
 351           viewport.showAllHiddenSeqs();
 352         }
 353       }
 354
 355       if (toggleCols)
 356       {
 357         if (viewport.colSel.getSelected().size() > 0)
 358         {
 359           viewport.hideSelectedColumns();
 360           if (!toggleSeqs)
 361           {
 362             viewport.selectionGroup = sg;
 363           }
 364         }
 365         else if (!hide)
 366         {
 367           viewport.showAllHiddenColumns();
 368         }
 369       }
 370       break;
 371     }
 372
 373     case KeyEvent.VK_PAGE_UP:
 374       if (viewport.wrapAlignment)
 375       {
 376         alignPanel.scrollUp(true);
 377       }
 378       else
 379       {
 380         alignPanel.setScrollValues(viewport.startRes, viewport.startSeq
 381                 - viewport.endSeq + viewport.startSeq);
 382       }
 383       break;
 384
 385     case KeyEvent.VK_PAGE_DOWN:
 386       if (viewport.wrapAlignment)
 387       {
 388         alignPanel.scrollUp(false);
 389       }
 390       else
 391       {
 392         alignPanel.setScrollValues(viewport.startRes, viewport.startSeq
 393                 + viewport.endSeq - viewport.startSeq);
 394       }
 395       break;
 396
 397     case KeyEvent.VK_Z:
 398       if (evt.isControlDown())
 399       {
 400         undoMenuItem_actionPerformed();
 401       }
 402       break;
 403
 404     case KeyEvent.VK_Y:
 405       if (evt.isControlDown())
 406       {
 407         redoMenuItem_actionPerformed();
 408       }
 409       break;
 410
 411     case KeyEvent.VK_L:
 412       if (evt.isControlDown())
 413       {
 414         trimAlignment(true);
 415       }
 416       break;
 417
 418     case KeyEvent.VK_R:
 419       if (evt.isControlDown())
 420       {
 421         trimAlignment(false);
 422       }
 423       break;
 424
 425     case KeyEvent.VK_E:
 426       if (evt.isControlDown())
 427       {
 428         if (evt.isShiftDown())
 429         {
 430           this.removeAllGapsMenuItem_actionPerformed();
 431         }
 432         else
 433         {
 434           removeGappedColumnMenuItem_actionPerformed();
 435         }
 436       }
 437       break;
 438     case KeyEvent.VK_I:
 439       if (evt.isControlDown())
 440       {
 441         if (evt.isAltDown())
 442         {
 443           viewport.invertColumnSelection();
 444         }
 445         else
 446         {
 447           this.invertSequenceMenuItem_actionPerformed();
 448         }
 449       }
 450       break;
 451
 452     case KeyEvent.VK_U:
 453       if (evt.isControlDown())
 454       {
 455         this.deleteGroups_actionPerformed();
 456       }
 457       break;
 458
 459     case KeyEvent.VK_T:
 460       if (evt.isControlDown())
 461       {
 462         newView(null);
 463       }
 464       break;
 465
 466     }
 467     alignPanel.paintAlignment(true);
 468   }
 469
 470   public void keyReleased(KeyEvent evt)
 471   {
 472   }
 473
 474   public void keyTyped(KeyEvent evt)
 475   {
 476   }
 477
 478   public void itemStateChanged(ItemEvent evt)
 479   {
 480     if (evt.getSource() == displayNonconservedMenuItem)
 481     {
 482       displayNonconservedMenuItem_actionPerformed();
 483     }
 484     else if (evt.getSource() == colourTextMenuItem)
 485     {
 486       colourTextMenuItem_actionPerformed();
 487     }
 488     else if (evt.getSource() == wrapMenuItem)
 489     {
 490       wrapMenuItem_actionPerformed();
 491     }
 492     else if (evt.getSource() == scaleAbove)
 493     {
 494       viewport.setScaleAboveWrapped(scaleAbove.getState());
 495     }
 496     else if (evt.getSource() == scaleLeft)
 497     {
 498       viewport.setScaleLeftWrapped(scaleLeft.getState());
 499     }
 500     else if (evt.getSource() == scaleRight)
 501     {
 502       viewport.setScaleRightWrapped(scaleRight.getState());
 503     }
 504     else if (evt.getSource() == seqLimits)
 505     {
 506       seqLimits_itemStateChanged();
 507     }
 508     else if (evt.getSource() == viewBoxesMenuItem)
 509     {
 510       viewport.setShowBoxes(viewBoxesMenuItem.getState());
 511     }
 512     else if (evt.getSource() == viewTextMenuItem)
 513     {
 514       viewport.setShowText(viewTextMenuItem.getState());
 515     }
 516     else if (evt.getSource() == renderGapsMenuItem)
 517     {
 518       viewport.setRenderGaps(renderGapsMenuItem.getState());
 519     }
 520     else if (evt.getSource() == annotationPanelMenuItem)
 521     {
 522       viewport.setShowAnnotation(annotationPanelMenuItem.getState());
 523       alignPanel.setAnnotationVisible(annotationPanelMenuItem.getState());
 524     }
 525     else if (evt.getSource() == sequenceFeatures)
 526     {
 527       viewport.showSequenceFeatures(sequenceFeatures.getState());
 528       alignPanel.seqPanel.seqCanvas.repaint();
 529     }
 530     else if (evt.getSource() == conservationMenuItem)
 531     {
 532       conservationMenuItem_actionPerformed();
 533     }
 534     else if (evt.getSource() == abovePIDThreshold)
 535     {
 536       abovePIDThreshold_actionPerformed();
 537     }
 538     else if (evt.getSource() == applyToAllGroups)
 539     {
 540       viewport.setColourAppliesToAllGroups(applyToAllGroups.getState());
 541     }
 542     else if (evt.getSource() == autoCalculate)
 543     {
 544       viewport.autocalculateConsensus = autoCalculate.getState();
 545     }
 546     else if (evt.getSource() == this.centreColumnLabelFlag)
 547     {
 548       centreColumnLabelFlag_stateChanged();
 549     } else if (evt.getSource() == this.followMouseOverFlag)
 550     {
 551       mouseOverFlag_stateChanged();
 552     }
 553
 554     alignPanel.paintAlignment(true);
 555   }
 556
 557   private void mouseOverFlag_stateChanged()
 558   {
 559     viewport.followHighlight = followMouseOverFlag.getState();
 560     // TODO: could kick the scrollTo mechanism to reset view for current searchresults.
 561   }
 562
 563   private void centreColumnLabelFlag_stateChanged()
 564   {
 565     viewport.centreColumnLabels = centreColumnLabelFlag.getState();
 566     this.alignPanel.annotationPanel.repaint();
 567   }
 568
 569   public void actionPerformed(ActionEvent evt)
 570   {
 571     Object source = evt.getSource();
 572
 573     if (source == inputText)
 574     {
 575       inputText_actionPerformed();
 576     }
 577     else if (source == loadTree)
 578     {
 579       loadTree_actionPerformed();
 580     }
 581     else if (source == loadApplication)
 582     {
 583       launchFullApplication();
 584     }
 585     else if (source == loadAnnotations)
 586     {
 587       loadAnnotations();
 588     }
 589     else if (source == outputAnnotations)
 590     {
 591       outputAnnotations(true);
 592     }
 593     else if (source == outputFeatures)
 594     {
 595       outputFeatures(true, "Jalview");
 596     }
 597     else if (source == closeMenuItem)
 598     {
 599       closeMenuItem_actionPerformed();
 600     }
 601     else if (source == copy)
 602     {
 603       copy_actionPerformed();
 604     }
 605     else if (source == undoMenuItem)
 606     {
 607       undoMenuItem_actionPerformed();
 608     }
 609     else if (source == redoMenuItem)
 610     {
 611       redoMenuItem_actionPerformed();
 612     }
 613     else if (source == inputText)
 614     {
 615       inputText_actionPerformed();
 616     }
 617     else if (source == closeMenuItem)
 618     {
 619       closeMenuItem_actionPerformed();
 620     }
 621     else if (source == undoMenuItem)
 622     {
 623       undoMenuItem_actionPerformed();
 624     }
 625     else if (source == redoMenuItem)
 626     {
 627       redoMenuItem_actionPerformed();
 628     }
 629     else if (source == copy)
 630     {
 631       copy_actionPerformed();
 632     }
 633     else if (source == pasteNew)
 634     {
 635       pasteNew_actionPerformed();
 636     }
 637     else if (source == pasteThis)
 638     {
 639       pasteThis_actionPerformed();
 640     }
 641     else if (source == cut)
 642     {
 643       cut_actionPerformed();
 644     }
 645     else if (source == delete)
 646     {
 647       delete_actionPerformed();
 648     }
 649     else if (source == deleteGroups)
 650     {
 651       deleteGroups_actionPerformed();
 652     }
 653     else if (source == selectAllSequenceMenuItem)
 654     {
 655       selectAllSequenceMenuItem_actionPerformed();
 656     }
 657     else if (source == deselectAllSequenceMenuItem)
 658     {
 659       deselectAllSequenceMenuItem_actionPerformed();
 660     }
 661     else if (source == invertSequenceMenuItem)
 662     {
 663       invertSequenceMenuItem_actionPerformed();
 664     }
 665     else if (source == invertColSel)
 666     {
 667       viewport.invertColumnSelection();
 668       alignPanel.paintAlignment(true);
 669     }
 670     else if (source == remove2LeftMenuItem)
 671     {
 672       trimAlignment(true);
 673     }
 674     else if (source == remove2RightMenuItem)
 675     {
 676       trimAlignment(false);
 677     }
 678     else if (source == removeGappedColumnMenuItem)
 679     {
 680       removeGappedColumnMenuItem_actionPerformed();
 681     }
 682     else if (source == removeAllGapsMenuItem)
 683     {
 684       removeAllGapsMenuItem_actionPerformed();
 685     }
 686     else if (source == findMenuItem)
 687     {
 688       findMenuItem_actionPerformed();
 689     }
 690     else if (source == font)
 691     {
 692       new FontChooser(alignPanel);
 693     }
 694     else if (source == newView)
 695     {
 696       newView(null);
 697     }
 698     else if (source == showColumns)
 699     {
 700       viewport.showAllHiddenColumns();
 701       alignPanel.paintAlignment(true);
 702     }
 703     else if (source == showSeqs)
 704     {
 705       viewport.showAllHiddenSeqs();
 706     }
 707     else if (source == hideColumns)
 708     {
 709       viewport.hideSelectedColumns();
 710       alignPanel.paintAlignment(true);
 711     }
 712     else if (source == hideSequences
 713             && viewport.getSelectionGroup() != null)
 714     {
 715       viewport.hideAllSelectedSeqs();
 716     }
 717     else if (source == featureSettings)
 718     {
 719       new FeatureSettings(alignPanel);
 720     }
 721     else if (source == alProperties)
 722     {
 723       StringBuffer contents = new StringBuffer();
 724
 725       float avg = 0;
 726       int min = Integer.MAX_VALUE, max = 0;
 727       for (int i = 0; i < viewport.alignment.getHeight(); i++)
 728       {
 729         int size = viewport.alignment.getSequenceAt(i).getEnd()
 730                 - viewport.alignment.getSequenceAt(i).getStart();
 731         avg += size;
 732         if (size > max)
 733           max = size;
 734         if (size < min)
 735           min = size;
 736       }
 737       avg = avg / (float) viewport.alignment.getHeight();
 738
 739       contents.append("\nSequences: " + viewport.alignment.getHeight());
 740       contents.append("\nMinimum Sequence Length: " + min);
 741       contents.append("\nMaximum Sequence Length: " + max);
 742       contents.append("\nAverage Length: " + (int) avg);
 743
 744       if (((Alignment) viewport.alignment).alignmentProperties != null)
 745       {
 746         Hashtable props = ((Alignment) viewport.alignment).alignmentProperties;
 747         Enumeration en = props.keys();
 748         while (en.hasMoreElements())
 749         {
 750           String key = en.nextElement().toString();
 751           contents.append("\n" + key + "\t" + props.get(key));
 752         }
 753       }
 754
 755       CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
 756       cap.setText(contents.toString());
 757       Frame frame = new Frame();
 758       frame.add(cap);
 759       jalview.bin.JalviewLite.addFrame(frame, "Alignment Properties: "
 760               + getTitle(), 400, 250);
 761     }
 762     else if (source == overviewMenuItem)
 763     {
 764       overviewMenuItem_actionPerformed();
 765     }
 766     else if (source == noColourmenuItem)
 767     {
 768       changeColour(null);
 769     }
 770     else if (source == clustalColour)
 771     {
 772       abovePIDThreshold.setState(false);
 773       changeColour(new ClustalxColourScheme(viewport.alignment
 774               .getSequences(), viewport.alignment.getWidth()));
 775     }
 776     else if (source == zappoColour)
 777     {
 778       changeColour(new ZappoColourScheme());
 779     }
 780     else if (source == taylorColour)
 781     {
 782       changeColour(new TaylorColourScheme());
 783     }
 784     else if (source == hydrophobicityColour)
 785     {
 786       changeColour(new HydrophobicColourScheme());
 787     }
 788     else if (source == helixColour)
 789     {
 790       changeColour(new HelixColourScheme());
 791     }
 792     else if (source == strandColour)
 793     {
 794       changeColour(new StrandColourScheme());
 795     }
 796     else if (source == turnColour)
 797     {
 798       changeColour(new TurnColourScheme());
 799     }
 800     else if (source == buriedColour)
 801     {
 802       changeColour(new BuriedColourScheme());
 803     }
 804     else if (source == nucleotideColour)
 805     {
 806       changeColour(new NucleotideColourScheme());
 807     }
 808     else if (source == modifyPID)
 809     {
 810       modifyPID_actionPerformed();
 811     }
 812     else if (source == modifyConservation)
 813     {
 814       modifyConservation_actionPerformed();
 815     }
 816     else if (source == userDefinedColour)
 817     {
 818       new UserDefinedColours(alignPanel, null);
 819     }
 820     else if (source == PIDColour)
 821     {
 822       changeColour(new PIDColourScheme());
 823     }
 824     else if (source == BLOSUM62Colour)
 825     {
 826       changeColour(new Blosum62ColourScheme());
 827     }
 828     else if (source == annotationColour)
 829     {
 830       new AnnotationColourChooser(viewport, alignPanel);
 831     }
 832     else if (source == sortPairwiseMenuItem)
 833     {
 834       sortPairwiseMenuItem_actionPerformed();
 835     }
 836     else if (source == sortIDMenuItem)
 837     {
 838       sortIDMenuItem_actionPerformed();
 839     }
 840     else if (source == sortGroupMenuItem)
 841     {
 842       sortGroupMenuItem_actionPerformed();
 843     }
 844     else if (source == removeRedundancyMenuItem)
 845     {
 846       removeRedundancyMenuItem_actionPerformed();
 847     }
 848     else if (source == pairwiseAlignmentMenuItem)
 849     {
 850       pairwiseAlignmentMenuItem_actionPerformed();
 851     }
 852     else if (source == PCAMenuItem)
 853     {
 854       PCAMenuItem_actionPerformed();
 855     }
 856     else if (source == averageDistanceTreeMenuItem)
 857     {
 858       averageDistanceTreeMenuItem_actionPerformed();
 859     }
 860     else if (source == neighbourTreeMenuItem)
 861     {
 862       neighbourTreeMenuItem_actionPerformed();
 863     }
 864     else if (source == njTreeBlosumMenuItem)
 865     {
 866       njTreeBlosumMenuItem_actionPerformed();
 867     }
 868     else if (source == avDistanceTreeBlosumMenuItem)
 869     {
 870       avTreeBlosumMenuItem_actionPerformed();
 871     }
 872     else if (source == documentation)
 873     {
 874       documentation_actionPerformed();
 875     }
 876     else if (source == about)
 877     {
 878       about_actionPerformed();
 879     }
 880
 881   }
 882
 883   public void inputText_actionPerformed()
 884   {
 885     CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
 886     Frame frame = new Frame();
 887     frame.add(cap);
 888     jalview.bin.JalviewLite.addFrame(frame, "Cut & Paste Input", 500, 500);
 889   }
 890
 891   protected void outputText_actionPerformed(ActionEvent e)
 892   {
 893     CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
 894     Frame frame = new Frame();
 895     frame.add(cap);
 896     jalview.bin.JalviewLite.addFrame(frame, "Alignment output - "
 897             + e.getActionCommand(), 600, 500);
 898     cap.setText(new AppletFormatAdapter().formatSequences(e
 899             .getActionCommand(), viewport.getAlignment(),
 900             viewport.showJVSuffix));
 901   }
 902
 903   public void loadAnnotations()
 904   {
 905     CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
 906     cap.setText("Paste your features / annotations file here.");
 907     cap.setAnnotationImport();
 908     Frame frame = new Frame();
 909     frame.add(cap);
 910     jalview.bin.JalviewLite.addFrame(frame, "Paste Annotations ", 400, 300);
 911
 912   }
 913
 914   public String outputAnnotations(boolean displayTextbox)
 915   {
 916     String annotation = new AnnotationFile().printAnnotations(
 917             viewport.showAnnotation ? viewport.alignment
 918                     .getAlignmentAnnotation() : null, viewport.alignment
 919                     .getGroups(),
 920             ((Alignment) viewport.alignment).alignmentProperties);
 921
 922     if (displayTextbox)
 923     {
 924       CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
 925       Frame frame = new Frame();
 926       frame.add(cap);
 927       jalview.bin.JalviewLite.addFrame(frame, "Annotations", 600, 500);
 928       cap.setText(annotation);
 929     }
 930
 931     return annotation;
 932   }
 933
 934   private Hashtable getDisplayedFeatureCols()
 935   {
 936     if (alignPanel.getFeatureRenderer()!=null) {
 937       FeatureRenderer fr = alignPanel.getFeatureRenderer();
 938       Hashtable fcols = new Hashtable();
 939       Enumeration en = viewport.featuresDisplayed.keys();
 940       while (en.hasMoreElements())
 941       {
 942         Object col = en.nextElement();
 943         fcols.put(col,fr.featureColours.get(col));
 944       }
 945       return fcols;
 946     }
 947     return null;
 948   }
 949
 950   public String outputFeatures(boolean displayTextbox, String format)
 951   {
 952     String features;
 953     if (format.equalsIgnoreCase("Jalview"))
 954     {
 955       features = new FeaturesFile().printJalviewFormat(viewport.alignment
 956               .getSequencesArray(), getDisplayedFeatureCols());
 957     }
 958     else
 959     {
 960       features = new FeaturesFile().printGFFFormat(viewport.alignment
 961               .getSequencesArray(), getDisplayedFeatureCols());
 962     }
 963
 964     if (displayTextbox)
 965     {
 966       CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
 967       Frame frame = new Frame();
 968       frame.add(cap);
 969       jalview.bin.JalviewLite.addFrame(frame, "Features", 600, 500);
 970
 971       cap.setText(features);
 972     }
 973
 974     return features;
 975   }
 976
 977   void launchFullApplication()
 978   {
 979     StringBuffer url = new StringBuffer(jalviewServletURL);
 980
 981     url.append("?open="
 982             + appendProtocol(viewport.applet.getParameter("file")));
 983
 984     if (viewport.applet.getParameter("features") != null)
 985     {
 986       url.append("&features=");
 987       url.append(appendProtocol(viewport.applet.getParameter("features")));
 988     }
 989
 990     if (viewport.applet.getParameter("annotations") != null)
 991     {
 992       url.append("&annotations=");
 993       url
 994               .append(appendProtocol(viewport.applet
 995                       .getParameter("annotations")));
 996     }
 997
 998     if (viewport.applet.getParameter("jnetfile") != null)
 999     {
1000       url.append("&annotations=");
1001       url.append(appendProtocol(viewport.applet.getParameter("jnetfile")));
1002     }
1003
1004     if (viewport.applet.getParameter("defaultColour") != null)
1005     {
1006       url.append("&colour="
1007               + removeWhiteSpace(viewport.applet
1008                       .getParameter("defaultColour")));
1009     }
1010
1011     if (viewport.applet.getParameter("userDefinedColour") != null)
1012     {
1013       url.append("&colour="
1014               + removeWhiteSpace(viewport.applet
1015                       .getParameter("userDefinedColour")));
1016     }
1017     if (viewport.applet.getParameter("tree") != null)
1018     {
1019       url.append("&tree="
1020               + appendProtocol(viewport.applet.getParameter("tree")));
1021     }
1022     if (viewport.applet.getParameter("treeFile") != null)
1023     {
1024       url.append("&tree="
1025               + appendProtocol(viewport.applet.getParameter("treeFile")));
1026     }
1027
1028     showURL(url.toString(), "FULL_APP");
1029   }
1030
1031   String removeWhiteSpace(String colour)
1032   {
1033     StringBuffer sb = new StringBuffer();
1034     for (int i = 0; i < colour.length(); i++)
1035     {
1036       if (Character.isWhitespace(colour.charAt(i)))
1037       {
1038         sb.append("%20");
1039       }
1040       else
1041       {
1042         sb.append(colour.charAt(i));
1043       }
1044     }
1045
1046     return sb.toString();
1047   }
1048
1049   String appendProtocol(String url)
1050   {
1051     try
1052     {
1053       new URL(url);
1054       url = URLEncoder.encode(url);
1055     }
1056     /*
1057      * When we finally deprecate 1.1 compatibility, we can start to use
1058      * URLEncoder.encode(url,"UTF-8") and then we'll need this catch: catch
1059      * (UnsupportedEncodingException ex) { System.err.println("WARNING -
1060      * IMPLEMENTATION ERROR - UNSUPPORTED ENCODING EXCEPTION FOR "+url);
1061      * ex.printStackTrace(); }
1062      */
1063     catch (java.net.MalformedURLException ex)
1064     {
1065       url = viewport.applet.getCodeBase() + url;
1066     }
1067     return url;
1068   }
1069
1070   public void closeMenuItem_actionPerformed()
1071   {
1072     PaintRefresher.RemoveComponent(alignPanel);
1073     PaintRefresher.RemoveComponent(alignPanel.seqPanel.seqCanvas);
1074     PaintRefresher.RemoveComponent(alignPanel.idPanel.idCanvas);
1075
1076     if (PaintRefresher.components.size() == 0 && viewport.applet == null)
1077     {
1078       System.exit(0);
1079     }
1080
1081     this.dispose();
1082   }
1083
1084   /**
1085    * DOCUMENT ME!
1086    */
1087   void updateEditMenuBar()
1088   {
1089
1090     if (viewport.historyList.size() > 0)
1091     {
1092       undoMenuItem.setEnabled(true);
1093       CommandI command = (CommandI) viewport.historyList.peek();
1094       undoMenuItem.setLabel("Undo " + command.getDescription());
1095     }
1096     else
1097     {
1098       undoMenuItem.setEnabled(false);
1099       undoMenuItem.setLabel("Undo");
1100     }
1101
1102     if (viewport.redoList.size() > 0)
1103     {
1104       redoMenuItem.setEnabled(true);
1105
1106       CommandI command = (CommandI) viewport.redoList.peek();
1107       redoMenuItem.setLabel("Redo " + command.getDescription());
1108     }
1109     else
1110     {
1111       redoMenuItem.setEnabled(false);
1112       redoMenuItem.setLabel("Redo");
1113     }
1114   }
1115
1116   public void addHistoryItem(CommandI command)
1117   {
1118     if (command.getSize() > 0)
1119     {
1120       viewport.historyList.push(command);
1121       viewport.redoList.removeAllElements();
1122       updateEditMenuBar();
1123       viewport.hasHiddenColumns = viewport.colSel.getHiddenColumns() != null;
1124     }
1125   }
1126
1127   /**
1128    * DOCUMENT ME!
1129    *
1130    * @param e
1131    *                DOCUMENT ME!
1132    */
1133   protected void undoMenuItem_actionPerformed()
1134   {
1135     if (viewport.historyList.size() < 1)
1136     {
1137       return;
1138     }
1139
1140     CommandI command = (CommandI) viewport.historyList.pop();
1141     viewport.redoList.push(command);
1142     command.undoCommand(null);
1143
1144     AlignViewport originalSource = getOriginatingSource(command);
1145
1146     originalSource.hasHiddenColumns = viewport.colSel.getHiddenColumns() != null;
1147     updateEditMenuBar();
1148     originalSource.firePropertyChange("alignment", null,
1149             originalSource.alignment.getSequences());
1150   }
1151
1152   /**
1153    * DOCUMENT ME!
1154    *
1155    * @param e
1156    *                DOCUMENT ME!
1157    */
1158   protected void redoMenuItem_actionPerformed()
1159   {
1160     if (viewport.redoList.size() < 1)
1161     {
1162       return;
1163     }
1164
1165     CommandI command = (CommandI) viewport.redoList.pop();
1166     viewport.historyList.push(command);
1167     command.doCommand(null);
1168
1169     AlignViewport originalSource = getOriginatingSource(command);
1170     originalSource.hasHiddenColumns = viewport.colSel.getHiddenColumns() != null;
1171
1172     updateEditMenuBar();
1173     originalSource.firePropertyChange("alignment", null,
1174             originalSource.alignment.getSequences());
1175   }
1176
1177   AlignViewport getOriginatingSource(CommandI command)
1178   {
1179     AlignViewport originalSource = null;
1180     // For sequence removal and addition, we need to fire
1181     // the property change event FROM the viewport where the
1182     // original alignment was altered
1183     AlignmentI al = null;
1184     if (command instanceof EditCommand)
1185     {
1186       EditCommand editCommand = (EditCommand) command;
1187       al = editCommand.getAlignment();
1188       Vector comps = (Vector) PaintRefresher.components.get(viewport
1189               .getSequenceSetId());
1190       for (int i = 0; i < comps.size(); i++)
1191       {
1192         if (comps.elementAt(i) instanceof AlignmentPanel)
1193         {
1194           if (al == ((AlignmentPanel) comps.elementAt(i)).av.alignment)
1195           {
1196             originalSource = ((AlignmentPanel) comps.elementAt(i)).av;
1197             break;
1198           }
1199         }
1200       }
1201     }
1202
1203     if (originalSource == null)
1204     {
1205       // The original view is closed, we must validate
1206       // the current view against the closed view first
1207       if (al != null)
1208       {
1209         PaintRefresher.validateSequences(al, viewport.alignment);
1210       }
1211
1212       originalSource = viewport;
1213     }
1214
1215     return originalSource;
1216   }
1217
1218   public void moveSelectedSequences(boolean up)
1219   {
1220     SequenceGroup sg = viewport.getSelectionGroup();
1221     if (sg == null)
1222     {
1223       return;
1224     }
1225
1226     if (up)
1227     {
1228       for (int i = 1; i < viewport.alignment.getHeight(); i++)
1229       {
1230         SequenceI seq = viewport.alignment.getSequenceAt(i);
1231         if (!sg.getSequences(null).contains(seq))
1232         {
1233           continue;
1234         }
1235
1236         SequenceI temp = viewport.alignment.getSequenceAt(i - 1);
1237         if (sg.getSequences(null).contains(temp))
1238         {
1239           continue;
1240         }
1241
1242         viewport.alignment.getSequences().setElementAt(temp, i);
1243         viewport.alignment.getSequences().setElementAt(seq, i - 1);
1244       }
1245     }
1246     else
1247     {
1248       for (int i = viewport.alignment.getHeight() - 2; i > -1; i--)
1249       {
1250         SequenceI seq = viewport.alignment.getSequenceAt(i);
1251         if (!sg.getSequences(viewport.hiddenRepSequences).contains(seq))
1252         {
1253           continue;
1254         }
1255
1256         SequenceI temp = viewport.alignment.getSequenceAt(i + 1);
1257         if (sg.getSequences(viewport.hiddenRepSequences).contains(temp))
1258         {
1259           continue;
1260         }
1261
1262         viewport.alignment.getSequences().setElementAt(temp, i);
1263         viewport.alignment.getSequences().setElementAt(seq, i + 1);
1264       }
1265     }
1266
1267     alignPanel.paintAlignment(true);
1268   }
1269
1270   synchronized void slideSequences(boolean right, int size)
1271   {
1272     Vector sg = new Vector();
1273     if (viewport.cursorMode)
1274     {
1275       sg.addElement(viewport.alignment
1276               .getSequenceAt(alignPanel.seqPanel.seqCanvas.cursorY));
1277     }
1278     else if (viewport.getSelectionGroup() != null
1279             && viewport.getSelectionGroup().getSize() != viewport.alignment
1280                     .getHeight())
1281     {
1282       sg = viewport.getSelectionGroup().getSequences(
1283               viewport.hiddenRepSequences);
1284     }
1285
1286     if (sg.size() < 1)
1287     {
1288       return;
1289     }
1290
1291     Vector invertGroup = new Vector();
1292
1293     for (int i = 0; i < viewport.alignment.getHeight(); i++)
1294     {
1295       if (!sg.contains(viewport.alignment.getSequenceAt(i)))
1296         invertGroup.addElement(viewport.alignment.getSequenceAt(i));
1297     }
1298
1299     SequenceI[] seqs1 = new SequenceI[sg.size()];
1300     for (int i = 0; i < sg.size(); i++)
1301       seqs1[i] = (SequenceI) sg.elementAt(i);
1302
1303     SequenceI[] seqs2 = new SequenceI[invertGroup.size()];
1304     for (int i = 0; i < invertGroup.size(); i++)
1305       seqs2[i] = (SequenceI) invertGroup.elementAt(i);
1306
1307     SlideSequencesCommand ssc;
1308     if (right)
1309       ssc = new SlideSequencesCommand("Slide Sequences", seqs2, seqs1,
1310               size, viewport.getGapCharacter());
1311     else
1312       ssc = new SlideSequencesCommand("Slide Sequences", seqs1, seqs2,
1313               size, viewport.getGapCharacter());
1314
1315     int groupAdjustment = 0;
1316     if (ssc.getGapsInsertedBegin() && right)
1317     {
1318       if (viewport.cursorMode)
1319         alignPanel.seqPanel.moveCursor(size, 0);
1320       else
1321         groupAdjustment = size;
1322     }
1323     else if (!ssc.getGapsInsertedBegin() && !right)
1324     {
1325       if (viewport.cursorMode)
1326         alignPanel.seqPanel.moveCursor(-size, 0);
1327       else
1328         groupAdjustment = -size;
1329     }
1330
1331     if (groupAdjustment != 0)
1332     {
1333       viewport.getSelectionGroup().setStartRes(
1334               viewport.getSelectionGroup().getStartRes() + groupAdjustment);
1335       viewport.getSelectionGroup().setEndRes(
1336               viewport.getSelectionGroup().getEndRes() + groupAdjustment);
1337     }
1338
1339     boolean appendHistoryItem = false;
1340     if (viewport.historyList != null && viewport.historyList.size() > 0
1341             && viewport.historyList.peek() instanceof SlideSequencesCommand)
1342     {
1343       appendHistoryItem = ssc
1344               .appendSlideCommand((SlideSequencesCommand) viewport.historyList
1345                       .peek());
1346     }
1347
1348     if (!appendHistoryItem)
1349       addHistoryItem(ssc);
1350
1351     repaint();
1352   }
1353
1354   static StringBuffer copiedSequences;
1355
1356   static Vector copiedHiddenColumns;
1357
1358   protected void copy_actionPerformed()
1359   {
1360     if (viewport.getSelectionGroup() == null)
1361     {
1362       return;
1363     }
1364
1365     SequenceGroup sg = viewport.getSelectionGroup();
1366     copiedSequences = new StringBuffer();
1367     Hashtable orderedSeqs = new Hashtable();
1368     for (int i = 0; i < sg.getSize(); i++)
1369     {
1370       SequenceI seq = sg.getSequenceAt(i);
1371       int index = viewport.alignment.findIndex(seq);
1372       orderedSeqs.put(index + "", seq);
1373     }
1374
1375     int index = 0, startRes, endRes;
1376     char ch;
1377
1378     if (viewport.hasHiddenColumns && viewport.getSelectionGroup() != null)
1379     {
1380       copiedHiddenColumns = new Vector();
1381       int hiddenOffset = viewport.getSelectionGroup().getStartRes();
1382       for (int i = 0; i < viewport.getColumnSelection().getHiddenColumns()
1383               .size(); i++)
1384       {
1385         int[] region = (int[]) viewport.getColumnSelection()
1386                 .getHiddenColumns().elementAt(i);
1387
1388         copiedHiddenColumns.addElement(new int[]
1389         { region[0] - hiddenOffset, region[1] - hiddenOffset });
1390       }
1391     }
1392     else
1393     {
1394       copiedHiddenColumns = null;
1395     }
1396
1397     for (int i = 0; i < sg.getSize(); i++)
1398     {
1399       SequenceI seq = null;
1400
1401       while (seq == null)
1402       {
1403         if (orderedSeqs.containsKey(index + ""))
1404         {
1405           seq = (SequenceI) orderedSeqs.get(index + "");
1406           index++;
1407
1408           break;
1409         }
1410         else
1411         {
1412           index++;
1413         }
1414       }
1415
1416       // FIND START RES
1417       // Returns residue following index if gap
1418       startRes = seq.findPosition(sg.getStartRes());
1419
1420       // FIND END RES
1421       // Need to find the residue preceeding index if gap
1422       endRes = 0;
1423
1424       for (int j = 0; j < sg.getEndRes() + 1 && j < seq.getLength(); j++)
1425       {
1426         ch = seq.getCharAt(j);
1427         if (!jalview.util.Comparison.isGap((ch)))
1428         {
1429           endRes++;
1430         }
1431       }
1432
1433       if (endRes > 0)
1434       {
1435         endRes += seq.getStart() - 1;
1436       }
1437
1438       copiedSequences.append(seq.getName()
1439               + "\t"
1440               + startRes
1441               + "\t"
1442               + endRes
1443               + "\t"
1444               + seq.getSequenceAsString(sg.getStartRes(),
1445                       sg.getEndRes() + 1) + "\n");
1446     }
1447
1448   }
1449
1450   protected void pasteNew_actionPerformed()
1451   {
1452     paste(true);
1453   }
1454
1455   protected void pasteThis_actionPerformed()
1456   {
1457     paste(false);
1458   }
1459
1460   void paste(boolean newAlignment)
1461   {
1462     try
1463     {
1464
1465       if (copiedSequences == null)
1466       {
1467         return;
1468       }
1469
1470       StringTokenizer st = new StringTokenizer(copiedSequences.toString());
1471       Vector seqs = new Vector();
1472       while (st.hasMoreElements())
1473       {
1474         String name = st.nextToken();
1475         int start = Integer.parseInt(st.nextToken());
1476         int end = Integer.parseInt(st.nextToken());
1477         seqs.addElement(new Sequence(name, st.nextToken(), start, end));
1478       }
1479       SequenceI[] newSeqs = new SequenceI[seqs.size()];
1480       for (int i = 0; i < seqs.size(); i++)
1481       {
1482         newSeqs[i] = (SequenceI) seqs.elementAt(i);
1483       }
1484
1485       if (newAlignment)
1486       {
1487         String newtitle = new String("Copied sequences");
1488         if (getTitle().startsWith("Copied sequences"))
1489         {
1490           newtitle = getTitle();
1491         }
1492         else
1493         {
1494           newtitle = newtitle.concat("- from " + getTitle());
1495         }
1496         AlignFrame af = new AlignFrame(new Alignment(newSeqs),
1497                 viewport.applet, newtitle, false);
1498         if (copiedHiddenColumns != null)
1499         {
1500           for (int i = 0; i < copiedHiddenColumns.size(); i++)
1501           {
1502             int[] region = (int[]) copiedHiddenColumns.elementAt(i);
1503             af.viewport.hideColumns(region[0], region[1]);
1504           }
1505         }
1506
1507         jalview.bin.JalviewLite.addFrame(af, newtitle, DEFAULT_WIDTH,
1508                 DEFAULT_HEIGHT);
1509       }
1510       else
1511       {
1512         addSequences(newSeqs);
1513       }
1514
1515     } catch (Exception ex)
1516     {
1517     } // could be anything being pasted in here
1518
1519   }
1520
1521   void addSequences(SequenceI[] seqs)
1522   {
1523     for (int i = 0; i < seqs.length; i++)
1524     {
1525       viewport.alignment.addSequence(seqs[i]);
1526     }
1527
1528     // !newAlignment
1529     addHistoryItem(new EditCommand("Add sequences", EditCommand.PASTE,
1530             seqs, 0, viewport.alignment.getWidth(), viewport.alignment));
1531
1532     viewport.setEndSeq(viewport.alignment.getHeight());
1533     viewport.alignment.getWidth();
1534     viewport.firePropertyChange("alignment", null, viewport.alignment
1535             .getSequences());
1536
1537   }
1538
1539   protected void cut_actionPerformed()
1540   {
1541     copy_actionPerformed();
1542     delete_actionPerformed();
1543   }
1544
1545   protected void delete_actionPerformed()
1546   {
1547
1548     SequenceGroup sg = viewport.getSelectionGroup();
1549     if (sg == null)
1550     {
1551       return;
1552     }
1553
1554     Vector seqs = new Vector();
1555     SequenceI seq;
1556     for (int i = 0; i < sg.getSize(); i++)
1557     {
1558       seq = sg.getSequenceAt(i);
1559       seqs.addElement(seq);
1560     }
1561
1562     // If the cut affects all sequences, remove highlighted columns
1563     if (sg.getSize() == viewport.alignment.getHeight())
1564     {
1565       viewport.getColumnSelection().removeElements(sg.getStartRes(),
1566               sg.getEndRes() + 1);
1567     }
1568
1569     SequenceI[] cut = new SequenceI[seqs.size()];
1570     for (int i = 0; i < seqs.size(); i++)
1571     {
1572       cut[i] = (SequenceI) seqs.elementAt(i);
1573     }
1574
1575     /*
1576      * //ADD HISTORY ITEM
1577      */
1578     addHistoryItem(new EditCommand("Cut Sequences", EditCommand.CUT, cut,
1579             sg.getStartRes(), sg.getEndRes() - sg.getStartRes() + 1,
1580             viewport.alignment));
1581
1582     viewport.setSelectionGroup(null);
1583     viewport.alignment.deleteGroup(sg);
1584
1585     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
1586             .getSequences());
1587
1588     if (viewport.getAlignment().getHeight() < 1)
1589     {
1590       this.setVisible(false);
1591     }
1592   }
1593
1594   protected void deleteGroups_actionPerformed()
1595   {
1596     viewport.alignment.deleteAllGroups();
1597     viewport.sequenceColours = null;
1598     viewport.setSelectionGroup(null);
1599
1600     alignPanel.paintAlignment(true);
1601   }
1602
1603   public void selectAllSequenceMenuItem_actionPerformed()
1604   {
1605     SequenceGroup sg = new SequenceGroup();
1606     for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
1607     {
1608       sg.addSequence(viewport.getAlignment().getSequenceAt(i), false);
1609     }
1610     sg.setEndRes(viewport.alignment.getWidth() - 1);
1611     viewport.setSelectionGroup(sg);
1612     alignPanel.paintAlignment(true);
1613     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
1614   }
1615
1616   public void deselectAllSequenceMenuItem_actionPerformed()
1617   {
1618     if (viewport.cursorMode)
1619     {
1620       alignPanel.seqPanel.keyboardNo1 = null;
1621       alignPanel.seqPanel.keyboardNo2 = null;
1622     }
1623     viewport.setSelectionGroup(null);
1624     viewport.getColumnSelection().clear();
1625     viewport.setSelectionGroup(null);
1626     alignPanel.idPanel.idCanvas.searchResults = null;
1627     alignPanel.seqPanel.seqCanvas.highlightSearchResults(null);
1628     alignPanel.paintAlignment(true);
1629     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
1630   }
1631
1632   public void invertSequenceMenuItem_actionPerformed()
1633   {
1634     SequenceGroup sg = viewport.getSelectionGroup();
1635     for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
1636     {
1637       sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false);
1638     }
1639
1640     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
1641   }
1642
1643   void trimAlignment(boolean trimLeft)
1644   {
1645     ColumnSelection colSel = viewport.getColumnSelection();
1646     int column;
1647
1648     if (colSel.size() > 0)
1649     {
1650       if (trimLeft)
1651       {
1652         column = colSel.getMin();
1653       }
1654       else
1655       {
1656         column = colSel.getMax();
1657       }
1658
1659       SequenceI[] seqs;
1660       if (viewport.getSelectionGroup() != null)
1661       {
1662         seqs = viewport.getSelectionGroup().getSequencesAsArray(
1663                 viewport.hiddenRepSequences);
1664       }
1665       else
1666       {
1667         seqs = viewport.alignment.getSequencesArray();
1668       }
1669
1670       TrimRegionCommand trimRegion;
1671       if (trimLeft)
1672       {
1673         trimRegion = new TrimRegionCommand("Remove Left",
1674                 TrimRegionCommand.TRIM_LEFT, seqs, column,
1675                 viewport.alignment, viewport.colSel,
1676                 viewport.selectionGroup);
1677         viewport.setStartRes(0);
1678       }
1679       else
1680       {
1681         trimRegion = new TrimRegionCommand("Remove Right",
1682                 TrimRegionCommand.TRIM_RIGHT, seqs, column,
1683                 viewport.alignment, viewport.colSel,
1684                 viewport.selectionGroup);
1685       }
1686
1687       statusBar.setText("Removed " + trimRegion.getSize() + " columns.");
1688
1689       addHistoryItem(trimRegion);
1690
1691       Vector groups = viewport.alignment.getGroups();
1692
1693       for (int i = 0; i < groups.size(); i++)
1694       {
1695         SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
1696
1697         if ((trimLeft && !sg.adjustForRemoveLeft(column))
1698                 || (!trimLeft && !sg.adjustForRemoveRight(column)))
1699         {
1700           viewport.alignment.deleteGroup(sg);
1701         }
1702       }
1703
1704       viewport.firePropertyChange("alignment", null, viewport
1705               .getAlignment().getSequences());
1706     }
1707   }
1708
1709   public void removeGappedColumnMenuItem_actionPerformed()
1710   {
1711     int start = 0, end = viewport.alignment.getWidth() - 1;
1712
1713     SequenceI[] seqs;
1714     if (viewport.getSelectionGroup() != null)
1715     {
1716       seqs = viewport.getSelectionGroup().getSequencesAsArray(
1717               viewport.hiddenRepSequences);
1718       start = viewport.getSelectionGroup().getStartRes();
1719       end = viewport.getSelectionGroup().getEndRes();
1720     }
1721     else
1722     {
1723       seqs = viewport.alignment.getSequencesArray();
1724     }
1725
1726     RemoveGapColCommand removeGapCols = new RemoveGapColCommand(
1727             "Remove Gapped Columns", seqs, start, end, viewport.alignment);
1728
1729     addHistoryItem(removeGapCols);
1730
1731     statusBar.setText("Removed " + removeGapCols.getSize()
1732             + " empty columns.");
1733
1734     // This is to maintain viewport position on first residue
1735     // of first sequence
1736     SequenceI seq = viewport.alignment.getSequenceAt(0);
1737     int startRes = seq.findPosition(viewport.startRes);
1738     // ShiftList shifts;
1739     // viewport.getAlignment().removeGaps(shifts=new ShiftList());
1740     // edit.alColumnChanges=shifts.getInverse();
1741     // if (viewport.hasHiddenColumns)
1742     // viewport.getColumnSelection().compensateForEdits(shifts);
1743     viewport.setStartRes(seq.findIndex(startRes) - 1);
1744     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
1745             .getSequences());
1746
1747   }
1748
1749   public void removeAllGapsMenuItem_actionPerformed()
1750   {
1751     int start = 0, end = viewport.alignment.getWidth() - 1;
1752
1753     SequenceI[] seqs;
1754     if (viewport.getSelectionGroup() != null)
1755     {
1756       seqs = viewport.getSelectionGroup().getSequencesAsArray(
1757               viewport.hiddenRepSequences);
1758       start = viewport.getSelectionGroup().getStartRes();
1759       end = viewport.getSelectionGroup().getEndRes();
1760     }
1761     else
1762     {
1763       seqs = viewport.alignment.getSequencesArray();
1764     }
1765
1766     // This is to maintain viewport position on first residue
1767     // of first sequence
1768     SequenceI seq = viewport.alignment.getSequenceAt(0);
1769     int startRes = seq.findPosition(viewport.startRes);
1770
1771     addHistoryItem(new RemoveGapsCommand("Remove Gaps", seqs, start, end,
1772             viewport.alignment));
1773
1774     viewport.setStartRes(seq.findIndex(startRes) - 1);
1775
1776     viewport.firePropertyChange("alignment", null, viewport.getAlignment()
1777             .getSequences());
1778
1779   }
1780
1781   public void findMenuItem_actionPerformed()
1782   {
1783     new Finder(alignPanel);
1784   }
1785
1786   /**
1787    * create a new view derived from the current view
1788    *
1789    * @param viewtitle
1790    * @return frame for the new view
1791    */
1792   public AlignFrame newView(String viewtitle)
1793   {
1794     AlignmentI newal;
1795     if (viewport.hasHiddenRows)
1796     {
1797       newal = new Alignment(viewport.getAlignment().getHiddenSequences()
1798               .getFullAlignment().getSequencesArray());
1799     }
1800     else
1801     {
1802       newal = new Alignment(viewport.alignment.getSequencesArray());
1803     }
1804
1805     if (viewport.alignment.getAlignmentAnnotation() != null)
1806     {
1807       for (int i = 0; i < viewport.alignment.getAlignmentAnnotation().length; i++)
1808       {
1809         if (!viewport.alignment.getAlignmentAnnotation()[i].autoCalculated)
1810         {
1811           newal
1812                   .addAnnotation(viewport.alignment
1813                           .getAlignmentAnnotation()[i]);
1814         }
1815       }
1816     }
1817
1818     AlignFrame newaf = new AlignFrame(newal, viewport.applet, "", false);
1819
1820     newaf.viewport.sequenceSetID = alignPanel.av.getSequenceSetId();
1821     PaintRefresher.Register(alignPanel, alignPanel.av.getSequenceSetId());
1822     PaintRefresher.Register(newaf.alignPanel, newaf.alignPanel.av
1823             .getSequenceSetId());
1824
1825     PaintRefresher.Register(newaf.alignPanel.idPanel.idCanvas,
1826             newaf.alignPanel.av.getSequenceSetId());
1827     PaintRefresher.Register(newaf.alignPanel.seqPanel.seqCanvas,
1828             newaf.alignPanel.av.getSequenceSetId());
1829
1830     Vector comps = (Vector) PaintRefresher.components.get(viewport
1831             .getSequenceSetId());
1832     int viewSize = -1;
1833     for (int i = 0; i < comps.size(); i++)
1834     {
1835       if (comps.elementAt(i) instanceof AlignmentPanel)
1836       {
1837         viewSize++;
1838       }
1839     }
1840
1841     String title = new String(this.getTitle());
1842     if (viewtitle != null)
1843     {
1844       title = viewtitle + " ( " + title + ")";
1845     }
1846     else
1847     {
1848       if (title.indexOf("(View") > -1)
1849       {
1850         title = title.substring(0, title.indexOf("(View"));
1851       }
1852       title += "(View " + viewSize + ")";
1853     }
1854
1855     newaf.setTitle(title.toString());
1856
1857     newaf.viewport.historyList = viewport.historyList;
1858     newaf.viewport.redoList = viewport.redoList;
1859     return newaf;
1860   }
1861
1862   /**
1863    *
1864    * @return list of feature groups on the view
1865    */
1866   public String[] getFeatureGroups()
1867   {
1868     FeatureRenderer fr = null;
1869     if (alignPanel != null
1870             && (fr = alignPanel.getFeatureRenderer()) != null)
1871     {
1872       return fr.getGroups();
1873     }
1874     return null;
1875   }
1876
1877   /**
1878    * get sequence feature groups that are hidden or shown
1879    *
1880    * @param visible
1881    *                true is visible
1882    * @return list
1883    */
1884   public String[] getFeatureGroupsOfState(boolean visible)
1885   {
1886     FeatureRenderer fr = null;
1887     if (alignPanel != null
1888             && (fr = alignPanel.getFeatureRenderer()) != null)
1889     {
1890       return fr.getGroups(visible);
1891     }
1892     return null;
1893   }
1894
1895   /**
1896    * Change the display state for the given feature groups
1897    *
1898    * @param groups
1899    *                list of group strings
1900    * @param state
1901    *                visible or invisible
1902    */
1903   public void setFeatureGroupState(String[] groups, boolean state)
1904   {
1905     FeatureRenderer fr = null;
1906     this.sequenceFeatures.setState(true);
1907     viewport.showSequenceFeatures(true);
1908     if (alignPanel != null
1909             && (fr = alignPanel.getFeatureRenderer()) != null)
1910     {
1911       fr.setGroupState(groups, state);
1912       alignPanel.seqPanel.seqCanvas.repaint();
1913       if (alignPanel.overviewPanel != null)
1914       {
1915         alignPanel.overviewPanel.updateOverviewImage();
1916       }
1917     }
1918   }
1919
1920   public void seqLimits_itemStateChanged()
1921   {
1922     viewport.setShowJVSuffix(seqLimits.getState());
1923     alignPanel.fontChanged();
1924     alignPanel.paintAlignment(true);
1925   }
1926
1927   protected void colourTextMenuItem_actionPerformed()
1928   {
1929     viewport.setColourText(colourTextMenuItem.getState());
1930     alignPanel.paintAlignment(true);
1931   }
1932
1933   protected void displayNonconservedMenuItem_actionPerformed()
1934   {
1935     viewport.setShowunconserved(displayNonconservedMenuItem.getState());
1936     alignPanel.paintAlignment(true);
1937   }
1938
1939   protected void wrapMenuItem_actionPerformed()
1940   {
1941     viewport.setWrapAlignment(wrapMenuItem.getState());
1942     alignPanel.setWrapAlignment(wrapMenuItem.getState());
1943     scaleAbove.setEnabled(wrapMenuItem.getState());
1944     scaleLeft.setEnabled(wrapMenuItem.getState());
1945     scaleRight.setEnabled(wrapMenuItem.getState());
1946     alignPanel.paintAlignment(true);
1947   }
1948
1949   public void overviewMenuItem_actionPerformed()
1950   {
1951     if (alignPanel.overviewPanel != null)
1952     {
1953       return;
1954     }
1955
1956     Frame frame = new Frame();
1957     OverviewPanel overview = new OverviewPanel(alignPanel);
1958     frame.add(overview);
1959     // +50 must allow for applet frame window
1960     jalview.bin.JalviewLite.addFrame(frame, "Overview " + this.getTitle(),
1961             overview.getPreferredSize().width,
1962             overview.getPreferredSize().height + 50);
1963
1964     frame.pack();
1965     frame.addWindowListener(new WindowAdapter()
1966     {
1967       public void windowClosing(WindowEvent e)
1968       {
1969         alignPanel.setOverviewPanel(null);
1970       };
1971     });
1972
1973     alignPanel.setOverviewPanel(overview);
1974
1975   }
1976
1977   void changeColour(ColourSchemeI cs)
1978   {
1979     int threshold = 0;
1980
1981     if (cs != null)
1982     {
1983       if (viewport.getAbovePIDThreshold())
1984       {
1985         threshold = SliderPanel.setPIDSliderSource(alignPanel, cs,
1986                 "Background");
1987
1988         cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
1989
1990         viewport.setGlobalColourScheme(cs);
1991       }
1992       else
1993       {
1994         cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
1995       }
1996
1997       if (viewport.getConservationSelected())
1998       {
1999
2000         Alignment al = (Alignment) viewport.alignment;
2001         Conservation c = new Conservation("All",
2002                 ResidueProperties.propHash, 3, al.getSequences(), 0, al
2003                         .getWidth() - 1);
2004
2005         c.calculate();
2006         c.verdict(false, viewport.ConsPercGaps);
2007
2008         cs.setConservation(c);
2009
2010         cs.setConservationInc(SliderPanel.setConservationSlider(alignPanel,
2011                 cs, "Background"));
2012
2013       }
2014       else
2015       {
2016         cs.setConservation(null);
2017       }
2018
2019       cs.setConsensus(viewport.hconsensus);
2020
2021     }
2022     viewport.setGlobalColourScheme(cs);
2023
2024     if (viewport.getColourAppliesToAllGroups())
2025     {
2026       Vector groups = viewport.alignment.getGroups();
2027       for (int i = 0; i < groups.size(); i++)
2028       {
2029         SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
2030
2031         if (cs == null)
2032         {
2033           sg.cs = null;
2034           continue;
2035         }
2036         if (cs instanceof ClustalxColourScheme)
2037         {
2038           sg.cs = new ClustalxColourScheme(sg
2039                   .getSequences(viewport.hiddenRepSequences), sg.getWidth());
2040         }
2041         else
2042         {
2043           try
2044           {
2045             sg.cs = (ColourSchemeI) cs.getClass().newInstance();
2046           } catch (Exception ex)
2047           {
2048             ex.printStackTrace();
2049             sg.cs = cs;
2050           }
2051         }
2052
2053         if (viewport.getAbovePIDThreshold()
2054                 || cs instanceof PIDColourScheme
2055                 || cs instanceof Blosum62ColourScheme)
2056         {
2057           sg.cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
2058           sg.cs.setConsensus(AAFrequency.calculate(sg
2059                   .getSequences(viewport.hiddenRepSequences), 0, sg
2060                   .getWidth()));
2061         }
2062         else
2063         {
2064           sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
2065         }
2066
2067         if (viewport.getConservationSelected())
2068         {
2069           Conservation c = new Conservation("Group",
2070                   ResidueProperties.propHash, 3, sg
2071                           .getSequences(viewport.hiddenRepSequences), 0,
2072                   viewport.alignment.getWidth() - 1);
2073           c.calculate();
2074           c.verdict(false, viewport.ConsPercGaps);
2075           sg.cs.setConservation(c);
2076         }
2077         else
2078         {
2079           sg.cs.setConservation(null);
2080           sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
2081         }
2082
2083       }
2084     }
2085
2086     if (alignPanel.getOverviewPanel() != null)
2087     {
2088       alignPanel.getOverviewPanel().updateOverviewImage();
2089     }
2090
2091     jalview.structure.StructureSelectionManager
2092             .getStructureSelectionManager().sequenceColoursChanged(
2093                     alignPanel);
2094
2095     alignPanel.paintAlignment(true);
2096   }
2097
2098   protected void modifyPID_actionPerformed()
2099   {
2100     if (viewport.getAbovePIDThreshold()
2101             && viewport.globalColourScheme != null)
2102     {
2103       SliderPanel.setPIDSliderSource(alignPanel, viewport
2104               .getGlobalColourScheme(), "Background");
2105       SliderPanel.showPIDSlider();
2106     }
2107   }
2108
2109   protected void modifyConservation_actionPerformed()
2110   {
2111     if (viewport.getConservationSelected()
2112             && viewport.globalColourScheme != null)
2113     {
2114       SliderPanel.setConservationSlider(alignPanel,
2115               viewport.globalColourScheme, "Background");
2116       SliderPanel.showConservationSlider();
2117     }
2118   }
2119
2120   protected void conservationMenuItem_actionPerformed()
2121   {
2122     viewport.setConservationSelected(conservationMenuItem.getState());
2123
2124     viewport.setAbovePIDThreshold(false);
2125     abovePIDThreshold.setState(false);
2126
2127     changeColour(viewport.getGlobalColourScheme());
2128
2129     modifyConservation_actionPerformed();
2130   }
2131
2132   public void abovePIDThreshold_actionPerformed()
2133   {
2134     viewport.setAbovePIDThreshold(abovePIDThreshold.getState());
2135
2136     conservationMenuItem.setState(false);
2137     viewport.setConservationSelected(false);
2138
2139     changeColour(viewport.getGlobalColourScheme());
2140
2141     modifyPID_actionPerformed();
2142   }
2143   public void sortPairwiseMenuItem_actionPerformed()
2144   {
2145     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2146     AlignmentSorter.sortByPID(viewport.getAlignment(), viewport
2147             .getAlignment().getSequenceAt(0), null);
2148
2149     addHistoryItem(new OrderCommand("Pairwise Sort", oldOrder,
2150             viewport.alignment));
2151     alignPanel.paintAlignment(true);
2152   }
2153
2154   public void sortIDMenuItem_actionPerformed()
2155   {
2156     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2157     AlignmentSorter.sortByID(viewport.getAlignment());
2158     addHistoryItem(new OrderCommand("ID Sort", oldOrder,
2159             viewport.alignment));
2160     alignPanel.paintAlignment(true);
2161   }
2162
2163   public void sortGroupMenuItem_actionPerformed()
2164   {
2165     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2166     AlignmentSorter.sortByGroup(viewport.getAlignment());
2167     addHistoryItem(new OrderCommand("Group Sort", oldOrder,
2168             viewport.alignment));
2169     alignPanel.paintAlignment(true);
2170
2171   }
2172
2173   public void removeRedundancyMenuItem_actionPerformed()
2174   {
2175     new RedundancyPanel(alignPanel);
2176   }
2177
2178   public void pairwiseAlignmentMenuItem_actionPerformed()
2179   {
2180     if (viewport.getSelectionGroup() != null
2181             && viewport.getSelectionGroup().getSize() > 1)
2182     {
2183       Frame frame = new Frame();
2184       frame.add(new PairwiseAlignPanel(alignPanel));
2185       jalview.bin.JalviewLite.addFrame(frame, "Pairwise Alignment", 600,
2186               500);
2187     }
2188   }
2189
2190   public void PCAMenuItem_actionPerformed()
2191   {
2192     // are the sequences aligned?
2193     if (!viewport.alignment.isAligned())
2194     {
2195       SequenceI current;
2196       int Width = viewport.getAlignment().getWidth();
2197
2198       for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
2199       {
2200         current = viewport.getAlignment().getSequenceAt(i);
2201
2202         if (current.getLength() < Width)
2203         {
2204           current.insertCharAt(Width - 1, viewport.getGapCharacter());
2205         }
2206       }
2207       alignPanel.paintAlignment(true);
2208     }
2209
2210     if ((viewport.getSelectionGroup() != null
2211             && viewport.getSelectionGroup().getSize() < 4 && viewport
2212             .getSelectionGroup().getSize() > 0)
2213             || viewport.getAlignment().getHeight() < 4)
2214     {
2215       return;
2216     }
2217
2218     try
2219     {
2220       new PCAPanel(viewport);
2221     } catch (java.lang.OutOfMemoryError ex)
2222     {
2223     }
2224
2225   }
2226
2227   public void averageDistanceTreeMenuItem_actionPerformed()
2228   {
2229     NewTreePanel("AV", "PID", "Average distance tree using PID");
2230   }
2231
2232   public void neighbourTreeMenuItem_actionPerformed()
2233   {
2234     NewTreePanel("NJ", "PID", "Neighbour joining tree using PID");
2235   }
2236
2237   protected void njTreeBlosumMenuItem_actionPerformed()
2238   {
2239     NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62");
2240   }
2241
2242   protected void avTreeBlosumMenuItem_actionPerformed()
2243   {
2244     NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62");
2245   }
2246
2247   void NewTreePanel(String type, String pwType, String title)
2248   {
2249     // are the sequences aligned?
2250     if (!viewport.alignment.isAligned())
2251     {
2252       SequenceI current;
2253       int Width = viewport.getAlignment().getWidth();
2254
2255       for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
2256       {
2257         current = viewport.getAlignment().getSequenceAt(i);
2258
2259         if (current.getLength() < Width)
2260         {
2261           current.insertCharAt(Width - 1, viewport.getGapCharacter());
2262         }
2263       }
2264       alignPanel.paintAlignment(true);
2265
2266     }
2267
2268     if ((viewport.getSelectionGroup() != null && viewport
2269             .getSelectionGroup().getSize() > 1)
2270             || (viewport.getSelectionGroup() == null && viewport.alignment
2271                     .getHeight() > 1))
2272     {
2273       final TreePanel tp = new TreePanel(viewport, type, pwType);
2274
2275       addTreeMenuItem(tp, title);
2276
2277       jalview.bin.JalviewLite.addFrame(tp, title, 600, 500);
2278     }
2279   }
2280
2281   void loadTree_actionPerformed()
2282   {
2283     CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
2284     cap.setText("Paste your Newick tree file here.");
2285     cap.setTreeImport();
2286     Frame frame = new Frame();
2287     frame.add(cap);
2288     jalview.bin.JalviewLite.addFrame(frame, "Paste Newick file ", 400, 300);
2289   }
2290
2291   public void loadTree(jalview.io.NewickFile tree, String treeFile)
2292   {
2293     TreePanel tp = new TreePanel(viewport, treeFile, "From File - ", tree);
2294     jalview.bin.JalviewLite.addFrame(tp, treeFile, 600, 500);
2295     addTreeMenuItem(tp, treeFile);
2296   }
2297   /**
2298    * sort the alignment using the given treePanel
2299    * @param treePanel tree used to sort view
2300    * @param title string used for undo event name
2301    */
2302   public void sortByTree(TreePanel treePanel, String title)
2303   {
2304     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2305     AlignmentSorter.sortByTree(viewport.getAlignment(), treePanel
2306             .getTree());
2307     // addHistoryItem(new HistoryItem("Sort", viewport.alignment,
2308     // HistoryItem.SORT));
2309     addHistoryItem(new OrderCommand("Order by "+title, oldOrder,
2310             viewport.alignment));
2311     alignPanel.paintAlignment(true);
2312   }
2313   /**
2314    * Do any automatic reordering of the alignment and add the necessary bits to the menu structure for the new tree
2315    * @param treePanel
2316    * @param title
2317    */
2318   protected void addTreeMenuItem(final TreePanel treePanel, final String title)
2319   {
2320     final MenuItem item = new MenuItem(title);
2321     sortByTreeMenu.add(item);
2322     item.addActionListener(new java.awt.event.ActionListener()
2323     {
2324       public void actionPerformed(ActionEvent evt)
2325       {
2326         sortByTree(treePanel, title); // treePanel.getTitle());
2327       }
2328     });
2329
2330     treePanel.addWindowListener(new WindowAdapter()
2331     {
2332       public void windowOpened(WindowEvent e)
2333       {
2334         if (viewport.sortByTree)
2335         {
2336           sortByTree(treePanel, title);
2337         }
2338         super.windowOpened(e);
2339       }
2340
2341       public void windowClosing(WindowEvent e)
2342       {
2343         sortByTreeMenu.remove(item);
2344       };
2345     });
2346   }
2347
2348   protected void documentation_actionPerformed()
2349   {
2350     showURL("http://www.jalview.org/help.html", "HELP");
2351   }
2352
2353   protected void about_actionPerformed()
2354   {
2355
2356     class AboutPanel extends Canvas
2357     {
2358       String version;
2359
2360       public AboutPanel(String version)
2361       {
2362         this.version = version;
2363       }
2364
2365       public void paint(Graphics g)
2366       {
2367         g.setColor(Color.white);
2368         g.fillRect(0, 0, getSize().width, getSize().height);
2369         g.setFont(new Font("Helvetica", Font.PLAIN, 12));
2370         FontMetrics fm = g.getFontMetrics();
2371         int fh = fm.getHeight();
2372         int y = 5, x = 7;
2373         g.setColor(Color.black);
2374         // TODO: update this text for each release or centrally store it for
2375         // lite and application
2376         g.setFont(new Font("Helvetica", Font.BOLD, 14));
2377         g.drawString("JalviewLite - Release " + version, x, y += fh);
2378         g.setFont(new Font("Helvetica", Font.PLAIN, 12));
2379         g
2380                 .drawString(
2381                         "Authors:  Andrew Waterhouse, Jim Procter, Michele Clamp, James Cuff, Steve Searle,",
2382                         x, y += fh * 1.5);
2383         g.drawString("David Martin & Geoff Barton.", x + 50, y += fh);
2384         g
2385                 .drawString(
2386                         "Development managed by The Barton Group, University of Dundee, Scotland, UK.",
2387                         x, y += fh);
2388         g
2389                 .drawString(
2390                         "For help, see the FAQ at www.jalview.org and/or join the jalview-discuss@jalview.org mailing list",
2391                         x, y += fh);
2392         g.drawString("If  you use Jalview, please cite:", x, y += fh + 8);
2393         g.drawString(
2394                         "Waterhouse, A.M., Procter, J.B., Martin, D.M.A, Clamp, M. and Barton, G. J. (2009)",x,y+=fh);
2395         g.drawString("Jalview Version 2 - a multiple sequence alignment editor and analysis workbench",x,y+=fh);
2396         g.drawString("Bioinformatics doi: 10.1093/bioinformatics/btp033",x,y+=fh);
2397       }
2398     }
2399
2400     String version = "test";
2401     java.net.URL url = getClass().getResource("/.build_properties");
2402     if (url != null)
2403     {
2404       try
2405       {
2406         BufferedReader reader = new BufferedReader(new InputStreamReader(
2407                 url.openStream()));
2408         String line;
2409         while ((line = reader.readLine()) != null)
2410         {
2411           if (line.indexOf("VERSION") > -1)
2412           {
2413             version = line.substring(line.indexOf("=") + 1);
2414           }
2415         }
2416       } catch (Exception ex)
2417       {
2418         ex.printStackTrace();
2419       }
2420     }
2421
2422     Frame frame = new Frame();
2423     frame.add(new AboutPanel(version));
2424     jalview.bin.JalviewLite.addFrame(frame, "Jalview", 580, 220);
2425
2426   }
2427
2428   public void showURL(String url, String target)
2429   {
2430     if (viewport.applet == null)
2431     {
2432       System.out.println("Not running as applet - no browser available.");
2433     }
2434     else
2435     {
2436       try
2437       {
2438         if (url.indexOf(":")==-1)
2439         {
2440           // TODO: verify (Bas Vroling bug) prepend codebase or server URL to form valid URL
2441           if (url.indexOf("/")==0)
2442           {
2443             String codebase = viewport.applet.getCodeBase().toString();
2444             url = codebase.substring(0,codebase.length()-viewport.applet.getCodeBase().getFile().length())+url;
2445           } else {
2446             url = viewport.applet.getCodeBase()+url;
2447           }
2448           System.out.println("Show url (prepended codebase): " + url);
2449         } else {
2450           System.out.println("Show url: " + url);
2451         }
2452         viewport.applet.getAppletContext().showDocument(
2453                 new java.net.URL(url), target);
2454       } catch (Exception ex)
2455       {
2456         ex.printStackTrace();
2457       }
2458     }
2459   }
2460
2461   // ////////////////////////////////////////////////////////////////////////////////
2462   // JBuilder Graphics here
2463
2464   MenuBar alignFrameMenuBar = new MenuBar();
2465
2466   Menu fileMenu = new Menu("File");
2467
2468   MenuItem loadApplication = new MenuItem("View in Full Application");
2469
2470   MenuItem loadTree = new MenuItem("Load Associated Tree ...");
2471
2472   MenuItem loadAnnotations = new MenuItem("Load Features/Annotations ...");
2473
2474   MenuItem outputFeatures = new MenuItem("Export Features ...");
2475
2476   MenuItem outputAnnotations = new MenuItem("Export Annotations ...");
2477
2478   MenuItem closeMenuItem = new MenuItem("Close");
2479
2480   Menu editMenu = new Menu("Edit");
2481
2482   Menu viewMenu = new Menu("View");
2483
2484   Menu colourMenu = new Menu("Colour");
2485
2486   Menu calculateMenu = new Menu("Calculate");
2487
2488   MenuItem selectAllSequenceMenuItem = new MenuItem("Select all");
2489
2490   MenuItem deselectAllSequenceMenuItem = new MenuItem("Deselect All");
2491
2492   MenuItem invertSequenceMenuItem = new MenuItem("Invert Selection");
2493
2494   MenuItem remove2LeftMenuItem = new MenuItem();
2495
2496   MenuItem remove2RightMenuItem = new MenuItem();
2497
2498   MenuItem removeGappedColumnMenuItem = new MenuItem();
2499
2500   MenuItem removeAllGapsMenuItem = new MenuItem();
2501
2502   CheckboxMenuItem viewBoxesMenuItem = new CheckboxMenuItem();
2503
2504   CheckboxMenuItem viewTextMenuItem = new CheckboxMenuItem();
2505
2506   MenuItem sortPairwiseMenuItem = new MenuItem();
2507
2508   MenuItem sortIDMenuItem = new MenuItem();
2509
2510   MenuItem sortGroupMenuItem = new MenuItem();
2511
2512   MenuItem removeRedundancyMenuItem = new MenuItem();
2513
2514   MenuItem pairwiseAlignmentMenuItem = new MenuItem();
2515
2516   MenuItem PCAMenuItem = new MenuItem();
2517
2518   MenuItem averageDistanceTreeMenuItem = new MenuItem();
2519
2520   MenuItem neighbourTreeMenuItem = new MenuItem();
2521
2522   BorderLayout borderLayout1 = new BorderLayout();
2523
2524   public Label statusBar = new Label();
2525
2526   Menu outputTextboxMenu = new Menu();
2527
2528   MenuItem clustalColour = new MenuItem();
2529
2530   MenuItem zappoColour = new MenuItem();
2531
2532   MenuItem taylorColour = new MenuItem();
2533
2534   MenuItem hydrophobicityColour = new MenuItem();
2535
2536   MenuItem helixColour = new MenuItem();
2537
2538   MenuItem strandColour = new MenuItem();
2539
2540   MenuItem turnColour = new MenuItem();
2541
2542   MenuItem buriedColour = new MenuItem();
2543
2544   MenuItem userDefinedColour = new MenuItem();
2545
2546   MenuItem PIDColour = new MenuItem();
2547
2548   MenuItem BLOSUM62Colour = new MenuItem();
2549
2550   MenuItem njTreeBlosumMenuItem = new MenuItem();
2551
2552   MenuItem avDistanceTreeBlosumMenuItem = new MenuItem();
2553
2554   CheckboxMenuItem annotationPanelMenuItem = new CheckboxMenuItem();
2555
2556   CheckboxMenuItem colourTextMenuItem = new CheckboxMenuItem();
2557
2558   CheckboxMenuItem displayNonconservedMenuItem = new CheckboxMenuItem();
2559
2560   MenuItem alProperties = new MenuItem("Alignment Properties...");
2561
2562   MenuItem overviewMenuItem = new MenuItem();
2563
2564   MenuItem undoMenuItem = new MenuItem();
2565
2566   MenuItem redoMenuItem = new MenuItem();
2567
2568   CheckboxMenuItem conservationMenuItem = new CheckboxMenuItem();
2569
2570   MenuItem noColourmenuItem = new MenuItem();
2571
2572   CheckboxMenuItem wrapMenuItem = new CheckboxMenuItem();
2573
2574   CheckboxMenuItem renderGapsMenuItem = new CheckboxMenuItem();
2575
2576   MenuItem findMenuItem = new MenuItem();
2577
2578   CheckboxMenuItem abovePIDThreshold = new CheckboxMenuItem();
2579
2580   MenuItem nucleotideColour = new MenuItem();
2581
2582   MenuItem deleteGroups = new MenuItem();
2583
2584   MenuItem delete = new MenuItem();
2585
2586   MenuItem copy = new MenuItem();
2587
2588   MenuItem cut = new MenuItem();
2589
2590   Menu pasteMenu = new Menu();
2591
2592   MenuItem pasteNew = new MenuItem();
2593
2594   MenuItem pasteThis = new MenuItem();
2595
2596   CheckboxMenuItem applyToAllGroups = new CheckboxMenuItem();
2597
2598   MenuItem font = new MenuItem();
2599
2600   CheckboxMenuItem scaleAbove = new CheckboxMenuItem();
2601
2602   CheckboxMenuItem scaleLeft = new CheckboxMenuItem();
2603
2604   CheckboxMenuItem scaleRight = new CheckboxMenuItem();
2605
2606   MenuItem modifyPID = new MenuItem();
2607
2608   MenuItem modifyConservation = new MenuItem();
2609
2610   CheckboxMenuItem autoCalculate = new CheckboxMenuItem(
2611           "Autocalculate Consensus", true);
2612
2613   Menu sortByTreeMenu = new Menu();
2614
2615   Menu sort = new Menu();
2616
2617   Menu calculate = new Menu();
2618
2619   MenuItem inputText = new MenuItem();
2620
2621   Menu helpMenu = new Menu();
2622
2623   MenuItem documentation = new MenuItem();
2624
2625   MenuItem about = new MenuItem();
2626
2627   CheckboxMenuItem seqLimits = new CheckboxMenuItem();
2628
2629   CheckboxMenuItem centreColumnLabelFlag = new CheckboxMenuItem();
2630
2631   CheckboxMenuItem followMouseOverFlag = new CheckboxMenuItem();
2632
2633   private void jbInit() throws Exception
2634   {
2635
2636     setMenuBar(alignFrameMenuBar);
2637
2638     MenuItem item;
2639
2640     // dynamically fill save as menu with available formats
2641     for (int i = 0; i < jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS.length; i++)
2642     {
2643
2644       item = new MenuItem(
2645               jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS[i]);
2646
2647       item.addActionListener(new java.awt.event.ActionListener()
2648       {
2649         public void actionPerformed(ActionEvent e)
2650         {
2651           outputText_actionPerformed(e);
2652         }
2653       });
2654
2655       outputTextboxMenu.add(item);
2656     }
2657     closeMenuItem.addActionListener(this);
2658     loadApplication.addActionListener(this);
2659
2660     loadTree.addActionListener(this);
2661     loadAnnotations.addActionListener(this);
2662     outputFeatures.addActionListener(this);
2663     outputAnnotations.addActionListener(this);
2664     selectAllSequenceMenuItem.addActionListener(this);
2665     deselectAllSequenceMenuItem.addActionListener(this);
2666     invertSequenceMenuItem.addActionListener(this);
2667     remove2LeftMenuItem.setLabel("Remove Left");
2668     remove2LeftMenuItem.addActionListener(this);
2669     remove2RightMenuItem.setLabel("Remove Right");
2670     remove2RightMenuItem.addActionListener(this);
2671     removeGappedColumnMenuItem.setLabel("Remove Empty Columns");
2672     removeGappedColumnMenuItem.addActionListener(this);
2673     removeAllGapsMenuItem.setLabel("Remove All Gaps");
2674     removeAllGapsMenuItem.addActionListener(this);
2675     viewBoxesMenuItem.setLabel("Boxes");
2676     viewBoxesMenuItem.setState(true);
2677     viewBoxesMenuItem.addItemListener(this);
2678     viewTextMenuItem.setLabel("Text");
2679     viewTextMenuItem.setState(true);
2680     viewTextMenuItem.addItemListener(this);
2681     sortPairwiseMenuItem.setLabel("by Pairwise Identity");
2682     sortPairwiseMenuItem.addActionListener(this);
2683     sortIDMenuItem.setLabel("by ID");
2684     sortIDMenuItem.addActionListener(this);
2685     sortGroupMenuItem.setLabel("by Group");
2686     sortGroupMenuItem.addActionListener(this);
2687     removeRedundancyMenuItem.setLabel("Remove Redundancy...");
2688     removeRedundancyMenuItem.addActionListener(this);
2689     pairwiseAlignmentMenuItem.setLabel("Pairwise Alignments...");
2690     pairwiseAlignmentMenuItem.addActionListener(this);
2691     PCAMenuItem.setLabel("Principal Component Analysis");
2692     PCAMenuItem.addActionListener(this);
2693     averageDistanceTreeMenuItem
2694             .setLabel("Average Distance Using % Identity");
2695     averageDistanceTreeMenuItem.addActionListener(this);
2696     neighbourTreeMenuItem.setLabel("Neighbour Joining Using % Identity");
2697     neighbourTreeMenuItem.addActionListener(this);
2698     statusBar.setBackground(Color.white);
2699     statusBar.setFont(new java.awt.Font("Verdana", 0, 11));
2700     statusBar.setText("Status bar");
2701     outputTextboxMenu.setLabel("Output to Textbox");
2702     clustalColour.setLabel("Clustalx");
2703
2704     clustalColour.addActionListener(this);
2705     zappoColour.setLabel("Zappo");
2706     zappoColour.addActionListener(this);
2707     taylorColour.setLabel("Taylor");
2708     taylorColour.addActionListener(this);
2709     hydrophobicityColour.setLabel("Hydrophobicity");
2710     hydrophobicityColour.addActionListener(this);
2711     helixColour.setLabel("Helix Propensity");
2712     helixColour.addActionListener(this);
2713     strandColour.setLabel("Strand Propensity");
2714     strandColour.addActionListener(this);
2715     turnColour.setLabel("Turn Propensity");
2716     turnColour.addActionListener(this);
2717     buriedColour.setLabel("Buried Index");
2718     buriedColour.addActionListener(this);
2719     userDefinedColour.setLabel("User Defined...");
2720     userDefinedColour.addActionListener(this);
2721     PIDColour.setLabel("Percentage Identity");
2722     PIDColour.addActionListener(this);
2723     BLOSUM62Colour.setLabel("BLOSUM62 Score");
2724     BLOSUM62Colour.addActionListener(this);
2725     avDistanceTreeBlosumMenuItem
2726             .setLabel("Average Distance Using BLOSUM62");
2727     avDistanceTreeBlosumMenuItem.addActionListener(this);
2728     njTreeBlosumMenuItem.setLabel("Neighbour Joining Using BLOSUM62");
2729     njTreeBlosumMenuItem.addActionListener(this);
2730     annotationPanelMenuItem.setLabel("Show Annotations");
2731     annotationPanelMenuItem.addItemListener(this);
2732     colourTextMenuItem.setLabel("Colour Text");
2733     colourTextMenuItem.addItemListener(this);
2734     displayNonconservedMenuItem.setLabel("Show non-conserved");
2735     displayNonconservedMenuItem.addItemListener(this);
2736     alProperties.addActionListener(this);
2737     overviewMenuItem.setLabel("Overview Window");
2738     overviewMenuItem.addActionListener(this);
2739     undoMenuItem.setEnabled(false);
2740     undoMenuItem.setLabel("Undo");
2741     undoMenuItem.addActionListener(this);
2742     redoMenuItem.setEnabled(false);
2743     redoMenuItem.setLabel("Redo");
2744     redoMenuItem.addActionListener(this);
2745     conservationMenuItem.setLabel("by Conservation");
2746     conservationMenuItem.addItemListener(this);
2747     noColourmenuItem.setLabel("None");
2748     noColourmenuItem.addActionListener(this);
2749     wrapMenuItem.setLabel("Wrap");
2750     wrapMenuItem.addItemListener(this);
2751     renderGapsMenuItem.setLabel("Show Gaps");
2752     renderGapsMenuItem.setState(true);
2753     renderGapsMenuItem.addItemListener(this);
2754     findMenuItem.setLabel("Find...");
2755     findMenuItem.addActionListener(this);
2756     abovePIDThreshold.setLabel("Above Identity Threshold");
2757     abovePIDThreshold.addItemListener(this);
2758     nucleotideColour.setLabel("Nucleotide");
2759     nucleotideColour.addActionListener(this);
2760     deleteGroups.setLabel("Undefine Groups");
2761     deleteGroups.addActionListener(this);
2762     copy.setLabel("Copy");
2763     copy.addActionListener(this);
2764     cut.setLabel("Cut");
2765     cut.addActionListener(this);
2766     delete.setLabel("Delete");
2767     delete.addActionListener(this);
2768     pasteMenu.setLabel("Paste");
2769     pasteNew.setLabel("To New Alignment");
2770     pasteNew.addActionListener(this);
2771     pasteThis.setLabel("Add To This Alignment");
2772     pasteThis.addActionListener(this);
2773     applyToAllGroups.setLabel("Apply Colour To All Groups");
2774     applyToAllGroups.setState(true);
2775     applyToAllGroups.addItemListener(this);
2776     font.setLabel("Font...");
2777     font.addActionListener(this);
2778     scaleAbove.setLabel("Scale Above");
2779     scaleAbove.setState(true);
2780     scaleAbove.setEnabled(false);
2781     scaleAbove.addItemListener(this);
2782     scaleLeft.setEnabled(false);
2783     scaleLeft.setState(true);
2784     scaleLeft.setLabel("Scale Left");
2785     scaleLeft.addItemListener(this);
2786     scaleRight.setEnabled(false);
2787     scaleRight.setState(true);
2788     scaleRight.setLabel("Scale Right");
2789     scaleRight.addItemListener(this);
2790     modifyPID.setLabel("Modify Identity Threshold...");
2791     modifyPID.addActionListener(this);
2792     modifyConservation.setLabel("Modify Conservation Threshold...");
2793     modifyConservation.addActionListener(this);
2794     sortByTreeMenu.setLabel("By Tree Order");
2795     sort.setLabel("Sort");
2796     calculate.setLabel("Calculate Tree");
2797     autoCalculate.addItemListener(this);
2798     inputText.setLabel("Input from textbox");
2799     inputText.addActionListener(this);
2800     centreColumnLabelFlag.setLabel("Centre column labels");
2801     centreColumnLabelFlag.addItemListener(this);
2802     followMouseOverFlag.setLabel("Automatic Scrolling");
2803     followMouseOverFlag.addItemListener(this);
2804     helpMenu.setLabel("Help");
2805     documentation.setLabel("Documentation");
2806     documentation.addActionListener(this);
2807
2808     about.setLabel("About...");
2809     about.addActionListener(this);
2810     seqLimits.setState(true);
2811     seqLimits.setLabel("Show Sequence Limits");
2812     seqLimits.addItemListener(this);
2813     featureSettings.setLabel("Feature Settings...");
2814     featureSettings.addActionListener(this);
2815     sequenceFeatures.setLabel("Sequence Features");
2816     sequenceFeatures.addItemListener(this);
2817     sequenceFeatures.setState(false);
2818     annotationColour.setLabel("by Annotation...");
2819     annotationColour.addActionListener(this);
2820     invertSequenceMenuItem.setLabel("Invert Sequence Selection");
2821     invertColSel.setLabel("Invert Column Selection");
2822     menu1.setLabel("Show");
2823     showColumns.setLabel("All Columns ");
2824     showSeqs.setLabel("All Sequences");
2825     menu2.setLabel("Hide");
2826     hideColumns.setLabel("Selected Columns");
2827     hideSequences.setLabel("Selected Sequences");
2828     invertColSel.addActionListener(this);
2829     showColumns.addActionListener(this);
2830     showSeqs.addActionListener(this);
2831     hideColumns.addActionListener(this);
2832     hideSequences.addActionListener(this);
2833     formatMenu.setLabel("Format");
2834     selectMenu.setLabel("Select");
2835     newView.setLabel("New View");
2836     newView.addActionListener(this);
2837     alignFrameMenuBar.add(fileMenu);
2838     alignFrameMenuBar.add(editMenu);
2839     alignFrameMenuBar.add(selectMenu);
2840     alignFrameMenuBar.add(viewMenu);
2841     alignFrameMenuBar.add(formatMenu);
2842     alignFrameMenuBar.add(colourMenu);
2843     alignFrameMenuBar.add(calculateMenu);
2844     alignFrameMenuBar.add(helpMenu);
2845
2846     fileMenu.add(inputText);
2847     fileMenu.add(loadTree);
2848     fileMenu.add(loadAnnotations);
2849
2850     fileMenu.addSeparator();
2851     fileMenu.add(outputTextboxMenu);
2852     fileMenu.add(outputFeatures);
2853     fileMenu.add(outputAnnotations);
2854
2855     if (jalviewServletURL != null)
2856     {
2857       fileMenu.add(loadApplication);
2858     }
2859
2860     fileMenu.addSeparator();
2861     fileMenu.add(closeMenuItem);
2862
2863     editMenu.add(undoMenuItem);
2864     editMenu.add(redoMenuItem);
2865     editMenu.add(cut);
2866     editMenu.add(copy);
2867     editMenu.add(pasteMenu);
2868     editMenu.add(delete);
2869     editMenu.addSeparator();
2870     editMenu.add(remove2LeftMenuItem);
2871     editMenu.add(remove2RightMenuItem);
2872     editMenu.add(removeGappedColumnMenuItem);
2873     editMenu.add(removeAllGapsMenuItem);
2874     editMenu.add(removeRedundancyMenuItem);
2875     viewMenu.add(newView);
2876     viewMenu.addSeparator();
2877     viewMenu.add(menu1);
2878     viewMenu.add(menu2);
2879     viewMenu.addSeparator();
2880     viewMenu.add(followMouseOverFlag);
2881     viewMenu.add(annotationPanelMenuItem);
2882     viewMenu.addSeparator();
2883     viewMenu.add(sequenceFeatures);
2884     viewMenu.add(featureSettings);
2885     viewMenu.addSeparator();
2886     viewMenu.add(alProperties);
2887     viewMenu.addSeparator();
2888     viewMenu.add(overviewMenuItem);
2889     colourMenu.add(applyToAllGroups);
2890     colourMenu.addSeparator();
2891     colourMenu.add(noColourmenuItem);
2892     colourMenu.add(clustalColour);
2893     colourMenu.add(BLOSUM62Colour);
2894     colourMenu.add(PIDColour);
2895     colourMenu.add(zappoColour);
2896     colourMenu.add(taylorColour);
2897     colourMenu.add(hydrophobicityColour);
2898     colourMenu.add(helixColour);
2899     colourMenu.add(strandColour);
2900     colourMenu.add(turnColour);
2901     colourMenu.add(buriedColour);
2902     colourMenu.add(nucleotideColour);
2903     colourMenu.add(userDefinedColour);
2904     colourMenu.addSeparator();
2905     colourMenu.add(conservationMenuItem);
2906     colourMenu.add(modifyConservation);
2907     colourMenu.add(abovePIDThreshold);
2908     colourMenu.add(modifyPID);
2909     colourMenu.add(annotationColour);
2910     calculateMenu.add(sort);
2911     calculateMenu.add(calculate);
2912     calculateMenu.addSeparator();
2913     calculateMenu.add(pairwiseAlignmentMenuItem);
2914     calculateMenu.add(PCAMenuItem);
2915     calculateMenu.add(autoCalculate);
2916     this.add(statusBar, BorderLayout.SOUTH);
2917     pasteMenu.add(pasteNew);
2918     pasteMenu.add(pasteThis);
2919     sort.add(sortIDMenuItem);
2920     sort.add(sortByTreeMenu);
2921     sort.add(sortGroupMenuItem);
2922     sort.add(sortPairwiseMenuItem);
2923     calculate.add(averageDistanceTreeMenuItem);
2924     calculate.add(neighbourTreeMenuItem);
2925     calculate.add(avDistanceTreeBlosumMenuItem);
2926     calculate.add(njTreeBlosumMenuItem);
2927     helpMenu.add(documentation);
2928     helpMenu.add(about);
2929     menu1.add(showColumns);
2930     menu1.add(showSeqs);
2931     menu2.add(hideColumns);
2932     menu2.add(hideSequences);
2933     formatMenu.add(font);
2934     formatMenu.add(seqLimits);
2935     formatMenu.add(wrapMenuItem);
2936     formatMenu.add(scaleAbove);
2937     formatMenu.add(scaleLeft);
2938     formatMenu.add(scaleRight);
2939     formatMenu.add(viewBoxesMenuItem);
2940     formatMenu.add(viewTextMenuItem);
2941     formatMenu.add(colourTextMenuItem);
2942     formatMenu.add(displayNonconservedMenuItem);
2943     formatMenu.add(renderGapsMenuItem);
2944     formatMenu.add(centreColumnLabelFlag);
2945     selectMenu.add(findMenuItem);
2946     selectMenu.addSeparator();
2947     selectMenu.add(selectAllSequenceMenuItem);
2948     selectMenu.add(deselectAllSequenceMenuItem);
2949     selectMenu.add(invertSequenceMenuItem);
2950     selectMenu.add(invertColSel);
2951     selectMenu.add(deleteGroups);
2952   }
2953
2954   MenuItem featureSettings = new MenuItem();
2955
2956   CheckboxMenuItem sequenceFeatures = new CheckboxMenuItem();
2957
2958   MenuItem annotationColour = new MenuItem();
2959
2960   MenuItem invertColSel = new MenuItem();
2961
2962   Menu menu1 = new Menu();
2963
2964   MenuItem showColumns = new MenuItem();
2965
2966   MenuItem showSeqs = new MenuItem();
2967
2968   Menu menu2 = new Menu();
2969
2970   MenuItem hideColumns = new MenuItem();
2971
2972   MenuItem hideSequences = new MenuItem();
2973
2974   Menu formatMenu = new Menu();
2975
2976   Menu selectMenu = new Menu();
2977
2978   MenuItem newView = new MenuItem();
2979
2980   /**
2981    * Attach the alignFrame panels after embedding menus, if necessary. This used
2982    * to be called setEmbedded, but is now creates the dropdown menus in a
2983    * platform independent manner to avoid OSX/Mac menu appendage daftness.
2984    *
2985    * @param reallyEmbedded
2986    *                true to attach the view to the applet area on the page
2987    *                rather than in a new window
2988    */
2989   public void createAlignFrameWindow(boolean reallyEmbedded, String title)
2990   {
2991     if (reallyEmbedded)
2992     {
2993       // ////
2994       // Explicly build the embedded menu panel for the on-page applet
2995       //
2996       // view cannot be closed if its actually on the page
2997       fileMenu.remove(closeMenuItem);
2998       fileMenu.remove(3); // Remove Seperator
2999       embeddedMenu = makeEmbeddedPopupMenu(alignFrameMenuBar, "Arial",
3000               Font.PLAIN, 10, false); // use our own fonts.
3001       // and actually add the components to the applet area
3002       viewport.applet.setLayout(new BorderLayout());
3003       viewport.applet.add(embeddedMenu, BorderLayout.NORTH);
3004       viewport.applet.add(statusBar, BorderLayout.SOUTH);
3005       alignPanel.setSize(viewport.applet.getSize().width, viewport.applet
3006               .getSize().height
3007               - embeddedMenu.HEIGHT - statusBar.HEIGHT);
3008       viewport.applet.add(alignPanel, BorderLayout.CENTER);
3009       viewport.applet.validate();
3010     }
3011     else
3012     {
3013       // //////
3014       // test and embed menu bar if necessary.
3015       //
3016       if (embedMenuIfNeeded(alignPanel))
3017       {
3018         // adjust for status bar height too
3019         alignPanel.setSize(getSize().width, getSize().height
3020                 - statusBar.HEIGHT);
3021       }
3022       add(statusBar, BorderLayout.SOUTH);
3023       add(alignPanel, BorderLayout.CENTER);
3024       // and register with the applet so it can pass external API calls to us
3025       jalview.bin.JalviewLite.addFrame(this, title, DEFAULT_WIDTH,
3026               DEFAULT_HEIGHT);
3027     }
3028   }
3029 }