X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fappletgui%2FAlignFrame.java;h=3e214b8e6bbfc899849f1d2b305a2c3865bbfdde;hb=6af03a975707c7e69cfba8885d69186d57a4c772;hp=0f7ac3ec77dd9cbb2e6e66f6d243bd1e40505282;hpb=1f3240f018a6442b1116c409a624fba042cc9efd;p=jalview.git

diff --git a/src/jalview/appletgui/AlignFrame.java b/src/jalview/appletgui/AlignFrame.java
index 0f7ac3e..3e214b8 100755
--- a/src/jalview/appletgui/AlignFrame.java
+++ b/src/jalview/appletgui/AlignFrame.java
@@ -1,58 +1,62 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer
- * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
- *
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.4)
+ * Copyright (C) 2008 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ * 
  * 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.schemes.*;
-import jalview.datamodel.*;
-import jalview.analysis.*;
-import jalview.io.*;
+import java.io.*;
+import java.net.*;
+import java.util.*;
+
 import java.awt.*;
 import java.awt.event.*;
-import java.util.*;
-import java.io.InputStreamReader;
-import java.io.BufferedReader;
-import java.net.URL;
 
+import jalview.analysis.*;
+import jalview.commands.*;
+import jalview.datamodel.*;
+import jalview.io.*;
+import jalview.schemes.*;
 
-public class AlignFrame extends Frame implements ActionListener,
-    ItemListener, KeyListener, MouseListener
+public class AlignFrame extends EmbmenuFrame implements ActionListener,
+        ItemListener, KeyListener
 {
   public AlignmentPanel alignPanel;
+
   public AlignViewport viewport;
-  int NEW_WINDOW_WIDTH = 700;
-  int NEW_WINDOW_HEIGHT = 500;
 
-  String jalviewServletURL;
+  int DEFAULT_WIDTH = 700;
+
+  int DEFAULT_HEIGHT = 500;
 
+  String jalviewServletURL;
 
-   public AlignFrame(AlignmentI al,
-                     jalview.bin.JalviewLite applet,
-                     String title,
-                     boolean embedded)
+  public AlignFrame(AlignmentI al, jalview.bin.JalviewLite applet,
+          String title, boolean embedded)
   {
 
-    jalviewServletURL = applet.getParameter("APPLICATION_URL");
+    if (applet != null)
+    {
+      jalviewServletURL = applet.getParameter("APPLICATION_URL");
+    }
 
-    try{
+    try
+    {
       jbInit();
-    }catch(Exception ex)
+    } catch (Exception ex)
     {
       ex.printStackTrace();
     }
@@ -60,19 +64,26 @@ public class AlignFrame extends Frame implements ActionListener,
     viewport = new AlignViewport(al, applet);
     alignPanel = new AlignmentPanel(this, viewport);
 
+    viewport.updateConservation(alignPanel);
+    viewport.updateConsensus(alignPanel);
+
     annotationPanelMenuItem.setState(viewport.showAnnotation);
 
     seqLimits.setState(viewport.showJVSuffix);
 
-    if(applet!=null)
+    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");
@@ -84,6 +95,12 @@ public class AlignFrame extends Frame implements ActionListener,
           wrapMenuItem_actionPerformed();
         }
       }
+      param = applet.getParameter("centrecolumnlabels");
+      if (param != null)
+      {
+        centreColumnLabelFlag.setState(true);
+        centreColumnLabelFlag_stateChanged();
+      }
 
       try
       {
@@ -91,53 +108,33 @@ public class AlignFrame extends Frame implements ActionListener,
         if (param != null)
         {
           int width = Integer.parseInt(param);
-          NEW_WINDOW_WIDTH = width;
+          DEFAULT_WIDTH = width;
         }
         param = applet.getParameter("windowHeight");
         if (param != null)
         {
           int height = Integer.parseInt(param);
-          NEW_WINDOW_HEIGHT = height;
+          DEFAULT_HEIGHT = height;
         }
+      } catch (Exception ex)
+      {
       }
-      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, NEW_WINDOW_WIDTH,
-                                      NEW_WINDOW_HEIGHT);
-   }
-   alignPanel.validate();
-   alignPanel.repaint();
+    // 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);
+    createAlignFrameWindow(embedded, title);
+    alignPanel.validate();
+    alignPanel.paintAlignment(true);
   }
+
   public AlignViewport getAlignViewport()
   {
     return viewport;
@@ -148,400 +145,727 @@ public class AlignFrame extends Frame implements ActionListener,
     return alignPanel.seqPanel.seqCanvas;
   }
 
-
   /**
    * DOCUMENT ME!
-   *
-   * @param String DOCUMENT ME!
+   * 
+   * @param String
+   *                DOCUMENT ME!
    */
 
   public void parseFeaturesFile(String file, String type)
   {
     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)
+    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 (featuresFile)
     {
-      if(featureLinks.size()>0)
-        alignPanel.seqPanel.seqCanvas
-            .getFeatureRenderer().featureLinks = featureLinks;
+      if (featureLinks.size() > 0)
+      {
+        alignPanel.seqPanel.seqCanvas.getFeatureRenderer().featureLinks = featureLinks;
+      }
       viewport.showSequenceFeatures = true;
       sequenceFeatures.setState(true);
-      alignPanel.repaint();
+      alignPanel.paintAlignment(true);
     }
 
   }
 
-
   public void keyPressed(KeyEvent evt)
   {
     if (viewport.cursorMode
-        && evt.getKeyCode() >= KeyEvent.VK_0
-        && evt.getKeyCode() <= KeyEvent.VK_9)
-    {
+            && ((evt.getKeyCode() >= KeyEvent.VK_0 && evt.getKeyCode() <= KeyEvent.VK_9) || (evt
+                    .getKeyCode() >= KeyEvent.VK_NUMPAD0 && evt
+                    .getKeyCode() <= KeyEvent.VK_NUMPAD9))
+            && Character.isDigit(evt.getKeyChar()))
       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 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())
+      {
+        paste(evt.isShiftDown());
+      }
+      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_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_LEFT:
+      if (evt.isAltDown() || !viewport.cursorMode)
+        slideSequences(false, alignPanel.seqPanel.getKeyboardNo1());
+      else
+        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());
-        }
-        break;
+    case KeyEvent.VK_RIGHT:
+      if (evt.isAltDown() || !viewport.cursorMode)
+        slideSequences(true, alignPanel.seqPanel.getKeyboardNo1());
+      else
+        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_DELETE:
-      case KeyEvent.VK_BACK_SPACE:
-        if(viewport.cursorMode)
+    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;
+      }
+      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() != viewport.alignment.getHeight())
         {
-          alignPanel.seqPanel.deleteGapAtCursor(evt.isControlDown());
+          hide = true;
+          viewport.hideAllSelectedSeqs();
         }
-       else
+        else if (!(toggleCols && viewport.colSel.getSelected().size() > 0))
         {
-          cut_actionPerformed();
-          alignPanel.seqPanel.seqCanvas.repaint();
+          viewport.showAllHiddenSeqs();
         }
-        break;
+      }
 
-      case KeyEvent.VK_S:
-        if(viewport.cursorMode)
+      if (toggleCols)
+      {
+        if (viewport.colSel.getSelected().size() > 0)
         {
-          alignPanel.seqPanel.setCursorRow();
+          viewport.hideSelectedColumns();
+          if (!toggleSeqs)
+          {
+            viewport.selectionGroup = sg;
+          }
         }
-        break;
-      case KeyEvent.VK_P:
-        if(viewport.cursorMode)
+        else if (!hide)
         {
-          alignPanel.seqPanel.setCursorPosition();
+          viewport.showAllHiddenColumns();
         }
-        break;
+      }
+      break;
+    }
 
-      case KeyEvent.VK_ENTER:
-      case KeyEvent.VK_COMMA:
-        if(viewport.cursorMode)
-        {
-          alignPanel.seqPanel.setCursorRowAndColumn();
-        }
-        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_Q:
-        if(viewport.cursorMode)
-        {
-          alignPanel.seqPanel.setSelectionAreaAtCursor(true);
-        }
-        break;
-      case KeyEvent.VK_M:
-        if(viewport.cursorMode)
+    case KeyEvent.VK_PAGE_DOWN:
+      if (viewport.wrapAlignment)
+      {
+        alignPanel.scrollUp(false);
+      }
+      else
+      {
+        alignPanel.setScrollValues(viewport.startRes, viewport.startSeq
+                + viewport.endSeq - viewport.startSeq);
+      }
+      break;
+
+    case KeyEvent.VK_Z:
+      if (evt.isControlDown())
+      {
+        undoMenuItem_actionPerformed();
+      }
+      break;
+
+    case KeyEvent.VK_Y:
+      if (evt.isControlDown())
+      {
+        redoMenuItem_actionPerformed();
+      }
+      break;
+
+    case KeyEvent.VK_L:
+      if (evt.isControlDown())
+      {
+        trimAlignment(true);
+      }
+      break;
+
+    case KeyEvent.VK_R:
+      if (evt.isControlDown())
+      {
+        trimAlignment(false);
+      }
+      break;
+
+    case KeyEvent.VK_E:
+      if (evt.isControlDown())
+      {
+        if (evt.isShiftDown())
         {
-          alignPanel.seqPanel.setSelectionAreaAtCursor(false);
+          this.removeAllGapsMenuItem_actionPerformed();
         }
-        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())
+        else
         {
-          findMenuItem_actionPerformed();
+          removeGappedColumnMenuItem_actionPerformed();
         }
-        break;
-      case KeyEvent.VK_H:
+      }
+      break;
+    case KeyEvent.VK_I:
+      if (evt.isControlDown())
       {
-        boolean toggleSeqs = !evt.isControlDown();
-        boolean toggleCols = !evt.isShiftDown();
-        boolean hide = false;
-        SequenceGroup sg = viewport.getSelectionGroup();
-
-        if(toggleSeqs)
+        if (evt.isAltDown())
         {
-          if (sg != null && sg.getSize(false) != viewport.alignment.getHeight())
-          {
-            hide = true;
-            viewport.hideAllSelectedSeqs();
-          }
-          else if (!(toggleCols && viewport.colSel.getSelected().size() > 0))
-            viewport.showAllHiddenSeqs();
+          viewport.invertColumnSelection();
         }
-
-        if(toggleCols)
+        else
         {
-          if (viewport.colSel.getSelected().size() > 0)
-          {
-            viewport.hideSelectedColumns();
-            if(!toggleSeqs)
-                   viewport.selectionGroup = sg;
-          }
-          else if (!hide)
-            viewport.showAllHiddenColumns();
+          this.invertSequenceMenuItem_actionPerformed();
         }
+      }
+      break;
 
