X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fjalview%2Fappletgui%2FAlignFrame.java;h=8e54ba904ddb02fa0ebf392df5dde0c13c711db5;hb=14ead5d8009f9ac9a139ae93faf44e67a3998d46;hp=28b7cb5f3df129cd7d09164abc9447c2f3098304;hpb=ec955aa655d8320258b91eb079bc57f688cd0a07;p=jalview.git

diff --git a/src/jalview/appletgui/AlignFrame.java b/src/jalview/appletgui/AlignFrame.java
index 28b7cb5..8e54ba9 100755
--- a/src/jalview/appletgui/AlignFrame.java
+++ b/src/jalview/appletgui/AlignFrame.java
@@ -1,17 +1,24 @@
-/********************
- * 2004 Jalview Reengineered
- * Barton Group
- * Dundee University
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer
+ * Copyright (C) 2006 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
  *
- * AM Waterhouse
- *******************/
-
-
-
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
 
 package jalview.appletgui;
 
-import jalview.jbappletgui.GAlignFrame;
 import jalview.schemes.*;
 import jalview.datamodel.*;
 import jalview.analysis.*;
@@ -19,55 +26,641 @@ import jalview.io.*;
 import java.awt.*;
 import java.awt.event.*;
 import java.util.*;
+import java.io.InputStreamReader;
+import java.io.BufferedReader;
+import java.net.URL;
 
 
-public class AlignFrame extends GAlignFrame
+public class AlignFrame extends Frame implements ActionListener,
+    ItemListener, KeyListener, MouseListener
 {
-  final AlignmentPanel alignPanel;
-  final AlignViewport  viewport;
-  public static final int NEW_WINDOW_WIDTH = 700;
-  public static final int NEW_WINDOW_HEIGHT = 500;
-  jalview.bin.JalviewLite applet;
+  public AlignmentPanel alignPanel;
+  public AlignViewport viewport;
+  int DEFAULT_WIDTH = 700;
+  int DEFAULT_HEIGHT = 500;
 
-  public AlignFrame(AlignmentI al)
+  String jalviewServletURL;
+
+
+   public AlignFrame(AlignmentI al,
+                     jalview.bin.JalviewLite applet,
+                     String title,
+                     boolean embedded)
   {
-    this.applet = null;
-    viewport = new AlignViewport(al, null);
+
+    jalviewServletURL = applet.getParameter("APPLICATION_URL");
+
+    try{
+      jbInit();
+    }catch(Exception ex)
+    {
+      ex.printStackTrace();
+    }
+
+    viewport = new AlignViewport(al, applet);
     alignPanel = new AlignmentPanel(this, viewport);
-    add(alignPanel);
-    alignPanel.validate();
+
+    annotationPanelMenuItem.setState(viewport.showAnnotation);
+
+    seqLimits.setState(viewport.showJVSuffix);
+
+    if(applet!=null)
+    {
+      String param = applet.getParameter("sortBy");
+      if (param != null)
+      {
+        if (param.equalsIgnoreCase("Id"))
+          sortIDMenuItem_actionPerformed();
+        else if (param.equalsIgnoreCase("Pairwise Identity"))
+          sortPairwiseMenuItem_actionPerformed();
+      }
+
+      param = applet.getParameter("wrap");
+      if (param != null)
+      {
+        if (param.equalsIgnoreCase("true"))
+        {
+          wrapMenuItem.setState(true);
+          wrapMenuItem_actionPerformed();
+        }
+      }
+
+      try
+      {
+        param = applet.getParameter("windowWidth");
+        if (param != null)
+        {
+          int width = Integer.parseInt(param);
+          DEFAULT_WIDTH = width;
+        }
+        param = applet.getParameter("windowHeight");
+        if (param != null)
+        {
+          int height = Integer.parseInt(param);
+          DEFAULT_HEIGHT = height;
+        }
+      }
+      catch (Exception ex)
+      {}
+
+    }
+
+   //Some JVMS send keyevents to Top frame or lowest panel,
+   //Havent worked out why yet. So add to both this frame and seqCanvas for now
+   this.addKeyListener(this);
+   alignPanel.seqPanel.seqCanvas.addKeyListener(this);
+   alignPanel.idPanel.idCanvas.addKeyListener(this);
+   alignPanel.scalePanel.addKeyListener(this);
+   alignPanel.annotationPanel.addKeyListener(this);
+
+    viewport.addPropertyChangeListener(new java.beans.PropertyChangeListener()
+    {
+     public void propertyChange(java.beans.PropertyChangeEvent evt)
+     {
+       if (evt.getPropertyName().equals("alignment"))
+       {
+         alignmentChanged();
+       }
+     }
+   });
+
+
+   if(embedded)
+   {
+     setEmbedded();
+   }
+   else
+   {
+     add(alignPanel, BorderLayout.CENTER);
+     jalview.bin.JalviewLite.addFrame(this, title, DEFAULT_WIDTH,
+                                      DEFAULT_HEIGHT);
+   }
+   alignPanel.validate();
+   alignPanel.repaint();
+  }
+  public AlignViewport getAlignViewport()
+  {
+    return viewport;
   }
 
-  public AlignFrame(AlignmentI al, jalview.bin.JalviewLite applet)
+  public SeqCanvas getSeqcanvas()
   {
-    this.applet = applet;
-    viewport = new AlignViewport(al, applet);
-    alignPanel = new AlignmentPanel(this, viewport);
-    add(alignPanel);
-    alignPanel.validate();
+    return alignPanel.seqPanel.seqCanvas;
   }
 
-  public void inputText_actionPerformed(ActionEvent e)
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param String DOCUMENT ME!
+   */
+
+  public void parseFeaturesFile(String file, String type)
   {
-     CutAndPasteTransfer cap = new CutAndPasteTransfer(true);
-     Frame frame = new Frame();
-     frame.add(cap);
-     jalview.bin.JalviewLite.addFrame(frame, "Cut & Paste Input", 500,500);
+    Hashtable featureLinks = new Hashtable();
+    boolean featuresFile = false;
+    try{
+      featuresFile = new jalview.io.FeaturesFile(file, type).parse(viewport.alignment,
+                                         alignPanel.seqPanel.seqCanvas.
+                                         getFeatureRenderer().featureColours,
+                                         featureLinks,
+                                         true);
+    }
+    catch(Exception ex)
+    {
+      ex.printStackTrace();
+    }
+
+    if(featuresFile)
+    {
+      if(featureLinks.size()>0)
+        alignPanel.seqPanel.seqCanvas
+            .getFeatureRenderer().featureLinks = featureLinks;
+      viewport.showSequenceFeatures = true;
+      sequenceFeatures.setState(true);
+      alignPanel.repaint();
+    }
+
   }
 
 
+  public void keyPressed(KeyEvent evt)
+  {
+    if (viewport.cursorMode
+        && evt.getKeyCode() >= KeyEvent.VK_0
+        && evt.getKeyCode() <= KeyEvent.VK_9)
+    {
+      alignPanel.seqPanel.numberPressed(evt.getKeyChar());
+    }
+
+    switch (evt.getKeyCode())
+    {
+      case 27: // escape key
+        deselectAllSequenceMenuItem_actionPerformed();
+        break;
+      case KeyEvent.VK_X:
+        if (evt.isControlDown() || evt.isMetaDown())
+        {
+          cut_actionPerformed();
+        }
+        break;
+      case KeyEvent.VK_C:
+        if (viewport.cursorMode && !evt.isControlDown())
+        {
+          alignPanel.seqPanel.setCursorColumn();
+        }
+        if (evt.isControlDown() || evt.isMetaDown())
+        {
+          copy_actionPerformed();
+        }
+        break;
+      case KeyEvent.VK_V:
+        if (evt.isControlDown() || evt.isMetaDown())
+        {
+          paste(true);
+        }
+        break;
+      case KeyEvent.VK_A:
+        if (evt.isControlDown() || evt.isMetaDown())
+        {
+          selectAllSequenceMenuItem_actionPerformed();
+        }
+        break;
+      case KeyEvent.VK_DOWN:
+        if(viewport.cursorMode)
+        {
+          alignPanel.seqPanel.moveCursor(0,1);
+        }
+        else
+          moveSelectedSequences(false);
+        break;
+
+      case KeyEvent.VK_UP:
+        if (viewport.cursorMode)
+        {
+          alignPanel.seqPanel.moveCursor(0,-1);
+        }
+        else
+          moveSelectedSequences(true);
+        break;
+
+      case KeyEvent.VK_LEFT:
+        if(viewport.cursorMode)
+        {
+          alignPanel.seqPanel.moveCursor(-1,0);
+        }
+        break;
+
+      case KeyEvent.VK_RIGHT:
+        if (viewport.cursorMode)
+        {
+          alignPanel.seqPanel.moveCursor(1,0);
+        }
+        break;
+      case KeyEvent.VK_SPACE:
+        if(viewport.cursorMode)
+        {
+          alignPanel.seqPanel.insertGapAtCursor(evt.isControlDown()
+                                                || evt.isShiftDown()
+                                                || evt.isAltDown()
+              );
+        }
+        break;
+
+      case KeyEvent.VK_DELETE:
+      case KeyEvent.VK_BACK_SPACE:
+        if(viewport.cursorMode)
+        {
+          alignPanel.seqPanel.deleteGapAtCursor(evt.isControlDown()
+                                                || evt.isShiftDown()
+                                                || evt.isAltDown()
+              );
+        }
+       else
+        {
+          cut_actionPerformed();
+          alignPanel.seqPanel.seqCanvas.repaint();
+        }
+        break;
+
+      case KeyEvent.VK_S:
+        if(viewport.cursorMode)
+        {
+          alignPanel.seqPanel.setCursorRow();
+        }
+        break;
+      case KeyEvent.VK_P:
+        if(viewport.cursorMode)
+        {
+          alignPanel.seqPanel.setCursorPosition();
+        }
+        break;
+
+      case KeyEvent.VK_ENTER:
+      case KeyEvent.VK_COMMA:
+        if(viewport.cursorMode)
+        {
+          alignPanel.seqPanel.setCursorRowAndColumn();
+        }
+        break;
+
+      case KeyEvent.VK_Q:
+        if(viewport.cursorMode)
+        {
+          alignPanel.seqPanel.setSelectionAreaAtCursor(true);
+        }
+        break;
+      case KeyEvent.VK_M:
+        if(viewport.cursorMode)
+        {
+          alignPanel.seqPanel.setSelectionAreaAtCursor(false);
+        }
+        break;
+
+     case KeyEvent.VK_F2:
+       viewport.cursorMode = ! viewport.cursorMode;
+       statusBar.setText("Keyboard editing mode is "+
+           (viewport.cursorMode ? "on" : "off"));
+       if(viewport.cursorMode)
+       {
+         alignPanel.seqPanel.seqCanvas.cursorX = viewport.startRes;
+         alignPanel.seqPanel.seqCanvas.cursorY = viewport.startSeq;
+       }
+       alignPanel.seqPanel.seqCanvas.repaint();
+       break;
+
+      case KeyEvent.VK_F:
+        if (evt.isControlDown())
+        {
+          findMenuItem_actionPerformed();
+        }
+        break;
+      case KeyEvent.VK_H:
+      {
+        boolean toggleSeqs = !evt.isControlDown();
+        boolean toggleCols = !evt.isShiftDown();
+        boolean hide = false;
+        SequenceGroup sg = viewport.getSelectionGroup();
+
+        if(toggleSeqs)
+        {
+          if (sg != null && sg.getSize(false) != viewport.alignment.getHeight())
+          {
+            hide = true;
+            viewport.hideAllSelectedSeqs();
+          }
+          else if (!(toggleCols && viewport.colSel.getSelected().size() > 0))
+            viewport.showAllHiddenSeqs();
+        }
+
+        if(toggleCols)
+        {
+          if (viewport.colSel.getSelected().size() > 0)
+          {
+            viewport.hideSelectedColumns();
+            if(!toggleSeqs)
+                   viewport.selectionGroup = sg;
+          }
+          else if (!hide)
+            viewport.showAllHiddenColumns();
+        }
+
+        alignPanel.repaint();
+        break;
+      }
+      case KeyEvent.VK_PAGE_UP:
+        if (viewport.wrapAlignment)
+          alignPanel.scrollUp(true);
+        else
+          alignPanel.setScrollValues(viewport.startRes,
+                                     viewport.startSeq
+                                     - viewport.endSeq + viewport.startSeq);
+        break;
+      case KeyEvent.VK_PAGE_DOWN:
+        if (viewport.wrapAlignment)
+          alignPanel.scrollUp(false);
+        else
+          alignPanel.setScrollValues(viewport.startRes,
+                                     viewport.startSeq
+                                     + viewport.endSeq - viewport.startSeq);
+        break;
+      }
+  }
+  public void keyReleased(KeyEvent evt)
+  {}
+  public void keyTyped(KeyEvent evt)
+  {}
+
+public void itemStateChanged(ItemEvent evt)
+  {
+    if(evt.getSource()==colourTextMenuItem)
+            colourTextMenuItem_actionPerformed();
+    else if(evt.getSource()==wrapMenuItem)
+            wrapMenuItem_actionPerformed();
+    else if(evt.getSource()==scaleAbove)
+            scaleAbove_actionPerformed();
+    else if(evt.getSource()==scaleLeft)
+            scaleLeft_actionPerformed();
+    else if(evt.getSource()==scaleRight)
+            scaleRight_actionPerformed();
+     else if(evt.getSource()==seqLimits)
+      seqLimits_itemStateChanged();
+    else if(evt.getSource()==viewBoxesMenuItem)
+            viewBoxesMenuItem_actionPerformed();
+    else if(evt.getSource()==viewTextMenuItem)
+            viewTextMenuItem_actionPerformed();
+    else if(evt.getSource()==renderGapsMenuItem)
+            renderGapsMenuItem_actionPerformed();
+    else if(evt.getSource()==annotationPanelMenuItem)
+            annotationPanelMenuItem_actionPerformed();
+      else if(evt.getSource()==sequenceFeatures)
+      {
+           viewport.showSequenceFeatures(sequenceFeatures.getState());
+            alignPanel.seqPanel.seqCanvas.repaint();
+      }
+      else if(evt.getSource()==conservationMenuItem)
+            conservationMenuItem_actionPerformed();
+      else if(evt.getSource()==abovePIDThreshold)
+            abovePIDThreshold_actionPerformed();
+          else if(evt.getSource()==applyToAllGroups)
+            applyToAllGroups_actionPerformed();
+      else if(evt.getSource()==autoCalculate)
+          viewport.autocalculateConsensus = autoCalculate.getState();
+  }
+ public void actionPerformed(ActionEvent evt)
+ {
+    Object source = evt.getSource();
+
+    if(source==inputText)
+      inputText_actionPerformed();
+    else if(source==loadTree)
+      loadTree_actionPerformed();
+    else if(source==loadApplication)
+      launchFullApplication();
+    else if(source==closeMenuItem)
+      closeMenuItem_actionPerformed();
+    else if(source==copy)
+      copy_actionPerformed();
+    else if(source==undoMenuItem)
+      undoMenuItem_actionPerformed();
+    else if(source==redoMenuItem)
+      redoMenuItem_actionPerformed();
+    else if(source==inputText)
+            inputText_actionPerformed();
+    else if(source==closeMenuItem)
+            closeMenuItem_actionPerformed();
+    else if(source==undoMenuItem)
+            undoMenuItem_actionPerformed();
+    else if(source==redoMenuItem)
+            redoMenuItem_actionPerformed();
+    else if(source==copy)
+            copy_actionPerformed();
+    else if(source==pasteNew)
+            pasteNew_actionPerformed();
+    else if(source==pasteThis)
+            pasteThis_actionPerformed();
+    else if(source==cut)
+            cut_actionPerformed();
+    else if(source==delete)
+            delete_actionPerformed();
+    else if(source==deleteGroups)
+            deleteGroups_actionPerformed();
+    else if(source==selectAllSequenceMenuItem)
+            selectAllSequenceMenuItem_actionPerformed();
+    else if(source==deselectAllSequenceMenuItem)
+            deselectAllSequenceMenuItem_actionPerformed();
+    else if(source==invertSequenceMenuItem)
+            invertSequenceMenuItem_actionPerformed();
+    else if(source==invertColSel)
+    { viewport.invertColumnSelection(); alignPanel.repaint(); }
+    else if(source==remove2LeftMenuItem)
+            remove2LeftMenuItem_actionPerformed();
+    else if(source==remove2RightMenuItem)
+            remove2RightMenuItem_actionPerformed();
+    else if(source==removeGappedColumnMenuItem)
+            removeGappedColumnMenuItem_actionPerformed();
+    else if(source==removeAllGapsMenuItem)
+            removeAllGapsMenuItem_actionPerformed();
+    else if(source==findMenuItem)
+            findMenuItem_actionPerformed();
+    else if(source==font)
+            font_actionPerformed();
+    else if(source==showColumns)
+    {
+      viewport.showAllHiddenColumns(); alignPanel.repaint();
+    }
+    else if(source==showSeqs)
+    {
+      viewport.showAllHiddenSeqs();
+    }
+    else if(source == hideColumns)
+    {
+      viewport.hideSelectedColumns(); alignPanel.repaint();
+    }
+    else if(source == hideSequences && viewport.getSelectionGroup()!=null)
+    {
+      viewport.hideAllSelectedSeqs();
+    }
+    else if(source==featureSettings)
+            featureSettings_actionPerformed();
+    else if(source==overviewMenuItem)
+            overviewMenuItem_actionPerformed();
+    else if(source==noColourmenuItem)
+            noColourmenuItem_actionPerformed();
+    else if(source==clustalColour)
+            clustalColour_actionPerformed();
+    else if(source==zappoColour)
+            zappoColour_actionPerformed();
+    else if(source==taylorColour)
+            taylorColour_actionPerformed();
+    else if(source==hydrophobicityColour)
+            hydrophobicityColour_actionPerformed();
+    else if(source==helixColour)
+            helixColour_actionPerformed();
+    else if(source==strandColour)
+            strandColour_actionPerformed();
+    else if(source==turnColour)
+            turnColour_actionPerformed();
+    else if(source==buriedColour)
+            buriedColour_actionPerformed();
+    else if(source==nucleotideColour)
+            nucleotideColour_actionPerformed();
+    else if(source==modifyPID)
+            modifyPID_actionPerformed();
+    else if(source==modifyConservation)
+            modifyConservation_actionPerformed();
+    else if(source==userDefinedColour)
+            userDefinedColour_actionPerformed();
+    else if(source==PIDColour)
+            PIDColour_actionPerformed();
+    else if(source==BLOSUM62Colour)
+            BLOSUM62Colour_actionPerformed();
+    else if(source==annotationColour)
+           new AnnotationColourChooser(viewport, alignPanel);
+    else if(source==sortPairwiseMenuItem)
+            sortPairwiseMenuItem_actionPerformed();
+    else if(source==sortIDMenuItem)
+            sortIDMenuItem_actionPerformed();
+    else if(source==sortGroupMenuItem)
+            sortGroupMenuItem_actionPerformed();
+    else if(source==removeRedundancyMenuItem)
+            removeRedundancyMenuItem_actionPerformed();
+    else if(source==pairwiseAlignmentMenuItem)
+            pairwiseAlignmentMenuItem_actionPerformed();
+    else if(source==PCAMenuItem)
+            PCAMenuItem_actionPerformed();
+    else if(source==averageDistanceTreeMenuItem)
+            averageDistanceTreeMenuItem_actionPerformed();
+    else if(source==neighbourTreeMenuItem)
+            neighbourTreeMenuItem_actionPerformed();
+    else if(source==njTreeBlosumMenuItem)
+            njTreeBlosumMenuItem_actionPerformed();
+    else if(source==avDistanceTreeBlosumMenuItem)
+            avTreeBlosumMenuItem_actionPerformed();
+    else if(source==documentation)
+            documentation_actionPerformed();
+    else if(source==about)
+            about_actionPerformed();
+
+ }
+
+  public void inputText_actionPerformed()
+  {
+    CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
+    Frame frame = new Frame();
+    frame.add(cap);
+    jalview.bin.JalviewLite.addFrame(frame, "Cut & Paste Input", 500, 500);
+  }
+
   protected void outputText_actionPerformed(ActionEvent e)
   {
-     CutAndPasteTransfer cap = new CutAndPasteTransfer(false);
-     Frame frame = new Frame();
-     frame.add(cap);
-     jalview.bin.JalviewLite.addFrame(frame,"Alignment output - "+e.getActionCommand(),600, 500);
-     cap.setText( FormatAdapter.formatSequences(e.getActionCommand(), viewport.getAlignment().getSequences()));
+    CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
+    Frame frame = new Frame();
+    frame.add(cap);
+    jalview.bin.JalviewLite.addFrame(frame,
+                                     "Alignment output - " + e.getActionCommand(),
+                                     600, 500);
+    cap.setText(new AppletFormatAdapter().formatSequences(e.getActionCommand(),
+                                              viewport.getAlignment().getSequences(),
+                                                      viewport.showJVSuffix));
   }
 
-  public void closeMenuItem_actionPerformed(ActionEvent e)
+  void launchFullApplication()
   {
-    dispose();
+    StringBuffer url = new StringBuffer(jalviewServletURL);
+
+    url.append("?open="+
+               appendProtocol( viewport.applet.getParameter("file") ) );
+
+    if(viewport.applet.getParameter("features")!=null)
+    {
+      url.append( "&features=" );
+      url.append( appendProtocol( viewport.applet.getParameter("features") ) );
+    }
+
+    if(viewport.applet.getParameter("annotations")!=null)
+    {
+      url.append( "&annotations=" );
+      url.append( appendProtocol( viewport.applet.getParameter("annotations") ) );
+    }
+
+    if(viewport.applet.getParameter("jnetfile")!=null)
+    {
+      url.append( "&annotations=" );
+      url.append( appendProtocol( viewport.applet.getParameter("jnetfile") ) );
+    }
+
+    if(viewport.applet.getParameter("defaultColour")!=null)
+    {
+      url.append("&colour=" +
+                 removeWhiteSpace(viewport.applet.getParameter("defaultColour"))
+          );
+    }
+
+    if(viewport.applet.getParameter("userDefinedColour")!=null)
+    {
+      url.append( "&colour=" +
+                 removeWhiteSpace( viewport.applet.getParameter("userDefinedColour") )
+         );
+    }
+
+    showURL(url.toString(), "FULL_APP");
+  }
+
+
+  String removeWhiteSpace(String colour)
+  {
+    StringBuffer sb = new StringBuffer();
+    for (int i = 0; i < colour.length(); i++)
+    {
+      if (Character.isWhitespace(colour.charAt(i)))
+        sb.append("%20");
+      else
+        sb.append(colour.charAt(i));
+    }
+
+    return sb.toString();
+  }
+
+
+  String appendProtocol(String url)
+  {
+    try{
+       new URL(url);
+    }catch(java.net.MalformedURLException ex)
+    {
+      url = viewport.applet.getCodeBase()+url;
+    }
+    return url;
+  }
+
+  public void closeMenuItem_actionPerformed()
+  {
+    PaintRefresher.components.remove(viewport.alignment);
+    if(PaintRefresher.components.size()==0 && viewport.applet==null)
+      System.exit(0);
+
+    this.dispose();
   }
 
   Stack historyList = new Stack();
@@ -75,24 +668,24 @@ public class AlignFrame extends GAlignFrame
 
   void updateEditMenuBar()
   {
-    if(historyList.size()>0)
-     {
-       undoMenuItem.setEnabled(true);
-       Object [] history = (Object[])historyList.elementAt(0);
-       undoMenuItem.setLabel("Undo "+history[0]);
-     }
+    if (historyList.size() > 0)
+    {
+      undoMenuItem.setEnabled(true);
+      HistoryItem hi = (HistoryItem) historyList.peek();
+      undoMenuItem.setLabel("Undo " + hi.getDescription());
+    }
     else
     {
       undoMenuItem.setEnabled(false);
       undoMenuItem.setLabel("Undo");
     }
 
-    if(redoList.size()>0)
-     {
-       redoMenuItem.setEnabled(true);
-       Object [] history = (Object[])redoList.elementAt(0);
-       redoMenuItem.setLabel("Redo "+history[0]);
-     }
+    if (redoList.size() > 0)
+    {
+      redoMenuItem.setEnabled(true);
+      HistoryItem hi = (HistoryItem) redoList.peek();
+      redoMenuItem.setLabel("Redo " + hi.getDescription());
+    }
     else
     {
       redoMenuItem.setEnabled(false);
@@ -100,67 +693,68 @@ public class AlignFrame extends GAlignFrame
     }
   }
 
-  public void addHistoryItem(String type)
+  public void addHistoryItem(HistoryItem hi)
   {
-    // must make sure we add new sequence objects her, not refs to the existing sequences
+    historyList.push(hi);
     redoList.removeAllElements();
-    SequenceI[] seq = new SequenceI[viewport.getAlignment().getHeight()];
-    for(int i=0; i<viewport.getAlignment().getHeight(); i++)
-    {
-      seq[i] = new Sequence( viewport.getAlignment().getSequenceAt(i).getName(),
-                             viewport.getAlignment().getSequenceAt(i).getSequence());
-    }
-
-    historyList.addElement(new Object[]{type,  seq} );
     updateEditMenuBar();
   }
 
-  protected void undoMenuItem_actionPerformed(ActionEvent e)
+  protected void undoMenuItem_actionPerformed()
   {
-    Object [] history = (Object[])historyList.elementAt(0);
-    historyList.removeElementAt(0);
-    // add the redo state before continuing!!
-    SequenceI[] seq = new SequenceI[viewport.getAlignment().getHeight()];
-    for (int i = 0; i < viewport.getAlignment().getHeight(); i++)
-    {
-      seq[i] = new Sequence(viewport.getAlignment().getSequenceAt(i).getName(),
-                            viewport.getAlignment().getSequenceAt(i).
-                            getSequence());
-    }
-    /////////
-
-    redoList.addElement(new Object[] {history[0], seq});
+    HistoryItem nh,hi = (HistoryItem) historyList.pop();
+    redoList.push(nh=new HistoryItem(hi.getDescription(), viewport.alignment,
+                                  HistoryItem.HIDE));
+    if (hi.alColumnChanges!=null)
+      nh.alColumnChanges=hi.alColumnChanges.getInverse();
+    restoreHistoryItem(hi);
+    viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
+  }
 
-      seq = (SequenceI[]) history[1];
+  protected void redoMenuItem_actionPerformed()
+  {
+    HistoryItem nh,hi = (HistoryItem) redoList.pop();
+    historyList.push(nh=new HistoryItem(hi.getDescription(), viewport.alignment,
+                                  HistoryItem.HIDE));
+    if (hi.alColumnChanges!=null)
+      nh.alColumnChanges=hi.alColumnChanges.getInverse();
+    restoreHistoryItem(hi);
+    updateEditMenuBar();
+    viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
+  }
 
-      AlignmentAnnotation[] old = viewport.alignment.getAlignmentAnnotation();
-      viewport.setAlignment(new Alignment(seq));
-      updateEditMenuBar();
-      for (int i = 0; i < old.length; i++)
-        viewport.alignment.addAnnotation(old[i]);
+  // used by undo and redo
+  void restoreHistoryItem(HistoryItem hi)
+  {
+    hi.restore(viewport.getColumnSelection());
+    updateEditMenuBar();
 
-      viewport.updateConservation();
-      viewport.updateConsensus();
-      alignPanel.repaint();
+    viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
   }
 
   public void moveSelectedSequences(boolean up)
   {
     SequenceGroup sg = viewport.getSelectionGroup();
     if (sg == null)
+    {
       return;
+    }
 
     if (up)
     {
       for (int i = 1; i < viewport.alignment.getHeight(); i++)
       {
         SequenceI seq = viewport.alignment.getSequenceAt(i);
-        if (!sg.sequences.contains(seq))
+        if (!sg.getSequences(false).contains(seq))
+        {
           continue;
+        }
 
         SequenceI temp = viewport.alignment.getSequenceAt(i - 1);
-        if (sg.sequences.contains(temp))
+        if (sg.getSequences(false).contains(temp))
+        {
           continue;
+        }
 
         viewport.alignment.getSequences().setElementAt(temp, i);
         viewport.alignment.getSequences().setElementAt(seq, i - 1);
@@ -171,12 +765,16 @@ public class AlignFrame extends GAlignFrame
       for (int i = viewport.alignment.getHeight() - 2; i > -1; i--)
       {
         SequenceI seq = viewport.alignment.getSequenceAt(i);
-        if (!sg.sequences.contains(seq))
+        if (!sg.getSequences(true).contains(seq))
+        {
           continue;
+        }
 
         SequenceI temp = viewport.alignment.getSequenceAt(i + 1);
-        if (sg.sequences.contains(temp))
+        if (sg.getSequences(true).contains(temp))
+        {
           continue;
+        }
 
         viewport.alignment.getSequences().setElementAt(temp, i);
         viewport.alignment.getSequences().setElementAt(seq, i + 1);
@@ -186,43 +784,117 @@ public class AlignFrame extends GAlignFrame
     alignPanel.repaint();
   }
 
-
-  StringBuffer copiedSequences;
-  protected void copy_actionPerformed(ActionEvent e)
+  static StringBuffer copiedSequences;
+  static Vector copiedHiddenColumns;
+  protected void copy_actionPerformed()
   {
-   if(viewport.getSelectionGroup()==null)
-     return;
+    if (viewport.getSelectionGroup() == null)
+    {
+      return;
+    }
 
-   SequenceGroup sg = viewport.getSelectionGroup();
-   copiedSequences = new StringBuffer();
+    SequenceGroup sg = viewport.getSelectionGroup();
+    copiedSequences = new StringBuffer();
+    Hashtable orderedSeqs = new Hashtable();
+    for (int i = 0; i < sg.getSize(false); i++)
+    {
+      SequenceI seq = sg.getSequenceAt(i);
+      int index = viewport.alignment.findIndex(seq);
+      orderedSeqs.put(index + "", seq);
+    }
 
-       for(int i=0; i<sg.getSize(); i++)
-       {
-         SequenceI seq = sg.getSequenceAt(i);
-         copiedSequences.append( seq.getName()+"\t"+seq.findPosition( sg.getStartRes() ) +"\t"
-                        +seq.findPosition( sg.getEndRes() )+ "\t"
-                        +sg.getSequenceAt(i).getSequence(sg.getStartRes(), sg.getEndRes()+1)+"\n");
-       }
+    int index = 0, startRes, endRes;
+    char ch;
 
-  }
+    if (viewport.hasHiddenColumns && viewport.getSelectionGroup() != null)
+    {
+      copiedHiddenColumns = new Vector();
+      int hiddenOffset = viewport.getSelectionGroup().getStartRes();
+      for (int i = 0; i < viewport.getColumnSelection().getHiddenColumns().size();
+           i++)
+      {
+        int[] region = (int[])
+            viewport.getColumnSelection().getHiddenColumns().elementAt(i);
 
+        copiedHiddenColumns.addElement(new int[]
+                                 {region[0] - hiddenOffset,
+                                 region[1] - hiddenOffset});
+      }
+    }
+    else
+      copiedHiddenColumns = null;
+
+
+    for (int i = 0; i < sg.getSize(false); i++)
+    {
+        SequenceI seq = null;
+
+        while (seq == null)
+        {
+            if (orderedSeqs.containsKey(index + ""))
+            {
+                seq = (SequenceI) orderedSeqs.get(index + "");
+                index++;
+
+                break;
+            }
+            else
+            {
+                index++;
+            }
+        }
 
-  protected void pasteNew_actionPerformed(ActionEvent e)
+        //FIND START RES
+        //Returns residue following index if gap
+        startRes = seq.findPosition(sg.getStartRes());
+
+        //FIND END RES
+        //Need to find the residue preceeding index if gap
+        endRes = 0;
+
+        for (int j = 0; j < sg.getEndRes()+1 && j < seq.getLength(); j++)
+        {
+          ch = seq.getCharAt(j);
+          if (!jalview.util.Comparison.isGap( (ch)))
+          {
+            endRes++;
+          }
+        }
+
+        if(endRes>0)
+        {
+          endRes += seq.getStart() -1;
+        }
+
+        copiedSequences.append(seq.getName() + "\t" +
+            startRes + "\t" +
+            endRes + "\t" +
+            seq.getSequence(sg.getStartRes(),
+                sg.getEndRes() + 1) + "\n");
+    }
+
+  }
+
+  protected void pasteNew_actionPerformed()
   {
     paste(true);
   }
 
-  protected void pasteThis_actionPerformed(ActionEvent e)
+  protected void pasteThis_actionPerformed()
   {
-    addHistoryItem("Paste");
+    addHistoryItem(new HistoryItem("Paste Sequences", viewport.alignment,
+                                   HistoryItem.PASTE));
     paste(false);
   }
 
   void paste(boolean newAlignment)
   {
-    try{
+    try
+    {
       if (copiedSequences == null)
+      {
         return;
+      }
 
       StringTokenizer st = new StringTokenizer(copiedSequences.toString());
       Vector seqs = new Vector();
@@ -231,96 +903,127 @@ public class AlignFrame extends GAlignFrame
         String name = st.nextToken();
         int start = Integer.parseInt(st.nextToken());
         int end = Integer.parseInt(st.nextToken());
-        Sequence sequence = new Sequence(name,st.nextToken(), start, end);
+        Sequence sequence = new Sequence(name, st.nextToken(), start, end);
 
-        if(!newAlignment)
+        if (!newAlignment)
+        {
           viewport.alignment.addSequence(sequence);
+        }
         else
+        {
           seqs.addElement(sequence);
+        }
       }
 
-      if(newAlignment)
+      if (newAlignment)
       {
         SequenceI[] newSeqs = new SequenceI[seqs.size()];
-        for(int i=0; i<seqs.size(); i++)
-         newSeqs[i] = (SequenceI)seqs.elementAt(i);
+        for (int i = 0; i < seqs.size(); i++)
+        {
+          newSeqs[i] = (SequenceI) seqs.elementAt(i);
+        }
+
+        String newtitle = new String("Copied sequences");
+        if (getTitle().startsWith("Copied sequences"))
+        {
+          newtitle = getTitle();
+        }
+        else
+        {
+          newtitle = newtitle.concat("- from " + getTitle());
+        }
+        AlignFrame af = new AlignFrame(new Alignment(newSeqs),
+                                       viewport.applet,
+                                       newtitle,
+                                       false);
+        if (copiedHiddenColumns != null)
+        {
+          for (int i = 0; i < copiedHiddenColumns.size(); i++)
+          {
+            int[] region = (int[]) copiedHiddenColumns.elementAt(i);
+            af.viewport.hideColumns(region[0], region[1]);
+          }
+        }
 
-        AlignFrame af = new AlignFrame(new Alignment(newSeqs), applet);
-        jalview.bin.JalviewLite.addFrame(af, "Copied sequences", NEW_WINDOW_WIDTH, NEW_WINDOW_HEIGHT);
+
+        jalview.bin.JalviewLite.addFrame(af, newtitle, DEFAULT_WIDTH,
+                                         DEFAULT_HEIGHT);
       }
       else
       {
         viewport.setEndSeq(viewport.alignment.getHeight());
         viewport.alignment.getWidth();
-        viewport.updateConservation();
-        viewport.updateConsensus();
-        alignPanel.repaint();
+        viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
       }
 
-    }catch(Exception ex){}// could be anything being pasted in here
+    }
+    catch (Exception ex)
+    {} // could be anything being pasted in here
 
   }
 
-
-  protected void cut_actionPerformed(ActionEvent e)
+  protected void cut_actionPerformed()
   {
-    copy_actionPerformed(null);
-    delete_actionPerformed(null);
+    copy_actionPerformed();
+    delete_actionPerformed();
   }
 
-  protected void delete_actionPerformed(ActionEvent e)
+  protected void delete_actionPerformed()
   {
-    addHistoryItem("Delete");
+    addHistoryItem(new HistoryItem("Delete Sequences", viewport.alignment,
+                                   HistoryItem.HIDE));
     if (viewport.getSelectionGroup() == null)
+    {
       return;
+    }
 
-     SequenceGroup sg = viewport.getSelectionGroup();
-     for (int i=0;i < sg.sequences.size(); i++)
-     {
-       SequenceI seq = sg.getSequenceAt(i);
-       int index = viewport.getAlignment().findIndex(seq);
-       seq.deleteChars(sg.getStartRes(), sg.getEndRes()+1);
-
-       if(seq.getSequence().length()<1)
-          viewport.getAlignment().deleteSequence(seq);
-      else
-          viewport.getAlignment().getSequences().setElementAt(seq, index);
-     }
 
-     viewport.setSelectionGroup(null);
-     viewport.alignment.deleteGroup(sg);
-     viewport.resetSeqLimits( alignPanel.seqPanel.seqCanvas.getSize().height);
-     if(viewport.getAlignment().getHeight()<1)
-     try
-     {
-       this.setVisible(false);
-     }catch(Exception ex){}
-   viewport.updateConservation();
-   viewport.updateConsensus();
-     alignPanel.repaint();
+    SequenceGroup sg = viewport.getSelectionGroup();
+    boolean allSequences = false;
+    if(sg.getSize(false)==viewport.alignment.getHeight())
+          allSequences = true;
 
-  }
+    for (int i = 0; i < sg.getSize(false); i++)
+    {
+      SequenceI seq = sg.getSequenceAt(i);
+      int index = viewport.getAlignment().findIndex(seq);
+      seq.deleteChars(sg.getStartRes(), sg.getEndRes() + 1);
 
+      // If the cut affects all sequences, remove highlighted columns
+      if (allSequences)
+      {
+        viewport.getColumnSelection().removeElements(sg.getStartRes(),
+                                                     sg.getEndRes() + 1);
+      }
 
 
-  protected void redoMenuItem_actionPerformed(ActionEvent e)
-  {
-     Object [] history = (Object[])redoList.pop();
-     SequenceI[] seq = (SequenceI[]) history[1];
+      if (seq.getSequence().length() < 1)
+      {
+        viewport.getAlignment().deleteSequence(seq);
+      }
+      else
+      {
+        viewport.getAlignment().getSequences().setElementAt(seq, index);
+      }
+    }
 
-     AlignmentAnnotation[] old = viewport.alignment.getAlignmentAnnotation();
-     viewport.setAlignment(new Alignment(seq));
-     for (int i = 0; i < old.length; i++)
-       viewport.alignment.addAnnotation(old[i]);
+    viewport.setSelectionGroup(null);
+    viewport.alignment.deleteGroup(sg);
+    viewport.resetSeqLimits(alignPanel.seqPanel.seqCanvas.getSize().height);
+    if (viewport.getAlignment().getHeight() < 1)
+    {
+      try
+      {
+        this.setVisible(false);
+      }
+      catch (Exception ex)
+      {}
+    }
+    viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
 
-     viewport.updateConservation();
-     viewport.updateConsensus();
-     updateEditMenuBar();
-     alignPanel.repaint();
   }
 
-
-  protected void deleteGroups_actionPerformed(ActionEvent e)
+  protected void deleteGroups_actionPerformed()
   {
     viewport.alignment.deleteAllGroups();
     viewport.setSelectionGroup(null);
@@ -328,362 +1031,485 @@ public class AlignFrame extends GAlignFrame
     alignPanel.repaint();
   }
 
-
-
-  public void selectAllSequenceMenuItem_actionPerformed(ActionEvent e)
+  public void selectAllSequenceMenuItem_actionPerformed()
   {
     SequenceGroup sg = new SequenceGroup();
-    for (int i=0; i<viewport.getAlignment().getSequences().size(); i++)
-      sg.addSequence( viewport.getAlignment().getSequenceAt(i));
-    sg.setEndRes(viewport.alignment.getWidth());
+    for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
+    {
+      sg.addSequence(viewport.getAlignment().getSequenceAt(i), false);
+    }
+    sg.setEndRes(viewport.alignment.getWidth()-1);
     viewport.setSelectionGroup(sg);
     alignPanel.repaint();
-    PaintRefresher.Refresh(null);
+    PaintRefresher.Refresh(null, viewport.alignment);
   }
 
-  public void deselectAllSequenceMenuItem_actionPerformed(ActionEvent e)
+  public void deselectAllSequenceMenuItem_actionPerformed()
   {
+    if(viewport.cursorMode)
+    {
+      alignPanel.seqPanel.keyboardNo1=null;
+      alignPanel.seqPanel.keyboardNo2=null;
+    }
     viewport.setSelectionGroup(null);
     viewport.getColumnSelection().clear();
     viewport.setSelectionGroup(null);
-    PaintRefresher.Refresh(null);
+    alignPanel.idPanel.idCanvas.searchResults = null;
+    alignPanel.seqPanel.seqCanvas.highlightSearchResults(null);
+    alignPanel.repaint();
+    PaintRefresher.Refresh(null, viewport.alignment);
   }
 
-  public void invertSequenceMenuItem_actionPerformed(ActionEvent e)
+  public void invertSequenceMenuItem_actionPerformed()
   {
     SequenceGroup sg = viewport.getSelectionGroup();
-    for (int i=0; i<viewport.getAlignment().getSequences().size(); i++)
-      sg.addOrRemove (viewport.getAlignment().getSequenceAt(i));
+    for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
+    {
+      sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false);
+    }
 
-    PaintRefresher.Refresh(null);
+    PaintRefresher.Refresh(null, viewport.alignment);
   }
 
-  public void remove2LeftMenuItem_actionPerformed(ActionEvent e)
+  public void remove2LeftMenuItem_actionPerformed()
   {
-    addHistoryItem("delete columns");
     ColumnSelection colSel = viewport.getColumnSelection();
     if (colSel.size() > 0)
     {
+      HistoryItem edit;
+      addHistoryItem(edit=new HistoryItem("Remove Left", viewport.alignment,
+                                     HistoryItem.HIDE));
       int min = colSel.getMin();
       viewport.getAlignment().trimLeft(min);
-      colSel.compensateForEdit(0,min);
-
-      if(viewport.getSelectionGroup()!=null)
+      colSel.compensateForEdit(0, min);
+      edit.addShift(0, min);
+      if (viewport.getSelectionGroup() != null)
+      {
         viewport.getSelectionGroup().adjustForRemoveLeft(min);
+      }
 
       Vector groups = viewport.alignment.getGroups();
-      for(int i=0; i<groups.size(); i++)
+      for (int i = 0; i < groups.size(); i++)
       {
         SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
-        if(!sg.adjustForRemoveLeft(min))
+        if (!sg.adjustForRemoveLeft(min))
+        {
           viewport.alignment.deleteGroup(sg);
+        }
       }
-
-      alignPanel.repaint();
+      viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
     }
   }
 
-  public void remove2RightMenuItem_actionPerformed(ActionEvent e)
+  public void remove2RightMenuItem_actionPerformed()
   {
-    addHistoryItem("delete columns");
     ColumnSelection colSel = viewport.getColumnSelection();
     if (colSel.size() > 0)
     {
+      addHistoryItem(new HistoryItem("Remove Right", viewport.alignment,
+                                     HistoryItem.HIDE));
       int max = colSel.getMax();
       viewport.getAlignment().trimRight(max);
-      if(viewport.getSelectionGroup()!=null)
+
+      if (viewport.getSelectionGroup() != null)
+      {
         viewport.getSelectionGroup().adjustForRemoveRight(max);
+      }
 
       Vector groups = viewport.alignment.getGroups();
-      for(int i=0; i<groups.size(); i++)
+      for (int i = 0; i < groups.size(); i++)
       {
         SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
-        if(!sg.adjustForRemoveRight(max))
+        if (!sg.adjustForRemoveRight(max))
+        {
           viewport.alignment.deleteGroup(sg);
+        }
       }
-
-
-
-      alignPanel.repaint();
+      viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
     }
 
   }
 
-  public void removeGappedColumnMenuItem_actionPerformed(ActionEvent e)
+  public void removeGappedColumnMenuItem_actionPerformed()
   {
-    addHistoryItem("delete gapped columns");
+    HistoryItem edit;
+    addHistoryItem(edit=new HistoryItem("Remove Gapped Columns",
+                                   viewport.alignment,
+                                   HistoryItem.HIDE));
+
+    //This is to maintain viewport position on first residue
+    //of first sequence
+    SequenceI seq = viewport.alignment.getSequenceAt(0);
+    int startRes = seq.findPosition(viewport.startRes);
+
     viewport.getAlignment().removeGaps();
-    viewport.updateConservation();
-    viewport.updateConsensus();
-    alignPanel.repaint();
+
+    viewport.setStartRes(seq.findIndex(startRes)-1);
+
+    viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
   }
 
-  public void removeAllGapsMenuItem_actionPerformed(ActionEvent e)
+  public void removeAllGapsMenuItem_actionPerformed()
   {
-    addHistoryItem("delete all gaps");
+    // TODO: hidden regions should not be touched by removeAllGaps - a minimal number of gaps will remain in alignment segments containing uneven length subsequences
+    // TODO: columnSelection.compensateforedits should be called (and passed to history item)
+    HistoryItem editgaps;
+    addHistoryItem(editgaps=new HistoryItem("Remove Gaps", viewport.alignment,
+                                   HistoryItem.HIDE));
+
+    //This is to maintain viewport position on first residue
+    //of first sequence
+    SequenceI seq = viewport.alignment.getSequenceAt(0);
+    int startRes = seq.findPosition(viewport.startRes);
+
     SequenceI current;
-    int jSize;
-    for (int i=0; i < viewport.getAlignment().getSequences().size();i++)
+    Vector seqs=null;
+
+    int start=0, end = viewport.alignment.getWidth();
+
+    if (viewport.getSelectionGroup() != null
+        && viewport.getSelectionGroup().getSequences(false) != null
+        && viewport.getSelectionGroup().getSize(false)>0)
     {
-      current = viewport.getAlignment().getSequenceAt(i);
-      jSize = current.getLength();
-      for (int j=0; j < jSize; j++)
-        if(jalview.util.Comparison.isGap(current.getCharAt(j)))
-        {
-          current.deleteCharAt(j);
-          j--;
-          jSize--;
-        }
+      seqs = viewport.getSelectionGroup().getSequences(true);
+      start = viewport.getSelectionGroup().getStartRes();
+      end = viewport.getSelectionGroup().getEndRes()+1;
     }
-    viewport.updateConservation();
-    viewport.updateConsensus();
-    alignPanel.repaint();
+    else
+      seqs = viewport.alignment.getSequences();
+
+    /* Commented out regions below are partial implementation of todo above.
+     * divide start,end into visible chunks, and for each:
+     int diff=end-start+1;
+     int diffmax=0;
+     int dr[] = new int[seqs.size()];
+     */
+    for (int i = 0; i < seqs.size(); i++)
+    {
+      current = (SequenceI) seqs.elementAt(i);
+      //dr[i]=
+      current.removeGaps(start, end);
+      /*if (d<diff) // can only shift
+        diff=d;
+      if (diffmax<d)
+        diffmax=d;
+        */
+    }
+    /* // after the end of each chunk -
+     * if (diff>0) {
+     // record shift for history.
+      editgaps.addShift(start, diff);
+      if (viewport.hasHiddenColumns && diffmax>diff) {
+      // pad sequence
+       StringBuffer gaps=new StringBuffer(diffmax);
+       for (int i=0,j=diffmax-diff; i<j; i++)
+       gaps.append(viewport.getGapCharacter());
+       for (int i=0, j=seqs.size(); i<j; i++) {
+       current = (SequenceI) seqs.elementAt(i);
+       if (dr[i]-diff>0) {
+       String sq = current.getSequence();
+       current.setSequence(sq.substring(0, hcend-dr[i])+gaps.substring(0, dr[i]-diff)+sq.substring());
+       }
+       }
+      }
+      }*/
+
+    viewport.setStartRes(seq.findIndex(startRes)-1);
+    viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
   }
 
+  public void alignmentChanged()
+  {
+    viewport.alignment.padGaps();
+    if(viewport.autocalculateConsensus)
+    {
+      viewport.updateConsensus();
+      viewport.updateConservation();
+    }
+
+    resetAllColourSchemes();
+    if(alignPanel.overviewPanel!=null)
+      alignPanel.overviewPanel.updateOverviewImage();
+
+    viewport.alignment.adjustSequenceAnnotations();
+    alignPanel.repaint();
+  }
 
-  public void findMenuItem_actionPerformed(ActionEvent e)
+  void resetAllColourSchemes()
   {
-    Finder finder = new Finder(alignPanel);
+    ColourSchemeI cs = viewport.globalColourScheme;
+    if(cs!=null)
+    {
+      if (cs instanceof ClustalxColourScheme)
+      {
+        ( (ClustalxColourScheme) viewport.getGlobalColourScheme()).
+            resetClustalX(viewport.alignment.getSequences(),
+                          viewport.alignment.getWidth());
+      }
+
+      cs.setConsensus(viewport.hconsensus);
+      if (cs.conservationApplied())
+      {
+        Alignment al = (Alignment) viewport.alignment;
+        Conservation c = new Conservation("All",
+                                          ResidueProperties.propHash, 3,
+                                          al.getSequences(), 0,
+                                          al.getWidth() - 1);
+        c.calculate();
+        c.verdict(false, viewport.ConsPercGaps);
+
+        cs.setConservation(c);
+      }
+    }
+
+    int s, sSize = viewport.alignment.getGroups().size();
+    for(s=0; s<sSize; s++)
+    {
+      SequenceGroup sg = (SequenceGroup)viewport.alignment.getGroups().elementAt(s);
+      if(sg.cs!=null && sg.cs instanceof ClustalxColourScheme)
+      {
+        ((ClustalxColourScheme)sg.cs).resetClustalX(
+            sg.getSequences(true), sg.getWidth());
+      }
+      sg.recalcConservation();
+    }
   }
 
 
-  public void font_actionPerformed(ActionEvent e)
+
+  public void findMenuItem_actionPerformed()
   {
-    Frame frame = new Frame();
-    FontChooser fc = new FontChooser( alignPanel, frame);
-    frame.add(fc);
-    jalview.bin.JalviewLite.addFrame(frame, "Change Font", 440,100);
+    new Finder(alignPanel);
+  }
 
+  public void font_actionPerformed()
+  {
+    new FontChooser(alignPanel);
   }
 
-  protected void fullSeqId_actionPerformed(ActionEvent e)
+
+  public void seqLimits_itemStateChanged()
   {
-    viewport.setShowFullId( fullSeqId.getState() );
-    alignPanel.idPanel.idCanvas.setSize( alignPanel.calculateIdWidth() );
+    viewport.setShowJVSuffix(seqLimits.getState());
+    alignPanel.fontChanged();
     alignPanel.repaint();
   }
 
-  protected void colourTextMenuItem_actionPerformed(ActionEvent e)
+
+  protected void colourTextMenuItem_actionPerformed()
   {
-      viewport.setColourText( colourTextMenuItem.getState() );
-      alignPanel.repaint();
+    viewport.setColourText(colourTextMenuItem.getState());
+    alignPanel.repaint();
   }
 
-  protected void wrapMenuItem_actionPerformed(ActionEvent e)
+  protected void wrapMenuItem_actionPerformed()
   {
-    viewport.setWrapAlignment( wrapMenuItem.getState() );
-    alignPanel.setWrapAlignment( wrapMenuItem.getState() );
-    scaleAbove.setEnabled( wrapMenuItem.getState() );
-    scaleLeft.setEnabled( wrapMenuItem.getState());
-    scaleRight.setEnabled( wrapMenuItem.getState());
+    viewport.setWrapAlignment(wrapMenuItem.getState());
+    alignPanel.setWrapAlignment(wrapMenuItem.getState());
+    scaleAbove.setEnabled(wrapMenuItem.getState());
+    scaleLeft.setEnabled(wrapMenuItem.getState());
+    scaleRight.setEnabled(wrapMenuItem.getState());
     alignPanel.repaint();
   }
 
-  protected void scaleAbove_actionPerformed(ActionEvent e)
+
+  protected void scaleAbove_actionPerformed()
   {
     viewport.setScaleAboveWrapped(scaleAbove.getState());
     alignPanel.repaint();
   }
 
-  protected void scaleLeft_actionPerformed(ActionEvent e)
+  protected void scaleLeft_actionPerformed()
   {
     viewport.setScaleLeftWrapped(scaleLeft.getState());
     alignPanel.repaint();
   }
 
-  protected void scaleRight_actionPerformed(ActionEvent e)
+  protected void scaleRight_actionPerformed()
   {
     viewport.setScaleRightWrapped(scaleRight.getState());
     alignPanel.repaint();
   }
 
-
-
-  public void viewBoxesMenuItem_actionPerformed(ActionEvent e)
+  public void viewBoxesMenuItem_actionPerformed()
   {
-    viewport.setShowBoxes( viewBoxesMenuItem.getState() );
+    viewport.setShowBoxes(viewBoxesMenuItem.getState());
     alignPanel.repaint();
   }
 
-  public void viewTextMenuItem_actionPerformed(ActionEvent e)
+  public void viewTextMenuItem_actionPerformed()
   {
-    viewport.setShowText( viewTextMenuItem.getState() );
+    viewport.setShowText(viewTextMenuItem.getState());
     alignPanel.repaint();
   }
 
-
-  protected void renderGapsMenuItem_actionPerformed(ActionEvent e)
+  protected void renderGapsMenuItem_actionPerformed()
   {
     viewport.setRenderGaps(renderGapsMenuItem.getState());
     alignPanel.repaint();
   }
 
+  public void annotationPanelMenuItem_actionPerformed()
+  {
+    viewport.setShowAnnotation(annotationPanelMenuItem.getState());
+    alignPanel.setAnnotationVisible(annotationPanelMenuItem.getState());
+  }
 
-  public void annotationPanelMenuItem_actionPerformed(ActionEvent e)
+  public void featureSettings_actionPerformed()
   {
-    if(annotationPanelMenuItem.getState() && viewport.getWrapAlignment())
-    {
-      annotationPanelMenuItem.setState(false);
-      return;
-    }
-    viewport.setShowAnnotation( annotationPanelMenuItem.getState() );
-    alignPanel.setAnnotationVisible( annotationPanelMenuItem.getState() );
+    new FeatureSettings(viewport, alignPanel);
   }
 
-  public void overviewMenuItem_actionPerformed(ActionEvent e)
+  public void overviewMenuItem_actionPerformed()
   {
-   if (alignPanel.overviewPanel != null)
+    if (alignPanel.overviewPanel != null)
+    {
       return;
+    }
 
     Frame frame = new Frame();
     OverviewPanel overview = new OverviewPanel(alignPanel);
     frame.add(overview);
     // +50 must allow for applet frame window
     jalview.bin.JalviewLite.addFrame(frame, "Overview " + this.getTitle(),
-                             overview.preferredSize().width, overview.preferredSize().height+50);
+                                     overview.preferredSize().width,
+                                     overview.preferredSize().height + 50);
 
     frame.pack();
     frame.addWindowListener(new WindowAdapter()
-    { public void windowClosing(WindowEvent e)
+    {
+      public void windowClosing(WindowEvent e)
       {
-            alignPanel.setOverviewPanel(null);
+        alignPanel.setOverviewPanel(null);
       };
     });
 
-    alignPanel.setOverviewPanel( overview );
-
+    alignPanel.setOverviewPanel(overview);
 
   }
 
-  protected void noColourmenuItem_actionPerformed(ActionEvent e)
+  protected void noColourmenuItem_actionPerformed()
   {
-    changeColour( null );
+    changeColour(null);
   }
 
-
-  public void clustalColour_actionPerformed(ActionEvent e)
+  public void clustalColour_actionPerformed()
   {
     abovePIDThreshold.setState(false);
-    changeColour(new ClustalxColourScheme(viewport.alignment.getSequences(), viewport.alignment.getWidth()));
+    changeColour(new ClustalxColourScheme(viewport.alignment.getSequences(),
+                                          viewport.alignment.getWidth()));
   }
 
-  public void zappoColour_actionPerformed(ActionEvent e)
+  public void zappoColour_actionPerformed()
   {
     changeColour(new ZappoColourScheme());
   }
 
-  public void taylorColour_actionPerformed(ActionEvent e)
+  public void taylorColour_actionPerformed()
   {
     changeColour(new TaylorColourScheme());
   }
 
-
-  public void hydrophobicityColour_actionPerformed(ActionEvent e)
+  public void hydrophobicityColour_actionPerformed()
   {
-    changeColour( new HydrophobicColourScheme() );
+    changeColour(new HydrophobicColourScheme());
   }
 
-  public void helixColour_actionPerformed(ActionEvent e)
+  public void helixColour_actionPerformed()
   {
-    changeColour(new HelixColourScheme() );
+    changeColour(new HelixColourScheme());
   }
 
-
-  public void strandColour_actionPerformed(ActionEvent e)
+  public void strandColour_actionPerformed()
   {
     changeColour(new StrandColourScheme());
   }
 
-
-  public void turnColour_actionPerformed(ActionEvent e)
+  public void turnColour_actionPerformed()
   {
     changeColour(new TurnColourScheme());
   }
 
-
-  public void buriedColour_actionPerformed(ActionEvent e)
+  public void buriedColour_actionPerformed()
   {
-    changeColour(new BuriedColourScheme() );
+    changeColour(new BuriedColourScheme());
   }
 
-  public void nucleotideColour_actionPerformed(ActionEvent e)
+  public void nucleotideColour_actionPerformed()
   {
     changeColour(new NucleotideColourScheme());
   }
 
-
-  protected void applyToAllGroups_actionPerformed(ActionEvent e)
+  protected void applyToAllGroups_actionPerformed()
   {
     viewport.setColourAppliesToAllGroups(applyToAllGroups.getState());
   }
 
-
-
   void changeColour(ColourSchemeI cs)
   {
     int threshold = 0;
 
-    if ( viewport.getAbovePIDThreshold() )
+    if(cs!=null)
     {
-      threshold = SliderPanel.setPIDSliderSource(alignPanel, cs, "Background");
-
-      if (cs instanceof ResidueColourScheme)
-        ( (ResidueColourScheme) cs).setThreshold(threshold);
-      else if (cs instanceof ScoreColourScheme)
-        ( (ScoreColourScheme) cs).setThreshold(threshold);
+      if (viewport.getAbovePIDThreshold())
+      {
+        threshold = SliderPanel.setPIDSliderSource(alignPanel, cs, "Background");
 
-      viewport.setGlobalColourScheme(cs);
-    }
-    else if (cs instanceof ResidueColourScheme)
-      ( (ResidueColourScheme) cs).setThreshold(0);
-    else if (cs instanceof ScoreColourScheme)
-      ( (ScoreColourScheme) cs).setThreshold(0);
+        cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
 
+        viewport.setGlobalColourScheme(cs);
+      }
+      else
+      {
+        cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
+      }
 
+      if (viewport.getConservationSelected())
+      {
 
-    if (viewport.getConservationSelected())
-    {
-      ConservationColourScheme ccs = null;
+        Alignment al = (Alignment) viewport.alignment;
+        Conservation c = new Conservation("All",
+                                          ResidueProperties.propHash, 3,
+                                          al.getSequences(), 0,
+                                          al.getWidth() - 1);
 
-      Alignment al = (Alignment) viewport.alignment;
-      Conservation c = new Conservation("All",
-                                        ResidueProperties.propHash, 3,
-                                        al.getSequences(), 0,
-                                        al.getWidth() - 1);
+        c.calculate();
+        c.verdict(false, viewport.ConsPercGaps);
 
-      c.calculate();
-      c.verdict(false, viewport.ConsPercGaps);
+        cs.setConservation(c);
 
-      ccs = new ConservationColourScheme(c, cs);
+        cs.setConservationInc(SliderPanel.setConservationSlider(alignPanel, cs,
+            "Background"));
 
-      // MUST NOTIFY THE COLOURSCHEME OF CONSENSUS!
-      ccs.setConsensus( viewport.vconsensus );
-      viewport.setGlobalColourScheme(ccs);
+      }
+      else
+      {
+        cs.setConservation(null);
+      }
 
-      SliderPanel.setConservationSlider(alignPanel, ccs, "Background");
+      cs.setConsensus(viewport.hconsensus);
 
     }
-    else
-    {
-        // MUST NOTIFY THE COLOURSCHEME OF CONSENSUS!
-        if (cs != null)
-          cs.setConsensus(viewport.vconsensus);
-        viewport.setGlobalColourScheme(cs);
-    }
+    viewport.setGlobalColourScheme(cs);
 
-
-    if(viewport.getColourAppliesToAllGroups())
+    if (viewport.getColourAppliesToAllGroups())
     {
       Vector groups = viewport.alignment.getGroups();
-      for(int i=0; i<groups.size(); i++)
+      for (int i = 0; i < groups.size(); i++)
       {
-        SequenceGroup sg = (SequenceGroup)groups.elementAt(i);
+        SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
 
+        if(cs==null)
+        {
+          sg.cs = null;
+          continue;
+        }
         if (cs instanceof ClustalxColourScheme)
         {
-          sg.cs = new ClustalxColourScheme(sg.sequences, sg.getWidth());
+          sg.cs = new ClustalxColourScheme(sg.getSequences(true), sg.getWidth());
         }
         else
+        {
           try
           {
             sg.cs = (ColourSchemeI) cs.getClass().newInstance();
@@ -693,58 +1519,61 @@ public class AlignFrame extends GAlignFrame
             ex.printStackTrace();
             sg.cs = cs;
           }
+        }
 
-        if(viewport.getAbovePIDThreshold())
+        if (viewport.getAbovePIDThreshold()
+            || cs instanceof PIDColourScheme
+            || cs instanceof Blosum62ColourScheme)
         {
-          if (sg.cs instanceof ResidueColourScheme)
-            ( (ResidueColourScheme) sg.cs).setThreshold(threshold);
-          else if (sg.cs instanceof ScoreColourScheme)
-            ( (ScoreColourScheme) sg.cs).setThreshold(threshold);
-
-           sg.cs.setConsensus( AAFrequency.calculate(sg.sequences, 0, sg.getWidth()) );
+          sg.cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
+          sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(true), 0, sg.getWidth()));
         }
+        else
+          sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
 
-        if( viewport.getConservationSelected() )
+        if (viewport.getConservationSelected())
         {
           Conservation c = new Conservation("Group",
                                             ResidueProperties.propHash, 3,
-                                            sg.sequences, 0, viewport.alignment.getWidth()-1);
+                                            sg.getSequences(true), 0,
+                                            viewport.alignment.getWidth() - 1);
           c.calculate();
           c.verdict(false, viewport.ConsPercGaps);
-          ConservationColourScheme ccs = new ConservationColourScheme(c, sg.cs);
-
-          // MUST NOTIFY THE COLOURSCHEME OF CONSENSUS!
-          ccs.setConsensus( AAFrequency.calculate(sg.sequences, 0, sg.getWidth()));
-          sg.cs = ccs;
+          sg.cs.setConservation(c);
         }
         else
         {
-          // MUST NOTIFY THE COLOURSCHEME OF CONSENSUS!
-          sg.cs.setConsensus(AAFrequency.calculate(sg.sequences, 0, sg.getWidth()));
+          sg.cs.setConservation(null);
+          sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
         }
 
       }
     }
 
