X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fappletgui%2FAlignFrame.java;h=759075a46a1b723a133a69bc0879f81f9a1f49b5;hb=a45774ee31d9f35d4eff46d54d7deab719afb092;hp=12a2938e982aaf51a5b104cbce943ac87ce982f8;hpb=1e58b8b312767fca84147372413044d6c152c3c3;p=jalview.git

diff --git a/src/jalview/appletgui/AlignFrame.java b/src/jalview/appletgui/AlignFrame.java
old mode 100755
new mode 100644
index 12a2938..759075a
--- a/src/jalview/appletgui/AlignFrame.java
+++ b/src/jalview/appletgui/AlignFrame.java
@@ -1,25 +1,22 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer
- * Copyright (C) 2007 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
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
+ * Copyright (C) 2011 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle
+ * 
+ * This file is part of Jalview.
+ * 
+ * Jalview 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 3 of the License, or (at your option) any later version.
+ * 
+ * Jalview 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 Jalview.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 package jalview.appletgui;
 
-import java.io.*;
 import java.net.*;
 import java.util.*;
 
@@ -27,26 +24,29 @@ import java.awt.*;
 import java.awt.event.*;
 
 import jalview.analysis.*;
+import jalview.api.SequenceStructureBinding;
+import jalview.bin.JalviewLite;
 import jalview.commands.*;
 import jalview.datamodel.*;
 import jalview.io.*;
 import jalview.schemes.*;
+import jalview.structure.StructureSelectionManager;
 
-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 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)
   {
 
     if (applet != null)
@@ -57,8 +57,7 @@ public class AlignFrame
     try
     {
       jbInit();
-    }
-    catch (Exception ex)
+    } catch (Exception ex)
     {
       ex.printStackTrace();
     }
@@ -70,6 +69,12 @@ public class AlignFrame
     viewport.updateConsensus(alignPanel);
 
     annotationPanelMenuItem.setState(viewport.showAnnotation);
+    displayNonconservedMenuItem.setState(viewport.getShowunconserved());
+    followMouseOverFlag.setState(viewport.getFollowHighlight());
+    showGroupConsensus.setState(viewport.showGroupConsensus);
+    showGroupConservation.setState(viewport.showGroupConservation);
+    showConsensusHistogram.setState(viewport.showConsensusHistogram);
+    showSequenceLogo.setState(viewport.showSequenceLogo);
 
     seqLimits.setState(viewport.showJVSuffix);
 
@@ -86,6 +91,10 @@ public class AlignFrame
         {
           sortPairwiseMenuItem_actionPerformed();
         }
+        else if (param.equalsIgnoreCase("Length"))
+        {
+          sortLengthMenuItem_actionPerformed();
+        }
       }
 
       param = applet.getParameter("wrap");
@@ -97,7 +106,12 @@ public class AlignFrame
           wrapMenuItem_actionPerformed();
         }
       }
-
+      param = applet.getParameter("centrecolumnlabels");
+      if (param != null)
+      {
+        centreColumnLabelFlag.setState(true);
+        centreColumnLabelFlag_stateChanged();
+      }
       try
       {
         param = applet.getParameter("windowWidth");
@@ -112,31 +126,27 @@ public class AlignFrame
           int height = Integer.parseInt(param);
           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
+    // 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);
+    alignPanel.annotationPanelHolder.addKeyListener(this);
+    alignPanel.annotationSpaceFillerHolder.addKeyListener(this);
+    alignPanel.alabels.addKeyListener(this);
+    createAlignFrameWindow(embedded, title);
 
-    if (embedded)
-    {
-      setEmbedded();
-    }
-    else
-    {
-      add(alignPanel, BorderLayout.CENTER);
-      jalview.bin.JalviewLite.addFrame(this, title, DEFAULT_WIDTH,
-                                       DEFAULT_HEIGHT);
-    }
-    alignPanel.validate();
+    validate();
+    alignPanel.adjustAnnotationHeight();
     alignPanel.paintAlignment(true);
   }
 
@@ -152,8 +162,9 @@ public class AlignFrame
 
   /**
    * DOCUMENT ME!
-   *
-   * @param String DOCUMENT ME!
+   * 
+   * @param String
+   *          DOCUMENT ME!
    */
 
   public void parseFeaturesFile(String file, String type)
@@ -162,14 +173,11 @@ public class AlignFrame
     boolean featuresFile = false;
     try
     {
-      featuresFile = new jalview.io.FeaturesFile(file,
-          type).parse(viewport.alignment,
-                      alignPanel.seqPanel.seqCanvas.
-                      getFeatureRenderer().featureColours,
-                      featureLinks,
-                      true);
-    }
-    catch (Exception ex)
+      featuresFile = new jalview.io.FeaturesFile(file, type)
+              .parse(viewport.alignment,
+                      alignPanel.seqPanel.seqCanvas.getFeatureRenderer().featureColours,
+                      featureLinks, true, viewport.applet.getDefaultParameter("relaxedidmatch", false));
+    } catch (Exception ex)
     {
       ex.printStackTrace();
     }
@@ -178,11 +186,14 @@ public class AlignFrame
     {
       if (featureLinks.size() > 0)
       {
-        alignPanel.seqPanel.seqCanvas
-            .getFeatureRenderer().featureLinks = featureLinks;
+        alignPanel.seqPanel.seqCanvas.getFeatureRenderer().featureLinks = featureLinks;
       }
       viewport.showSequenceFeatures = true;
       sequenceFeatures.setState(true);
+      if (viewport.featureSettings != null)
+      {
+        viewport.featureSettings.refreshTable();
+      }
       alignPanel.paintAlignment(true);
     }
 