-        alignPanel.repaint();
-        break;
+    case KeyEvent.VK_U:
+      if (evt.isControlDown())
+      {
+        this.deleteGroups_actionPerformed();
+      }
+      break;
+
+    case KeyEvent.VK_T:
+      if (evt.isControlDown())
+      {
+        newView(null);
       }
+      break;
 
     }
+    alignPanel.paintAlignment(true);
   }
+
   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)
+  {
+  }
+
+  public void itemStateChanged(ItemEvent evt)
+  {
+    if (evt.getSource() == colourTextMenuItem)
+    {
+      colourTextMenuItem_actionPerformed();
+    }
+    else if (evt.getSource() == wrapMenuItem)
+    {
+      wrapMenuItem_actionPerformed();
+    }
+    else if (evt.getSource() == scaleAbove)
+    {
+      viewport.setScaleAboveWrapped(scaleAbove.getState());
+    }
+    else if (evt.getSource() == scaleLeft)
+    {
+      viewport.setScaleLeftWrapped(scaleLeft.getState());
+    }
+    else if (evt.getSource() == scaleRight)
+    {
+      viewport.setScaleRightWrapped(scaleRight.getState());
+    }
+    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)
- {
+    }
+    else if (evt.getSource() == viewBoxesMenuItem)
+    {
+      viewport.setShowBoxes(viewBoxesMenuItem.getState());
+    }
+    else if (evt.getSource() == viewTextMenuItem)
+    {
+      viewport.setShowText(viewTextMenuItem.getState());
+    }
+    else if (evt.getSource() == renderGapsMenuItem)
+    {
+      viewport.setRenderGaps(renderGapsMenuItem.getState());
+    }
+    else if (evt.getSource() == annotationPanelMenuItem)
+    {
+      viewport.setShowAnnotation(annotationPanelMenuItem.getState());
+      alignPanel.setAnnotationVisible(annotationPanelMenuItem.getState());
+    }
+    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)
+    {
+      viewport.setColourAppliesToAllGroups(applyToAllGroups.getState());
+    }
+    else if (evt.getSource() == autoCalculate)
+    {
+      viewport.autocalculateConsensus = autoCalculate.getState();
+    }
+    else if (evt.getSource() == this.centreColumnLabelFlag)
+    {
+      centreColumnLabelFlag_stateChanged();
+    }
+
+    alignPanel.paintAlignment(true);
+  }
+
+  private void centreColumnLabelFlag_stateChanged()
+  {
+    viewport.centreColumnLabels = centreColumnLabelFlag.getState();
+    this.alignPanel.annotationPanel.repaint();
+  }
+
+  public void actionPerformed(ActionEvent evt)
+  {
     Object source = evt.getSource();
 
-    if(source==inputText)
+    if (source == inputText)
+    {
       inputText_actionPerformed();
-    else if(source==loadTree)
+    }
+    else if (source == loadTree)
+    {
       loadTree_actionPerformed();
-    else if(source==loadApplication)
+    }
+    else if (source == loadApplication)
+    {
       launchFullApplication();
-    else if(source==closeMenuItem)
+    }
+    else if (source == loadAnnotations)
+    {
+      loadAnnotations();
+    }
+    else if (source == outputAnnotations)
+    {
+      outputAnnotations(true);
+    }
+    else if (source == outputFeatures)
+    {
+      outputFeatures(true, "Jalview");
+    }
+    else if (source == closeMenuItem)
+    {
       closeMenuItem_actionPerformed();
-    else if(source==copy)
+    }
+    else if (source == copy)
+    {
       copy_actionPerformed();
-    else if(source==undoMenuItem)
+    }
+    else if (source == undoMenuItem)
+    {
       undoMenuItem_actionPerformed();
-    else if(source==redoMenuItem)
+    }
+    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)
+    }
+    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.paintAlignment(true);
+    }
+    else if (source == remove2LeftMenuItem)
+    {
+      trimAlignment(true);
+    }
+    else if (source == remove2RightMenuItem)
+    {
+      trimAlignment(false);
+    }
+    else if (source == removeGappedColumnMenuItem)
+    {
+      removeGappedColumnMenuItem_actionPerformed();
+    }
+    else if (source == removeAllGapsMenuItem)
+    {
+      removeAllGapsMenuItem_actionPerformed();
+    }
+    else if (source == findMenuItem)
+    {
+      findMenuItem_actionPerformed();
+    }
+    else if (source == font)
+    {
+      new FontChooser(alignPanel);
+    }
+    else if (source == newView)
+    {
+      newView(null);
+    }
+    else if (source == showColumns)
+    {
+      viewport.showAllHiddenColumns();
+      alignPanel.paintAlignment(true);
+    }
+    else if (source == showSeqs)
     {
       viewport.showAllHiddenSeqs();
     }
-    else if(source == hideColumns)
+    else if (source == hideColumns)
     {
-      viewport.hideSelectedColumns(); alignPanel.repaint();
+      viewport.hideSelectedColumns();
+      alignPanel.paintAlignment(true);
     }
-    else if(source == hideSequences && viewport.getSelectionGroup()!=null)
+    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();
-
- }
+    else if (source == featureSettings)
+    {
+      new FeatureSettings(alignPanel);
+    }
+    else if (source == alProperties)
+    {
+      StringBuffer contents = new StringBuffer();
+
+      float avg = 0;
+      int min = Integer.MAX_VALUE, max = 0;
+      for (int i = 0; i < viewport.alignment.getHeight(); i++)
+      {
+        int size = viewport.alignment.getSequenceAt(i).getEnd()
+                - viewport.alignment.getSequenceAt(i).getStart();
+        avg += size;
+        if (size > max)
+          max = size;
+        if (size < min)
+          min = size;
+      }
+      avg = avg / (float) viewport.alignment.getHeight();
+
+      contents.append("\nSequences: " + viewport.alignment.getHeight());
+      contents.append("\nMinimum Sequence Length: " + min);
+      contents.append("\nMaximum Sequence Length: " + max);
+      contents.append("\nAverage Length: " + (int) avg);
+
+      if (((Alignment) viewport.alignment).alignmentProperties != null)
+      {
+        Hashtable props = ((Alignment) viewport.alignment).alignmentProperties;
+        Enumeration en = props.keys();
+        while (en.hasMoreElements())
+        {
+          String key = en.nextElement().toString();
+          contents.append("\n" + key + "\t" + props.get(key));
+        }
+      }
+
+      CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
+      cap.setText(contents.toString());
+      Frame frame = new Frame();
+      frame.add(cap);
+      jalview.bin.JalviewLite.addFrame(frame, "Alignment Properties: "
+              + getTitle(), 400, 250);
+    }
+    else if (source == overviewMenuItem)
+    {
+      overviewMenuItem_actionPerformed();
+    }
+    else if (source == noColourmenuItem)
+    {
+      changeColour(null);
+    }
+    else if (source == clustalColour)
+    {
+      abovePIDThreshold.setState(false);
+      changeColour(new ClustalxColourScheme(viewport.alignment
+              .getSequences(), viewport.alignment.getWidth()));
+    }
+    else if (source == zappoColour)
+    {
+      changeColour(new ZappoColourScheme());
+    }
+    else if (source == taylorColour)
+    {
+      changeColour(new TaylorColourScheme());
+    }
+    else if (source == hydrophobicityColour)
+    {
+      changeColour(new HydrophobicColourScheme());
+    }
+    else if (source == helixColour)
+    {
+      changeColour(new HelixColourScheme());
+    }
+    else if (source == strandColour)
+    {
+      changeColour(new StrandColourScheme());
+    }
+    else if (source == turnColour)
+    {
+      changeColour(new TurnColourScheme());
+    }
+    else if (source == buriedColour)
+    {
+      changeColour(new BuriedColourScheme());
+    }
+    else if (source == nucleotideColour)
+    {
+      changeColour(new NucleotideColourScheme());
+    }
+    else if (source == modifyPID)
+    {
+      modifyPID_actionPerformed();
+    }
+    else if (source == modifyConservation)
+    {
+      modifyConservation_actionPerformed();
+    }
+    else if (source == userDefinedColour)
+    {
+      new UserDefinedColours(alignPanel, null);
+    }
+    else if (source == PIDColour)
+    {
+      changeColour(new PIDColourScheme());
+    }
+    else if (source == BLOSUM62Colour)
+    {
+      changeColour(new Blosum62ColourScheme());
+    }
+    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()
   {
@@ -551,101 +875,194 @@ public void itemStateChanged(ItemEvent evt)
     jalview.bin.JalviewLite.addFrame(frame, "Cut & Paste Input", 500, 500);
   }
 
-  protected void outputText_actionPerformed(ActionEvent e)
+  protected void outputText_actionPerformed(ActionEvent e)
+  {
+    CutAndPasteTransfer cap = new CutAndPasteTransfer(true, 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(),
+            viewport.showJVSuffix));
+  }
+
+  public void loadAnnotations()
+  {
+    CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
+    cap.setText("Paste your features / annotations file here.");
+    cap.setAnnotationImport();
+    Frame frame = new Frame();
+    frame.add(cap);
+    jalview.bin.JalviewLite.addFrame(frame, "Paste Annotations ", 400, 300);
+
+  }
+
+  public String outputAnnotations(boolean displayTextbox)
+  {
+    String annotation = new AnnotationFile().printAnnotations(
+            viewport.showAnnotation ? viewport.alignment
+                    .getAlignmentAnnotation() : null, viewport.alignment
+                    .getGroups(),
+            ((Alignment) viewport.alignment).alignmentProperties);
+
+    if (displayTextbox)
+    {
+      CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
+      Frame frame = new Frame();
+      frame.add(cap);
+      jalview.bin.JalviewLite.addFrame(frame, "Annotations", 600, 500);
+      cap.setText(annotation);
+    }
+
+    return annotation;
+  }
+
+  public String outputFeatures(boolean displayTextbox, String format)
   {
-    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));
+    String features;
+    if (format.equalsIgnoreCase("Jalview"))
+    {
+      features = new FeaturesFile().printJalviewFormat(viewport.alignment
+              .getSequencesArray(), viewport.featuresDisplayed);
+    }
+    else
+    {
+      features = new FeaturesFile().printGFFFormat(viewport.alignment
+              .getSequencesArray(), viewport.featuresDisplayed);
+    }
+
+    if (displayTextbox)
+    {
+      CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
+      Frame frame = new Frame();
+      frame.add(cap);
+      jalview.bin.JalviewLite.addFrame(frame, "Features", 600, 500);
+
+      cap.setText(features);
+    }
+
+    return features;
   }
 
   void launchFullApplication()
   {
     StringBuffer url = new StringBuffer(jalviewServletURL);
 
-    url.append("?open="+
-               appendProtocol( viewport.applet.getParameter("file") ) );
+    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("features")!=null)
+    if (viewport.applet.getParameter("annotations") != null)
     {
-      url.append( "&features=" );
-      url.append( appendProtocol( viewport.applet.getParameter("features") ) );
+      url.append("&annotations=");
+      url
+              .append(appendProtocol(viewport.applet
+                      .getParameter("annotations")));
     }
 