-    if(alignPanel.getOverviewPanel()!=null)
+
+    if (alignPanel.getOverviewPanel() != null)
+    {
       alignPanel.getOverviewPanel().updateOverviewImage();
+    }
 
     alignPanel.repaint();
   }
 
-  protected void modifyPID_actionPerformed(ActionEvent e)
+
+
+  protected void modifyPID_actionPerformed()
   {
-      if(viewport.getAbovePIDThreshold())
-      {
-        SliderPanel.setPIDSliderSource(alignPanel, viewport.getGlobalColourScheme(),
-                                   "Background");
-        SliderPanel.showPIDSlider();
-      }
+    if (viewport.getAbovePIDThreshold() && viewport.globalColourScheme!=null)
+    {
+      SliderPanel.setPIDSliderSource(alignPanel, viewport.getGlobalColourScheme(),
+                                     "Background");
+      SliderPanel.showPIDSlider();
+    }
   }
 
-  protected void modifyConservation_actionPerformed(ActionEvent e)
+  protected void modifyConservation_actionPerformed()
   {
-    if(viewport.getConservationSelected())
+    if (viewport.getConservationSelected() && viewport.globalColourScheme!=null)
     {
       SliderPanel.setConservationSlider(alignPanel, viewport.globalColourScheme,
                                         "Background");
@@ -752,139 +1581,142 @@ public class AlignFrame extends GAlignFrame
     }
   }
 