@@ -190,311 +201,345 @@ public class AlignFrame
 
   public void keyPressed(KeyEvent evt)
   {
-    if (viewport.cursorMode &&
-        ( (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());
-
+    if (viewport.cursorMode
+            && ((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())
-        {
-          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 27: // escape key
+      deselectAllSequenceMenuItem_actionPerformed();
+      
+      alignPanel.alabels.cancelDrag(); 
+      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 (evt.isAltDown() || !viewport.cursorMode)
-          slideSequences(false,
-                         alignPanel.seqPanel.getKeyboardNo1());
-        else
-          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 (evt.isAltDown() || !viewport.cursorMode)
-          slideSequences(true,
-                         alignPanel.seqPanel.getKeyboardNo1());
-        else
-          alignPanel.seqPanel.moveCursor( 1, 0);
-            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_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)
+      {
+        alignPanel.seqPanel.deleteGapAtCursor(evt.isControlDown()
+                || evt.isShiftDown() || evt.isAltDown());
+      }
+      else
+      {
+        cut_actionPerformed();
+        alignPanel.seqPanel.seqCanvas.repaint();
+      }
+      break;
 
-      case KeyEvent.VK_S:
-        if (viewport.cursorMode)
-        {
-          alignPanel.seqPanel.setCursorRow();
-        }
-        break;
-      case KeyEvent.VK_P:
-        if (viewport.cursorMode)
-        {
-          alignPanel.seqPanel.setCursorPosition();
-        }
-        break;
+    case KeyEvent.VK_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_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_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_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_F:
+      if (evt.isControlDown())
+      {
+        findMenuItem_actionPerformed();
+      }
+      break;
 
-      case KeyEvent.VK_H:
+    case KeyEvent.VK_H:
+    {
+      boolean toggleSeqs = !evt.isControlDown();
+      boolean toggleCols = !evt.isShiftDown();
+      toggleHiddenRegions(toggleSeqs, toggleCols);
+      break;
+    }
+
+    case KeyEvent.VK_PAGE_UP:
+      if (viewport.wrapAlignment)
+      {
+        alignPanel.scrollUp(true);
+      }
+      else
       {
-        boolean toggleSeqs = !evt.isControlDown();
-        boolean toggleCols = !evt.isShiftDown();
-        boolean hide = false;
-        SequenceGroup sg = viewport.getSelectionGroup();
+        alignPanel.setScrollValues(viewport.startRes, viewport.startSeq
+                - viewport.endSeq + viewport.startSeq);
+      }
+      break;
 
-        if (toggleSeqs)
-        {
-          if (sg != null && sg.getSize() != viewport.alignment.getHeight())
-          {
-            hide = true;
-            viewport.hideAllSelectedSeqs();
-          }
-          else if (! (toggleCols && viewport.colSel.getSelected().size() > 0))
-          {
-            viewport.showAllHiddenSeqs();
-          }
-        }
+    case KeyEvent.VK_PAGE_DOWN:
+      if (viewport.wrapAlignment)
+      {
+        alignPanel.scrollUp(false);
+      }
+      else
+      {
+        alignPanel.setScrollValues(viewport.startRes, viewport.startSeq
+                + viewport.endSeq - viewport.startSeq);
+      }
+      break;
 
-        if (toggleCols)
-        {
-          if (viewport.colSel.getSelected().size() > 0)
-          {
-            viewport.hideSelectedColumns();
-            if (!toggleSeqs)
-            {
-              viewport.selectionGroup = sg;
-            }
-          }
-          else if (!hide)
-          {
-            viewport.showAllHiddenColumns();
-          }
-        }
-        break;
+    case KeyEvent.VK_Z:
+      if (evt.isControlDown())
+      {
+        undoMenuItem_actionPerformed();
       }
+      break;
 
-      case KeyEvent.VK_PAGE_UP:
-        if (viewport.wrapAlignment)
+    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.scrollUp(true);
+          this.removeAllGapsMenuItem_actionPerformed();
         }
         else
         {
-          alignPanel.setScrollValues(viewport.startRes,
-                                     viewport.startSeq
-                                     - viewport.endSeq + viewport.startSeq);
+          removeGappedColumnMenuItem_actionPerformed();
         }
-        break;
-
-      case KeyEvent.VK_PAGE_DOWN:
-        if (viewport.wrapAlignment)
+      }
+      break;
+    case KeyEvent.VK_I:
+      if (evt.isControlDown())
+      {
+        if (evt.isAltDown())
         {
-          alignPanel.scrollUp(false);
+          invertColSel_actionPerformed();
         }
         else
         {
-          alignPanel.setScrollValues(viewport.startRes,
-                                     viewport.startSeq
-                                     + viewport.endSeq - viewport.startSeq);
+          invertSequenceMenuItem_actionPerformed();
         }
-        break;
+      }
+      break;
 
-      case KeyEvent.VK_Z:
-        if (evt.isControlDown())
-        {
-          undoMenuItem_actionPerformed();
-        }
-        break;
+    case KeyEvent.VK_U:
+      if (evt.isControlDown())
+      {
+        this.deleteGroups_actionPerformed();
+      }
+      break;
 
-      case KeyEvent.VK_Y:
-        if (evt.isControlDown())
-        {
-          redoMenuItem_actionPerformed();
-        }
-        break;
+    case KeyEvent.VK_T:
+      if (evt.isControlDown())
+      {
+        newView(null);
+      }
+      break;
 
-      case KeyEvent.VK_L:
-        if (evt.isControlDown())
-        {
-          trimAlignment(true);
-        }
-        break;
+    }
+    alignPanel.paintAlignment(true);
+  }
 
-      case KeyEvent.VK_R:
-        if (evt.isControlDown())
+  /**
+   * called by key handler and the hide all/show all menu items
+   * 
+   * @param toggleSeqs
+   * @param toggleCols
+   */
+  private void toggleHiddenRegions(boolean toggleSeqs, boolean toggleCols)
+  {
+    boolean hide = false;
+    SequenceGroup sg = viewport.getSelectionGroup();
+    if (!toggleSeqs && !toggleCols)
+    {
+      // Hide everything by the current selection - this is a hack - we do the
+      // invert and then hide
+      // first check that there will be visible columns after the invert.
+      if ((viewport.colSel != null && viewport.colSel.getSelected() != null && viewport.colSel
+              .getSelected().size() > 0)
+              || (sg != null && sg.getSize() > 0 && sg.getStartRes() <= sg
+                      .getEndRes()))
+      {
+        // now invert the sequence set, if required - empty selection implies
+        // that no hiding is required.
+        if (sg != null)
         {
-          trimAlignment(false);
-        }
-        break;
+          invertSequenceMenuItem_actionPerformed();
+          sg = viewport.getSelectionGroup();
+          toggleSeqs = true;
 
-      case KeyEvent.VK_E:
-        if (evt.isControlDown())
-        {
-          if (evt.isShiftDown())
-          {
-            this.removeAllGapsMenuItem_actionPerformed();
-          }
-          else
-          {
-            removeGappedColumnMenuItem_actionPerformed();
-          }
-        }
-        break;
-      case KeyEvent.VK_I:
-        if (evt.isControlDown())
-        {
-          if (evt.isAltDown())
-          {
-            viewport.invertColumnSelection();
-          }
-          else
-          {
-            this.invertSequenceMenuItem_actionPerformed();
-          }
         }
-        break;
+        viewport.expandColSelection(sg, true);
+        // finally invert the column selection and get the new sequence
+        // selection and indicate it should be hidden.
+        invertColSel_actionPerformed();
+        toggleCols = true;
+      }
+    }
 
-      case KeyEvent.VK_U:
-        if (evt.isControlDown())
-        {
-          this.deleteGroups_actionPerformed();
-        }
-        break;
+    if (toggleSeqs)
+    {
+      if (sg != null && sg.getSize() != viewport.alignment.getHeight())
+      {
+        hide = true;
+        viewport.hideAllSelectedSeqs();
+      }
+      else if (!(toggleCols && viewport.colSel.getSelected().size() > 0))
+      {
+        viewport.showAllHiddenSeqs();
+      }
+    }
 
-      case KeyEvent.VK_T:
-        if (evt.isControlDown())
+    if (toggleCols)
+    {
+      if (viewport.colSel.getSelected().size() > 0)
+      {
+        viewport.hideSelectedColumns();
+        if (!toggleSeqs)
         {
-          newView();
+          viewport.selectionGroup = sg;
         }
-        break;
-
+      }
+      else if (!hide)
+      {
+        viewport.showAllHiddenColumns();
+      }
     }
-    alignPanel.paintAlignment(true);
   }
 
   public void keyReleased(KeyEvent evt)
-  {}
+  {
+  }
 
   public void keyTyped(KeyEvent evt)
-  {}
+  {
+  }
 
   public void itemStateChanged(ItemEvent evt)
   {
-    if (evt.getSource() == colourTextMenuItem)
+    if (evt.getSource() == displayNonconservedMenuItem)
+    {
+      displayNonconservedMenuItem_actionPerformed();
+    }
+    else if (evt.getSource() == colourTextMenuItem)
     {
       colourTextMenuItem_actionPerformed();
     }
@@ -556,10 +601,54 @@ public class AlignFrame
     {
       viewport.autocalculateConsensus = autoCalculate.getState();
     }
-
+    else if (evt.getSource() == sortByTree)
+    {
+      viewport.sortByTree = sortByTree.getState();
+    }
+    else if (evt.getSource() == this.centreColumnLabelFlag)
+    {
+      centreColumnLabelFlag_stateChanged();
+    }
+    else if (evt.getSource() == this.followMouseOverFlag)
+    {
+      mouseOverFlag_stateChanged();
+    }
+    else if (evt.getSource() == showGroupConsensus)
+    {
+      showGroupConsensus_actionPerformed();
+    }
+    else if (evt.getSource() == showGroupConservation)
+    {
+      showGroupConservation_actionPerformed();
+    }
+    else if (evt.getSource() == showSequenceLogo)
+    {
+      showSequenceLogo_actionPerformed();
+    }
+    else if (evt.getSource() == showConsensusHistogram)
+    {
+      showConsensusHistogram_actionPerformed();
+    }
+    else if (evt.getSource() == applyAutoAnnotationSettings)
+    {
+      applyAutoAnnotationSettings_actionPerformed();
+    }
     alignPanel.paintAlignment(true);
   }
 
+  private void mouseOverFlag_stateChanged()
+  {
+    viewport.followHighlight = followMouseOverFlag.getState();
+    // TODO: could kick the scrollTo mechanism to reset view for current
+    // searchresults.
+  }
+
+  private void centreColumnLabelFlag_stateChanged()
+  {
+    viewport.centreColumnLabels = centreColumnLabelFlag.getState();
+    this.alignPanel.annotationPanel.repaint();
+  }
+
   public void actionPerformed(ActionEvent evt)
   {
     Object source = evt.getSource();
@@ -640,6 +729,10 @@ public class AlignFrame
     {
       delete_actionPerformed();
     }
+    else if (source == grpsFromSelection)
+    {
+      makeGrpsFromSelection_actionPerformed();
+    }
     else if (source == deleteGroups)
     {
       deleteGroups_actionPerformed();
@@ -687,7 +780,7 @@ public class AlignFrame
     }
     else if (source == newView)
     {
-      newView();
+      newView(null);
     }
     else if (source == showColumns)
     {
@@ -697,61 +790,72 @@ public class AlignFrame
     else if (source == showSeqs)
     {
       viewport.showAllHiddenSeqs();
+      alignPanel.paintAlignment(true);
     }
     else if (source == hideColumns)
     {
       viewport.hideSelectedColumns();
       alignPanel.paintAlignment(true);
     }
-    else if (source == hideSequences && viewport.getSelectionGroup() != null)
+    else if (source == hideSequences
+            && viewport.getSelectionGroup() != null)
+    {
+      viewport.hideAllSelectedSeqs();
+      alignPanel.paintAlignment(true);
+    }
+    else if (source == hideAllButSelection)
+    {
+      toggleHiddenRegions(false, false);
+      alignPanel.paintAlignment(true);
+    }
+    else if (source == hideAllSelection)
     {
+      SequenceGroup sg = viewport.getSelectionGroup();
+      viewport.expandColSelection(sg, false);
       viewport.hideAllSelectedSeqs();
+      viewport.hideSelectedColumns();
+      alignPanel.paintAlignment(true);
+    }
+    else if (source == showAllHidden)
+    {
+      viewport.showAllHiddenColumns();
+      viewport.showAllHiddenSeqs();
+      alignPanel.paintAlignment(true);
+    }
+    else if (source == showGroupConsensus)
+    {
+      showGroupConsensus_actionPerformed();
+    }
+    else if (source == showGroupConservation)
+    {
+      showGroupConservation_actionPerformed();
+    }
+    else if (source == showSequenceLogo)
+    {
+      showSequenceLogo_actionPerformed();
+    }
+    else if (source == showConsensusHistogram)
+    {
+      showConsensusHistogram_actionPerformed();
+    }
+    else if (source == applyAutoAnnotationSettings)
+    {
+      applyAutoAnnotationSettings_actionPerformed();
     }
     else if (source == featureSettings)
     {
       new FeatureSettings(alignPanel);
     }
-    else if(source== alProperties)
+    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);
+      StringBuffer contents = new jalview.io.AlignmentProperties(
+              viewport.alignment).formatAsString();
+      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)
     {
@@ -764,8 +868,9 @@ public class AlignFrame
     else if (source == clustalColour)
     {
       abovePIDThreshold.setState(false);
-      changeColour(new ClustalxColourScheme(viewport.alignment.getSequences(),
-                                            viewport.alignment.getWidth()));
+      changeColour(new ClustalxColourScheme(
+              viewport.alignment.getSequences(),
+              viewport.alignment.getWidth()));
     }
     else if (source == zappoColour)
     {
@@ -831,6 +936,10 @@ public class AlignFrame
     {
       sortIDMenuItem_actionPerformed();
     }
+    else if (source == sortLengthMenuItem)
+    {
+      sortLengthMenuItem_actionPerformed();
+    }
     else if (source == sortGroupMenuItem)
     {
       sortGroupMenuItem_actionPerformed();
@@ -888,11 +997,10 @@ public class AlignFrame
     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));
+            "Alignment output - " + e.getActionCommand(), 600, 500);
+    cap.setText(new AppletFormatAdapter().formatSequences(
+            e.getActionCommand(), viewport.getAlignment(),
+            viewport.showJVSuffix));
   }
 
   public void loadAnnotations()