-    if(viewport.applet.getParameter("annotations")!=null)
+    if (viewport.applet.getParameter("jnetfile") != null)
     {
-      url.append( "&annotations=" );
-      url.append( appendProtocol( viewport.applet.getParameter("annotations") ) );
+      url.append("&annotations=");
+      url.append(appendProtocol(viewport.applet.getParameter("jnetfile")));
     }
 
-    if(viewport.applet.getParameter("defaultColour")!=null)
+    if (viewport.applet.getParameter("defaultColour") != null)
     {
-      url.append("&colour=" +
-                 removeWhiteSpace(viewport.applet.getParameter("defaultColour"))
-          );
+      url.append("&colour="
+              + removeWhiteSpace(viewport.applet
+                      .getParameter("defaultColour")));
     }
 
-    if(viewport.applet.getParameter("userDefinedColour")!=null)
+    if (viewport.applet.getParameter("userDefinedColour") != null)
+    {
+      url.append("&colour="
+              + removeWhiteSpace(viewport.applet
+                      .getParameter("userDefinedColour")));
+    }
+    if (viewport.applet.getParameter("tree") != null)
     {
-      url.append( "&colour=" +
-                 removeWhiteSpace( viewport.applet.getParameter("userDefinedColour") )
-         );
+      url.append("&tree="
+              + appendProtocol(viewport.applet.getParameter("tree")));
+    }
+    if (viewport.applet.getParameter("treeFile") != null)
+    {
+      url.append("&tree="
+              + appendProtocol(viewport.applet.getParameter("treeFile")));
     }
 
     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)
+    try
+    {
+      new URL(url);
+      url = URLEncoder.encode(url);
+    }
+    /*
+     * When we finally deprecate 1.1 compatibility, we can start to use
+     * URLEncoder.encode(url,"UTF-8") and then we'll need this catch: catch
+     * (UnsupportedEncodingException ex) { System.err.println("WARNING -
+     * IMPLEMENTATION ERROR - UNSUPPORTED ENCODING EXCEPTION FOR "+url);
+     * ex.printStackTrace(); }
+     */
+    catch (java.net.MalformedURLException ex)
     {
-      url = viewport.applet.getCodeBase()+url;
+      url = viewport.applet.getCodeBase() + url;
     }
     return url;
   }
 
   public void closeMenuItem_actionPerformed()
   {
-    PaintRefresher.components.remove(viewport.alignment);
-    if(PaintRefresher.components.size()==0 && viewport.applet==null)
+    PaintRefresher.RemoveComponent(alignPanel);
+    PaintRefresher.RemoveComponent(alignPanel.seqPanel.seqCanvas);
+    PaintRefresher.RemoveComponent(alignPanel.idPanel.idCanvas);
+
+    if (PaintRefresher.components.size() == 0 && viewport.applet == null)
+    {
       System.exit(0);
+    }
 
     this.dispose();
   }
 
-  Stack historyList = new Stack();
-  Stack redoList = new Stack();
-
+  /**
+   * DOCUMENT ME!
+   */
   void updateEditMenuBar()
   {
-    if (historyList.size() > 0)
+
+    if (viewport.historyList.size() > 0)
     {
       undoMenuItem.setEnabled(true);
-      HistoryItem hi = (HistoryItem) historyList.peek();
-      undoMenuItem.setLabel("Undo " + hi.getDescription());
+      CommandI command = (CommandI) viewport.historyList.peek();
+      undoMenuItem.setLabel("Undo " + command.getDescription());
     }
     else
     {
@@ -653,11 +1070,12 @@ public void itemStateChanged(ItemEvent evt)
       undoMenuItem.setLabel("Undo");
     }
 
-    if (redoList.size() > 0)
+    if (viewport.redoList.size() > 0)
     {
       redoMenuItem.setEnabled(true);
-      HistoryItem hi = (HistoryItem) redoList.peek();
-      redoMenuItem.setLabel("Redo " + hi.getDescription());
+
+      CommandI command = (CommandI) viewport.redoList.peek();
+      redoMenuItem.setLabel("Redo " + command.getDescription());
     }
     else
     {
@@ -666,43 +1084,106 @@ public void itemStateChanged(ItemEvent evt)
     }
   }
 
-  public void addHistoryItem(HistoryItem hi)
+  public void addHistoryItem(CommandI command)
   {
-    historyList.push(hi);
-    redoList.clear();
-    updateEditMenuBar();
+    if (command.getSize() > 0)
+    {
+      viewport.historyList.push(command);
+      viewport.redoList.removeAllElements();
+      updateEditMenuBar();
+      viewport.hasHiddenColumns = viewport.colSel.getHiddenColumns() != null;
+    }
   }
 
+  /**
+   * DOCUMENT ME!
+   * 
+   * @param e
+   *                DOCUMENT ME!
+   */
   protected void undoMenuItem_actionPerformed()
   {
-    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());
+    if (viewport.historyList.size() < 1)
+    {
+      return;
+    }
+
+    CommandI command = (CommandI) viewport.historyList.pop();
+    viewport.redoList.push(command);
+    command.undoCommand(null);
+
+    AlignViewport originalSource = getOriginatingSource(command);
+
+    originalSource.hasHiddenColumns = viewport.colSel.getHiddenColumns() != null;
+    updateEditMenuBar();
+    originalSource.firePropertyChange("alignment", null,
+            originalSource.alignment.getSequences());
   }
 
+  /**
+   * DOCUMENT ME!
+   * 
+   * @param e
+   *                DOCUMENT ME!
+   */
   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);
+    if (viewport.redoList.size() < 1)
+    {
+      return;
+    }
+
+    CommandI command = (CommandI) viewport.redoList.pop();
+    viewport.historyList.push(command);
+    command.doCommand(null);
+
+    AlignViewport originalSource = getOriginatingSource(command);
+    originalSource.hasHiddenColumns = viewport.colSel.getHiddenColumns() != null;
+
     updateEditMenuBar();
-    viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
+    originalSource.firePropertyChange("alignment", null,
+            originalSource.alignment.getSequences());
   }
 
-  // used by undo and redo
-  void restoreHistoryItem(HistoryItem hi)
+  AlignViewport getOriginatingSource(CommandI command)
   {
-    hi.restore(viewport.getColumnSelection());
-    updateEditMenuBar();
+    AlignViewport originalSource = null;
+    // For sequence removal and addition, we need to fire
+    // the property change event FROM the viewport where the
+    // original alignment was altered
+    AlignmentI al = null;
+    if (command instanceof EditCommand)
+    {
+      EditCommand editCommand = (EditCommand) command;
+      al = editCommand.getAlignment();
+      Vector comps = (Vector) PaintRefresher.components.get(viewport
+              .getSequenceSetId());
+      for (int i = 0; i < comps.size(); i++)
+      {
+        if (comps.elementAt(i) instanceof AlignmentPanel)
+        {
+          if (al == ((AlignmentPanel) comps.elementAt(i)).av.alignment)
+          {
+            originalSource = ((AlignmentPanel) comps.elementAt(i)).av;
+            break;
+          }
+        }
+      }
+    }
 
-    viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
+    if (originalSource == null)
+    {
+      // The original view is closed, we must validate
+      // the current view against the closed view first
+      if (al != null)
+      {
+        PaintRefresher.validateSequences(al, viewport.alignment);
+      }
+
+      originalSource = viewport;
+    }
+
+    return originalSource;
   }
 
   public void moveSelectedSequences(boolean up)
@@ -718,13 +1199,13 @@ public void itemStateChanged(ItemEvent evt)
       for (int i = 1; i < viewport.alignment.getHeight(); i++)
       {
         SequenceI seq = viewport.alignment.getSequenceAt(i);
-        if (!sg.getSequences(false).contains(seq))
+        if (!sg.getSequences(null).contains(seq))
         {
           continue;
         }
 
         SequenceI temp = viewport.alignment.getSequenceAt(i - 1);
-        if (sg.getSequences(false).contains(temp))
+        if (sg.getSequences(null).contains(temp))
         {
           continue;
         }
@@ -738,13 +1219,13 @@ public void itemStateChanged(ItemEvent evt)
       for (int i = viewport.alignment.getHeight() - 2; i > -1; i--)
       {
         SequenceI seq = viewport.alignment.getSequenceAt(i);
-        if (!sg.getSequences(true).contains(seq))
+        if (!sg.getSequences(viewport.hiddenRepSequences).contains(seq))
         {
           continue;
         }
 
         SequenceI temp = viewport.alignment.getSequenceAt(i + 1);
-        if (sg.getSequences(true).contains(temp))
+        if (sg.getSequences(viewport.hiddenRepSequences).contains(temp))
         {
           continue;
         }
@@ -754,11 +1235,97 @@ public void itemStateChanged(ItemEvent evt)
       }
     }
 
-    alignPanel.repaint();
+    alignPanel.paintAlignment(true);
+  }
+
+  synchronized void slideSequences(boolean right, int size)
+  {
+    Vector sg = new Vector();
+    if (viewport.cursorMode)
+    {
+      sg.addElement(viewport.alignment
+              .getSequenceAt(alignPanel.seqPanel.seqCanvas.cursorY));
+    }
+    else if (viewport.getSelectionGroup() != null
+            && viewport.getSelectionGroup().getSize() != viewport.alignment
+                    .getHeight())
+    {
+      sg = viewport.getSelectionGroup().getSequences(
+              viewport.hiddenRepSequences);
+    }
+
+    if (sg.size() < 1)
+    {
+      return;
+    }
+
+    Vector invertGroup = new Vector();
+
+    for (int i = 0; i < viewport.alignment.getHeight(); i++)
+    {
+      if (!sg.contains(viewport.alignment.getSequenceAt(i)))
+        invertGroup.addElement(viewport.alignment.getSequenceAt(i));
+    }
+
+    SequenceI[] seqs1 = new SequenceI[sg.size()];
+    for (int i = 0; i < sg.size(); i++)
+      seqs1[i] = (SequenceI) sg.elementAt(i);
+
+    SequenceI[] seqs2 = new SequenceI[invertGroup.size()];
+    for (int i = 0; i < invertGroup.size(); i++)
+      seqs2[i] = (SequenceI) invertGroup.elementAt(i);
+
+    SlideSequencesCommand ssc;
+    if (right)
+      ssc = new SlideSequencesCommand("Slide Sequences", seqs2, seqs1,
+              size, viewport.getGapCharacter());
+    else
+      ssc = new SlideSequencesCommand("Slide Sequences", seqs1, seqs2,
+              size, viewport.getGapCharacter());
+
+    int groupAdjustment = 0;
+    if (ssc.getGapsInsertedBegin() && right)
+    {
+      if (viewport.cursorMode)
+        alignPanel.seqPanel.moveCursor(size, 0);
+      else
+        groupAdjustment = size;
+    }
+    else if (!ssc.getGapsInsertedBegin() && !right)
+    {
+      if (viewport.cursorMode)
+        alignPanel.seqPanel.moveCursor(-size, 0);
+      else
+        groupAdjustment = -size;
+    }
+
+    if (groupAdjustment != 0)
+    {
+      viewport.getSelectionGroup().setStartRes(
+              viewport.getSelectionGroup().getStartRes() + groupAdjustment);
+      viewport.getSelectionGroup().setEndRes(
+              viewport.getSelectionGroup().getEndRes() + groupAdjustment);
+    }
+
+    boolean appendHistoryItem = false;
+    if (viewport.historyList != null && viewport.historyList.size() > 0
+            && viewport.historyList.peek() instanceof SlideSequencesCommand)
+    {
+      appendHistoryItem = ssc
+              .appendSlideCommand((SlideSequencesCommand) viewport.historyList
+                      .peek());
+    }
+
+    if (!appendHistoryItem)
+      addHistoryItem(ssc);
+
+    repaint();
   }
 
   static StringBuffer copiedSequences;