-
-  protected  void conservationMenuItem_actionPerformed(ActionEvent e)
+  protected void conservationMenuItem_actionPerformed()
   {
     viewport.setConservationSelected(conservationMenuItem.getState());
 
     viewport.setAbovePIDThreshold(false);
     abovePIDThreshold.setState(false);
 
-   ColourSchemeI cs = viewport.getGlobalColourScheme();
-   if(cs instanceof ConservationColourScheme )
-     changeColour( ((ConservationColourScheme)cs).cs );
-    else
-      changeColour( cs );
+    changeColour(viewport.getGlobalColourScheme());
 
-    modifyConservation_actionPerformed(null);
+    modifyConservation_actionPerformed();
   }
 
-  public void abovePIDThreshold_actionPerformed(ActionEvent e)
+  public void abovePIDThreshold_actionPerformed()
   {
     viewport.setAbovePIDThreshold(abovePIDThreshold.getState());
 
     conservationMenuItem.setState(false);
     viewport.setConservationSelected(false);
 
-    ColourSchemeI cs = viewport.getGlobalColourScheme();
-
-    if(cs instanceof ConservationColourScheme )
-        changeColour( ((ConservationColourScheme)cs).cs );
-    else
-        changeColour( cs );
+    changeColour(viewport.getGlobalColourScheme());
 
-    modifyPID_actionPerformed(null);
+    modifyPID_actionPerformed();
   }
 