@@ -909,50 +1017,77 @@ public class AlignFrame
   public String outputAnnotations(boolean displayTextbox)
   {
     String annotation = new AnnotationFile().printAnnotations(
-        viewport.showAnnotation ? viewport.alignment.getAlignmentAnnotation() : null,
-        viewport.alignment.getGroups(),
-         ((Alignment) viewport.alignment).alignmentProperties);
+            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);
+      jalview.bin.JalviewLite.addFrame(frame, "Annotations", 600, 500);
       cap.setText(annotation);
     }
 
     return annotation;
   }
 
+  private Hashtable getDisplayedFeatureCols()
+  {
+    if (alignPanel.getFeatureRenderer() != null && viewport.featuresDisplayed!=null)
+    {
+      FeatureRenderer fr = alignPanel.getFeatureRenderer();
+      Hashtable fcols = new Hashtable();
+      Enumeration en = viewport.featuresDisplayed.keys();
+      while (en.hasMoreElements())
+      {
+        Object col = en.nextElement();
+        fcols.put(col, fr.featureColours.get(col));
+      }
+      return fcols;
+    }
+    return null;
+  }
+
   public String outputFeatures(boolean displayTextbox, String format)
   {
     String features;
     if (format.equalsIgnoreCase("Jalview"))
     {
       features = new FeaturesFile().printJalviewFormat(
-          viewport.alignment.getSequencesArray(),
-          viewport.featuresDisplayed);
+              viewport.alignment.getSequencesArray(),
+              getDisplayedFeatureCols());
     }
     else
     {
       features = new FeaturesFile().printGFFFormat(
-          viewport.alignment.getSequencesArray(),
-          viewport.featuresDisplayed);
+              viewport.alignment.getSequencesArray(),
+              getDisplayedFeatureCols());
     }
 
     if (displayTextbox)
     {
-      CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
+      boolean frimport=false;
+      if (features==null || features.equals("No Features Visible"))
+      {
+        features = "# No features visible - paste some and import them here.";
+        frimport=true;
+      }
+      
+      CutAndPasteTransfer cap = new CutAndPasteTransfer(frimport, this);
+      if (frimport)
+      {
+        cap.setAnnotationImport();
+      }
       Frame frame = new Frame();
       frame.add(cap);
-      jalview.bin.JalviewLite.addFrame(frame,
-                                       "Features",
-                                       600, 500);
-
+      jalview.bin.JalviewLite.addFrame(frame, "Features", 600, 500);
       cap.setText(features);
+    } else {
+      if (features==null)
+        features = "";
     }
 
     return features;
@@ -962,8 +1097,8 @@ public class AlignFrame
   {
     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)
     {
@@ -985,17 +1120,26 @@ public class AlignFrame
 
     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)
     {
-      url.append("&colour=" +
-                 removeWhiteSpace(viewport.applet.getParameter(
-          "userDefinedColour"))
-          );
+      url.append("&colour="
+              + removeWhiteSpace(viewport.applet
+                      .getParameter("userDefinedColour")));
+    }
+    if (viewport.applet.getParameter("tree") != null)
+    {
+      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");
@@ -1024,7 +1168,15 @@ public class AlignFrame
     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;
@@ -1041,8 +1193,10 @@ public class AlignFrame
     if (PaintRefresher.components.size() == 0 && viewport.applet == null)
     {
       System.exit(0);
+    } else {
     }
-
+    viewport = null;
+    alignPanel = null;
     this.dispose();
   }
 
@@ -1091,8 +1245,9 @@ public class AlignFrame
 
   /**
    * DOCUMENT ME!
-   *
-   * @param e DOCUMENT ME!
+   * 
+   * @param e
+   *          DOCUMENT ME!
    */
   protected void undoMenuItem_actionPerformed()
   {
@@ -1103,20 +1258,21 @@ public class AlignFrame
 
     CommandI command = (CommandI) viewport.historyList.pop();
     viewport.redoList.push(command);
-    command.undoCommand();
+    command.undoCommand(null);
 
     AlignViewport originalSource = getOriginatingSource(command);
 
     originalSource.hasHiddenColumns = viewport.colSel.getHiddenColumns() != null;
     updateEditMenuBar();
     originalSource.firePropertyChange("alignment", null,
-                                      originalSource.alignment.getSequences());
+            originalSource.alignment.getSequences());
   }
 
   /**
    * DOCUMENT ME!
-   *
-   * @param e DOCUMENT ME!
+   * 
+   * @param e
+   *          DOCUMENT ME!
    */
   protected void redoMenuItem_actionPerformed()
   {
@@ -1127,36 +1283,36 @@ public class AlignFrame
 
     CommandI command = (CommandI) viewport.redoList.pop();
     viewport.historyList.push(command);
-    command.doCommand();
+    command.doCommand(null);
 
     AlignViewport originalSource = getOriginatingSource(command);
     originalSource.hasHiddenColumns = viewport.colSel.getHiddenColumns() != null;
 
     updateEditMenuBar();
     originalSource.firePropertyChange("alignment", null,
-                                      originalSource.alignment.getSequences());
+            originalSource.alignment.getSequences());
   }
 
   AlignViewport getOriginatingSource(CommandI command)
   {
     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
+    // 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());
+      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)
+          if (al == ((AlignmentPanel) comps.elementAt(i)).av.alignment)
           {
-            originalSource = ( (AlignmentPanel) comps.elementAt(i)).av;
+            originalSource = ((AlignmentPanel) comps.elementAt(i)).av;
             break;
           }
         }
@@ -1165,8 +1321,8 @@ public class AlignFrame
 
     if (originalSource == null)
     {
-      //The original view is closed, we must validate
-      //the current view against the closed view first
+      // The original view is closed, we must validate
+      // the current view against the closed view first
       if (al != null)
       {
         PaintRefresher.validateSequences(al, viewport.alignment);
@@ -1233,19 +1389,20 @@ public class AlignFrame
   synchronized void slideSequences(boolean right, int size)
   {
     Vector sg = new Vector();
-    if(viewport.cursorMode)
+    if (viewport.cursorMode)
+    {
+      sg.addElement(viewport.alignment
+              .getSequenceAt(alignPanel.seqPanel.seqCanvas.cursorY));
+    }
+    else if (viewport.getSelectionGroup() != null
+            && viewport.getSelectionGroup().getSize() != viewport.alignment
+                    .getHeight())
     {
-      sg.addElement(viewport.alignment.getSequenceAt(
-          alignPanel.seqPanel.seqCanvas.cursorY));
+      sg = viewport.getSelectionGroup().getSequences(
+              viewport.hiddenRepSequences);
     }
-    else if(viewport.getSelectionGroup()!=null
-        && viewport.getSelectionGroup().getSize()!=viewport.alignment.getHeight())
-   {
-     sg = viewport.getSelectionGroup().getSequences(
-         viewport.hiddenRepSequences);
-   }
 
-    if(sg.size()<1)
+    if (sg.size() < 1)
     {
       return;
     }
@@ -1254,8 +1411,8 @@ public class AlignFrame
 
     for (int i = 0; i < viewport.alignment.getHeight(); i++)
     {
-      if(!sg.contains(viewport.alignment.getSequenceAt(i)))
-         invertGroup.addElement(viewport.alignment.getSequenceAt(i));
+      if (!sg.contains(viewport.alignment.getSequenceAt(i)))
+        invertGroup.addElement(viewport.alignment.getSequenceAt(i));
     }
 
     SequenceI[] seqs1 = new SequenceI[sg.size()];
@@ -1268,15 +1425,11 @@ public class AlignFrame
 
     SlideSequencesCommand ssc;
     if (right)
-      ssc = new SlideSequencesCommand("Slide Sequences",
-                                      seqs2, seqs1, size,
-                                      viewport.getGapCharacter()
-          );
+      ssc = new SlideSequencesCommand("Slide Sequences", seqs2, seqs1,
+              size, viewport.getGapCharacter());
     else
-      ssc = new SlideSequencesCommand("Slide Sequences",
-                                      seqs1, seqs2, size,
-                                      viewport.getGapCharacter()
-          );
+      ssc = new SlideSequencesCommand("Slide Sequences", seqs1, seqs2,
+              size, viewport.getGapCharacter());
 
     int groupAdjustment = 0;
     if (ssc.getGapsInsertedBegin() && right)
@@ -1289,7 +1442,7 @@ public class AlignFrame
     else if (!ssc.getGapsInsertedBegin() && !right)
     {
       if (viewport.cursorMode)
-        alignPanel.seqPanel.moveCursor( -size, 0);
+        alignPanel.seqPanel.moveCursor(-size, 0);
       else
         groupAdjustment = -size;
     }
@@ -1297,30 +1450,30 @@ public class AlignFrame
     if (groupAdjustment != 0)
     {
       viewport.getSelectionGroup().setStartRes(
-          viewport.getSelectionGroup().getStartRes() + groupAdjustment);
+              viewport.getSelectionGroup().getStartRes() + groupAdjustment);
       viewport.getSelectionGroup().setEndRes(
-          viewport.getSelectionGroup().getEndRes() + groupAdjustment);
+              viewport.getSelectionGroup().getEndRes() + groupAdjustment);
     }
 
-
     boolean appendHistoryItem = false;
-    if(viewport.historyList!=null
-       && viewport.historyList.size()>0
-      && viewport.historyList.peek() instanceof SlideSequencesCommand)
+    if (viewport.historyList != null && viewport.historyList.size() > 0
+            && viewport.historyList.peek() instanceof SlideSequencesCommand)
     {
-      appendHistoryItem = ssc.appendSlideCommand(
-          (SlideSequencesCommand)viewport.historyList.peek())
-          ;
+      appendHistoryItem = ssc
+              .appendSlideCommand((SlideSequencesCommand) viewport.historyList
+                      .peek());
     }
 
-    if(!appendHistoryItem)
+    if (!appendHistoryItem)
       addHistoryItem(ssc);
 
     repaint();
   }
 
   static StringBuffer copiedSequences;
+
   static Vector copiedHiddenColumns;