+
   static Vector copiedHiddenColumns;
+
   protected void copy_actionPerformed()
   {
     if (viewport.getSelectionGroup() == null)
@@ -769,7 +1336,7 @@ public void itemStateChanged(ItemEvent evt)
     SequenceGroup sg = viewport.getSelectionGroup();
     copiedSequences = new StringBuffer();
     Hashtable orderedSeqs = new Hashtable();
-    for (int i = 0; i < sg.getSize(false); i++)
+    for (int i = 0; i < sg.getSize(); i++)
     {
       SequenceI seq = sg.getSequenceAt(i);
       int index = viewport.alignment.findIndex(seq);
@@ -783,67 +1350,70 @@ public void itemStateChanged(ItemEvent evt)
     {
       copiedHiddenColumns = new Vector();
       int hiddenOffset = viewport.getSelectionGroup().getStartRes();
-      for (int i = 0; i < viewport.getColumnSelection().getHiddenColumns().size();
-           i++)
+      for (int i = 0; i < viewport.getColumnSelection().getHiddenColumns()
+              .size(); i++)
       {
-        int[] region = (int[])
-            viewport.getColumnSelection().getHiddenColumns().elementAt(i);
+        int[] region = (int[]) viewport.getColumnSelection()
+                .getHiddenColumns().elementAt(i);
 
         copiedHiddenColumns.addElement(new int[]
-                                 {region[0] - hiddenOffset,
-                                 region[1] - hiddenOffset});
+        { region[0] - hiddenOffset, region[1] - hiddenOffset });
       }
     }
     else
+    {
       copiedHiddenColumns = null;
+    }
 
-
-    for (int i = 0; i < sg.getSize(false); i++)
+    for (int i = 0; i < sg.getSize(); i++)
     {
-        SequenceI seq = null;
+      SequenceI seq = null;
+
+      while (seq == null)
+      {
+        if (orderedSeqs.containsKey(index + ""))
+        {
+          seq = (SequenceI) orderedSeqs.get(index + "");
+          index++;
 
-        while (seq == null)
+          break;
+        }
+        else
         {
-            if (orderedSeqs.containsKey(index + ""))
-            {
-                seq = (SequenceI) orderedSeqs.get(index + "");
-                index++;
-
-                break;
-            }
-            else
-            {
-                index++;
-            }
+          index++;
         }
+      }
 
-        //FIND START RES
-        //Returns residue following index if gap
-        startRes = seq.findPosition(sg.getStartRes());
+      // 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;
+      // 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++)
+      for (int j = 0; j < sg.getEndRes() + 1 && j < seq.getLength(); j++)
+      {
+        ch = seq.getCharAt(j);
+        if (!jalview.util.Comparison.isGap((ch)))
         {
-          ch = seq.getCharAt(j);
-          if (!jalview.util.Comparison.isGap( (ch)))
-          {
-            endRes++;
-          }
+          endRes++;
         }
+      }
 
-        if(endRes>0)
-        {
-          endRes += seq.getStart() -1;
-        }
+      if (endRes > 0)
+      {
+        endRes += seq.getStart() - 1;
+      }
 
-        copiedSequences.append(seq.getName() + "\t" +
-            startRes + "\t" +
-            endRes + "\t" +
-            seq.getSequence(sg.getStartRes(),
-                sg.getEndRes() + 1) + "\n");
+      copiedSequences.append(seq.getName()
+              + "\t"
+              + startRes
+              + "\t"
+              + endRes
+              + "\t"
+              + seq.getSequenceAsString(sg.getStartRes(),
+                      sg.getEndRes() + 1) + "\n");
     }
 
   }
@@ -855,8 +1425,6 @@ public void itemStateChanged(ItemEvent evt)
 
   protected void pasteThis_actionPerformed()
   {
-    addHistoryItem(new HistoryItem("Paste Sequences", viewport.alignment,
-                                   HistoryItem.PASTE));
     paste(false);
   }
 
@@ -864,6 +1432,7 @@ public void itemStateChanged(ItemEvent evt)
   {
     try
     {
+
       if (copiedSequences == null)
       {
         return;
@@ -876,26 +1445,16 @@ public void itemStateChanged(ItemEvent evt)
         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);
-
-        if (!newAlignment)
-        {
-          viewport.alignment.addSequence(sequence);
-        }
-        else
-        {
-          seqs.addElement(sequence);
-        }
+        seqs.addElement(new Sequence(name, st.nextToken(), start, end));
+      }
+      SequenceI[] newSeqs = new SequenceI[seqs.size()];
+      for (int i = 0; i < seqs.size(); i++)
+      {
+        newSeqs[i] = (SequenceI) seqs.elementAt(i);
       }
 
       if (newAlignment)
       {
-        SequenceI[] newSeqs = new SequenceI[seqs.size()];
-        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"))
         {
@@ -906,9 +1465,7 @@ public void itemStateChanged(ItemEvent evt)
           newtitle = newtitle.concat("- from " + getTitle());
         }
         AlignFrame af = new AlignFrame(new Alignment(newSeqs),
-                                       viewport.applet,
-                                       newtitle,
-                                       false);
+                viewport.applet, newtitle, false);
         if (copiedHiddenColumns != null)
         {
           for (int i = 0; i < copiedHiddenColumns.size(); i++)
@@ -918,20 +1475,35 @@ public void itemStateChanged(ItemEvent evt)
           }
         }
 
-
-        jalview.bin.JalviewLite.addFrame(af, newtitle, 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.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
+        addSequences(newSeqs);
       }
 
+    } catch (Exception ex)
+    {
+    } // could be anything being pasted in here
+
+  }
+
+  void addSequences(SequenceI[] seqs)
+  {
+    for (int i = 0; i < seqs.length; i++)
+    {
+      viewport.alignment.addSequence(seqs[i]);
     }
-    catch (Exception ex)
-    {} // could be anything being pasted in here
+
+    // !newAlignment
+    addHistoryItem(new EditCommand("Add sequences", EditCommand.PASTE,
+            seqs, 0, viewport.alignment.getWidth(), viewport.alignment));
+
+    viewport.setEndSeq(viewport.alignment.getHeight());
+    viewport.alignment.getWidth();
+    viewport.firePropertyChange("alignment", null, viewport.alignment
+            .getSequences());
 
   }
 
@@ -943,65 +1515,60 @@ public void itemStateChanged(ItemEvent evt)
 
   protected void delete_actionPerformed()
   {
-    addHistoryItem(new HistoryItem("Delete Sequences", viewport.alignment,
-                                   HistoryItem.HIDE));
-    if (viewport.getSelectionGroup() == null)
+
+    SequenceGroup sg = viewport.getSelectionGroup();
+    if (sg == null)
     {
       return;
     }
 
-
-    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++)
+    Vector seqs = new Vector();
+    SequenceI seq;
+    for (int i = 0; i < sg.getSize(); 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);
-      }
+      seq = sg.getSequenceAt(i);
+      seqs.addElement(seq);
+    }
 
+    // If the cut affects all sequences, remove highlighted columns
+    if (sg.getSize() == viewport.alignment.getHeight())
+    {
+      viewport.getColumnSelection().removeElements(sg.getStartRes(),
+              sg.getEndRes() + 1);
+    }
 
-      if (seq.getSequence().length() < 1)
-      {
-        viewport.getAlignment().deleteSequence(seq);
-      }
-      else
-      {
-        viewport.getAlignment().getSequences().setElementAt(seq, index);
-      }
+    SequenceI[] cut = new SequenceI[seqs.size()];
+    for (int i = 0; i < seqs.size(); i++)
+    {
+      cut[i] = (SequenceI) seqs.elementAt(i);
     }
 
+    /*
+     * //ADD HISTORY ITEM
+     */
+    addHistoryItem(new EditCommand("Cut Sequences", EditCommand.CUT, cut,
+            sg.getStartRes(), sg.getEndRes() - sg.getStartRes() + 1,
+            viewport.alignment));
+
     viewport.setSelectionGroup(null);
     viewport.alignment.deleteGroup(sg);
-    viewport.resetSeqLimits(alignPanel.seqPanel.seqCanvas.getSize().height);
+
+    viewport.firePropertyChange("alignment", null, viewport.getAlignment()
+            .getSequences());
+
     if (viewport.getAlignment().getHeight() < 1)
     {
-      try
-      {
-        this.setVisible(false);
-      }
-      catch (Exception ex)
-      {}
+      this.setVisible(false);
     }
-    viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
-
   }
 
   protected void deleteGroups_actionPerformed()
   {
     viewport.alignment.deleteAllGroups();
+    viewport.sequenceColours = null;
     viewport.setSelectionGroup(null);
 
-    alignPanel.repaint();
+    alignPanel.paintAlignment(true);
   }
 
   public void selectAllSequenceMenuItem_actionPerformed()
@@ -1011,26 +1578,26 @@ public void itemStateChanged(ItemEvent evt)
     {
       sg.addSequence(viewport.getAlignment().getSequenceAt(i), false);
     }
-    sg.setEndRes(viewport.alignment.getWidth()-1);
+    sg.setEndRes(viewport.alignment.getWidth() - 1);
     viewport.setSelectionGroup(sg);