-
-
-  public void userDefinedColour_actionPerformed(ActionEvent e)
+  public void userDefinedColour_actionPerformed()
   {
-    UserDefinedColours chooser = new UserDefinedColours( alignPanel, null);
+    new UserDefinedColours(alignPanel, null);
   }
 
-  public void PIDColour_actionPerformed(ActionEvent e)
+  public void PIDColour_actionPerformed()
   {
-    changeColour( new PIDColourScheme() );
+    changeColour(new PIDColourScheme());
   }
 
-
-  public void BLOSUM62Colour_actionPerformed(ActionEvent e)
+  public void BLOSUM62Colour_actionPerformed()
   {
-    changeColour(new Blosum62ColourScheme() );
+    changeColour(new Blosum62ColourScheme());
   }
 
-
-
-  public void sortPairwiseMenuItem_actionPerformed(ActionEvent e)
+  public void sortPairwiseMenuItem_actionPerformed()
   {
-    addHistoryItem("sort");
-    AlignmentSorter.sortByPID(viewport.getAlignment(), viewport.getAlignment().getSequenceAt(0));
+    addHistoryItem(new HistoryItem("Pairwise Sort", viewport.alignment,
+                                   HistoryItem.SORT));
+    AlignmentSorter.sortByPID(viewport.getAlignment(),
+                              viewport.getAlignment().getSequenceAt(0));
     alignPanel.repaint();
   }
 