+
   protected void copy_actionPerformed()
   {
     if (viewport.getSelectionGroup() == null)
@@ -1345,15 +1498,14 @@ public class AlignFrame
     {
       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
@@ -1380,18 +1532,18 @@ public class AlignFrame
         }
       }
 
-      //FIND START RES
-      //Returns residue following index if gap
+      // 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
+      // FIND END RES
+      // Need to find the residue preceeding index if gap
       endRes = 0;
 
       for (int j = 0; j < sg.getEndRes() + 1 && j < seq.getLength(); j++)
       {
         ch = seq.getCharAt(j);
-        if (!jalview.util.Comparison.isGap( (ch)))
+        if (!jalview.util.Comparison.isGap((ch)))
         {
           endRes++;
         }
@@ -1402,11 +1554,14 @@ public class AlignFrame
         endRes += seq.getStart() - 1;
       }
 
-      copiedSequences.append(seq.getName() + "\t" +
-                             startRes + "\t" +
-                             endRes + "\t" +
-                             seq.getSequenceAsString(sg.getStartRes(),
-          sg.getEndRes() + 1) + "\n");
+      copiedSequences.append(seq.getName()
+              + "\t"
+              + startRes
+              + "\t"
+              + endRes
+              + "\t"
+              + seq.getSequenceAsString(sg.getStartRes(),
+                      sg.getEndRes() + 1) + "\n");
     }
 
   }
@@ -1458,9 +1613,7 @@ public class AlignFrame
           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++)
@@ -1471,16 +1624,16 @@ public class AlignFrame
         }
 
         jalview.bin.JalviewLite.addFrame(af, newtitle, DEFAULT_WIDTH,
-                                         DEFAULT_HEIGHT);
+                DEFAULT_HEIGHT);
       }
       else
       {
         addSequences(newSeqs);
       }
 
-    }
-    catch (Exception ex)
-    {} // could be anything being pasted in here
+    } catch (Exception ex)
+    {
+    } // could be anything being pasted in here
 
   }
 
@@ -1491,20 +1644,14 @@ public class AlignFrame
       viewport.alignment.addSequence(seqs[i]);
     }
 
-    //!newAlignment
-    addHistoryItem(new EditCommand(
-        "Add sequences",
-        EditCommand.PASTE,
-        seqs,
-        0,
-        viewport.alignment.getWidth(),
-        viewport.alignment)
-        );
+    // !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());
+            viewport.alignment.getSequences());
 
   }
 
@@ -1535,7 +1682,7 @@ public class AlignFrame
     if (sg.getSize() == viewport.alignment.getHeight())
     {
       viewport.getColumnSelection().removeElements(sg.getStartRes(),
-          sg.getEndRes() + 1);
+              sg.getEndRes() + 1);
     }
 
     SequenceI[] cut = new SequenceI[seqs.size()];
@@ -1545,25 +1692,105 @@ public class AlignFrame
     }
 
     /*
-         //ADD HISTORY ITEM
+     * //ADD HISTORY ITEM
      */
-    addHistoryItem(new EditCommand("Cut Sequences",
-                                   EditCommand.CUT,
-                                   cut,
-                                   sg.getStartRes(),
-                                   sg.getEndRes() - sg.getStartRes() + 1,
-                                   viewport.alignment));
+    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.firePropertyChange("alignment", null,
-                                viewport.getAlignment().getSequences());
+    viewport.firePropertyChange("alignment", null, viewport.getAlignment()
+            .getSequences());
 
     if (viewport.getAlignment().getHeight() < 1)
     {
       this.setVisible(false);
     }
+    viewport.sendSelection();
+  }
+
+  /**
+   * group consensus toggled
+   * 
+   */
+  protected void showGroupConsensus_actionPerformed()
+  {
+    viewport.setShowGroupConsensus(showGroupConsensus.getState());
+    alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
+
+  }
+
+  /**
+   * group conservation toggled.
+   */
+  protected void showGroupConservation_actionPerformed()
+  {
+    viewport.setShowGroupConservation(showGroupConservation.getState());
+    alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see
+   * jalview.jbgui.GAlignFrame#showConsensusHistogram_actionPerformed(java.awt
+   * .event.ActionEvent)
+   */
+  protected void showConsensusHistogram_actionPerformed()
+  {
+    viewport.setShowConsensusHistogram(showConsensusHistogram.getState());
+    alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
+  }
+  /*
+   * (non-Javadoc)
+   * 
+   * @see
+   * jalview.jbgui.GAlignFrame#showConsensusProfile_actionPerformed(java.awt
+   * .event.ActionEvent)
+   */
+  protected void showSequenceLogo_actionPerformed()
+  {
+    viewport.setShowSequenceLogo(showSequenceLogo.getState());
+    alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
+  }
+
+  protected void applyAutoAnnotationSettings_actionPerformed()
+  {
+    alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
+  }
+
+  protected void makeGrpsFromSelection_actionPerformed()
+  {
+    if (viewport.getSelectionGroup() != null)
+    {
+      SequenceGroup[] gps = jalview.analysis.Grouping.makeGroupsFrom(
+              viewport.getSequenceSelection(),
+              viewport.getAlignmentView(true).getSequenceStrings(
+                      viewport.getGapCharacter()),
+              viewport.alignment.getGroups());
+      viewport.alignment.deleteAllGroups();
+      viewport.sequenceColours = null;
+      viewport.setSelectionGroup(null);
+      // set view properties for each group
+      for (int g = 0; g < gps.length; g++)
+      {
+        // gps[g].setShowunconserved(viewport.getShowUnconserved());
+        gps[g].setshowSequenceLogo(viewport.isShowSequenceLogo());
+        viewport.alignment.addGroup(gps[g]);
+        Color col = new Color((int) (Math.random() * 255),
+                (int) (Math.random() * 255), (int) (Math.random() * 255));
+        col = col.brighter();
+        for (Enumeration sq = gps[g].getSequences(null).elements(); sq
+                .hasMoreElements(); viewport.setSequenceColour(
+                (SequenceI) sq.nextElement(), col))
+          ;
+      }
+      PaintRefresher.Refresh(this, viewport.getSequenceSetId());
+      alignPanel.updateAnnotation();
+      alignPanel.paintAlignment(true);
+    }
   }
 
   protected void deleteGroups_actionPerformed()
@@ -1586,6 +1813,7 @@ public class AlignFrame
     viewport.setSelectionGroup(sg);
     alignPanel.paintAlignment(true);
     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
+    viewport.sendSelection();
   }
 
   public void deselectAllSequenceMenuItem_actionPerformed()
@@ -1602,6 +1830,7 @@ public class AlignFrame
     alignPanel.seqPanel.seqCanvas.highlightSearchResults(null);
     alignPanel.paintAlignment(true);
     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
+    viewport.sendSelection();
   }
 
   public void invertSequenceMenuItem_actionPerformed()
@@ -1613,6 +1842,15 @@ public class AlignFrame
     }
 
     PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
+    viewport.sendSelection();
+  }
+
+  public void invertColSel_actionPerformed()
+  {
+    viewport.invertColumnSelection();
+    alignPanel.paintAlignment(true);
+    PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
+    viewport.sendSelection();
   }
 
   void trimAlignment(boolean trimLeft)
@@ -1634,8 +1872,8 @@ public class AlignFrame
       SequenceI[] seqs;
       if (viewport.getSelectionGroup() != null)
       {
-        seqs = viewport.getSelectionGroup().getSequencesAsArray(viewport.
-            hiddenRepSequences);
+        seqs = viewport.getSelectionGroup().getSequencesAsArray(
+                viewport.hiddenRepSequences);
       }
       else
       {
@@ -1646,23 +1884,17 @@ public class AlignFrame
       if (trimLeft)
       {
         trimRegion = new TrimRegionCommand("Remove Left",
-                                           TrimRegionCommand.TRIM_LEFT,
-                                           seqs,
-                                           column,
-                                           viewport.alignment,
-                                           viewport.colSel,
-                                           viewport.selectionGroup);
+                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);
+                TrimRegionCommand.TRIM_RIGHT, seqs, column,
+                viewport.alignment, viewport.colSel,
+                viewport.selectionGroup);
       }
 
       statusBar.setText("Removed " + trimRegion.getSize() + " columns.");
@@ -1675,15 +1907,15 @@ public class AlignFrame
       {
         SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
 
-        if ( (trimLeft && !sg.adjustForRemoveLeft(column))
-            || (!trimLeft && !sg.adjustForRemoveRight(column)))
+        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());
     }
   }
 
@@ -1694,8 +1926,8 @@ public class AlignFrame
     SequenceI[] seqs;
     if (viewport.getSelectionGroup() != null)
     {
-      seqs = viewport.getSelectionGroup().getSequencesAsArray(viewport.
-          hiddenRepSequences);
+      seqs = viewport.getSelectionGroup().getSequencesAsArray(
+              viewport.hiddenRepSequences);
       start = viewport.getSelectionGroup().getStartRes();
       end = viewport.getSelectionGroup().getEndRes();
     }
@@ -1704,28 +1936,26 @@ public class AlignFrame
       seqs = viewport.alignment.getSequencesArray();
     }
 
-    RemoveGapColCommand removeGapCols =
-        new RemoveGapColCommand("Remove Gapped Columns",
-                                seqs,
-                                start, end,
-                                viewport.alignment);
+    RemoveGapColCommand removeGapCols = new RemoveGapColCommand(
+            "Remove Gapped Columns", seqs, start, end, viewport.alignment);
 
     addHistoryItem(removeGapCols);
 
-    statusBar.setText("Removed " + removeGapCols.getSize() + " empty columns.");
+    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.getColumnSelection().compensateForEdits(shifts);
     viewport.setStartRes(seq.findIndex(startRes) - 1);
-    viewport.firePropertyChange("alignment", null,
-                                viewport.getAlignment().getSequences());
+    viewport.firePropertyChange("alignment", null, viewport.getAlignment()
+            .getSequences());
 
   }
 