-    alignPanel.repaint();
-    PaintRefresher.Refresh(null, viewport.alignment);
+    alignPanel.paintAlignment(true);
+    PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
   }
 
   public void deselectAllSequenceMenuItem_actionPerformed()
   {
-    if(viewport.cursorMode)
+    if (viewport.cursorMode)
     {
-      alignPanel.seqPanel.keyboardNo1=null;
-      alignPanel.seqPanel.keyboardNo2=null;
+      alignPanel.seqPanel.keyboardNo1 = null;
+      alignPanel.seqPanel.keyboardNo2 = null;
     }
     viewport.setSelectionGroup(null);
     viewport.getColumnSelection().clear();
     viewport.setSelectionGroup(null);
     alignPanel.idPanel.idCanvas.searchResults = null;
     alignPanel.seqPanel.seqCanvas.highlightSearchResults(null);
-    alignPanel.repaint();
-    PaintRefresher.Refresh(null, viewport.alignment);
+    alignPanel.paintAlignment(true);
+    PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
   }
 
   public void invertSequenceMenuItem_actionPerformed()
@@ -1041,238 +1608,297 @@ public void itemStateChanged(ItemEvent evt)
       sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false);
     }
 
-    PaintRefresher.Refresh(null, viewport.alignment);
+    PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
   }
 
-  public void remove2LeftMenuItem_actionPerformed()
+  void trimAlignment(boolean trimLeft)
   {
     ColumnSelection colSel = viewport.getColumnSelection();
+    int column;
+
     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);
-      edit.addShift(0, min);
-      if (viewport.getSelectionGroup() != null)
+      if (trimLeft)
       {
-        viewport.getSelectionGroup().adjustForRemoveLeft(min);
+        column = colSel.getMin();
       }
-
-      Vector groups = viewport.alignment.getGroups();
-      for (int i = 0; i < groups.size(); i++)
+      else
       {
-        SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
-        if (!sg.adjustForRemoveLeft(min))
-        {
-          viewport.alignment.deleteGroup(sg);
-        }
+        column = colSel.getMax();
       }
-      viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
-    }
-  }
 
-  public void remove2RightMenuItem_actionPerformed()
-  {
-    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);
-      
+      SequenceI[] seqs;
       if (viewport.getSelectionGroup() != null)
       {
-        viewport.getSelectionGroup().adjustForRemoveRight(max);
+        seqs = viewport.getSelectionGroup().getSequencesAsArray(
+                viewport.hiddenRepSequences);
+      }
+      else
+      {
+        seqs = viewport.alignment.getSequencesArray();
       }
 
+      TrimRegionCommand trimRegion;
+      if (trimLeft)
+      {
+        trimRegion = new TrimRegionCommand("Remove Left",
+                TrimRegionCommand.TRIM_LEFT, seqs, column,
+                viewport.alignment, viewport.colSel,
+                viewport.selectionGroup);
+        viewport.setStartRes(0);
+      }
+      else
+      {
+        trimRegion = new TrimRegionCommand("Remove Right",
+                TrimRegionCommand.TRIM_RIGHT, seqs, column,
+                viewport.alignment, viewport.colSel,
+                viewport.selectionGroup);
+      }
+
+      statusBar.setText("Removed " + trimRegion.getSize() + " columns.");
+
+      addHistoryItem(trimRegion);
+
       Vector groups = viewport.alignment.getGroups();
+
       for (int i = 0; i < groups.size(); i++)
       {
         SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
-        if (!sg.adjustForRemoveRight(max))
+
+        if ((trimLeft && !sg.adjustForRemoveLeft(column))
+                || (!trimLeft && !sg.adjustForRemoveRight(column)))
         {
           viewport.alignment.deleteGroup(sg);
         }
       }
-      viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
-    }
 
+      viewport.firePropertyChange("alignment", null, viewport
+              .getAlignment().getSequences());
+    }
   }
 
   public void removeGappedColumnMenuItem_actionPerformed()
   {
-    HistoryItem edit;
-    addHistoryItem(edit=new HistoryItem("Remove Gapped Columns",
-                                   viewport.alignment,
-                                   HistoryItem.HIDE));
+    int start = 0, end = viewport.alignment.getWidth() - 1;
 
-    //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[] seqs;
+    if (viewport.getSelectionGroup() != null)
+    {
+      seqs = viewport.getSelectionGroup().getSequencesAsArray(
+              viewport.hiddenRepSequences);
+      start = viewport.getSelectionGroup().getStartRes();
+      end = viewport.getSelectionGroup().getEndRes();
+    }
+    else
+    {
+      seqs = viewport.alignment.getSequencesArray();
+    }
 
-    viewport.getAlignment().removeGaps();
-    
-    viewport.setStartRes(seq.findIndex(startRes)-1);
+    RemoveGapColCommand removeGapCols = new RemoveGapColCommand(
+            "Remove Gapped Columns", seqs, start, end, viewport.alignment);
 
-    viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
-  }
+    addHistoryItem(removeGapCols);
 
-  public void removeAllGapsMenuItem_actionPerformed()
-  {
-    // 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));
+    statusBar.setText("Removed " + removeGapCols.getSize()
+            + " empty columns.");
 
-    //This is to maintain viewport position on first residue
-    //of first sequence
+    // This is to maintain viewport position on first residue
+    // of first sequence
     SequenceI seq = viewport.alignment.getSequenceAt(0);
     int startRes = seq.findPosition(viewport.startRes);
+    // ShiftList shifts;
+    // viewport.getAlignment().removeGaps(shifts=new ShiftList());
+    // edit.alColumnChanges=shifts.getInverse();
+    // if (viewport.hasHiddenColumns)
+    // viewport.getColumnSelection().compensateForEdits(shifts);
+    viewport.setStartRes(seq.findIndex(startRes) - 1);
+    viewport.firePropertyChange("alignment", null, viewport.getAlignment()
+            .getSequences());
 
-    SequenceI current;
-    Vector seqs=null;
+  }
 
-    int start=0, end = viewport.alignment.getWidth();
+  public void removeAllGapsMenuItem_actionPerformed()
+  {
+    int start = 0, end = viewport.alignment.getWidth() - 1;
 
-    if (viewport.getSelectionGroup() != null
-        && viewport.getSelectionGroup().getSequences(false) != null
-        && viewport.getSelectionGroup().getSize(false)>0)
+    SequenceI[] seqs;
+    if (viewport.getSelectionGroup() != null)
     {
-      seqs = viewport.getSelectionGroup().getSequences(true);
+      seqs = viewport.getSelectionGroup().getSequencesAsArray(
+              viewport.hiddenRepSequences);
       start = viewport.getSelectionGroup().getStartRes();
-      end = viewport.getSelectionGroup().getEndRes()+1;
+      end = viewport.getSelectionGroup().getEndRes();
     }
     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;
-        */
+      seqs = viewport.alignment.getSequencesArray();
     }
-    /* // 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();
-    }
+    // This is to maintain viewport position on first residue
+    // of first sequence
+    SequenceI seq = viewport.alignment.getSequenceAt(0);
+    int startRes = seq.findPosition(viewport.startRes);
+
+    addHistoryItem(new RemoveGapsCommand("Remove Gaps", seqs, start, end,
+            viewport.alignment));
 
-    resetAllColourSchemes();
-    if(alignPanel.overviewPanel!=null)
-      alignPanel.overviewPanel.updateOverviewImage();
+    viewport.setStartRes(seq.findIndex(startRes) - 1);
 
-    viewport.alignment.adjustSequenceAnnotations();
-    alignPanel.repaint();
+    viewport.firePropertyChange("alignment", null, viewport.getAlignment()
+            .getSequences());
+
+  }
+
+  public void findMenuItem_actionPerformed()
+  {
+    new Finder(alignPanel);
   }
 
-  void resetAllColourSchemes()
+  /**
+   * create a new view derived from the current view
+   * 
+   * @param viewtitle
+   * @return frame for the new view
+   */
+  public AlignFrame newView(String viewtitle)
   {
-    ColourSchemeI cs = viewport.globalColourScheme;
-    if(cs!=null)
+    AlignmentI newal;
+    if (viewport.hasHiddenRows)
+    {
+      newal = new Alignment(viewport.getAlignment().getHiddenSequences()
+              .getFullAlignment().getSequencesArray());
+    }
+    else
+    {
+      newal = new Alignment(viewport.alignment.getSequencesArray());
+    }
+
+    if (viewport.alignment.getAlignmentAnnotation() != null)
     {
-      if (cs instanceof ClustalxColourScheme)
+      for (int i = 0; i < viewport.alignment.getAlignmentAnnotation().length; i++)
       {
-        ( (ClustalxColourScheme) viewport.getGlobalColourScheme()).
-            resetClustalX(viewport.alignment.getSequences(),
-                          viewport.alignment.getWidth());
+        if (!viewport.alignment.getAlignmentAnnotation()[i].autoCalculated)
+        {
+          newal
+                  .addAnnotation(viewport.alignment
+                          .getAlignmentAnnotation()[i]);
+        }
       }
+    }
+
+    AlignFrame newaf = new AlignFrame(newal, viewport.applet, "", false);
+
+    newaf.viewport.sequenceSetID = alignPanel.av.getSequenceSetId();
+    PaintRefresher.Register(alignPanel, alignPanel.av.getSequenceSetId());
+    PaintRefresher.Register(newaf.alignPanel, newaf.alignPanel.av
+            .getSequenceSetId());
+
+    PaintRefresher.Register(newaf.alignPanel.idPanel.idCanvas,
+            newaf.alignPanel.av.getSequenceSetId());
+    PaintRefresher.Register(newaf.alignPanel.seqPanel.seqCanvas,
+            newaf.alignPanel.av.getSequenceSetId());
 
-      cs.setConsensus(viewport.vconsensus);
-      if (cs.conservationApplied())
+    Vector comps = (Vector) PaintRefresher.components.get(viewport
+            .getSequenceSetId());
+    int viewSize = -1;
+    for (int i = 0; i < comps.size(); i++)
+    {
+      if (comps.elementAt(i) instanceof AlignmentPanel)
       {
-        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);
+        viewSize++;
       }
     }
 
-    int s, sSize = viewport.alignment.getGroups().size();
-    for(s=0; s<sSize; s++)
+    String title = new String(this.getTitle());
+    if (viewtitle != null)
+    {
+      title = viewtitle + " ( " + title + ")";
+    }
+    else
     {
-      SequenceGroup sg = (SequenceGroup)viewport.alignment.getGroups().elementAt(s);
-      if(sg.cs!=null && sg.cs instanceof ClustalxColourScheme)
+      if (title.indexOf("(View") > -1)
       {
-        ((ClustalxColourScheme)sg.cs).resetClustalX(
-            sg.getSequences(true), sg.getWidth());
+        title = title.substring(0, title.indexOf("(View"));
       }
-      sg.recalcConservation();
+      title += "(View " + viewSize + ")";
     }
-  }
 
+    newaf.setTitle(title.toString());
 
+    newaf.viewport.historyList = viewport.historyList;
+    newaf.viewport.redoList = viewport.redoList;
+    return newaf;
+  }
 