-  public void sortIDMenuItem_actionPerformed(ActionEvent e)
+  public void sortIDMenuItem_actionPerformed()
   {
-    addHistoryItem("sort");
-    AlignmentSorter.sortByID( viewport.getAlignment() );
+    addHistoryItem(new HistoryItem("ID Sort", viewport.alignment,
+                                   HistoryItem.SORT));
+    AlignmentSorter.sortByID(viewport.getAlignment());
     alignPanel.repaint();
   }
 
-  public void sortGroupMenuItem_actionPerformed(ActionEvent e)
+  public void sortGroupMenuItem_actionPerformed()
   {
-    addHistoryItem("sort");
+    addHistoryItem(new HistoryItem("Group Sort", viewport.alignment,
+                                   HistoryItem.SORT));
     AlignmentSorter.sortByGroup(viewport.getAlignment());
-    AlignmentSorter.sortGroups(viewport.getAlignment());
     alignPanel.repaint();
+
   }
 
-  public void removeRedundancyMenuItem_actionPerformed(ActionEvent e)
+  public void removeRedundancyMenuItem_actionPerformed()
   {
-    RedundancyPanel sp = new RedundancyPanel(alignPanel);
-    Frame frame = new Frame();
-    frame.add(sp);
-    jalview.bin.JalviewLite.addFrame(frame, "Redundancy threshold selection", 400, 120);
-
+     new RedundancyPanel(alignPanel);
   }
 