@@ -1736,8 +1966,8 @@ public class AlignFrame
     SequenceI[] seqs;
     if (viewport.getSelectionGroup() != null)
     {
-      seqs = viewport.getSelectionGroup().getSequencesAsArray(viewport.
-          hiddenRepSequences);
+      seqs = viewport.getSelectionGroup().getSequencesAsArray(
+              viewport.hiddenRepSequences);
       start = viewport.getSelectionGroup().getStartRes();
       end = viewport.getSelectionGroup().getEndRes();
     }
@@ -1746,20 +1976,18 @@ public class AlignFrame
       seqs = viewport.alignment.getSequencesArray();
     }
 
-    //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);
 
-    addHistoryItem(new RemoveGapsCommand("Remove Gaps",
-                                         seqs,
-                                         start, end,
-                                         viewport.alignment));
+    addHistoryItem(new RemoveGapsCommand("Remove Gaps", seqs, start, end,
+            viewport.alignment));
 
     viewport.setStartRes(seq.findIndex(startRes) - 1);
 
-    viewport.firePropertyChange("alignment", null,
-                                viewport.getAlignment().getSequences());
+    viewport.firePropertyChange("alignment", null, viewport.getAlignment()
+            .getSequences());
 
   }
 
@@ -1768,15 +1996,19 @@ public class AlignFrame
     new Finder(alignPanel);
   }
 
-  public void newView()
+  /**
+   * create a new view derived from the current view
+   * 
+   * @param viewtitle
+   * @return frame for the new view
+   */
+  public AlignFrame newView(String viewtitle)
   {
     AlignmentI newal;
     if (viewport.hasHiddenRows)
     {
-      newal = new Alignment(viewport.getAlignment().
-                            getHiddenSequences()
-                            .getFullAlignment().
-                            getSequencesArray());
+      newal = new Alignment(viewport.getAlignment().getHiddenSequences()
+              .getFullAlignment().getSequencesArray());
     }
     else
     {
@@ -1794,23 +2026,20 @@ public class AlignFrame
       }
     }
 
-    AlignFrame newaf = new AlignFrame(newal,
-                                      viewport.applet,
-                                      "",
-                                      false);
+    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());
+            newaf.alignPanel.av.getSequenceSetId());
 
     PaintRefresher.Register(newaf.alignPanel.idPanel.idCanvas,
-                            newaf.alignPanel.av.getSequenceSetId());
+            newaf.alignPanel.av.getSequenceSetId());
     PaintRefresher.Register(newaf.alignPanel.seqPanel.seqCanvas,
-                            newaf.alignPanel.av.getSequenceSetId());
+            newaf.alignPanel.av.getSequenceSetId());
 
-    Vector comps = (Vector) PaintRefresher.components.get(viewport.
-        getSequenceSetId());
+    Vector comps = (Vector) PaintRefresher.components.get(viewport
+            .getSequenceSetId());
     int viewSize = -1;
     for (int i = 0; i < comps.size(); i++)
     {
@@ -1821,18 +2050,82 @@ public class AlignFrame
     }
 
     String title = new String(this.getTitle());
-    if (title.indexOf("(View") > -1)
+    if (viewtitle != null)
     {
-      title = title.substring(0, title.indexOf("(View"));
+      title = viewtitle + " ( " + title + ")";
+    }
+    else
+    {
+      if (title.indexOf("(View") > -1)
+      {
+        title = title.substring(0, title.indexOf("(View"));
+      }
+      title += "(View " + viewSize + ")";
     }
-
-    title += "(View " + viewSize + ")";
 
     newaf.setTitle(title.toString());
 
     newaf.viewport.historyList = viewport.historyList;
     newaf.viewport.redoList = viewport.redoList;
+    return newaf;
+  }
+
+  /**
+   * 
+   * @return list of feature groups on the view
+   */
+  public String[] getFeatureGroups()
+  {
+    FeatureRenderer fr = null;
+    if (alignPanel != null
+            && (fr = alignPanel.getFeatureRenderer()) != null)
+    {
+      return fr.getGroups();
+    }
+    return null;
+  }
+
+  /**
+   * get sequence feature groups that are hidden or shown
+   * 
+   * @param visible
+   *          true is visible
+   * @return list
+   */
+  public String[] getFeatureGroupsOfState(boolean visible)
+  {
+    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()
@@ -1848,6 +2141,12 @@ public class AlignFrame
     alignPanel.paintAlignment(true);
   }
 
+  protected void displayNonconservedMenuItem_actionPerformed()
+  {
+    viewport.setShowunconserved(displayNonconservedMenuItem.getState());
+    alignPanel.paintAlignment(true);
+  }
+
   protected void wrapMenuItem_actionPerformed()
   {
     viewport.setWrapAlignment(wrapMenuItem.getState());
@@ -1870,8 +2169,8 @@ public class AlignFrame
     frame.add(overview);
     // +50 must allow for applet frame window
     jalview.bin.JalviewLite.addFrame(frame, "Overview " + this.getTitle(),
-                                     overview.getPreferredSize().width,
-                                     overview.getPreferredSize().height + 50);
+            overview.getPreferredSize().width,
+            overview.getPreferredSize().height + 50);
 
     frame.pack();
     frame.addWindowListener(new WindowAdapter()
@@ -1894,7 +2193,8 @@ public class AlignFrame
     {
       if (viewport.getAbovePIDThreshold())
       {
-        threshold = SliderPanel.setPIDSliderSource(alignPanel, cs, "Background");
+        threshold = SliderPanel.setPIDSliderSource(alignPanel, cs,
+                "Background");
 
         cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
 
@@ -1910,17 +2210,16 @@ public class AlignFrame
 
         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
@@ -1948,16 +2247,15 @@ public class AlignFrame
         if (cs instanceof ClustalxColourScheme)
         {
           sg.cs = new ClustalxColourScheme(
-              sg.getSequences(viewport.hiddenRepSequences),
-              sg.getWidth());
+                  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;
@@ -1965,12 +2263,13 @@ public class AlignFrame
         }
 
         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(viewport.hiddenRepSequences), 0, sg.getWidth()));
+                  sg.getSequences(viewport.hiddenRepSequences), 0,
+                  sg.getWidth()));
         }
         else
         {
@@ -1980,10 +2279,9 @@ public class AlignFrame
         if (viewport.getConservationSelected())
         {
           Conservation c = new Conservation("Group",
-                                            ResidueProperties.propHash, 3,
-                                            sg.getSequences(viewport.
-              hiddenRepSequences), 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);
@@ -2002,28 +2300,31 @@ public class AlignFrame
       alignPanel.getOverviewPanel().updateOverviewImage();
     }
 
-    jalview.structure.StructureSelectionManager.getStructureSelectionManager()
-        .sequenceColoursChanged(alignPanel);
+    jalview.structure.StructureSelectionManager
+            .getStructureSelectionManager(viewport.applet).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();
     }
   }
@@ -2055,26 +2356,37 @@ public class AlignFrame
   public void sortPairwiseMenuItem_actionPerformed()
   {
     SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
-    AlignmentSorter.sortByPID(viewport.getAlignment(),
-                              viewport.getAlignment().getSequenceAt(0));
+    AlignmentSorter.sortByPID(viewport.getAlignment(), viewport
+            .getAlignment().getSequenceAt(0), null);
+
     addHistoryItem(new OrderCommand("Pairwise Sort", oldOrder,
-                                    viewport.alignment));
+            viewport.alignment));
     alignPanel.paintAlignment(true);
   }
 
   public void sortIDMenuItem_actionPerformed()
   {
-    //  addHistoryItem(new HistoryItem("ID Sort", viewport.alignment,
-    //                                HistoryItem.SORT));
+    SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
     AlignmentSorter.sortByID(viewport.getAlignment());
+    addHistoryItem(new OrderCommand("ID Sort", oldOrder, viewport.alignment));
+    alignPanel.paintAlignment(true);
+  }
+
+  public void sortLengthMenuItem_actionPerformed()
+  {
+    SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
+    AlignmentSorter.sortByLength(viewport.getAlignment());
+    addHistoryItem(new OrderCommand("Length Sort", oldOrder,
+            viewport.alignment));
     alignPanel.paintAlignment(true);
   }
 
   public void sortGroupMenuItem_actionPerformed()
   {
-    //  addHistoryItem(new HistoryItem("Group Sort", viewport.alignment,
-    //                                 HistoryItem.SORT));
+    SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
     AlignmentSorter.sortByGroup(viewport.getAlignment());
+    addHistoryItem(new OrderCommand("Group Sort", oldOrder,
+            viewport.alignment));
     alignPanel.paintAlignment(true);
 
   }
@@ -2087,24 +2399,24 @@ public class AlignFrame
   public void pairwiseAlignmentMenuItem_actionPerformed()
   {
     if (viewport.getSelectionGroup() != null
-        && viewport.getSelectionGroup().getSize() > 1)
+            && 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?
-    if (!viewport.alignment.isAligned())
+    // are the sequences aligned?
+    if (!viewport.alignment.isAligned(false))
     {
       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);
 
@@ -2116,10 +2428,10 @@ public class AlignFrame
       alignPanel.paintAlignment(true);
     }
 
-    if ( (viewport.getSelectionGroup() != null &&
-          viewport.getSelectionGroup().getSize() < 4 &&
-          viewport.getSelectionGroup().getSize() > 0)
-        || viewport.getAlignment().getHeight() < 4)
+    if ((viewport.getSelectionGroup() != null
+            && viewport.getSelectionGroup().getSize() < 4 && viewport
+            .getSelectionGroup().getSize() > 0)
+            || viewport.getAlignment().getHeight() < 4)
     {
       return;
     }
@@ -2127,8 +2439,7 @@ public class AlignFrame
     try
     {
       new PCAPanel(viewport);
-    }
-    catch (java.lang.OutOfMemoryError ex)
+    } catch (java.lang.OutOfMemoryError ex)
     {
     }
 
@@ -2156,14 +2467,13 @@ public class AlignFrame
 
   void NewTreePanel(String type, String pwType, String title)
   {
-    //are the sequences aligned?
-    if (!viewport.alignment.isAligned())
+    // are the sequences aligned?
+    if (!viewport.alignment.isAligned(false))
     {
       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);
 
@@ -2176,14 +2486,12 @@ public class AlignFrame
 
     }
 