-  public void findMenuItem_actionPerformed()
+  /**
+   * 
+   * @return list of feature groups on the view
+   */
+  public String[] getFeatureGroups()
   {
-    new Finder(alignPanel);
+    FeatureRenderer fr = null;
+    if (alignPanel != null
+            && (fr = alignPanel.getFeatureRenderer()) != null)
+    {
+      return fr.getGroups();
+    }
+    return null;
   }
 
-  public void font_actionPerformed()
+  /**
+   * get sequence feature groups that are hidden or shown
+   * 
+   * @param visible
+   *                true is visible
+   * @return list
+   */
+  public String[] getFeatureGroupsOfState(boolean visible)
   {
-    new FontChooser(alignPanel);
+    FeatureRenderer fr = null;
+    if (alignPanel != null
+            && (fr = alignPanel.getFeatureRenderer()) != null)
+    {
+      return fr.getGroups(visible);
+    }
+    return null;
   }
 
+  /**
+   * Change the display state for the given feature groups
+   * 
+   * @param groups
+   *                list of group strings
+   * @param state
+   *                visible or invisible
+   */
+  public void setFeatureGroupState(String[] groups, boolean state)
+  {
+    FeatureRenderer fr = null;
+    this.sequenceFeatures.setState(true);
+    viewport.showSequenceFeatures(true);
+    if (alignPanel != null
+            && (fr = alignPanel.getFeatureRenderer()) != null)
+    {
+      fr.setGroupState(groups, state);
+      alignPanel.seqPanel.seqCanvas.repaint();
+      if (alignPanel.overviewPanel != null)
+      {
+        alignPanel.overviewPanel.updateOverviewImage();
+      }
+    }
+  }
 
   public void seqLimits_itemStateChanged()
   {
     viewport.setShowJVSuffix(seqLimits.getState());
     alignPanel.fontChanged();
-    alignPanel.repaint();
+    alignPanel.paintAlignment(true);
   }
 
-
   protected void colourTextMenuItem_actionPerformed()
   {
     viewport.setColourText(colourTextMenuItem.getState());
-    alignPanel.repaint();
+    alignPanel.paintAlignment(true);
   }
 
   protected void wrapMenuItem_actionPerformed()
@@ -1282,55 +1908,7 @@ public void itemStateChanged(ItemEvent evt)
     scaleAbove.setEnabled(wrapMenuItem.getState());
     scaleLeft.setEnabled(wrapMenuItem.getState());
     scaleRight.setEnabled(wrapMenuItem.getState());
-    alignPanel.repaint();
-  }
-
-
-  protected void scaleAbove_actionPerformed()
-  {
-    viewport.setScaleAboveWrapped(scaleAbove.getState());
-    alignPanel.repaint();
-  }
-
-  protected void scaleLeft_actionPerformed()
-  {
-    viewport.setScaleLeftWrapped(scaleLeft.getState());
-    alignPanel.repaint();
-  }
-
-  protected void scaleRight_actionPerformed()
-  {
-    viewport.setScaleRightWrapped(scaleRight.getState());
-    alignPanel.repaint();
-  }
-
-  public void viewBoxesMenuItem_actionPerformed()
-  {
-    viewport.setShowBoxes(viewBoxesMenuItem.getState());
-    alignPanel.repaint();
-  }
-
-  public void viewTextMenuItem_actionPerformed()
-  {
-    viewport.setShowText(viewTextMenuItem.getState());
-    alignPanel.repaint();
-  }
-
-  protected void renderGapsMenuItem_actionPerformed()
-  {
-    viewport.setRenderGaps(renderGapsMenuItem.getState());
-    alignPanel.repaint();
-  }
-
-  public void annotationPanelMenuItem_actionPerformed()
-  {
-    viewport.setShowAnnotation(annotationPanelMenuItem.getState());
-    alignPanel.setAnnotationVisible(annotationPanelMenuItem.getState());
-  }
-
-  public void featureSettings_actionPerformed()
-  {
-    new FeatureSettings(viewport, alignPanel);
+    alignPanel.paintAlignment(true);
   }
 
   public void overviewMenuItem_actionPerformed()
@@ -1345,8 +1923,8 @@ public void itemStateChanged(ItemEvent evt)
     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.getPreferredSize().width,
+            overview.getPreferredSize().height + 50);
 
     frame.pack();
     frame.addWindowListener(new WindowAdapter()
@@ -1361,72 +1939,16 @@ public void itemStateChanged(ItemEvent evt)
 
   }
 
-  protected void noColourmenuItem_actionPerformed()
-  {
-    changeColour(null);
-  }
-
-  public void clustalColour_actionPerformed()
-  {
-    abovePIDThreshold.setState(false);
-    changeColour(new ClustalxColourScheme(viewport.alignment.getSequences(),
-                                          viewport.alignment.getWidth()));
-  }
-
-  public void zappoColour_actionPerformed()
-  {
-    changeColour(new ZappoColourScheme());
-  }
-
-  public void taylorColour_actionPerformed()
-  {
-    changeColour(new TaylorColourScheme());
-  }
-
-  public void hydrophobicityColour_actionPerformed()
-  {
-    changeColour(new HydrophobicColourScheme());
-  }
-
-  public void helixColour_actionPerformed()
-  {
-    changeColour(new HelixColourScheme());
-  }
-
-  public void strandColour_actionPerformed()
-  {
-    changeColour(new StrandColourScheme());
-  }
-
-  public void turnColour_actionPerformed()
-  {
-    changeColour(new TurnColourScheme());
-  }
-
-  public void buriedColour_actionPerformed()
-  {
-    changeColour(new BuriedColourScheme());
-  }
-
-  public void nucleotideColour_actionPerformed()
-  {
-    changeColour(new NucleotideColourScheme());
-  }
-
-  protected void applyToAllGroups_actionPerformed()
-  {
-    viewport.setColourAppliesToAllGroups(applyToAllGroups.getState());
-  }
-
   void changeColour(ColourSchemeI cs)
   {
     int threshold = 0;
 
-    if(cs!=null)
+    if (cs != null)
     {
       if (viewport.getAbovePIDThreshold())
       {
-        threshold = SliderPanel.setPIDSliderSource(alignPanel, cs, "Background");
+        threshold = SliderPanel.setPIDSliderSource(alignPanel, cs,
+                "Background");
 
         cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
 
@@ -1442,17 +1964,16 @@ public void itemStateChanged(ItemEvent evt)
 
         Alignment al = (Alignment) viewport.alignment;
         Conservation c = new Conservation("All",
-                                          ResidueProperties.propHash, 3,
-                                          al.getSequences(), 0,
-                                          al.getWidth() - 1);
+                ResidueProperties.propHash, 3, al.getSequences(), 0, al
+                        .getWidth() - 1);
 
         c.calculate();
         c.verdict(false, viewport.ConsPercGaps);
 
         cs.setConservation(c);
 
-        cs.setConservationInc(SliderPanel.setConservationSlider(alignPanel, cs,
-            "Background"));
+        cs.setConservationInc(SliderPanel.setConservationSlider(alignPanel,
+                cs, "Background"));
 
       }
       else
@@ -1460,7 +1981,7 @@ public void itemStateChanged(ItemEvent evt)
         cs.setConservation(null);
       }
 
-      cs.setConsensus(viewport.vconsensus);
+      cs.setConsensus(viewport.hconsensus);
 
     }
     viewport.setGlobalColourScheme(cs);
@@ -1472,22 +1993,22 @@ public void itemStateChanged(ItemEvent evt)
       {
         SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
 
-        if(cs==null)
+        if (cs == null)
         {
           sg.cs = null;
           continue;
         }
         if (cs instanceof ClustalxColourScheme)
         {
-          sg.cs = new ClustalxColourScheme(sg.getSequences(true), sg.getWidth());
+          sg.cs = new ClustalxColourScheme(sg
+                  .getSequences(viewport.hiddenRepSequences), sg.getWidth());
         }
         else
         {
           try
           {
             sg.cs = (ColourSchemeI) cs.getClass().newInstance();
-          }
-          catch (Exception ex)
+          } catch (Exception ex)
           {
             ex.printStackTrace();
             sg.cs = cs;
@@ -1495,21 +2016,25 @@ public void itemStateChanged(ItemEvent evt)
         }
 
         if (viewport.getAbovePIDThreshold()
-            || cs instanceof PIDColourScheme
-            || cs instanceof Blosum62ColourScheme)
+                || cs instanceof PIDColourScheme
+                || cs instanceof Blosum62ColourScheme)
         {
           sg.cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
-          sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(true), 0, sg.getWidth()));
+          sg.cs.setConsensus(AAFrequency.calculate(sg
+                  .getSequences(viewport.hiddenRepSequences), 0, sg
+                  .getWidth()));
         }
         else
+        {
           sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
+        }
 
         if (viewport.getConservationSelected())
         {
           Conservation c = new Conservation("Group",
-                                            ResidueProperties.propHash, 3,
-                                            sg.getSequences(true), 0,
-                                            viewport.alignment.getWidth() - 1);
+                  ResidueProperties.propHash, 3, sg
+                          .getSequences(viewport.hiddenRepSequences), 0,
+                  viewport.alignment.getWidth() - 1);
           c.calculate();
           c.verdict(false, viewport.ConsPercGaps);
           sg.cs.setConservation(c);
@@ -1523,33 +2048,36 @@ public void itemStateChanged(ItemEvent evt)
       }
     }
 
-
     if (alignPanel.getOverviewPanel() != null)
     {
       alignPanel.getOverviewPanel().updateOverviewImage();
     }
 
-    alignPanel.repaint();
-  }
-
+    jalview.structure.StructureSelectionManager
+            .getStructureSelectionManager().sequenceColoursChanged(
+                    alignPanel);
 
+    alignPanel.paintAlignment(true);
+  }
 
   protected void modifyPID_actionPerformed()
   {
-    if (viewport.getAbovePIDThreshold() && viewport.globalColourScheme!=null)
+    if (viewport.getAbovePIDThreshold()
+            && viewport.globalColourScheme != null)
     {
-      SliderPanel.setPIDSliderSource(alignPanel, viewport.getGlobalColourScheme(),
-                                     "Background");
+      SliderPanel.setPIDSliderSource(alignPanel, viewport
+              .getGlobalColourScheme(), "Background");
       SliderPanel.showPIDSlider();
     }
   }
 
   protected void modifyConservation_actionPerformed()
   {
-    if (viewport.getConservationSelected() && viewport.globalColourScheme!=null)
+    if (viewport.getConservationSelected()
+            && viewport.globalColourScheme != null)
     {
-      SliderPanel.setConservationSlider(alignPanel, viewport.globalColourScheme,
-                                        "Background");
+      SliderPanel.setConservationSlider(alignPanel,
+              viewport.globalColourScheme, "Background");
       SliderPanel.showConservationSlider();
     }
   }
@@ -1578,73 +2106,59 @@ public void itemStateChanged(ItemEvent evt)
     modifyPID_actionPerformed();
   }
 