-  public void pairwiseAlignmentMenuItem_actionPerformed(ActionEvent e)
+  public void pairwiseAlignmentMenuItem_actionPerformed()
   {
-    if(viewport.getSelectionGroup().getSize()>1)
+    if (viewport.getSelectionGroup()!=null
+        && viewport.getSelectionGroup().getSize(false) > 1)
     {
       Frame frame = new Frame();
-      frame.add(new PairwiseAlignPanel(viewport));
+      frame.add(new PairwiseAlignPanel(alignPanel));
       jalview.bin.JalviewLite.addFrame(frame, "Pairwise Alignment", 600, 500);
     }
   }
 
-  public void PCAMenuItem_actionPerformed(ActionEvent e)
+  public void PCAMenuItem_actionPerformed()
   {
+    //are the sequences aligned?
+    if (!viewport.alignment.isAligned())
+    {
+      SequenceI current;
+      int Width = viewport.getAlignment().getWidth();
+
+      for (int i = 0; i < viewport.getAlignment().getSequences().size();
+           i++)
+      {
+        current = viewport.getAlignment().getSequenceAt(i);
+
+        if (current.getLength() < Width)
+        {
+          current.insertCharAt(Width - 1, viewport.getGapCharacter());
+        }
+      }
+      alignPanel.repaint();
+    }
 
-    if( (viewport.getSelectionGroup()!=null && viewport.getSelectionGroup().getSize()<4 && viewport.getSelectionGroup().getSize()>0)
-       || viewport.getAlignment().getHeight()<4)
+    if ( (viewport.getSelectionGroup() != null &&
+          viewport.getSelectionGroup().getSize(false) < 4 &&
+          viewport.getSelectionGroup().getSize(false) > 0)
+        || viewport.getAlignment().getHeight() < 4)
     {
       return;
     }
 
-    try{
-      PCAPanel pcaPanel = new PCAPanel(viewport, null);
-      Frame frame = new Frame();
-      frame.add(pcaPanel);
-      jalview.bin.JalviewLite.addFrame(frame, "Principal component analysis", 400, 400);
-   }catch(java.lang.OutOfMemoryError ex)
-   {
-   }
-
+    try
+    {
+      new PCAPanel(viewport);
+    }
+    catch (java.lang.OutOfMemoryError ex)
+    {
+    }
 
   }
 
-  public void averageDistanceTreeMenuItem_actionPerformed(ActionEvent e)
+  public void averageDistanceTreeMenuItem_actionPerformed()
   {
     NewTreePanel("AV", "PID", "Average distance tree using PID");
   }
 
-  public void neighbourTreeMenuItem_actionPerformed(ActionEvent e)
+  public void neighbourTreeMenuItem_actionPerformed()
   {
     NewTreePanel("NJ", "PID", "Neighbour joining tree using PID");
   }
 
-
-  protected void njTreeBlosumMenuItem_actionPerformed(ActionEvent e)
+  protected void njTreeBlosumMenuItem_actionPerformed()
   {
     NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62");
   }
 
-  protected void avTreeBlosumMenuItem_actionPerformed(ActionEvent e)
+  protected void avTreeBlosumMenuItem_actionPerformed()
   {
     NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62PID");
   }
@@ -892,28 +1724,58 @@ public class AlignFrame extends GAlignFrame
   void NewTreePanel(String type, String pwType, String title)
   {
     //are the sequences aligned?
-    if(!viewport.alignment.isAligned())
+    if (!viewport.alignment.isAligned())
     {
-      return;
-    }
+      SequenceI current;
+      int Width = viewport.getAlignment().getWidth();
+
+      for (int i = 0; i < viewport.getAlignment().getSequences().size();
+           i++)
+      {
+        current = viewport.getAlignment().getSequenceAt(i);
+
+        if (current.getLength() < Width)
+        {
+          current.insertCharAt(Width - 1, viewport.getGapCharacter());
+        }
+      }
+      alignPanel.repaint();
 
-    final TreePanel tp;
-    if (viewport.getSelectionGroup() != null &&
-        viewport.getSelectionGroup().getSize() > 3)
-    {
-      tp = new TreePanel(viewport, viewport.getSelectionGroup().sequences, type,
-                         pwType,
-                         0, viewport.alignment.getWidth());
     }
-    else
+
+    if ( (viewport.getSelectionGroup() != null &&
+          viewport.getSelectionGroup().getSize(false) > 1)
+      || (viewport.getSelectionGroup() == null
+          && viewport.alignment.getHeight() > 1))
     {
-      tp = new TreePanel(viewport, viewport.getAlignment().getSequences(),
-                         type, pwType, 0, viewport.alignment.getWidth());
+      final TreePanel tp = new TreePanel(viewport,
+                                         type,
+                                         pwType);
+
+      addTreeMenuItem(tp, title);
+
+      jalview.bin.JalviewLite.addFrame(tp, title, 600, 500);
     }
+  }
 
-   addTreeMenuItem(tp, title);
+  void loadTree_actionPerformed()
+  {
+      CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
+      cap.setText("Paste your Newick tree file here.");
+      cap.treeImport = true;
+      Frame frame = new Frame();
+      frame.add(cap);
+      jalview.bin.JalviewLite.addFrame(frame, "Paste Newick file ", 400, 300);
+  }
 
-   jalview.bin.JalviewLite.addFrame(tp, title, 600, 500);
+  public void loadTree(jalview.io.NewickFile tree, String treeFile)
+  {
+    TreePanel tp = new TreePanel(viewport,
+                                 treeFile,
+                                 "From File - ",
+                                 tree);
+    jalview.bin.JalviewLite.addFrame(tp, treeFile, 600, 500);
+    addTreeMenuItem(tp, treeFile);
   }
 
   void addTreeMenuItem(final TreePanel treePanel, String title)
@@ -922,9 +1784,10 @@ public class AlignFrame extends GAlignFrame
     sortByTreeMenu.add(item);
     item.addActionListener(new java.awt.event.ActionListener()
     {
-      public void actionPerformed(ActionEvent e)
+      public void actionPerformed(ActionEvent evt)
       {
-        addHistoryItem("sort");
+        addHistoryItem(new HistoryItem("Sort", viewport.alignment,
+                                       HistoryItem.SORT));
         AlignmentSorter.sortByTree(viewport.getAlignment(), treePanel.getTree());
         alignPanel.repaint();
       }
@@ -939,40 +1802,626 @@ public class AlignFrame extends GAlignFrame
     });
   }
 