-    if ( (viewport.getSelectionGroup() != null &&
-          viewport.getSelectionGroup().getSize() > 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(alignPanel, type, pwType);
 
       addTreeMenuItem(tp, title);
 
@@ -2203,15 +2511,40 @@ public class AlignFrame
 
   public void loadTree(jalview.io.NewickFile tree, String treeFile)
   {
-    TreePanel tp = new TreePanel(viewport,
-                                 treeFile,
-                                 "From File - ",
-                                 tree);
+    TreePanel tp = new TreePanel(alignPanel, treeFile, "From File - ", tree);
     jalview.bin.JalviewLite.addFrame(tp, treeFile, 600, 500);
     addTreeMenuItem(tp, treeFile);
   }
 
-  void addTreeMenuItem(final TreePanel treePanel, String title)
+  /**
+   * sort the alignment using the given treePanel
+   * 
+   * @param treePanel
+   *          tree used to sort view
+   * @param title
+   *          string used for undo event name
+   */
+  public void sortByTree(TreePanel treePanel, String title)
+  {
+    SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
+    AlignmentSorter
+            .sortByTree(viewport.getAlignment(), treePanel.getTree());
+    // addHistoryItem(new HistoryItem("Sort", viewport.alignment,
+    // HistoryItem.SORT));
+    addHistoryItem(new OrderCommand("Order by " + title, oldOrder,
+            viewport.alignment));
+    alignPanel.paintAlignment(true);
+  }
+
+  /**
+   * Do any automatic reordering of the alignment and add the necessary bits to
+   * the menu structure for the new tree
+   * 
+   * @param treePanel
+   * @param title
+   */
+  protected void addTreeMenuItem(final TreePanel treePanel,
+          final String title)
   {
     final MenuItem item = new MenuItem(title);
     sortByTreeMenu.add(item);
@@ -2219,37 +2552,62 @@ public class AlignFrame
     {
       public void actionPerformed(ActionEvent evt)
       {
-        //  addHistoryItem(new HistoryItem("Sort", viewport.alignment,
-        //                                 HistoryItem.SORT));
-        AlignmentSorter.sortByTree(viewport.getAlignment(), treePanel.getTree());
-        alignPanel.paintAlignment(true);
+        sortByTree(treePanel, title); // treePanel.getTitle());
       }
     });
-
+    
     treePanel.addWindowListener(new WindowAdapter()
     {
+      public void windowOpened(WindowEvent e)
+      {
+        if (viewport.sortByTree)
+        {
+          sortByTree(treePanel, title);
+        }
+        super.windowOpened(e);
+      }
+
       public void windowClosing(WindowEvent e)
       {
         sortByTreeMenu.remove(item);
       };
     });
   }
+  public boolean sortBy(AlignmentOrder alorder, String undoname)
+  {
+    SequenceI[] oldOrder = viewport.getAlignment()
+    .getSequencesArray();
+    if (viewport.applet.debug)
+    {
+      System.err.println("Sorting "+alorder.getOrder().size()+" in alignment '"+getTitle()+"'");
+    }
+    AlignmentSorter.sortBy(viewport.getAlignment(), alorder);
+    if (undoname!=null)
+    {
+      addHistoryItem(new OrderCommand(undoname, oldOrder, viewport.alignment));
+    }
+    alignPanel.paintAlignment(true);
+    return true;
+  }
 
   protected void documentation_actionPerformed()
   {
-    showURL("http://www.jalview.org/help.html", "HELP");
+    alignPanel.av.applet.openJalviewHelpUrl();
   }
 
   protected void about_actionPerformed()
   {
 
-    class AboutPanel
-        extends Canvas
+    class AboutPanel extends Canvas
     {
       String version;
-      public AboutPanel(String version)
+
+      String builddate;
+
+      public AboutPanel(String version, String builddate)
       {
         this.version = version;
+        this.builddate = builddate;
       }
 
       public void paint(Graphics g)
@@ -2261,49 +2619,39 @@ public class AlignFrame
         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.BOLD, 12));
+        g.drawString("Build date: " + builddate, 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("Bioinformatics,  2004 20;426-7.", x, y += fh);
-      }
-    }
-
-    String version = "test";
-    java.net.URL url = getClass().getResource("/.build_properties");
-    if (url != null)
-    {
-      try
-      {
-        BufferedReader reader = new BufferedReader(new InputStreamReader(
-            url.openStream()));
-        String line;
-        while ( (line = reader.readLine()) != null)
-        {
-          if (line.indexOf("VERSION") > -1)
-          {
-            version = line.substring(line.indexOf("=") + 1);
-          }
-        }
-      }
-      catch (Exception ex)
-      {
-        ex.printStackTrace();
+                "Authors:  Jim Procter, Andrew Waterhouse, 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(
+                "Waterhouse, A.M., Procter, J.B., Martin, D.M.A, Clamp, M. and Barton, G. J. (2009)",
+                x, y += fh);
+        g.drawString(
+                "Jalview Version 2 - a multiple sequence alignment editor and analysis workbench",
+                x, y += fh);
+        g.drawString("Bioinformatics doi: 10.1093/bioinformatics/btp033",
+                x, y += fh);
       }
     }
 
     Frame frame = new Frame();
-    frame.add(new AboutPanel(version));
-    jalview.bin.JalviewLite.addFrame(frame, "Jalview", 580, 200);
+    frame.add(new AboutPanel(JalviewLite.getVersion(), JalviewLite
+            .getBuildDate()));
+    jalview.bin.JalviewLite.addFrame(frame, "Jalview", 580, 220);
 
   }
 
@@ -2315,119 +2663,196 @@ public class AlignFrame
     }
     else
     {
-      try
-      {
-        System.out.println("Show url: " + url);
-        viewport.applet.getAppletContext().showDocument(new java.net.URL(url),
-            target);
-      }
-      catch (Exception ex)
-      {
-        ex.printStackTrace();
-      }
-    }
-  }
-
-  //////////////////////////////////////////////////////////////////////////////////
-  //JBuilder Graphics here
-
-   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 ...");
-   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();
+      viewport.applet.showURL(url, target);
+    }
+  }
+
+  // ////////////////////////////////////////////////////////////////////////////////
+  // 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 ...");
+
+  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 sortLengthMenuItem = 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();
+
+  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...");
+
+  CheckboxMenuItem annotationPanelMenuItem = new CheckboxMenuItem();
+
+  CheckboxMenuItem colourTextMenuItem = new CheckboxMenuItem();
+
+  CheckboxMenuItem displayNonconservedMenuItem = 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 undoMenuItem = new MenuItem();
+
+  MenuItem redoMenuItem = new MenuItem();
+
+  CheckboxMenuItem conservationMenuItem = new CheckboxMenuItem();
+
   MenuItem noColourmenuItem = new MenuItem();
-   CheckboxMenuItem wrapMenuItem = new CheckboxMenuItem();
-   CheckboxMenuItem renderGapsMenuItem = new CheckboxMenuItem();
+
+  CheckboxMenuItem wrapMenuItem = new CheckboxMenuItem();
+
+  CheckboxMenuItem renderGapsMenuItem = new CheckboxMenuItem();
+
   MenuItem findMenuItem = new MenuItem();
-   CheckboxMenuItem abovePIDThreshold = new CheckboxMenuItem();
-   MenuItem nucleotideColour = new MenuItem();
+
+  CheckboxMenuItem abovePIDThreshold = new CheckboxMenuItem();
+
+  MenuItem nucleotideColour = new MenuItem();
+
   MenuItem deleteGroups = new MenuItem();