-  public void userDefinedColour_actionPerformed()
-  {
-    new UserDefinedColours(alignPanel, null);
-  }
-
-  public void PIDColour_actionPerformed()
-  {
-    changeColour(new PIDColourScheme());
-  }
-
-  public void BLOSUM62Colour_actionPerformed()
-  {
-    changeColour(new Blosum62ColourScheme());
-  }
-
   public void sortPairwiseMenuItem_actionPerformed()
   {
-    addHistoryItem(new HistoryItem("Pairwise Sort", viewport.alignment,
-                                   HistoryItem.SORT));
-    AlignmentSorter.sortByPID(viewport.getAlignment(),
-                              viewport.getAlignment().getSequenceAt(0));
-    alignPanel.repaint();
+    SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
+    AlignmentSorter.sortByPID(viewport.getAlignment(), viewport
+            .getAlignment().getSequenceAt(0), null);
+    addHistoryItem(new OrderCommand("Pairwise Sort", oldOrder,
+            viewport.alignment));
+    alignPanel.paintAlignment(true);
   }
 
   public void sortIDMenuItem_actionPerformed()
   {
-    addHistoryItem(new HistoryItem("ID Sort", viewport.alignment,
-                                   HistoryItem.SORT));
+    // addHistoryItem(new HistoryItem("ID Sort", viewport.alignment,
+    // HistoryItem.SORT));
     AlignmentSorter.sortByID(viewport.getAlignment());
-    alignPanel.repaint();
+    alignPanel.paintAlignment(true);
   }
 
   public void sortGroupMenuItem_actionPerformed()
   {
-    addHistoryItem(new HistoryItem("Group Sort", viewport.alignment,
-                                   HistoryItem.SORT));
+    // addHistoryItem(new HistoryItem("Group Sort", viewport.alignment,
+    // HistoryItem.SORT));
     AlignmentSorter.sortByGroup(viewport.getAlignment());
-    alignPanel.repaint();
+    alignPanel.paintAlignment(true);
 
   }
 
   public void removeRedundancyMenuItem_actionPerformed()
   {
-     new RedundancyPanel(alignPanel);
+    new RedundancyPanel(alignPanel);
   }
 
   public void pairwiseAlignmentMenuItem_actionPerformed()
   {
-    if (viewport.getSelectionGroup()!=null
-        && viewport.getSelectionGroup().getSize(false) > 1)
+    if (viewport.getSelectionGroup() != null
+            && viewport.getSelectionGroup().getSize() > 1)
     {
       Frame frame = new Frame();
       frame.add(new PairwiseAlignPanel(alignPanel));
-      jalview.bin.JalviewLite.addFrame(frame, "Pairwise Alignment", 600, 500);
+      jalview.bin.JalviewLite.addFrame(frame, "Pairwise Alignment", 600,
+              500);
     }
   }
 
   public void PCAMenuItem_actionPerformed()
   {
-    //are the sequences aligned?
+    // 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++)
+      for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
       {
         current = viewport.getAlignment().getSequenceAt(i);
 
@@ -1653,13 +2167,13 @@ public void itemStateChanged(ItemEvent evt)
           current.insertCharAt(Width - 1, viewport.getGapCharacter());
         }
       }
-      alignPanel.repaint();
+      alignPanel.paintAlignment(true);
     }
 
-    if ( (viewport.getSelectionGroup() != null &&
-          viewport.getSelectionGroup().getSize(false) < 4 &&
-          viewport.getSelectionGroup().getSize(false) > 0)
-        || viewport.getAlignment().getHeight() < 4)
+    if ((viewport.getSelectionGroup() != null
+            && viewport.getSelectionGroup().getSize() < 4 && viewport
+            .getSelectionGroup().getSize() > 0)
+            || viewport.getAlignment().getHeight() < 4)
     {
       return;
     }
@@ -1667,8 +2181,7 @@ public void itemStateChanged(ItemEvent evt)
     try
     {
       new PCAPanel(viewport);
-    }
-    catch (java.lang.OutOfMemoryError ex)
+    } catch (java.lang.OutOfMemoryError ex)
     {
     }
 
@@ -1691,19 +2204,18 @@ public void itemStateChanged(ItemEvent evt)
 
   protected void avTreeBlosumMenuItem_actionPerformed()
   {
-    NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62PID");
+    NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62");
   }
 
   void NewTreePanel(String type, String pwType, String title)
   {
-    //are the sequences aligned?
+    // 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++)
+      for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
       {
         current = viewport.getAlignment().getSequenceAt(i);
 
@@ -1712,18 +2224,16 @@ public void itemStateChanged(ItemEvent evt)
           current.insertCharAt(Width - 1, viewport.getGapCharacter());
         }
       }
-      alignPanel.repaint();
+      alignPanel.paintAlignment(true);
 
     }
 
-    if ( (viewport.getSelectionGroup() != null &&
-          viewport.getSelectionGroup().getSize(false) > 1)
-      || (viewport.getSelectionGroup() == null
-          && viewport.alignment.getHeight() > 1))
+    if ((viewport.getSelectionGroup() != null && viewport
+            .getSelectionGroup().getSize() > 1)
+            || (viewport.getSelectionGroup() == null && viewport.alignment
+                    .getHeight() > 1))
     {
-      final TreePanel tp = new TreePanel(viewport,
-                                         type,
-                                         pwType);
+      final TreePanel tp = new TreePanel(viewport, type, pwType);
 
       addTreeMenuItem(tp, title);
 
@@ -1733,20 +2243,17 @@ public void itemStateChanged(ItemEvent evt)
 
   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);
+    CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
+    cap.setText("Paste your Newick tree file here.");
+    cap.setTreeImport();
+    Frame frame = new Frame();
+    frame.add(cap);
+    jalview.bin.JalviewLite.addFrame(frame, "Paste Newick file ", 400, 300);
   }
 
   public void loadTree(jalview.io.NewickFile tree, String treeFile)
   {
-    TreePanel tp = new TreePanel(viewport,
-                                 treeFile,
-                                 "From File - ",
-                                 tree);
+    TreePanel tp = new TreePanel(viewport, treeFile, "From File - ", tree);
     jalview.bin.JalviewLite.addFrame(tp, treeFile, 600, 500);
     addTreeMenuItem(tp, treeFile);
   }
@@ -1759,10 +2266,11 @@ public void itemStateChanged(ItemEvent evt)
     {
       public void actionPerformed(ActionEvent evt)
       {
-        addHistoryItem(new HistoryItem("Sort", viewport.alignment,
-                                       HistoryItem.SORT));
-        AlignmentSorter.sortByTree(viewport.getAlignment(), treePanel.getTree());
-        alignPanel.repaint();
+        // addHistoryItem(new HistoryItem("Sort", viewport.alignment,
+        // HistoryItem.SORT));
+        AlignmentSorter.sortByTree(viewport.getAlignment(), treePanel
+                .getTree());
+        alignPanel.paintAlignment(true);
       }
     });
 
@@ -1786,8 +2294,11 @@ public void itemStateChanged(ItemEvent evt)
     class AboutPanel extends Canvas
     {
       String version;
+
       public AboutPanel(String version)
-      { this.version = version; }
+      {
+        this.version = version;
+      }
 
       public void paint(Graphics g)
       {
@@ -1798,19 +2309,29 @@ public void itemStateChanged(ItemEvent evt)
         int fh = fm.getHeight();
         int y = 5, x = 7;
         g.setColor(Color.black);
+        // TODO: update this text for each release or centrally store it for
+        // lite and application
         g.setFont(new Font("Helvetica", Font.BOLD, 14));
-        g.drawString("Jalview - Release "+version, 200, y += fh);
+        g.drawString("JalviewLite - Release " + version, x, 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(
-            "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(
+                        "Authors:  Andrew Waterhouse, Jim Procter, Michele Clamp, James Cuff, Steve Searle,",
+                        x, y += fh * 1.5);
+        g.drawString("David Martin & Geoff Barton.", x + 50, y += fh);
+        g
+                .drawString(
+                        "Development managed by The Barton Group, University of Dundee, Scotland, UK.",
+                        x, y += fh);
+        g
+                .drawString(
+                        "For help, see the FAQ at www.jalview.org and/or join the jalview-discuss@jalview.org mailing list",
+                        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);
       }
     }
@@ -1822,26 +2343,24 @@ public void itemStateChanged(ItemEvent evt)
       try
       {
         BufferedReader reader = new BufferedReader(new InputStreamReader(
-            url.openStream()));
+                url.openStream()));
         String line;
-        while ( (line = reader.readLine()) != null)
+        while ((line = reader.readLine()) != null)
         {
           if (line.indexOf("VERSION") > -1)
           {
             version = line.substring(line.indexOf("=") + 1);
           }
         }
-      }
-      catch (Exception ex)
+      } catch (Exception ex)
       {
         ex.printStackTrace();
       }
     }
 
-
     Frame frame = new Frame();
     frame.add(new AboutPanel(version));
-    jalview.bin.JalviewLite.addFrame(frame, "Jalview", 580, 200);
+    jalview.bin.JalviewLite.addFrame(frame, "Jalview", 580, 220);
 
   }
 
@@ -1855,280 +2374,372 @@ public void itemStateChanged(ItemEvent evt)
     {
       try
       {
-        System.out.println("Show url: "+url);
-        viewport.applet.getAppletContext().showDocument(new java.net.URL(url),
-                                               target);
-      }
-      catch (Exception ex)
+        if (url.indexOf(":")==-1)
+        {
+          // TODO: verify (Bas Vroling bug) prepend codebase or server URL to form valid URL
+          if (url.indexOf("/")==0)
+          {
+            String codebase = viewport.applet.getCodeBase().toString();
+            url = codebase.substring(0,codebase.length()-viewport.applet.getCodeBase().getFile().length())+url;
+          } else {
+            url = viewport.applet.getCodeBase()+url;
+          }
+          System.out.println("Show url (prepended codebase): " + url);
+        } else {
+          System.out.println("Show url: " + url);
+        }
+        viewport.applet.getAppletContext().showDocument(
+                new java.net.URL(url), target);
+      } catch (Exception ex)
       {
         ex.printStackTrace();
       }
     }
   }
 
+  // ////////////////////////////////////////////////////////////////////////////////
+  // JBuilder Graphics here
+
+  MenuBar alignFrameMenuBar = new MenuBar();
+
+  Menu fileMenu = new Menu("File");
+
+  MenuItem loadApplication = new MenuItem("View in Full Application");
+
+  MenuItem loadTree = new MenuItem("Load Associated Tree ...");
+
+  MenuItem loadAnnotations = new MenuItem("Load Features/Annotations ...");
 