-  protected void documentation_actionPerformed(ActionEvent e) {
-
-    jalview.bin.JalviewLite.showURL("http://www.jalview.org");
-
+  protected void documentation_actionPerformed()
+  {
+    showURL("http://www.jalview.org/help.html", "HELP");
   }
 
-  protected void about_actionPerformed(ActionEvent e)
+  protected void about_actionPerformed()
   {
+
     class AboutPanel extends Canvas
     {
+      String version;
+      public AboutPanel(String version)
+      { this.version = version; }
+
       public void paint(Graphics g)
       {
         g.setColor(Color.white);
-        g.fillRect(0,0,getSize().width, getSize().height);
+        g.fillRect(0, 0, getSize().width, getSize().height);
         g.setFont(new Font("Helvetica", Font.PLAIN, 12));
         FontMetrics fm = g.getFontMetrics();
         int fh = fm.getHeight();
-        int y=20, x=7;
+        int y = 5, x = 7;
         g.setColor(Color.black);
         g.setFont(new Font("Helvetica", Font.BOLD, 14));
-        g.drawString("JalView 2005", 200,y+=fh);
+        g.drawString("Jalview - Release "+version, 200, y += fh);
         g.setFont(new Font("Helvetica", Font.PLAIN, 12));
-        g.drawString("Authors:  Michele Clamp, James Cuff, Steve Searle, Andrew Waterhouse, Jim Procter & Geoff Barton.",x,y+=fh*2);
-        g.drawString("Current development managed by Andrew Waterhouse; Barton Group, University of Dundee.",x,y+=fh);
-        g.drawString("If  you use JalView, please cite:",x,y+=fh+8);
-        g.drawString("\"Clamp, M., Cuff, J., Searle, S. M. and Barton, G. J. (2004), The Jalview Java Alignment Editor\"",x,y+=fh);
-        g.drawString("Bioinformatics,  2004 12;426-7.",x,y+=fh);
+        g.drawString("Authors:  Michele Clamp, James Cuff, Steve Searle, Andrew Waterhouse, Jim Procter & Geoff Barton.",
+                     x, y += fh * 2);
+        g.drawString("Current development managed by Andrew Waterhouse; Barton Group, University of Dundee.",
+                     x, y += fh);
+        g.drawString(
+            "For any issues relating to Jalview, email help@jalview.org", x,
+            y += fh);
+        g.drawString("If  you use JalView, please cite:", x, y += fh + 8);
+        g.drawString("\"Clamp, M., Cuff, J., Searle, S. M. and Barton, G. J. (2004), The Jalview Java Alignment Editor\"",
+                     x, y += fh);
+        g.drawString("Bioinformatics,  2004 20;426-7.", x, y += fh);
+      }
+    }
+
+    String version = "test";
+    java.net.URL url = getClass().getResource("/.build_properties");
+    if (url != null)
+    {
+      try
+      {
+        BufferedReader reader = new BufferedReader(new InputStreamReader(
+            url.openStream()));
+        String line;
+        while ( (line = reader.readLine()) != null)
+        {
+          if (line.indexOf("VERSION") > -1)
+          {
+            version = line.substring(line.indexOf("=") + 1);
+          }
+        }
+      }
+      catch (Exception ex)
+      {
+        ex.printStackTrace();
       }
     }
+
+
     Frame frame = new Frame();
-    frame.add(new AboutPanel());
-    jalview.bin.JalviewLite.addFrame(frame, "Jalview 2005", 580,200);
+    frame.add(new AboutPanel(version));
+    jalview.bin.JalviewLite.addFrame(frame, "Jalview", 580, 200);
+
+  }
+
+  public void showURL(String url, String target)
+  {
+    if (viewport.applet == null)
+    {
+      System.out.println("Not running as applet - no browser available.");
+    }
+    else
+    {
+      try
+      {
+        System.out.println("Show url: "+url);
+        viewport.applet.getAppletContext().showDocument(new java.net.URL(url),
+                                               target);
+      }
+      catch (Exception ex)
+      {
+        ex.printStackTrace();
+      }
+    }
+  }
 
 
+  //////////////////////////////////////////////////////////////////////////////////
+  //JBuilder Graphics here
+
+    protected MenuBar alignFrameMenuBar = new MenuBar();
+    protected Menu fileMenu = new Menu("File");
+    protected MenuItem loadApplication = new MenuItem("View in Full Application");
+    protected MenuItem loadTree = new MenuItem("Load Associated Tree");
+    protected MenuItem closeMenuItem = new MenuItem("Close");
+    protected Menu editMenu = new Menu("Edit");
+    protected Menu viewMenu = new Menu("View");
+    protected Menu colourMenu = new Menu("Colour");
+    protected Menu calculateMenu = new Menu("Calculate");
+    protected MenuItem selectAllSequenceMenuItem = new MenuItem("Select all");
+    protected MenuItem deselectAllSequenceMenuItem = new MenuItem("Deselect All");
+    protected MenuItem invertSequenceMenuItem = new MenuItem("Invert Selection");
+    protected MenuItem remove2LeftMenuItem = new MenuItem();
+    protected MenuItem remove2RightMenuItem = new MenuItem();
+    protected MenuItem removeGappedColumnMenuItem = new MenuItem();
+    protected MenuItem removeAllGapsMenuItem = new MenuItem();
+    protected CheckboxMenuItem viewBoxesMenuItem = new CheckboxMenuItem();
+    protected CheckboxMenuItem viewTextMenuItem = new CheckboxMenuItem();
+    protected MenuItem sortPairwiseMenuItem = new MenuItem();
+    protected MenuItem sortIDMenuItem = new MenuItem();
+    protected MenuItem sortGroupMenuItem = new MenuItem();
+    protected MenuItem removeRedundancyMenuItem = new MenuItem();
+    protected MenuItem pairwiseAlignmentMenuItem = new MenuItem();
+    protected MenuItem PCAMenuItem = new MenuItem();
+    protected MenuItem averageDistanceTreeMenuItem = new MenuItem();
+    protected MenuItem neighbourTreeMenuItem = new MenuItem();
+    BorderLayout borderLayout1 = new BorderLayout();
+    public Label statusBar = new Label();
+    protected Menu outputTextboxMenu = new Menu();
+    protected MenuItem clustalColour = new MenuItem();
+    protected MenuItem zappoColour = new MenuItem();
+    protected MenuItem taylorColour = new MenuItem();
+    protected MenuItem hydrophobicityColour = new MenuItem();
+    protected MenuItem helixColour = new MenuItem();
+    protected MenuItem strandColour = new MenuItem();
+    protected MenuItem turnColour = new MenuItem();
+    protected MenuItem buriedColour = new MenuItem();
+    protected MenuItem userDefinedColour = new MenuItem();
+    protected MenuItem PIDColour = new MenuItem();
+    protected MenuItem BLOSUM62Colour = new MenuItem();
+    MenuItem njTreeBlosumMenuItem = new MenuItem();
+    MenuItem avDistanceTreeBlosumMenuItem = new MenuItem();
+    protected CheckboxMenuItem annotationPanelMenuItem = new CheckboxMenuItem();
+    protected CheckboxMenuItem colourTextMenuItem = new CheckboxMenuItem();
+    MenuItem overviewMenuItem = new MenuItem();
+    protected MenuItem undoMenuItem = new MenuItem();
+    protected MenuItem redoMenuItem = new MenuItem();
+    protected CheckboxMenuItem conservationMenuItem = new CheckboxMenuItem();
+    MenuItem noColourmenuItem = new MenuItem();
+    protected CheckboxMenuItem wrapMenuItem = new CheckboxMenuItem();
+    protected CheckboxMenuItem renderGapsMenuItem = new CheckboxMenuItem();
+    MenuItem findMenuItem = new MenuItem();
+    Menu searchMenu = new Menu();
+    protected CheckboxMenuItem abovePIDThreshold = new CheckboxMenuItem();
+    protected MenuItem nucleotideColour = new MenuItem();
+    MenuItem deleteGroups = new MenuItem();
+    MenuItem delete = new MenuItem();
+    MenuItem copy = new MenuItem();
+    MenuItem cut = new MenuItem();
+    Menu pasteMenu = new Menu();
+    MenuItem pasteNew = new MenuItem();
+    MenuItem pasteThis = new MenuItem();
+    protected CheckboxMenuItem applyToAllGroups = new CheckboxMenuItem();
+    protected MenuItem font = new MenuItem();
+    protected CheckboxMenuItem scaleAbove = new CheckboxMenuItem();
+    protected CheckboxMenuItem scaleLeft = new CheckboxMenuItem();
+    protected CheckboxMenuItem scaleRight = new CheckboxMenuItem();
+    MenuItem modifyPID = new MenuItem();
+    MenuItem modifyConservation = new MenuItem();
+    protected CheckboxMenuItem autoCalculate
+        = new CheckboxMenuItem("Autocalculate Consensus", true);
+    protected Menu sortByTreeMenu = new Menu();
+    Menu sort = new Menu();
+    Menu calculate = new Menu();
+    MenuItem inputText = new MenuItem();
+    Menu helpMenu = new Menu();
+    MenuItem documentation = new MenuItem();
+    MenuItem about = new MenuItem();
+    protected CheckboxMenuItem seqLimits = new CheckboxMenuItem();
+  Panel embeddedMenu;
+  Label embeddedEdit;
+  Label embeddedSearch;
+  Label embeddedView;
+  Label embeddedColour;
+  Label embeddedFile;
+  Label embeddedHelp;
+  Label embeddedCalculate;
+  FlowLayout flowLayout1;
+
+  private void jbInit() throws Exception {
+
+      setMenuBar(alignFrameMenuBar);
+
+      MenuItem item;
+
+      // dynamically fill save as menu with available formats
+      for (int i = 0; i < jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS.length; i++)
+      {
+
+        item = new MenuItem( jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS[i]);
+
+        item.addActionListener(new java.awt.event.ActionListener()
+        {
+          public void actionPerformed(ActionEvent e)
+          {
+            outputText_actionPerformed(e);
+          }
+        });
+
+        outputTextboxMenu.add(item);
+      }
+        closeMenuItem.addActionListener(this);
+        loadApplication.addActionListener(this);
+
+        loadTree.addActionListener(this);
+        selectAllSequenceMenuItem.addActionListener(this);
+        deselectAllSequenceMenuItem.addActionListener(this);
+        invertSequenceMenuItem.addActionListener(this);
+        remove2LeftMenuItem.setLabel("Remove Left");
+        remove2LeftMenuItem.addActionListener(this);
+        remove2RightMenuItem.setLabel("Remove Right");
+        remove2RightMenuItem.addActionListener(this);
+        removeGappedColumnMenuItem.setLabel("Remove Empty Columns");
+        removeGappedColumnMenuItem.addActionListener(this);
+        removeAllGapsMenuItem.setLabel("Remove All Gaps");
+        removeAllGapsMenuItem.addActionListener(this);
+        viewBoxesMenuItem.setLabel("Boxes");
+        viewBoxesMenuItem.setState(true);
+        viewBoxesMenuItem.addItemListener(this);
+        viewTextMenuItem.setLabel("Text");
+        viewTextMenuItem.setState(true);
+        viewTextMenuItem.addItemListener(this);
+        sortPairwiseMenuItem.setLabel("by Pairwise Identity");
+        sortPairwiseMenuItem.addActionListener(this);
+        sortIDMenuItem.setLabel("by ID");
+        sortIDMenuItem.addActionListener(this);
+        sortGroupMenuItem.setLabel("by Group");
+        sortGroupMenuItem.addActionListener(this);
+        removeRedundancyMenuItem.setLabel("Remove Redundancy...");
+        removeRedundancyMenuItem.addActionListener(this);
+        pairwiseAlignmentMenuItem.setLabel("Pairwise Alignments...");
+        pairwiseAlignmentMenuItem.addActionListener(this);
+        PCAMenuItem.setLabel("Principal Component Analysis");
+        PCAMenuItem.addActionListener(this);
+        averageDistanceTreeMenuItem.setLabel(
+            "Average Distance Using % Identity");
+        averageDistanceTreeMenuItem.addActionListener(this);
+        neighbourTreeMenuItem.setLabel("Neighbour Joining Using % Identity");
+        neighbourTreeMenuItem.addActionListener(this);
+        alignFrameMenuBar.setFont(new java.awt.Font("Verdana", 0, 11));
+        statusBar.setBackground(Color.white);
+        statusBar.setFont(new java.awt.Font("Verdana", 0, 11));
+        statusBar.setText("Status bar");
+        outputTextboxMenu.setLabel("Output to Textbox");
+        clustalColour.setLabel("Clustalx");
+
+        clustalColour.addActionListener(this);
+        zappoColour.setLabel("Zappo");
+        zappoColour.addActionListener(this);
+        taylorColour.setLabel("Taylor");
+        taylorColour.addActionListener(this);
+        hydrophobicityColour.setLabel("Hydrophobicity");
+        hydrophobicityColour.addActionListener(this);
+        helixColour.setLabel("Helix Propensity");
+        helixColour.addActionListener(this);
+        strandColour.setLabel("Strand Propensity");
+        strandColour.addActionListener(this);
+        turnColour.setLabel("Turn Propensity");
+        turnColour.addActionListener(this);
+        buriedColour.setLabel("Buried Index");
+        buriedColour.addActionListener(this);
+        userDefinedColour.setLabel("User Defined...");
+        userDefinedColour.addActionListener(this);
+        PIDColour.setLabel("Percentage Identity");
+        PIDColour.addActionListener(this);
+        BLOSUM62Colour.setLabel("BLOSUM62 Score");
+        BLOSUM62Colour.addActionListener(this);
+        avDistanceTreeBlosumMenuItem.setLabel(
+            "Average Distance Using BLOSUM62");
+        avDistanceTreeBlosumMenuItem.addActionListener(this);
+        njTreeBlosumMenuItem.setLabel("Neighbour Joining Using BLOSUM62");
+        njTreeBlosumMenuItem.addActionListener(this);
+        annotationPanelMenuItem.setLabel("Show Annotations");
+        annotationPanelMenuItem.addItemListener(this);
+        colourTextMenuItem.setLabel("Colour Text");
+        colourTextMenuItem.addItemListener(this);
+        overviewMenuItem.setLabel("Overview Window");
+        overviewMenuItem.addActionListener(this);
+        undoMenuItem.setEnabled(false);
+        undoMenuItem.setLabel("Undo");
+        undoMenuItem.addActionListener(this);
+        redoMenuItem.setEnabled(false);
+        redoMenuItem.setLabel("Redo");
+        redoMenuItem.addActionListener(this);
+        conservationMenuItem.setLabel("by Conservation");
+        conservationMenuItem.addItemListener(this);
+        noColourmenuItem.setLabel("None");
+        noColourmenuItem.addActionListener(this);
+        wrapMenuItem.setLabel("Wrap");
+        wrapMenuItem.addItemListener(this);
+        renderGapsMenuItem.setLabel("Show Gaps");
+        renderGapsMenuItem.setState(true);
+        renderGapsMenuItem.addItemListener(this);
+        findMenuItem.setLabel("Find...");
+        findMenuItem.addActionListener(this);
+        searchMenu.setLabel("Search");
+
+        abovePIDThreshold.setLabel("Above Identity Threshold");
+        abovePIDThreshold.addItemListener(this);
+        nucleotideColour.setLabel("Nucleotide");
+        nucleotideColour.addActionListener(this);
+        deleteGroups.setLabel("Undefine Groups");
+        deleteGroups.addActionListener(this);
+        copy.setLabel("Copy");
+        copy.addActionListener(this);
+        cut.setLabel("Cut");
+        cut.addActionListener(this);
+        delete.setLabel("Delete");
+        delete.addActionListener(this);
+        pasteMenu.setLabel("Paste");
+        pasteNew.setLabel("To New Alignment");
+        pasteNew.addActionListener(this);
+        pasteThis.setLabel("Add To This Alignment");
+        pasteThis.addActionListener(this);
+        applyToAllGroups.setLabel("Apply Colour To All Groups");
+        applyToAllGroups.setState(true);
+        applyToAllGroups.addItemListener(this);
+        font.setLabel("Font...");
+        font.addActionListener(this);
+        scaleAbove.setLabel("Scale Above");
+        scaleAbove.setState(true);
+        scaleAbove.setEnabled(false);
+        scaleAbove.addItemListener(this);
+        scaleLeft.setEnabled(false);
+        scaleLeft.setState(true);
+        scaleLeft.setLabel("Scale Left");
+        scaleLeft.addItemListener(this);
+        scaleRight.setEnabled(false);
+        scaleRight.setState(true);
+        scaleRight.setLabel("Scale Right");
+        scaleRight.addItemListener(this);
+        modifyPID.setLabel("Modify Identity Threshold...");
+        modifyPID.addActionListener(this);
+        modifyConservation.setLabel("Modify Conservation Threshold...");
+        modifyConservation.addActionListener(this);
+        sortByTreeMenu.setLabel("By Tree Order");
+        sort.setLabel("Sort");
+        calculate.setLabel("Calculate Tree");
+        autoCalculate.addItemListener(this);
+        inputText.setLabel("Input from textbox");
+        inputText.addActionListener(this);
+
+        helpMenu.setLabel("Help");
+        documentation.setLabel("Documentation");
+        documentation.addActionListener(this);
+
+        about.setLabel("About...");
+        about.addActionListener(this);
+          seqLimits.setState(true);
+    seqLimits.setLabel("Show Sequence Limits");
+    seqLimits.addItemListener(this);
+    featureSettings.setLabel("Feature Settings...");
+    featureSettings.addActionListener(this);
+    sequenceFeatures.setLabel("Sequence Features");
+    sequenceFeatures.addItemListener(this);
+    sequenceFeatures.setState(false);
+    annotationColour.setLabel("by Annotation...");
+    annotationColour.addActionListener(this);
+    invertSequenceMenuItem.setLabel("Invert Sequence Selection");
+    invertColSel.setLabel("Invert Column Selection");
+    menu1.setLabel("Show");
+    showColumns.setLabel("All Columns ");
+    showSeqs.setLabel("All Sequences");
+    menu2.setLabel("Hide");
+    hideColumns.setLabel("Selected Columns");
+    hideSequences.setLabel("Selected Sequences");
+    invertColSel.addActionListener(this);
+    showColumns.addActionListener(this);
+    showSeqs.addActionListener(this);
+    hideColumns.addActionListener(this);
+    hideSequences.addActionListener(this);
+
+
+    alignFrameMenuBar.add(fileMenu);
+        alignFrameMenuBar.add(editMenu);
+        alignFrameMenuBar.add(searchMenu);
+        alignFrameMenuBar.add(viewMenu);
+        alignFrameMenuBar.add(colourMenu);
+        alignFrameMenuBar.add(calculateMenu);
+        alignFrameMenuBar.add(helpMenu);
+        fileMenu.add(inputText);
+        fileMenu.add(outputTextboxMenu);
+        if(jalviewServletURL!=null)
+          fileMenu.add(loadApplication);
+        fileMenu.addSeparator();
+        fileMenu.add(loadTree);
+        fileMenu.add(closeMenuItem);
+        editMenu.add(undoMenuItem);
+        editMenu.add(redoMenuItem);
+        editMenu.add(cut);
+        editMenu.add(copy);
+        editMenu.add(pasteMenu);
+        editMenu.add(delete);
+        editMenu.addSeparator();
+        editMenu.add(selectAllSequenceMenuItem);
+        editMenu.add(deselectAllSequenceMenuItem);
+        editMenu.add(invertSequenceMenuItem);
+    editMenu.add(invertColSel);
+    editMenu.add(deleteGroups);
+        editMenu.addSeparator();
+        editMenu.add(remove2LeftMenuItem);
+        editMenu.add(remove2RightMenuItem);
+        editMenu.add(removeGappedColumnMenuItem);
+        editMenu.add(removeAllGapsMenuItem);
+        editMenu.add(removeRedundancyMenuItem);
+        searchMenu.add(findMenuItem);
+        viewMenu.add(font);
+        viewMenu.addSeparator();
+    viewMenu.add(menu1);
+    viewMenu.add(menu2);
+    viewMenu.addSeparator();
+    viewMenu.add(wrapMenuItem);
+        viewMenu.add(scaleAbove);
+        viewMenu.add(scaleLeft);
+        viewMenu.add(scaleRight);
+        viewMenu.addSeparator();
+    viewMenu.add(seqLimits);
+    viewMenu.add(viewBoxesMenuItem);
+        viewMenu.add(viewTextMenuItem);
+        viewMenu.add(colourTextMenuItem);
+        viewMenu.add(renderGapsMenuItem);
+        viewMenu.add(annotationPanelMenuItem);
+    viewMenu.addSeparator();
+        viewMenu.add(sequenceFeatures);
+        viewMenu.add(featureSettings);
+    viewMenu.addSeparator();
+        viewMenu.add(overviewMenuItem);
+        colourMenu.add(applyToAllGroups);
+        colourMenu.addSeparator();
+        colourMenu.add(noColourmenuItem);
+        colourMenu.add(clustalColour);
+        colourMenu.add(BLOSUM62Colour);
+        colourMenu.add(PIDColour);
+        colourMenu.add(zappoColour);
+        colourMenu.add(taylorColour);
+        colourMenu.add(hydrophobicityColour);
+        colourMenu.add(helixColour);
+        colourMenu.add(strandColour);
+        colourMenu.add(turnColour);
+        colourMenu.add(buriedColour);
+        colourMenu.add(nucleotideColour);
+        colourMenu.add(userDefinedColour);
+        colourMenu.addSeparator();
+        colourMenu.add(conservationMenuItem);
+        colourMenu.add(modifyConservation);
+        colourMenu.add(abovePIDThreshold);
+        colourMenu.add(modifyPID);
+    colourMenu.add(annotationColour);
+    calculateMenu.add(sort);
+        calculateMenu.add(calculate);
+        calculateMenu.addSeparator();
+        calculateMenu.add(pairwiseAlignmentMenuItem);
+        calculateMenu.add(PCAMenuItem);
+        calculateMenu.add(autoCalculate);
+        this.add(statusBar, BorderLayout.SOUTH);
+        pasteMenu.add(pasteNew);
+        pasteMenu.add(pasteThis);
+        sort.add(sortIDMenuItem);
+        sort.add(sortByTreeMenu);
+        sort.add(sortGroupMenuItem);
+        sort.add(sortPairwiseMenuItem);
+        calculate.add(averageDistanceTreeMenuItem);
+        calculate.add(neighbourTreeMenuItem);
+        calculate.add(avDistanceTreeBlosumMenuItem);
+        calculate.add(njTreeBlosumMenuItem);
+        helpMenu.add(documentation);
+        helpMenu.add(about);
+    menu1.add(showColumns);
+    menu1.add(showSeqs);
+    menu2.add(hideColumns);
+    menu2.add(hideSequences);
+  }
+
+  public void setEmbedded()
+  {
+
+    embeddedMenu = new Panel();
+    embeddedEdit = new Label();
+    embeddedSearch = new Label();
+    embeddedView = new Label();
+    embeddedColour = new Label();
+    embeddedFile = new Label();
+    embeddedHelp = new Label();
+    embeddedCalculate = new Label();
+    flowLayout1 = new FlowLayout();
+    embeddedMenu.setBackground(Color.lightGray);
+    embeddedMenu.setLayout(flowLayout1);
+    embeddedEdit.setText("Edit");
+    embeddedEdit.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
+    embeddedSearch.setText("Search");
+    embeddedSearch.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
+    embeddedView.setText("View");
+    embeddedView.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
+    embeddedColour.setText("Colour");
+    embeddedColour.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
+    embeddedFile.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
+    embeddedFile.setText("File");
+    embeddedHelp.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
+    embeddedHelp.setText("Help");
+    embeddedCalculate.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
+    embeddedCalculate.setText("Calculate");
+    embeddedMenu.add(embeddedFile);
+    embeddedMenu.add(embeddedEdit);
+    embeddedMenu.add(embeddedSearch);
+    embeddedMenu.add(embeddedView);
+    embeddedMenu.add(embeddedColour);
+    embeddedMenu.add(embeddedCalculate);
+    embeddedMenu.add(embeddedHelp);
+    flowLayout1.setAlignment(FlowLayout.LEFT);
+    flowLayout1.setHgap(2);
+    flowLayout1.setVgap(0);
+    embeddedFile.addMouseListener(this);
+    embeddedEdit.addMouseListener(this);
+    embeddedSearch.addMouseListener(this);
+    embeddedView.addMouseListener(this);
+    embeddedColour.addMouseListener(this);
+    embeddedCalculate.addMouseListener(this);
+    embeddedHelp.addMouseListener(this);
+
+   // setVisible(false);
+    fileMenu.remove(closeMenuItem);
+    fileMenu.remove(3); // Seperator
+
+    viewport.applet.setLayout(new BorderLayout());
+    viewport.applet.add(embeddedMenu, BorderLayout.NORTH);
+    viewport.applet.add(statusBar, BorderLayout.SOUTH);
+   // viewport.applet.validate();
+
+    alignPanel.setSize(viewport.applet.size().width, viewport.applet.size().height
+                       - embeddedMenu.HEIGHT - statusBar.HEIGHT);
+
+     viewport.applet.add(alignPanel, BorderLayout.CENTER);
+     viewport.applet.validate();
+
+  }
+
+
+
+  PopupMenu filePopup, editPopup, searchPopup,
+      viewPopup, colourPopup, calculatePopup, helpPopup;
+  MenuItem featureSettings = new MenuItem();
+  CheckboxMenuItem sequenceFeatures = new CheckboxMenuItem();
+  MenuItem annotationColour = new MenuItem();
+  MenuItem invertColSel = new MenuItem();
+  Menu menu1 = new Menu();
+  MenuItem showColumns = new MenuItem();
+  MenuItem showSeqs = new MenuItem();
+  Menu menu2 = new Menu();
+  MenuItem hideColumns = new MenuItem();
+  MenuItem hideSequences = new MenuItem();
+
+  public void mousePressed(MouseEvent evt)
+  {
+    PopupMenu popup = null;
+    Label source = (Label)evt.getSource();
+    if(source==embeddedFile)
+    {
+      popup = filePopup = genPopupMenu(filePopup, fileMenu);
+    }
+    else if(source==embeddedEdit)
+    {
+      popup = editPopup = genPopupMenu(editPopup, editMenu);
+    }
+    else if(source==embeddedSearch)
+    {
+      popup = searchPopup = genPopupMenu(searchPopup, searchMenu);
+    }
+    else if(source==embeddedView)
+    {
+      popup = viewPopup = genPopupMenu(viewPopup, viewMenu);
+    }
+    else if(source==embeddedColour)
+    {
+      popup = colourPopup = genPopupMenu(colourPopup, colourMenu);
+    }
+    else if(source==embeddedCalculate)
+    {
+      popup = calculatePopup = genPopupMenu(calculatePopup, calculateMenu);
+    }
+    else if(source==embeddedHelp)
+    {
+      popup = helpPopup = genPopupMenu(helpPopup, helpMenu);
+    }
+
+    embeddedMenu.add(popup);
+    popup.show(embeddedMenu,
+               source.getBounds().x,
+               source.getBounds().y + source.getBounds().getSize().height);
+  }
 
+  PopupMenu genPopupMenu(PopupMenu popup, Menu original)
+  {
+    if(popup!=null)
+    {
+      return popup;
+    }
+    popup = new PopupMenu();
+    int m, mSize = original.getItemCount();
+    for(m=0; m<mSize; m++)
+    {
+      popup.add(original.getItem(m));
+      mSize--;
+      m--;
+    }
+
+    return popup;
   }
+  public void mouseClicked(MouseEvent evt)
+  {}
+  public void mouseReleased(MouseEvent evt)
+  {}
+  public void mouseEntered(MouseEvent evt)
+  {}
+  public void mouseExited(MouseEvent evt)
+  {}
+
 }
+