+
+  MenuItem grpsFromSelection = 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();
+
+  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();
+
+  CheckboxMenuItem autoCalculate = new CheckboxMenuItem(
+          "Autocalculate Consensus", true);
+
+  CheckboxMenuItem sortByTree = new CheckboxMenuItem(
+          "Sort Alignment With New Tree", 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();
-  Panel embeddedMenu;
-  Label embeddedEdit;
-  Label embeddedSelect;
-  Label embeddedView;
-  Label embeddedFormat;
-  Label embeddedColour;
-  Label embeddedFile;
-  Label embeddedHelp;
-  Label embeddedCalculate;
-  FlowLayout flowLayout1;
-
-  private void jbInit()
-      throws Exception
+
+  CheckboxMenuItem seqLimits = new CheckboxMenuItem();
+
+  CheckboxMenuItem centreColumnLabelFlag = new CheckboxMenuItem();
+  
+  CheckboxMenuItem followMouseOverFlag = new CheckboxMenuItem();
+  Menu autoAnnMenu=new Menu();
+  CheckboxMenuItem showSequenceLogo= new CheckboxMenuItem();
+  CheckboxMenuItem applyAutoAnnotationSettings = new CheckboxMenuItem();
+  CheckboxMenuItem showConsensusHistogram = new CheckboxMenuItem();
+  CheckboxMenuItem showGroupConsensus = new CheckboxMenuItem();
+  CheckboxMenuItem showGroupConservation = new CheckboxMenuItem();
+
+  private void jbInit() throws Exception
   {
 
     setMenuBar(alignFrameMenuBar);
@@ -2435,11 +2860,11 @@ public class AlignFrame
     MenuItem item;
 
     // dynamically fill save as menu with available formats
-    for (int i = 0; i < jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS.length;
-         i++)
+    for (int i = 0; i < jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS.length; i++)
     {
 
-      item = new MenuItem(jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS[i]);
+      item = new MenuItem(
+              jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS[i]);
 
       item.addActionListener(new java.awt.event.ActionListener()
       {
@@ -2479,6 +2904,8 @@ public class AlignFrame
     sortPairwiseMenuItem.addActionListener(this);
     sortIDMenuItem.setLabel("by ID");
     sortIDMenuItem.addActionListener(this);
+    sortLengthMenuItem.setLabel("by Length");
+    sortLengthMenuItem.addActionListener(this);
     sortGroupMenuItem.setLabel("by Group");
     sortGroupMenuItem.addActionListener(this);
     removeRedundancyMenuItem.setLabel("Remove Redundancy...");
@@ -2487,8 +2914,8 @@ public class AlignFrame
     pairwiseAlignmentMenuItem.addActionListener(this);
     PCAMenuItem.setLabel("Principal Component Analysis");
     PCAMenuItem.addActionListener(this);
-    averageDistanceTreeMenuItem.setLabel(
-        "Average Distance Using % Identity");
+    averageDistanceTreeMenuItem
+            .setLabel("Average Distance Using % Identity");
     averageDistanceTreeMenuItem.addActionListener(this);
     neighbourTreeMenuItem.setLabel("Neighbour Joining Using % Identity");
     neighbourTreeMenuItem.addActionListener(this);
@@ -2519,8 +2946,8 @@ public class AlignFrame
     PIDColour.addActionListener(this);
     BLOSUM62Colour.setLabel("BLOSUM62 Score");
     BLOSUM62Colour.addActionListener(this);
-    avDistanceTreeBlosumMenuItem.setLabel(
-        "Average Distance Using BLOSUM62");
+    avDistanceTreeBlosumMenuItem
+            .setLabel("Average Distance Using BLOSUM62");
     avDistanceTreeBlosumMenuItem.addActionListener(this);
     njTreeBlosumMenuItem.setLabel("Neighbour Joining Using BLOSUM62");
     njTreeBlosumMenuItem.addActionListener(this);
@@ -2528,6 +2955,8 @@ public class AlignFrame
     annotationPanelMenuItem.addItemListener(this);
     colourTextMenuItem.setLabel("Colour Text");
     colourTextMenuItem.addItemListener(this);
+    displayNonconservedMenuItem.setLabel("Show nonconserved");
+    displayNonconservedMenuItem.addItemListener(this);
     alProperties.addActionListener(this);
     overviewMenuItem.setLabel("Overview Window");
     overviewMenuItem.addActionListener(this);
@@ -2554,6 +2983,8 @@ public class AlignFrame
     nucleotideColour.addActionListener(this);
     deleteGroups.setLabel("Undefine Groups");
     deleteGroups.addActionListener(this);
+    grpsFromSelection.setLabel("Make Groups for selection");
+    grpsFromSelection.addActionListener(this);
     copy.setLabel("Copy");
     copy.addActionListener(this);
     cut.setLabel("Cut");
@@ -2590,9 +3021,13 @@ public class AlignFrame
     sort.setLabel("Sort");
     calculate.setLabel("Calculate Tree");
     autoCalculate.addItemListener(this);
+    sortByTree.addItemListener(this);
     inputText.setLabel("Input from textbox");
     inputText.addActionListener(this);
-
+    centreColumnLabelFlag.setLabel("Centre column labels");
+    centreColumnLabelFlag.addItemListener(this);
+    followMouseOverFlag.setLabel("Automatic Scrolling");
+    followMouseOverFlag.addItemListener(this);
     helpMenu.setLabel("Help");
     documentation.setLabel("Documentation");
     documentation.addActionListener(this);
@@ -2617,11 +3052,30 @@ public class AlignFrame
     menu2.setLabel("Hide");
     hideColumns.setLabel("Selected Columns");
     hideSequences.setLabel("Selected Sequences");
+    hideAllButSelection.setLabel("All but Selected Region (Shift+Ctrl+H)");
+    hideAllSelection.setLabel("Selected Region");
+    showAllHidden.setLabel("All Sequences and Columns");
+    showGroupConsensus.setLabel("Group Consensus");
+    showGroupConservation.setLabel("Group Conservation");
+    showConsensusHistogram.setLabel("Show Consensus Histogram");
+    showSequenceLogo.setLabel("Show Consensus Logo");
+    applyAutoAnnotationSettings.setLabel("Apply to all groups");
+    applyAutoAnnotationSettings.setState(true);
+    autoAnnMenu.setLabel("Autocalculated Annotation");
+    
     invertColSel.addActionListener(this);
     showColumns.addActionListener(this);
     showSeqs.addActionListener(this);
     hideColumns.addActionListener(this);
     hideSequences.addActionListener(this);
+    hideAllButSelection.addActionListener(this);
+    hideAllSelection.addActionListener(this);
+    showAllHidden.addActionListener(this);
+    showGroupConsensus.addItemListener(this);
+    showGroupConservation.addItemListener(this);
+    showConsensusHistogram.addItemListener(this);
+    showSequenceLogo.addItemListener(this);
+    applyAutoAnnotationSettings.addItemListener(this);
     formatMenu.setLabel("Format");
     selectMenu.setLabel("Select");
     newView.setLabel("New View");
@@ -2669,7 +3123,15 @@ public class AlignFrame
     viewMenu.add(menu1);
     viewMenu.add(menu2);
     viewMenu.addSeparator();
+    viewMenu.add(followMouseOverFlag);
     viewMenu.add(annotationPanelMenuItem);
+    autoAnnMenu.add(applyAutoAnnotationSettings);
+    autoAnnMenu.add(showConsensusHistogram);
+    autoAnnMenu.add(showSequenceLogo);
+    autoAnnMenu.addSeparator();
+    autoAnnMenu.add(showGroupConservation);
+    autoAnnMenu.add(showGroupConsensus);
+    viewMenu.add(autoAnnMenu);
     viewMenu.addSeparator();
     viewMenu.add(sequenceFeatures);
     viewMenu.add(featureSettings);
@@ -2704,10 +3166,12 @@ public class AlignFrame
     calculateMenu.add(pairwiseAlignmentMenuItem);
     calculateMenu.add(PCAMenuItem);
     calculateMenu.add(autoCalculate);
+    calculateMenu.add(sortByTree);
     this.add(statusBar, BorderLayout.SOUTH);
     pasteMenu.add(pasteNew);
     pasteMenu.add(pasteThis);
     sort.add(sortIDMenuItem);
+    sort.add(sortLengthMenuItem);
     sort.add(sortByTreeMenu);
     sort.add(sortGroupMenuItem);
     sort.add(sortPairwiseMenuItem);
@@ -2719,8 +3183,11 @@ public class AlignFrame
     helpMenu.add(about);
     menu1.add(showColumns);
     menu1.add(showSeqs);
+    menu1.add(showAllHidden);
     menu2.add(hideColumns);
     menu2.add(hideSequences);
+    menu2.add(hideAllSelection);
+    menu2.add(hideAllButSelection);
     formatMenu.add(font);
     formatMenu.add(seqLimits);
     formatMenu.add(wrapMenuItem);
@@ -2730,162 +3197,387 @@ public class AlignFrame
     formatMenu.add(viewBoxesMenuItem);
     formatMenu.add(viewTextMenuItem);
     formatMenu.add(colourTextMenuItem);
+    formatMenu.add(displayNonconservedMenuItem);
     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(grpsFromSelection);
     selectMenu.add(deleteGroups);
+
   }
 
-  public void setEmbedded()
-  {
-
-    embeddedMenu = new Panel();
-    embeddedEdit = new Label("Edit");
-    embeddedSelect = new Label("Select");
-    embeddedView = new Label("View");
-    embeddedFormat = new Label("Format");
-    embeddedColour = new Label("Colour");
-    embeddedFile = new Label("File");
-    embeddedHelp = new Label("Help");
-    embeddedCalculate = new Label("Calculate");
-    flowLayout1 = new FlowLayout();
-    embeddedMenu.setBackground(Color.lightGray);
-    embeddedMenu.setLayout(flowLayout1);
-    embeddedEdit.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
-    embeddedSelect.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
-    embeddedView.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
-    embeddedFormat.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
-    embeddedColour.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
-    embeddedFile.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
-    embeddedHelp.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
-    embeddedCalculate.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
-    embeddedMenu.add(embeddedFile);
-    embeddedMenu.add(embeddedEdit);
-    embeddedMenu.add(embeddedSelect);
-    embeddedMenu.add(embeddedView);
-    embeddedMenu.add(embeddedFormat);
-    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);
-    embeddedSelect.addMouseListener(this);
-    embeddedView.addMouseListener(this);
-    embeddedFormat.addMouseListener(this);
-    embeddedColour.addMouseListener(this);
-    embeddedCalculate.addMouseListener(this);
-    embeddedHelp.addMouseListener(this);
-
-    fileMenu.remove(closeMenuItem);
-    fileMenu.remove(3); // Seperator
-
-    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();
-
-  }
-
-  PopupMenu filePopup, editPopup, searchPopup,
-  viewPopup, formatPopup, 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();
+
+  MenuItem hideAllButSelection = new MenuItem();
+
+  MenuItem hideAllSelection = new MenuItem();
+
+  MenuItem showAllHidden = new MenuItem();
+
   Menu formatMenu = new Menu();
+
   Menu selectMenu = new Menu();
+
   MenuItem newView = new MenuItem();
 
-  public void mousePressed(MouseEvent evt)
-  {
-    PopupMenu popup = null;
-    Label source = (Label) evt.getSource();
-    if (source == embeddedFile)
-    {
-      popup = filePopup = genPopupMenu(filePopup, fileMenu);
+  /**
+   * 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);
+      final AlignFrame me = this;
+      viewport.applet.addFocusListener(new FocusListener()
+      {
+        
+        @Override
+        public void focusLost(FocusEvent e)
+        {
+          if (me.viewport.applet.currentAlignFrame==me) {
+                  me.viewport.applet.currentAlignFrame = null;
+        }}
+        
+        @Override
+        public void focusGained(FocusEvent e)
+        {
+          me.viewport.applet.currentAlignFrame = me;
+        }
+      });
+      viewport.applet.validate();
     }
-    else if (source == embeddedEdit)
+    else
     {
-      popup = editPopup = genPopupMenu(editPopup, editMenu);
+      // //////
+      // 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);
     }
-    else if (source == embeddedSelect)
+  }
+
+  /**
+   * create a new binding between structures in an existing jmol viewer instance
+   * and an alignpanel with sequences that have existing PDBFile entries. Note,
+   * this does not open a new Jmol window, or modify the display of the
+   * structures in the original jmol window. Note This method doesn't work
+   * without an additional javascript library to exchange messages between the
+   * distinct applets. See http://issues.jalview.org/browse/JAL-621
+   * 
+   * @param viewer
+   *          JmolViewer instance
+   * @param sequenceIds
+   *          - sequence Ids to search for associations
+   */
+  public SequenceStructureBinding addStructureViewInstance(
+          Object jmolviewer, String[] sequenceIds)
+  {
+    org.jmol.api.JmolViewer viewer = null;
+    try
     {
-      popup = searchPopup = genPopupMenu(searchPopup, selectMenu);
+      viewer = (org.jmol.api.JmolViewer) jmolviewer;
+    } catch (ClassCastException ex)
+    {
+      System.err.println("Unsupported viewer object :"
+              + jmolviewer.getClass());
     }
-    else if (source == embeddedView)
+    if (viewer == null)
     {
-      popup = viewPopup = genPopupMenu(viewPopup, viewMenu);
+      System.err.println("Can't use this object as a structure viewer:"
+              + jmolviewer.getClass());
+      return null;
     }
-    else if (source == embeddedFormat)
+    SequenceI[] seqs = null;
+    if (sequenceIds == null || sequenceIds.length == 0)
     {
-      popup = formatPopup = genPopupMenu(formatPopup, formatMenu);
+      seqs = viewport.getAlignment().getSequencesArray();
     }
-    else if (source == embeddedColour)
+    else
     {
-      popup = colourPopup = genPopupMenu(colourPopup, colourMenu);
+      Vector sqi = new Vector();
+      AlignmentI al = viewport.getAlignment();
+      for (int sid = 0; sid < sequenceIds.length; sid++)
+      {
+        SequenceI sq = al.findName(sequenceIds[sid]);
+        if (sq != null)
+        {
+          sqi.addElement(sq);
+        }
+      }
+      if (sqi.size() > 0)
+      {
+        seqs = new SequenceI[sqi.size()];
+        for (int sid = 0, sSize = sqi.size(); sid < sSize; sid++)
+        {
+          seqs[sid] = (SequenceI) sqi.elementAt(sid);
+        }
+      }
+      else
+      {
+        return null;
+      }
+    }
+    ExtJmol jmv = null;
+    // TODO: search for a jmv that involves viewer
+    if (jmv == null)
+    { // create a new viewer/jalview binding.
+      jmv = new ExtJmol(viewer, alignPanel, new SequenceI[][] {seqs});
     }
-    else if (source == embeddedCalculate)
+    return jmv;
+
+  }
+  /**
+   * bind a pdb file to a sequence in the current view
+   * 
+   * @param sequenceId
+   *          - sequenceId within the dataset.
+   * @param pdbEntryString
+   *          - the short name for the PDB file
+   * @param pdbFile
+   *          - pdb file - either a URL or a valid PDB file.
+   * @return true if binding was as success TODO: consider making an exception
+   *         structure for indicating when PDB parsing or sequenceId location
+   *         fails.
+   */
+  public boolean addPdbFile(String sequenceId, String pdbEntryString,
+          String pdbFile)
+  {
+    SequenceI toaddpdb = viewport.getAlignment().findName(sequenceId);
+    boolean needtoadd = false;
+    if (toaddpdb != null)
     {
-      popup = calculatePopup = genPopupMenu(calculatePopup, calculateMenu);
+      Vector pdbe = toaddpdb.getPDBId();
+      PDBEntry pdbentry = null;
+      if (pdbe != null && pdbe.size() > 0)
+      {
+        for (int pe = 0, peSize = pdbe.size(); pe < peSize; pe++)
+        {
+          pdbentry = (PDBEntry) pdbe.elementAt(pe);
+          if (!pdbentry.getId().equals(pdbEntryString)
+                  && !pdbentry.getFile().equals(pdbFile))
+          {
+            pdbentry = null;
+          }
+          else
+          {
+            continue;
+          }
+        }
+      }
+      if (pdbentry == null)
+      {
+        pdbentry = new PDBEntry();
+        pdbentry.setId(pdbEntryString);
+        pdbentry.setFile(pdbFile);
+        needtoadd = true; // add this new entry to sequence.
+      }
+      // resolve data source
+      // TODO: this code should be a refactored to an io package
+      String protocol = AppletFormatAdapter.resolveProtocol(pdbFile, "PDB");
+      if (protocol == null)
+      {
+        return false;
+      }
+      if (needtoadd)
+      {
+        // make a note of the access mode and add
+        if (pdbentry.getProperty() == null)
+        {
+          pdbentry.setProperty(new Hashtable());
+        }
+        pdbentry.getProperty().put("protocol", protocol);
+        toaddpdb.addPDBId(pdbentry);
+      }
     }
-    else if (source == embeddedHelp)
+    return true;
+  }
+
+  private Object[] cleanSeqChainArrays(SequenceI[] seqs, String[] chains)
+  {
+    if (seqs != null)
     {
-      popup = helpPopup = genPopupMenu(helpPopup, helpMenu);
+      Vector sequences = new Vector();
+      for (int i = 0; i < seqs.length; i++)
+      {
+        if (seqs[i] != null)
+        {
+          sequences.addElement(new Object[]
+          { seqs[i], (chains != null) ? chains[i] : null });
+        }
+      }
+      seqs = new SequenceI[sequences.size()];
+      chains = new String[sequences.size()];
+      for (int i = 0, isize = sequences.size(); i < isize; i++)
+      {
+        Object[] oj = (Object[]) sequences.elementAt(i);
+
+        seqs[i] = (SequenceI) oj[0];
+        chains[i] = (String) oj[1];
+      }
     }
+    return new Object[]
+    { seqs, chains };
 
-    embeddedMenu.add(popup);
-    popup.show(embeddedMenu,
-               source.getBounds().x,
-               source.getBounds().y + source.getBounds().getSize().height);
   }
 
-  PopupMenu genPopupMenu(PopupMenu popup, Menu original)
+  public void newStructureView(JalviewLite applet, PDBEntry pdb,
+          SequenceI[] seqs, String[] chains, String protocol)
   {
-    if (popup != null)
+    // Scrub any null sequences from the array
+    Object[] sqch = cleanSeqChainArrays(seqs, chains);
+    seqs = (SequenceI[]) sqch[0];
+    chains = (String[]) sqch[1];
+    if (seqs == null || seqs.length == 0)
+    {
+      System.err
+              .println("JalviewLite.AlignFrame:newStructureView: No sequence to bind structure to.");
+    }
+    if (protocol == null || protocol.trim().length() == 0
+            || protocol.equals("null"))
+    {
+      protocol = (String) pdb.getProperty().get("protocol");
+      if (protocol == null)
+      {
+        System.err.println("Couldn't work out protocol to open structure: "
+                + pdb.getId());
+        return;
+      }
+    }
+    if (applet.useXtrnalSviewer)
+    {
+      // register the association(s) and quit, don't create any windows.
+      if (StructureSelectionManager.getStructureSelectionManager(applet).setMapping(seqs, chains, pdb.getFile(), protocol)==null) {
+        System.err.println("Failed to map "+pdb.getFile()+" ("+protocol+") to any sequences");
+      }
+      return;
+    }
+    if (applet.isAlignPdbStructures() && applet.jmolAvailable)
+    {
+      // can only do alignments with Jmol
+      // find the last jmol window assigned to this alignment
+      jalview.appletgui.AppletJmol ajm = null, tajm;
+      Vector jmols = applet
+              .getAppletWindow(jalview.appletgui.AppletJmol.class);
+      for (int i = 0, iSize = jmols.size(); i < iSize; i++)
+      {
+        tajm = (jalview.appletgui.AppletJmol) jmols.elementAt(i);
+        if (tajm.ap.alignFrame == this)
+        {
+          ajm = tajm;
+          break;
+        }
+      }
+      if (ajm != null)
+      {
+        System.err
+                .println("Incremental adding and aligning structure to existing Jmol view not yet implemented.");
+        // try and add the pdb structure
+        // ajm.addS
+        ajm = null;
+      }
+    }
+    // otherwise, create a new window
+    if (applet.jmolAvailable)
     {
-      return popup;
+      new jalview.appletgui.AppletJmol(pdb, seqs, chains, alignPanel,
+              protocol);
+      applet.lastFrameX += 40;
+      applet.lastFrameY += 40;
     }
-    popup = new PopupMenu();
-    int m, mSize = original.getItemCount();
-    for (m = 0; m < mSize; m++)
+    else
     {
-      popup.add(original.getItem(m));
-      mSize--;
-      m--;
+      new MCview.AppletPDBViewer(pdb, seqs, chains, alignPanel, protocol);
     }
 
-    return popup;
   }
 
-  public void mouseClicked(MouseEvent evt)
-  {}
-
-  public void mouseReleased(MouseEvent evt)
-  {}
-
-  public void mouseEntered(MouseEvent evt)
-  {}
+  public void alignedStructureView(JalviewLite applet, PDBEntry[] pdb,
+          SequenceI[][] seqs, String[][] chains, String[] protocols)
+  {
+    // TODO Auto-generated method stub
+    System.err.println("Aligned Structure View: Not yet implemented.");
+  }
 
-  public void mouseExited(MouseEvent evt)
-  {}
+  /**
+   * modify the current selection, providing the user has not made a selection already.
+   * @param sel - sequences from this alignment 
+   * @param csel - columns to be selected on the alignment
+   */
+  public void select(SequenceGroup sel, ColumnSelection csel)
+  {
+    alignPanel.seqPanel.selection(sel, csel, null);
+  }
 
+  public void scrollTo(int row, int column)
+  {
+    alignPanel.seqPanel.scrollTo(row, column);    
+  }
+  public void scrollToRow(int row)
+  {
+    alignPanel.seqPanel.scrollToRow(row);    
+  }
+  public void scrollToColumn(int column)
+  {
+    alignPanel.seqPanel.scrollToColumn(column);    
+  }
+  /**
+   * @return the alignments unique ID.
+   */
+  public String getSequenceSetId() {
+    return viewport.getSequenceSetId();
+  }
 }