-  //////////////////////////////////////////////////////////////////////////////////
-  //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()
+  MenuItem outputFeatures = new MenuItem("Export Features ...");
+
+  MenuItem outputAnnotations = new MenuItem("Export Annotations ...");
+
+  MenuItem closeMenuItem = new MenuItem("Close");
+
+  Menu editMenu = new Menu("Edit");
+
+  Menu viewMenu = new Menu("View");
+
+  Menu colourMenu = new Menu("Colour");
+
+  Menu calculateMenu = new Menu("Calculate");
+
+  MenuItem selectAllSequenceMenuItem = new MenuItem("Select all");
+
+  MenuItem deselectAllSequenceMenuItem = new MenuItem("Deselect All");
+
+  MenuItem invertSequenceMenuItem = new MenuItem("Invert Selection");
+
+  MenuItem remove2LeftMenuItem = new MenuItem();
+
+  MenuItem remove2RightMenuItem = new MenuItem();
+
+  MenuItem removeGappedColumnMenuItem = new MenuItem();
+
+  MenuItem removeAllGapsMenuItem = new MenuItem();
+
+  CheckboxMenuItem viewBoxesMenuItem = new CheckboxMenuItem();
+
+  CheckboxMenuItem viewTextMenuItem = new CheckboxMenuItem();
+
+  MenuItem sortPairwiseMenuItem = new MenuItem();
+
+  MenuItem sortIDMenuItem = new MenuItem();
+
+  MenuItem sortGroupMenuItem = new MenuItem();
+
+  MenuItem removeRedundancyMenuItem = new MenuItem();
+
+  MenuItem pairwiseAlignmentMenuItem = new MenuItem();
+
+  MenuItem PCAMenuItem = new MenuItem();
+
+  MenuItem averageDistanceTreeMenuItem = new MenuItem();
+
+  MenuItem neighbourTreeMenuItem = new MenuItem();
+
+  BorderLayout borderLayout1 = new BorderLayout();
+
+  public Label statusBar = new Label();
+
+  Menu outputTextboxMenu = new Menu();
+
+  MenuItem clustalColour = new MenuItem();
+
+  MenuItem zappoColour = new MenuItem();
+
+  MenuItem taylorColour = new MenuItem();
+
+  MenuItem hydrophobicityColour = new MenuItem();
+
+  MenuItem helixColour = new MenuItem();
+
+  MenuItem strandColour = new MenuItem();
+
+  MenuItem turnColour = new MenuItem();
+
+  MenuItem buriedColour = new MenuItem();
+
+  MenuItem userDefinedColour = new MenuItem();
+
+  MenuItem PIDColour = new MenuItem();
+
+  MenuItem BLOSUM62Colour = new MenuItem();
+
+  MenuItem njTreeBlosumMenuItem = new MenuItem();
+
+  MenuItem avDistanceTreeBlosumMenuItem = new MenuItem();
+
+  CheckboxMenuItem annotationPanelMenuItem = new CheckboxMenuItem();
+
+  CheckboxMenuItem colourTextMenuItem = new CheckboxMenuItem();
+
+  MenuItem alProperties = new MenuItem("Alignment Properties...");
+
+  MenuItem overviewMenuItem = new MenuItem();
+
+  MenuItem undoMenuItem = new MenuItem();
+
+  MenuItem redoMenuItem = new MenuItem();
+
+  CheckboxMenuItem conservationMenuItem = new CheckboxMenuItem();
+
+  MenuItem noColourmenuItem = new MenuItem();
+
+  CheckboxMenuItem wrapMenuItem = new CheckboxMenuItem();
+
+  CheckboxMenuItem renderGapsMenuItem = new CheckboxMenuItem();
+
+  MenuItem findMenuItem = new MenuItem();
+
+  CheckboxMenuItem abovePIDThreshold = new CheckboxMenuItem();
+
+  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();
+
+  CheckboxMenuItem applyToAllGroups = new CheckboxMenuItem();
+
+  MenuItem font = new MenuItem();
+
+  CheckboxMenuItem scaleAbove = new CheckboxMenuItem();
+
+  CheckboxMenuItem scaleLeft = new CheckboxMenuItem();
+
+  CheckboxMenuItem scaleRight = new CheckboxMenuItem();
+
+  MenuItem modifyPID = new MenuItem();
+
+  MenuItem modifyConservation = new MenuItem();
+
+  CheckboxMenuItem autoCalculate = new CheckboxMenuItem(
+          "Autocalculate Consensus", true);
+
+  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();
+
+  CheckboxMenuItem seqLimits = new CheckboxMenuItem();
+
+  CheckboxMenuItem centreColumnLabelFlag = new CheckboxMenuItem();
+
+  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)
         {
-          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);
+          outputText_actionPerformed(e);
+        }
+      });
+
+      outputTextboxMenu.add(item);
+    }
+    closeMenuItem.addActionListener(this);
+    loadApplication.addActionListener(this);
+
+    loadTree.addActionListener(this);
+    loadAnnotations.addActionListener(this);
+    outputFeatures.addActionListener(this);
+    outputAnnotations.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);
+    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);
+    alProperties.addActionListener(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);
+    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);
+    centreColumnLabelFlag.setLabel("Centre column labels");
+    centreColumnLabelFlag.addItemListener(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...");
@@ -2151,250 +2762,198 @@ public void itemStateChanged(ItemEvent evt)
     showSeqs.addActionListener(this);
     hideColumns.addActionListener(this);
     hideSequences.addActionListener(this);
-
-
+    formatMenu.setLabel("Format");
+    selectMenu.setLabel("Select");
+    newView.setLabel("New View");
+    newView.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();
+    alignFrameMenuBar.add(editMenu);
+    alignFrameMenuBar.add(selectMenu);
+    alignFrameMenuBar.add(viewMenu);
+    alignFrameMenuBar.add(formatMenu);
+    alignFrameMenuBar.add(colourMenu);
+    alignFrameMenuBar.add(calculateMenu);
+    alignFrameMenuBar.add(helpMenu);
+
+    fileMenu.add(inputText);
+    fileMenu.add(loadTree);
+    fileMenu.add(loadAnnotations);
+
+    fileMenu.addSeparator();
+    fileMenu.add(outputTextboxMenu);
+    fileMenu.add(outputFeatures);
+    fileMenu.add(outputAnnotations);
+
+    if (jalviewServletURL != null)
+    {
+      fileMenu.add(loadApplication);
+    }
+
+    fileMenu.addSeparator();
+    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(remove2LeftMenuItem);
+    editMenu.add(remove2RightMenuItem);
+    editMenu.add(removeGappedColumnMenuItem);
+    editMenu.add(removeAllGapsMenuItem);
+    editMenu.add(removeRedundancyMenuItem);
+    viewMenu.add(newView);
+    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.add(annotationPanelMenuItem);
+    viewMenu.addSeparator();
+    viewMenu.add(sequenceFeatures);
+    viewMenu.add(featureSettings);
     viewMenu.addSeparator();
-        viewMenu.add(sequenceFeatures);
-        viewMenu.add(featureSettings);
+    viewMenu.add(alProperties);
     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);
+    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);
+    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);
+    formatMenu.add(font);
+    formatMenu.add(seqLimits);
+    formatMenu.add(wrapMenuItem);
+    formatMenu.add(scaleAbove);
+    formatMenu.add(scaleLeft);
+    formatMenu.add(scaleRight);
+    formatMenu.add(viewBoxesMenuItem);
+    formatMenu.add(viewTextMenuItem);
+    formatMenu.add(colourTextMenuItem);
+    formatMenu.add(renderGapsMenuItem);
+    formatMenu.add(centreColumnLabelFlag);
+    selectMenu.add(findMenuItem);
+    selectMenu.addSeparator();
+    selectMenu.add(selectAllSequenceMenuItem);
+    selectMenu.add(deselectAllSequenceMenuItem);
+    selectMenu.add(invertSequenceMenuItem);
+    selectMenu.add(invertColSel);
+    selectMenu.add(deleteGroups);
   }
 
-  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);
-    }
+  Menu formatMenu = new Menu();
 
-    embeddedMenu.add(popup);
-    popup.show(embeddedMenu,
-               source.getBounds().x,
-               source.getBounds().y + source.getBounds().getSize().height);
-  }
+  Menu selectMenu = new Menu();
 
-  PopupMenu genPopupMenu(PopupMenu popup, Menu original)
-  {
-    if(popup!=null)
-    {
-      return popup;
+  MenuItem newView = new MenuItem();
+
+  /**
+   * Attach the alignFrame panels after embedding menus, if necessary. This used
+   * to be called setEmbedded, but is now creates the dropdown menus in a
+   * platform independent manner to avoid OSX/Mac menu appendage daftness.
+   * 
+   * @param reallyEmbedded
+   *                true to attach the view to the applet area on the page
+   *                rather than in a new window
+   */
+  public void createAlignFrameWindow(boolean reallyEmbedded, String title)
+  {
+    if (reallyEmbedded)
+    {
+      // ////
+      // Explicly build the embedded menu panel for the on-page applet
+      //
+      // view cannot be closed if its actually on the page
+      fileMenu.remove(closeMenuItem);
+      fileMenu.remove(3); // Remove Seperator
+      embeddedMenu = makeEmbeddedPopupMenu(alignFrameMenuBar, "Arial",
+              Font.PLAIN, 10, false); // use our own fonts.
+      // and actually add the components to the applet area
+      viewport.applet.setLayout(new BorderLayout());
+      viewport.applet.add(embeddedMenu, BorderLayout.NORTH);
+      viewport.applet.add(statusBar, BorderLayout.SOUTH);
+      alignPanel.setSize(viewport.applet.getSize().width, viewport.applet
+              .getSize().height
+              - embeddedMenu.HEIGHT - statusBar.HEIGHT);
+      viewport.applet.add(alignPanel, BorderLayout.CENTER);
+      viewport.applet.validate();
     }
-    popup = new PopupMenu();
-    int m, mSize = original.getItemCount();
-    for(m=0; m<mSize; m++)
+    else
     {
-      popup.add(original.getItem(m));
-      mSize--;
-      m--;
+      // //////
+      // test and embed menu bar if necessary.
+      //
+      if (embedMenuIfNeeded(alignPanel))
+      {
+        // adjust for status bar height too
+        alignPanel.setSize(getSize().width, getSize().height
+                - statusBar.HEIGHT);
+      }
+      add(statusBar, BorderLayout.SOUTH);
+      add(alignPanel, BorderLayout.CENTER);
+      // and register with the applet so it can pass external API calls to us
+      jalview.bin.JalviewLite.addFrame(this, title, DEFAULT_WIDTH,
+              DEFAULT_HEIGHT);
     }
-
-    return popup;
   }
-  public void mouseClicked(MouseEvent evt)
-  {}
-  public void mouseReleased(MouseEvent evt)
-  {}
-  public void mouseEntered(MouseEvent evt)
-  {}
-  public void mouseExited(MouseEvent evt)
-  {}
-
 }
-