From 5cd5b6e7864fe435ceb3f5c2f339a436ea0aac93 Mon Sep 17 00:00:00 2001
From: amwaterhouse <Andrew Waterhouse>
Date: Tue, 8 Aug 2006 15:44:08 +0000
Subject: [PATCH] Applet has hidden regions

---
 src/jalview/appletgui/APopupMenu.java          |  163 +++++--
 src/jalview/appletgui/AlignFrame.java          |   40 +-
 src/jalview/appletgui/AlignViewport.java       |  281 +++++++++++
 src/jalview/appletgui/AlignmentPanel.java      |   40 +-
 src/jalview/appletgui/AnnotationPanel.java     |  232 +++++----
 src/jalview/appletgui/CutAndPasteTransfer.java |    2 +-
 src/jalview/appletgui/FeatureRenderer.java     |   31 +-
 src/jalview/appletgui/IdCanvas.java            |  153 ++++--
 src/jalview/appletgui/IdPanel.java             |    6 +-
 src/jalview/appletgui/OverviewPanel.java       |  197 +++++---
 src/jalview/appletgui/PCAPanel.java            |   57 ++-
 src/jalview/appletgui/PairwiseAlignPanel.java  |   53 ++-
 src/jalview/appletgui/ScalePanel.java          |  318 ++++++++++---
 src/jalview/appletgui/SeqCanvas.java           |  599 +++++++++++++++---------
 src/jalview/appletgui/SeqPanel.java            |  372 +++++++++------
 src/jalview/appletgui/SequenceRenderer.java    |   32 +-
 src/jalview/appletgui/TreePanel.java           |   51 +-
 17 files changed, 1845 insertions(+), 782 deletions(-)

diff --git a/src/jalview/appletgui/APopupMenu.java b/src/jalview/appletgui/APopupMenu.java
index 3401cc4..28e40eb 100755
--- a/src/jalview/appletgui/APopupMenu.java
+++ b/src/jalview/appletgui/APopupMenu.java
@@ -59,6 +59,14 @@ public class APopupMenu
   MenuItem toUpper = new MenuItem("To Upper Case");
   MenuItem toLower = new MenuItem("To Lower Case");
   MenuItem toggleCase = new MenuItem("Toggle Case");
+  Menu outputmenu = new Menu();
+  Menu seqMenu = new Menu();
+  MenuItem pdb = new MenuItem();
+  MenuItem hideSeqs = new MenuItem();
+  MenuItem repGroup = new MenuItem();
+
+  Sequence seq;
+  MenuItem revealAll = new MenuItem();
 
   public APopupMenu(AlignmentPanel apanel, final Sequence seq, Vector links)
   {
@@ -70,6 +78,7 @@ public class APopupMenu
     //////////////////////////////////////////////////////////
 
     this.ap = apanel;
+    this.seq = seq;
 
     try
     {
@@ -80,6 +89,15 @@ public class APopupMenu
       e.printStackTrace();
     }
 
+    for (int i = 0; i < jalview.io.AppletFormatAdapter.formats.size()-1; i++)
+    {
+      MenuItem item = new MenuItem( (String) jalview.io.AppletFormatAdapter.formats.
+                                     elementAt(
+                                         i));
+      item.addActionListener(this);
+      outputmenu.add(item);
+    }
+
     SequenceGroup sg = ap.av.getSelectionGroup();
 
     if (sg != null && sg.getSize(false)>0)
@@ -96,7 +114,6 @@ public class APopupMenu
     else
     {
       remove(groupMenu);
-      remove(editMenu);
     }
 
     if (links!=null)
@@ -135,22 +152,18 @@ public class APopupMenu
            });
           linkMenu.add(item);
       }
-      add(linkMenu);
-
-      if(seq!=null)
-      {
-        item = new MenuItem("Show PDB Structure");
-        item.addActionListener(new java.awt.event.ActionListener()
-        {
-          public void actionPerformed(ActionEvent e)
-          {
-            addPDB(seq);
-          }
-        });
-
-        add(item);
-      }
+      seqMenu.add(linkMenu);
     }
+    if(seq!=null)
+    {
+      seqMenu.setLabel(seq.getName());
+      repGroup.setLabel("Represent Group with " + seq.getName());
+    }
+    else
+      remove(seqMenu);
+
+    if(!ap.av.hasHiddenRows)
+      remove(revealAll);
   }
 
   public void itemStateChanged(ItemEvent evt)
@@ -187,19 +200,31 @@ public class APopupMenu
     else if(source==nucleotideMenuItem)
       nucleotideMenuItem_actionPerformed();
 
-    else if(source==userDefinedColour)
-          userDefinedColour_actionPerformed();
-        else if(source==PIDColour)
-       PIDColour_actionPerformed();
-     else if(source==BLOSUM62Colour)
+    else if (source == userDefinedColour)
+      userDefinedColour_actionPerformed();
+    else if (source == PIDColour)
+      PIDColour_actionPerformed();
+    else if (source == BLOSUM62Colour)
       BLOSUM62Colour_actionPerformed();
-    else if(source==noColourmenuItem)
+    else if (source == noColourmenuItem)
       noColourmenuItem_actionPerformed();
-    else if(source==conservationMenuItem)
-        conservationMenuItem_itemStateChanged();
-      else if(source==unGroupMenuItem)
+    else if (source == conservationMenuItem)
+      conservationMenuItem_itemStateChanged();
+    else if (source == unGroupMenuItem)
       unGroupMenuItem_actionPerformed();
 
+    else if(source == pdb)
+      addPDB();
+    else if(source == hideSeqs)
+      hideSequences(false);
+    else if(source == repGroup)
+      hideSequences(true);
+    else if(source == revealAll)
+    {
+        ap.av.showAllHiddenSeqs();
+        ap.repaint();
+    }
+
     else if(source==copy)
       ap.alignFrame.copy_actionPerformed();
     else if(source==cut)
@@ -222,10 +247,45 @@ public class APopupMenu
         ap.seqPanel.seqCanvas.repaint();
       }
     }
+    else
+      outputText(evt);
+
+  }
+
+  void outputText(ActionEvent e)
+  {
+    CutAndPasteTransfer cap = new CutAndPasteTransfer(false, ap.alignFrame);
+    Vector vseqs = new Vector();
+
+      String [] selection = ap.av.getViewAsString(true);
+      SequenceI [] seqs = ap.av.getSelectionAsNewSequence();
+      if (selection != null)
+      {
+        for (int i = 0; i < selection.length; i++)
+        {
+          Sequence seq = new Sequence(
+              seqs[i].getName(),
+              selection[i],
+              seqs[i].getStart(), seqs[i].getEnd());
+          seq.setDescription(seqs[i].getDescription());
+          vseqs.addElement( seq );
+      }
+    }
+
+    Frame frame = new Frame();
+    frame.add(cap);
+    jalview.bin.JalviewLite.addFrame(frame,
+                                     "Selection output - " + e.getActionCommand(),
+                                     600, 500);
+
+    cap.setText(new jalview.io.AppletFormatAdapter().formatSequences(
+        e.getActionCommand(),
+        vseqs,
+        ap.av.showJVSuffix));
 
   }
 
-  void addPDB(Sequence seq)
+  void addPDB()
   {
     CutAndPasteTransfer cap = new CutAndPasteTransfer(true, ap.alignFrame);
     cap.setText("Paste your PDB file here.");
@@ -239,7 +299,7 @@ public class APopupMenu
       throws Exception
   {
     groupMenu.setLabel("Group");
-    groupMenu.setLabel("Define");
+    groupMenu.setLabel("Selection");
 
     unGroupMenuItem.setLabel("Remove Group");
     unGroupMenuItem.addActionListener(this);
@@ -257,11 +317,22 @@ public class APopupMenu
     showText.addItemListener(this);
     showColourText.setLabel("Colour Text");
     showColourText.addItemListener(this);
+    outputmenu.setLabel("Output to Textbox...");
+    seqMenu.setLabel("Sequence");
+    pdb.setLabel("View PDB Structure");
+    hideSeqs.setLabel("Hide Sequences");
+    repGroup.setLabel("Represent Group with");
+    revealAll.setLabel("Reveal All");
 
     add(groupMenu);
+    this.add(seqMenu);
+    this.add(hideSeqs);
+    this.add(revealAll);
+    groupMenu.add(editMenu);
+    groupMenu.add(outputmenu);
+    groupMenu.addSeparator();
     groupMenu.add(unGroupMenuItem);
     groupMenu.add(colourMenu);
-    groupMenu.addSeparator();
     groupMenu.add(showBoxes);
     groupMenu.add(showText);
     groupMenu.add(showColourText);
@@ -311,7 +382,6 @@ public class APopupMenu
     BLOSUM62Colour.addActionListener(this);
     conservationMenuItem.setLabel("Conservation");
 
-    add(editMenu);
     editMenu.add(copy);
     copy.addActionListener(this);
     editMenu.add(cut);
@@ -321,7 +391,13 @@ public class APopupMenu
     editMenu.add(toLower);
     toLower.addActionListener(this);
     editMenu.add(toggleCase);
+    seqMenu.add(pdb);
+    seqMenu.add(repGroup);
     toggleCase.addActionListener(this);
+    pdb.addActionListener(this);
+    hideSeqs.addActionListener(this);
+    repGroup.addActionListener(this);
+    revealAll.addActionListener(this);
 
   }
 
@@ -514,4 +590,33 @@ public class APopupMenu
     refresh();
   }
 
+  void hideSequences(boolean representGroup)
+  {
+    SequenceGroup sg = ap.av.getSelectionGroup();
+    if(sg==null || sg.getSize(false)<1)
+    {
+      ap.av.hideSequence(seq);
+      return;
+    }
+
+      int index = 0;
+      while(index < sg.getSize(false))
+      {
+        if(representGroup && sg.getSequenceAt(index)!=seq)
+        {
+          seq.addHiddenSequence(sg.getSequenceAt(index));
+          ap.av.hideSequence(sg.getSequenceAt(index));
+        }
+        else if(!representGroup)
+        {
+          ap.av.hideSequence(sg.getSequenceAt(index));
+        }
+        index ++;
+      }
+
+      ap.av.setSelectionGroup(null);
+      ap.repaint();
+      refresh();
+    }
+
 }
diff --git a/src/jalview/appletgui/AlignFrame.java b/src/jalview/appletgui/AlignFrame.java
index 2b53d76..e1d8ce8 100755
--- a/src/jalview/appletgui/AlignFrame.java
+++ b/src/jalview/appletgui/AlignFrame.java
@@ -38,7 +38,6 @@ public class AlignFrame extends Frame implements ActionListener,
   public AlignViewport viewport;
   int NEW_WINDOW_WIDTH = 700;
   int NEW_WINDOW_HEIGHT = 500;
-  jalview.bin.JalviewLite applet;
 
   String jalviewServletURL;
 
@@ -58,7 +57,6 @@ public class AlignFrame extends Frame implements ActionListener,
       ex.printStackTrace();
     }
 
-    this.applet = applet;
     viewport = new AlignViewport(al, applet);
     alignPanel = new AlignmentPanel(this, viewport);
 
@@ -515,25 +513,25 @@ public void itemStateChanged(ItemEvent evt)
     StringBuffer url = new StringBuffer(jalviewServletURL);
 
     url.append("?open="+
-               appendProtocol( applet.getParameter("file") ) );
+               appendProtocol( viewport.applet.getParameter("file") ) );
 
-    if(applet.getParameter("features")!=null)
+    if(viewport.applet.getParameter("features")!=null)
     {
       url.append( "&features=" );
-      url.append( appendProtocol( applet.getParameter("features") ) );
+      url.append( appendProtocol( viewport.applet.getParameter("features") ) );
     }
 
-    if(applet.getParameter("defaultColour")!=null)
+    if(viewport.applet.getParameter("defaultColour")!=null)
     {
       url.append("&colour=" +
-                 removeWhiteSpace(applet.getParameter("defaultColour"))
+                 removeWhiteSpace(viewport.applet.getParameter("defaultColour"))
           );
     }
 
-    if(applet.getParameter("userDefinedColour")!=null)
+    if(viewport.applet.getParameter("userDefinedColour")!=null)
     {
       url.append( "&colour=" +
-                 removeWhiteSpace( applet.getParameter("userDefinedColour") )
+                 removeWhiteSpace( viewport.applet.getParameter("userDefinedColour") )
          );
     }
 
@@ -562,7 +560,7 @@ public void itemStateChanged(ItemEvent evt)
        new URL(url);
     }catch(java.net.MalformedURLException ex)
     {
-      url = applet.getCodeBase()+url;
+      url = viewport.applet.getCodeBase()+url;
     }
     return url;
   }
@@ -570,7 +568,7 @@ public void itemStateChanged(ItemEvent evt)
   public void closeMenuItem_actionPerformed()
   {
     PaintRefresher.components.remove(viewport.alignment);
-    if(PaintRefresher.components.size()==0 && applet==null)
+    if(PaintRefresher.components.size()==0 && viewport.applet==null)
       System.exit(0);
 
     this.dispose();
@@ -820,7 +818,7 @@ public void itemStateChanged(ItemEvent evt)
           newtitle = newtitle.concat("- from " + getTitle());
         }
         AlignFrame af = new AlignFrame(new Alignment(newSeqs),
-                                       applet,
+                                       viewport.applet,
                                        newtitle,
                                        false);
 
@@ -1749,7 +1747,7 @@ public void itemStateChanged(ItemEvent evt)
 
   public void showURL(String url, String target)
   {
-    if (applet == null)
+    if (viewport.applet == null)
     {
       System.out.println("Not running as applet - no browser available.");
     }
@@ -1758,7 +1756,7 @@ public void itemStateChanged(ItemEvent evt)
       try
       {
         System.out.println("Show url: "+url);
-        applet.getAppletContext().showDocument(new java.net.URL(url),
+        viewport.applet.getAppletContext().showDocument(new java.net.URL(url),
                                                target);
       }
       catch (Exception ex)
@@ -2185,16 +2183,16 @@ public void itemStateChanged(ItemEvent evt)
     fileMenu.remove(closeMenuItem);
     fileMenu.remove(3); // Seperator
 
-    applet.setLayout(new BorderLayout());
-    applet.add(embeddedMenu, BorderLayout.NORTH);
-    applet.add(statusBar, BorderLayout.SOUTH);
-   // applet.validate();
+    viewport.applet.setLayout(new BorderLayout());
+    viewport.applet.add(embeddedMenu, BorderLayout.NORTH);
+    viewport.applet.add(statusBar, BorderLayout.SOUTH);
+   // viewport.applet.validate();
 
-    alignPanel.setSize(applet.size().width, applet.size().height
+    alignPanel.setSize(viewport.applet.size().width, viewport.applet.size().height
                        - embeddedMenu.HEIGHT - statusBar.HEIGHT);
 
-     applet.add(alignPanel, BorderLayout.CENTER);
-     applet.validate();
+     viewport.applet.add(alignPanel, BorderLayout.CENTER);
+     viewport.applet.validate();
 
   }
 
diff --git a/src/jalview/appletgui/AlignViewport.java b/src/jalview/appletgui/AlignViewport.java
index 9f6448d..b4cac5c 100755
--- a/src/jalview/appletgui/AlignViewport.java
+++ b/src/jalview/appletgui/AlignViewport.java
@@ -81,6 +81,10 @@ public class AlignViewport
  // currently visible, in the correct order or rendering
   Hashtable featuresDisplayed;
 
+  boolean hasHiddenColumns = false;
+  boolean hasHiddenRows = false;
+  boolean showHiddenMarkers = true;
+
 
   public Vector vconsensus;
   AlignmentAnnotation consensus;
@@ -95,8 +99,11 @@ public class AlignViewport
 
   boolean ignoreGapsInConsensusCalculation = false;
 
+  jalview.bin.JalviewLite applet;
+
   public AlignViewport(AlignmentI al, JalviewLite applet)
   {
+    this.applet = applet;
     setAlignment(al);
     this.startRes = 0;
     this.endRes = al.getWidth() - 1;
@@ -581,6 +588,13 @@ public class AlignViewport
     return increment;
   }
 
+  public void setHiddenColumns(ColumnSelection colsel)
+  {
+    this.colSel = colsel;
+    if(colSel.getHiddenColumns()!=null)
+      hasHiddenColumns = true;
+  }
+
   public ColumnSelection getColumnSelection()
   {
     return colSel;
@@ -713,6 +727,273 @@ public class AlignViewport
   {
     return ignoreGapsInConsensusCalculation;
   }
+  public void hideSelectedColumns()
+  {
+    if (colSel.size() < 1)
+      return;
+
+    colSel.hideSelectedColumns();
+    setSelectionGroup(null);
+
+    hasHiddenColumns = true;
+  }
+
+
+  public void hideColumns(int start, int end)
+  {
+    if(start==end)
+      colSel.hideColumns(start);
+    else
+      colSel.hideColumns(start, end);
+    setSelectionGroup(null);
+    hasHiddenColumns = true;
+  }
+
+  public void hideSequence(SequenceI seq)
+  {
+    if(seq!=null)
+    {
+      alignment.getHiddenSequences().hideSequence(seq);
+      hasHiddenRows = true;
+    }
+  }
+
+  public void showSequence(int index)
+  {
+    alignment.getHiddenSequences().showSequence(index);
+
+    if(alignment.getHiddenSequences().getSize()<1)
+      hasHiddenRows = false;
+  }
+
+  public void showColumn(int col)
+  {
+    colSel.revealHiddenColumns(col);
+    if(colSel.getHiddenColumns()==null)
+      hasHiddenColumns = false;
+  }
+
+  public void showAllHiddenColumns()
+  {
+    colSel.revealAllHiddenColumns();
+    hasHiddenColumns = false;
+  }
+
+  public void showAllHiddenSeqs()
+  {
+    if(alignment.getHiddenSequences().getSize()>0)
+    {
+      alignment.getHiddenSequences().showAll();
+      hasHiddenRows = false;
+    }
+  }
+
+  public int adjustForHiddenSeqs(int alignmentIndex)
+  {
+    return alignment.getHiddenSequences().adjustForHiddenSeqs(alignmentIndex);
+  }
+
+  /**
+   * This method returns the a new SequenceI [] with
+   * the selection sequence and start and end points adjusted
+   * @return String[]
+   */
+  public SequenceI[] getSelectionAsNewSequence()
+  {
+    SequenceI[] sequences;
+
+    if (selectionGroup == null)
+      sequences = alignment.getSequencesArray();
+    else
+      sequences = selectionGroup.getSelectionAsNewSequences(alignment);
+
+    return sequences;
+  }
+
+  /**
+   * This method returns the visible alignment as text, as
+   * seen on the GUI, ie if columns are hidden they will not
+   * be returned in the result.
+   * Use this for calculating trees, PCA, redundancy etc on views
+   * which contain hidden columns.
+   * @return String[]
+   */
+  public jalview.datamodel.CigarArray getViewAsCigars(boolean selectedRegionOnly)
+  {
+    CigarArray selection=null;
+    SequenceI [] seqs= null;
+    int i, iSize;
+    int start = 0, end = 0;
+    if(selectedRegionOnly && selectionGroup!=null)
+    {
+      iSize = selectionGroup.getSize(false);
+      seqs = selectionGroup.getSequencesInOrder(alignment);
+      start = selectionGroup.getStartRes();
+      end = selectionGroup.getEndRes(); // inclusive for start and end in SeqCigar constructor
+    }
+    else
+    {
+      iSize = alignment.getHeight();
+      seqs = alignment.getSequencesArray();
+      end = alignment.getWidth()-1;
+    }
+    SeqCigar[] selseqs = new SeqCigar[iSize];
+    for(i=0; i<iSize; i++)
+    {
+      selseqs[i] = new SeqCigar(seqs[i], start, end);
+    }
+    selection=new CigarArray(selseqs);
+    // now construct the CigarArray operations
+    if (hasHiddenColumns) {
+      Vector regions = colSel.getHiddenColumns();
+      int [] region;
+      int hideStart, hideEnd;
+      int last=start;
+      for (int j = 0; last<end & j < regions.size(); j++)
+      {
+        region = (int[]) regions.elementAt(j);
+        hideStart = region[0];
+        hideEnd = region[1];
+        // edit hidden regions to selection range
+        if(hideStart<last) {
+          if (hideEnd > last)
+          {
+            hideStart = last;
+          } else
+            continue;
+        }
+
+        if (hideStart>end)
+          break;
+
+        if (hideEnd>end)
+          hideEnd=end;
+
+        if (hideStart>hideEnd)
+          break;
+        /**
+         * form operations...
+         */
+        if (last<hideStart)
+          selection.addOperation(CigarArray.M, hideStart-last);
+        selection.addOperation(CigarArray.D, 1+hideEnd-hideStart);
+        last = hideEnd+1;
+      }
+      // Final match if necessary.
+      if (last<end)
+        selection.addOperation(CigarArray.M, end-last);
+    } else {
+      selection.addOperation(CigarArray.M, end-start);
+    }
+    return selection;
+  }
+  /**
+   * return a compact representation of the current alignment selection to
+   * pass to an analysis function
+   * @param selectedOnly boolean true to just return the selected view
+   * @return AlignmentView
+   */
+  jalview.datamodel.AlignmentView getAlignmentView(boolean selectedOnly) {
+    // JBPNote:
+    // this is here because the AlignmentView constructor modifies the CigarArray
+    // object. Refactoring of Cigar and alignment view representation should
+    // be done to remove redundancy.
+    CigarArray aligview = getViewAsCigars(selectedOnly);
+    if (aligview!=null)
+      return new AlignmentView(aligview);
+    return null;
+  }
+  /**
+   * This method returns the visible alignment as text, as
+   * seen on the GUI, ie if columns are hidden they will not
+   * be returned in the result.
+   * Use this for calculating trees, PCA, redundancy etc on views
+   * which contain hidden columns.
+   * @return String[]
+   */
+  public String [] getViewAsString(boolean selectedRegionOnly)
+  {
+    String [] selection = null;
+    SequenceI [] seqs= null;
+    int i, iSize;
+    int start = 0, end = 0;
+    if(selectedRegionOnly && selectionGroup!=null)
+    {
+      iSize = selectionGroup.getSize(false);
+      seqs = selectionGroup.getSequencesInOrder(alignment);
+      start = selectionGroup.getStartRes();
+      end = selectionGroup.getEndRes()+1;
+    }
+    else
+    {
+      iSize = alignment.getHeight();
+      seqs = alignment.getSequencesArray();
+      end = alignment.getWidth();
+    }
+
+    selection = new String[iSize];
+
+
+    for(i=0; i<iSize; i++)
+    {
+      if (hasHiddenColumns)
+      {
+           StringBuffer visibleSeq = new StringBuffer();
+           Vector regions = colSel.getHiddenColumns();
+
+           int blockStart = start, blockEnd=end;
+           int [] region;
+           int hideStart, hideEnd;
+
+           for (int j = 0; j < regions.size(); j++)
+           {
+             region = (int[]) regions.elementAt(j);
+             hideStart = region[0];
+             hideEnd = region[1];
+
+             if(hideStart < start)
+             {
+               continue;
+             }
+
+             blockStart = Math.min(blockStart, hideEnd+1);
+             blockEnd = Math.min(blockEnd, hideStart);
+
+             if(blockStart>blockEnd)
+             {
+                break;
+             }
+
+
+             visibleSeq.append(seqs[i].getSequence(blockStart, blockEnd));
+
+             blockStart = hideEnd+1;
+             blockEnd = end;
+           }
+
+           if(end>blockStart)
+             visibleSeq.append(seqs[i].getSequence(blockStart, end));
+
+           selection[i] = visibleSeq.toString();
+      }
+      else
+      {
+        selection[i] = seqs[i].getSequence(start, end);
+      }
+    }
+
+    return selection;
+  }
+
+  public boolean getShowHiddenMarkers()
+  {
+    return showHiddenMarkers;
+  }
+
+  public void setShowHiddenMarkers(boolean show)
+  {
+    showHiddenMarkers = show;
+  }
 
 
 }
diff --git a/src/jalview/appletgui/AlignmentPanel.java b/src/jalview/appletgui/AlignmentPanel.java
index b1a8b8b..13eb06f 100755
--- a/src/jalview/appletgui/AlignmentPanel.java
+++ b/src/jalview/appletgui/AlignmentPanel.java
@@ -341,30 +341,35 @@ public class AlignmentPanel extends Panel implements AdjustmentListener
 
   public void setScrollValues(int x, int y)
   {
-    av.setStartRes(x);
-    av.setStartSeq(y);
-    av.setEndRes(x + seqPanel.seqCanvas.getSize().width / av.getCharWidth() - 1);
+    int width = av.alignment.getWidth();
+    int height = av.alignment.getHeight();
+
+    if(av.hasHiddenColumns)
+     width = av.getColumnSelection().findColumnPosition(width);
+
+    av.setEndRes( (x + (seqPanel.seqCanvas.getSize().width / av.charWidth)) -1);
 
     hextent = seqPanel.seqCanvas.getSize().width / av.charWidth;
     vextent = seqPanel.seqCanvas.getSize().height / av.charHeight;
 
-    if (hextent > av.alignment.getWidth())
+    if (hextent > width)
     {
-      hextent = av.alignment.getWidth();
+      hextent = width;
     }
-    if (vextent > av.alignment.getHeight())
+
+    if (vextent > height)
     {
-      vextent = av.alignment.getHeight();
+      vextent = height;
     }
 
-    if (hextent + x > av.getAlignment().getWidth())
+    if ( (hextent + x) > width)
     {
-      x = av.getAlignment().getWidth() - hextent;
+      x = width - hextent;
     }
 
-    if (vextent + y > av.getAlignment().getHeight())
+    if ( (vextent + y) > height)
     {
-      y = av.getAlignment().getHeight() - vextent;
+      y = height - vextent;
     }
 
     if (y < 0)
@@ -389,6 +394,7 @@ public class AlignmentPanel extends Panel implements AdjustmentListener
 
     if(overviewPanel!=null)
           overviewPanel.setBoxPosition();
+
   }
 
   public void adjustmentValueChanged(AdjustmentEvent evt)
@@ -477,9 +483,15 @@ public class AlignmentPanel extends Panel implements AdjustmentListener
 
     if (av.getWrapAlignment())
     {
-      int max = av.alignment.getWidth() /
-          seqPanel.seqCanvas.
-          getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width) +1;
+      int maxwidth = av.alignment.getWidth();
+
+      if (av.hasHiddenColumns)
+        maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
+
+      int max = maxwidth /
+          seqPanel.seqCanvas.getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width) +
+          1;
+
       vscroll.setMaximum(max);
       vscroll.setUnitIncrement(1);
       vscroll.setVisibleAmount(1);
diff --git a/src/jalview/appletgui/AnnotationPanel.java b/src/jalview/appletgui/AnnotationPanel.java
index 614498c..82d2a1e 100755
--- a/src/jalview/appletgui/AnnotationPanel.java
+++ b/src/jalview/appletgui/AnnotationPanel.java
@@ -192,6 +192,10 @@ public class AnnotationPanel
     }
 
     int res = evt.getX() / av.getCharWidth() + av.getStartRes();
+
+    if(av.hasHiddenColumns)
+          res = av.getColumnSelection().adjustForHiddenColumns(res);
+
     if (row > -1 && res < aa[row].annotations.length && aa[row].annotations[res] != null)
     {
       StringBuffer text = new StringBuffer("Sequence position " + (res + 1) +
@@ -209,7 +213,6 @@ public class AnnotationPanel
   public void paint(Graphics g)
   {
 
-
     imgWidth = (av.endRes - av.startRes + 1) * av.charWidth;
 
     if (image == null || imgWidth != image.getWidth(this))
@@ -302,6 +305,7 @@ public class AnnotationPanel
 
       int x = 0;
       int y = 0;
+      int column=0;
       char lastSS;
       int lastSSX;
       int iconOffset = av.charHeight / 2;
@@ -346,21 +350,30 @@ public class AnnotationPanel
               iconOffset = 0;
           }
 
-          int column = startRes;
-          while(column < endRes)
+           x = 0;
+          while(x < endRes-startRes)
           {
-              if ((row.annotations.length <= column) ||
-                      (row.annotations[column] == null))
+            if (av.hasHiddenColumns)
+            {
+              column = av.getColumnSelection().adjustForHiddenColumns(startRes+x);
+              if (column > row.annotations.length-1)
+              {
+                break;
+              }
+            }
+            else
+                column = startRes+x;
+
+              if ( (row.annotations.length <= column) ||
+                  (row.annotations[column] == null))
               {
-                  validRes = false;
+                validRes = false;
               }
               else
               {
-                  validRes = true;
+                validRes = true;
               }
 
-              x = (column - startRes) * av.charWidth;
-
 
               if (av.validCharWidth && validRes &&
                         (row.annotations[column].displayCharacter.length() > 0))
@@ -372,7 +385,8 @@ public class AnnotationPanel
 
                 if (column == 0 || row.graph>0)
                 {
-                    g.drawString(row.annotations[column].displayCharacter, x+charOffset,
+                    g.drawString(row.annotations[column].displayCharacter,
+                                (x*av.charWidth)+charOffset,
                         y + iconOffset + 3);
                 }
                 else if (
@@ -383,7 +397,8 @@ public class AnnotationPanel
               (row.annotations[column].displayCharacter.length() <2 &&
                row.annotations[column].secondaryStructure==' ')))
                 {
-                    g.drawString(row.annotations[column].displayCharacter, x+charOffset,
+                    g.drawString(row.annotations[column].displayCharacter,
+                       (x*av.charWidth)+charOffset,
                         y + iconOffset + 3);
                     }
               }
@@ -402,13 +417,13 @@ public class AnnotationPanel
                           //Off by 1 offset when drawing rects and ovals
                           //to offscreen image on the MAC
                           g.fillRoundRect(lastSSX, y + 4 + iconOffset,
-                                          x - lastSSX, 7, 8, 8);
+                                          (x*av.charWidth) - lastSSX, 7, 8, 8);
                           break;
                         }
 
                         int sCol = (lastSSX / av.charWidth) + startRes;
                         int x1 = lastSSX;
-                        int x2 = x;
+                        int x2 = (x*av.charWidth);
 
                        if(sCol==0 ||
                           row.annotations[sCol-1]==null ||
@@ -421,7 +436,8 @@ public class AnnotationPanel
                         if(row.annotations[column]==null ||
                            row.annotations[column].secondaryStructure!='H')
                         {
-                          g.fillArc(x-av.charWidth, y+4+iconOffset, av.charWidth, 8, 270,180);
+                          g.fillArc((x*av.charWidth)-av.charWidth,
+                                    y+4+iconOffset, av.charWidth, 8, 270,180);
                           x2 -= av.charWidth/2;
                         }
 
@@ -431,8 +447,10 @@ public class AnnotationPanel
                       case 'E':
                           g.setColor(SHEET_COLOUR);
                           g.fillRect(lastSSX, y + 4 + iconOffset,
-                              x - lastSSX - 4, 7);
-                          g.fillPolygon(new int[] { x - 4, x - 4, x },
+                              (x*av.charWidth) - lastSSX - 4, 7);
+                          g.fillPolygon(new int[] { (x*av.charWidth) - 4,
+                                        (x*av.charWidth) - 4,
+                                        (x*av.charWidth) },
                               new int[]
                               {
                                   y + iconOffset, y + 14 + iconOffset,
@@ -445,7 +463,7 @@ public class AnnotationPanel
                       default:
                           g.setColor(Color.gray);
                           g.fillRect(lastSSX, y + 6 + iconOffset,
-                              x - lastSSX, 2);
+                              (x*av.charWidth) - lastSSX, 2);
 
                           break;
                       }
@@ -459,23 +477,24 @@ public class AnnotationPanel
                           lastSS = ' ';
                       }
 
-                      lastSSX = x;
+                      lastSSX = (x*av.charWidth);
                   }
               }
 
 
           column++;
+          x++;
           }
 
           if(column>=row.annotations.length)
               column = row.annotations.length-1;
 
-          x += av.charWidth;
+        //  x ++;
 
           if (row.hasIcons)
           {
-              switch (lastSS)
-              {
+            switch (lastSS)
+            {
               case 'H':
                 g.setColor(HELIX_COLOUR);
                 if (MAC)
@@ -483,63 +502,67 @@ public class AnnotationPanel
                   //Off by 1 offset when drawing rects and ovals
                   //to offscreen image on the MAC
                   g.fillRoundRect(lastSSX, y + 4 + iconOffset,
-                                  x - lastSSX, 7, 8, 8);
+                                  (x*av.charWidth) - lastSSX, 7, 8, 8);
                   break;
                 }
 
-
                 int sCol = (lastSSX / av.charWidth) + startRes;
                 int x1 = lastSSX;
-                int x2 = x;
-
-               if(sCol==0 ||
-                  row.annotations[sCol-1]==null ||
-                  row.annotations[sCol-1].secondaryStructure!='H')
-               {
-                 g.fillArc(lastSSX, y+4+iconOffset, av.charWidth, 8, 90,180) ;
-                 x1 += av.charWidth/2;
-               }
-
-                if(row.annotations[column]==null ||
-                   row.annotations[column].secondaryStructure!='H')
+                int x2 = (x*av.charWidth);
+
+                if (sCol == 0 ||
+                    row.annotations[sCol - 1] == null ||
+                    row.annotations[sCol - 1].secondaryStructure != 'H')
                 {
-                  g.fillArc(x-av.charWidth, y+4+iconOffset, av.charWidth, 8, 270,180);
-                  x2 -= av.charWidth/2;
+                  g.fillArc(lastSSX, y + 4 + iconOffset, av.charWidth, 8, 90, 180);
+                  x1 += av.charWidth / 2;
                 }
 
-                g.fillRect(x1, y+4+iconOffset, x2-x1, 8);
+                if (row.annotations[column] == null ||
+                    row.annotations[column].secondaryStructure != 'H')
+                {
+                  g.fillArc((x*av.charWidth) - av.charWidth,
+                            y + 4 + iconOffset, av.charWidth, 8, 270,
+                            180);
+                  x2 -= av.charWidth / 2;
+                }
 
-                    break;
+                g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8);
 
-              case 'E':
-                  g.setColor(SHEET_COLOUR);
+                break;
 
-                  if (row.annotations[endRes] ==null
-                        || row.annotations[endRes].secondaryStructure != 'E')
-                  {
-                    g.fillRect(lastSSX, y + 4 + iconOffset,
-                               x - lastSSX - 4, 7);
-                    g.fillPolygon(new int[]
-                                  {x - 4, x - 4, x},
-                                  new int[]
-                                  {
-                                  y + iconOffset, y + 14 + iconOffset,
-                                  y + 7 + iconOffset
-                    }, 3);
-                  }
-                  else
-                    g.fillRect(lastSSX, y + 4 + iconOffset,
-                               x - lastSSX, 7);
-
-                  break;
+              case 'E':
+                g.setColor(SHEET_COLOUR);
 
+                if (row.annotations[endRes] == null
+                    || row.annotations[endRes].secondaryStructure != 'E')
+                {
+                  g.fillRect(lastSSX, y + 4 + iconOffset,
+                             (x*av.charWidth) - lastSSX - 4, 7);
+                  g.fillPolygon(new int[]
+                                {(x*av.charWidth) - 4,
+                                (x*av.charWidth) - 4,
+                               (x*av.charWidth)},
+                                new int[]
+                                {
+                                y + iconOffset, y + 14 + iconOffset,
+                                y + 7 + iconOffset
+                  }, 3);
+                }
+                else
+                 {
+                   g.fillRect(lastSSX, y + 4 + iconOffset,
+                              (x+1) * av.charWidth - lastSSX, 7);
+                 }
+                break;
 
               default:
-                  g.setColor(Color.gray);
-                  g.fillRect(lastSSX, y + 6 + iconOffset, x - lastSSX, 2);
+                g.setColor(Color.gray);
+                g.fillRect(lastSSX, y + 6 + iconOffset,
+                           (x*av.charWidth) - lastSSX, 2);
 
-                  break;
-              }
+                break;
+            }
           }
 
           if (row.graph>0)
@@ -632,29 +655,45 @@ public class AnnotationPanel
     g.setColor(Color.gray);
     g.drawLine(x-av.charWidth,y2,(eRes-sRes)*av.charWidth,y2);
 
+    eRes = Math.min(eRes, aa.annotations.length);
+
+    int column;
+    int aaMax = aa.annotations.length-1;
 
-    for (int j = sRes; j < eRes; j++)
+    while( x < eRes - sRes )
     {
-      if(aa.annotations[j]==null || aa.annotations[j-1]==null)
+      column = sRes + x;
+      if(av.hasHiddenColumns)
+      {
+        column = av.getColumnSelection().adjustForHiddenColumns(column);
+      }
+
+      if (column > aaMax)
+      {
+        break;
+      }
+
+      if(aa.annotations[column]==null || aa.annotations[column-1]==null)
       {
-        x+=av.charWidth;
+        x++;
         continue;
       }
-        g.setColor(aa.annotations[j].colour);
-        y1 = y - (int) (((aa.annotations[j-1].value-min) / range) * graphHeight);
-        y2 = y - (int) (((aa.annotations[j].value-min) / range) * graphHeight);
-        g.drawLine(x-av.charWidth/2, y1, x+av.charWidth/2, y2);
-        x += av.charWidth;
-     }
 
+        g.setColor(aa.annotations[column].colour);
+        y1 = y - (int) (((aa.annotations[column-1].value-min) / range) * graphHeight);
+        y2 = y - (int) (((aa.annotations[column].value-min) / range) * graphHeight);
+
+        g.drawLine(x*av.charWidth-av.charWidth/2, y1, x*av.charWidth+av.charWidth/2, y2);
+        x ++;
+     }
 
      if(aa.threshold!=null)
      {
          g.setColor(aa.threshold.colour);
-         y2 = (int)(y - ((aa.threshold.value-min) / range)*aa.graphHeight);
-         g.drawLine(0,y2,(eRes-sRes)*av.charWidth,y2);
-     }
 
+         y2 = (int)(y - ((aa.threshold.value-min) / range)*graphHeight);
+         g.drawLine(0,y2,(eRes-sRes)*av.charWidth,y2);
+    }
   }
 
   public void drawBarGraph(Graphics g, AlignmentAnnotation aa,
@@ -665,51 +704,58 @@ public class AnnotationPanel
     if(sRes>aa.annotations.length)
       return;
 
-
     eRes = Math.min(eRes, aa.annotations.length);
 
-    int x=0, y1, y2;
+    int x=0, y1=y, y2=y;
 
     float range = max - min;
 
-    y1 = y2 = y;
-
     if(min<0)
-      y2 = y -(int)( (0-min / (range))*aa.graphHeight);
+      y2 = y - (int)((0-min / (range))*aa.graphHeight);
 
     g.setColor(Color.gray);
 
     g.drawLine(x,y2,(eRes-sRes)*av.charWidth,y2);
 
-    for (int j = sRes; j < eRes; j++)
+    int column;
+    int aaMax = aa.annotations.length-1;
+
+    while( x < eRes-sRes )
     {
+      column = sRes + x;
+      if(av.hasHiddenColumns)
+      {
+        column = av.getColumnSelection().adjustForHiddenColumns(column);
+      }
+
+      if(column > aaMax)
+      {
+          break;
+      }
 
-      if (aa.annotations[j] == null)
+      if (aa.annotations[column] == null)
       {
-        x += av.charWidth;
+        x ++;
         continue;
       }
 
-        g.setColor(aa.annotations[j].colour);
-        y1 = y - (int) (((aa.annotations[j].value-min) / (range)) * aa.graphHeight);
+        g.setColor(aa.annotations[column].colour);
+        y1 = y - (int) (((aa.annotations[column].value-min) / (range)) * aa.graphHeight);
 
         if(y1-y2>0)
-          g.fillRect(x, y2, av.charWidth, y1-y2 );
+          g.fillRect(x*av.charWidth, y2, av.charWidth, y1-y2 );
         else
-          g.fillRect(x, y1, av.charWidth, y2-y1 );
-
-        x += av.charWidth;
-    }
+          g.fillRect(x*av.charWidth, y1, av.charWidth, y2-y1 );
 
+        x ++ ;
 
+    }
     if(aa.threshold!=null)
     {
         g.setColor(aa.threshold.colour);
         y2 = (int)(y - ((aa.threshold.value-min) / range)*aa.graphHeight);
         g.drawLine(0,y2,(eRes-sRes)*av.charWidth,y2);
-    }
-
-
+      }
   }
 
   // used by overview window
diff --git a/src/jalview/appletgui/CutAndPasteTransfer.java b/src/jalview/appletgui/CutAndPasteTransfer.java
index 4b890bb..e885c65 100755
--- a/src/jalview/appletgui/CutAndPasteTransfer.java
+++ b/src/jalview/appletgui/CutAndPasteTransfer.java
@@ -128,7 +128,7 @@ public class CutAndPasteTransfer extends Panel implements ActionListener, MouseL
       }
       if (sequences != null)
       {
-        AlignFrame af = new AlignFrame(new Alignment(sequences), alignFrame.applet,
+        AlignFrame af = new AlignFrame(new Alignment(sequences), alignFrame.viewport.applet,
                                        "Cut & Paste input - " + format,
                                        false);
         af.statusBar.setText("Successfully pasted alignment file");
diff --git a/src/jalview/appletgui/FeatureRenderer.java b/src/jalview/appletgui/FeatureRenderer.java
index 66a9bc2..31b09c7 100755
--- a/src/jalview/appletgui/FeatureRenderer.java
+++ b/src/jalview/appletgui/FeatureRenderer.java
@@ -78,6 +78,7 @@ public class FeatureRenderer
       renderOrder = fr.renderOrder;
       featureGroups = fr.featureGroups;
       featureColours = fr.featureColours;
+      transparency =  fr.transparency;
     }
 
 
@@ -99,7 +100,7 @@ public class FeatureRenderer
 
       currentColour = null;
 
-      drawSequence(null, lastSequence, lastSequence.findPosition(i), -1,-1, -1, -1);
+      drawSequence(null, lastSequence, lastSequence.findPosition(i), -1,-1);
 
       if(currentColour==null)
         return initialCol;
@@ -136,7 +137,7 @@ public class FeatureRenderer
 
       currentColour = null;
 
-      drawSequence(null, lastSequence, lastSequence.findPosition(column), -1,-1, -1, -1);
+      drawSequence(null, lastSequence, lastSequence.findPosition(column), -1,-1);
 
       if(currentColour==null)
         return initialCol;
@@ -166,7 +167,7 @@ public class FeatureRenderer
     int sfSize, sfindex, spos, epos;
 
     public void drawSequence(Graphics g, SequenceI seq,
-                             int start, int end, int y1, int width, int height)
+                             int start, int end, int y1)
     {
       if (   seq.getSequenceFeatures() == null
           || seq.getSequenceFeatures().length==0)
@@ -246,13 +247,13 @@ public class FeatureRenderer
                           seq.findIndex(sequenceFeatures[sfindex].begin) - 1,
                           new Color( ( (Integer) av.featuresDisplayed.get(
                 sequenceFeatures[sfindex].type)).intValue()),
-                          start, end, y1, width, height);
+                          start, end, y1);
             renderFeature(g, seq,
                           seq.findIndex(sequenceFeatures[sfindex].end) - 1,
                           seq.findIndex(sequenceFeatures[sfindex].end) - 1,
                           new Color( ( (Integer) av.featuresDisplayed.get(
                 sequenceFeatures[sfindex].type)).intValue()),
-                          start, end, y1, width, height);
+                          start, end, y1);
 
           }
           else
@@ -260,7 +261,7 @@ public class FeatureRenderer
                           seq.findIndex(sequenceFeatures[sfindex].begin) - 1,
                           seq.findIndex(sequenceFeatures[sfindex].end) - 1,
                           getColour(sequenceFeatures[sfindex].type),
-                          start, end, y1, width, height);
+                          start, end, y1);
 
         }
       }
@@ -275,7 +276,7 @@ public class FeatureRenderer
     char s;
     int i;
     void renderFeature(Graphics g, SequenceI seq,
-                       int fstart, int fend, Color featureColour, int start, int end,  int y1, int width, int height)
+                       int fstart, int fend, Color featureColour, int start, int end,  int y1)
     {
 
       if (((fstart <= end) && (fend >= start)))
@@ -301,16 +302,16 @@ public class FeatureRenderer
 
             g.setColor(featureColour);
 
-            g.fillRect( (i - start) * width, y1, width, height);
+            g.fillRect( (i - start) * av.charWidth, y1, av.charWidth, av.charHeight);
 
             if(!av.validCharWidth)
               continue;
 
             g.setColor(Color.white);
-            charOffset = (width - fm.charWidth(s)) / 2;
+            charOffset = (av.charWidth - fm.charWidth(s)) / 2;
             g.drawString(String.valueOf(s),
-                         charOffset + (width * (i - start)),
-                         (y1 + height) - height / 5); //pady = height / 5;
+                         charOffset + (av.charWidth * (i - start)),
+                         (y1 + av.charHeight) - av.charHeight / 5); //pady = height / 5;
 
           }
       }
@@ -411,10 +412,10 @@ public class FeatureRenderer
   {
     void setTransparency(Graphics g, float value)
     {
-      Graphics2D g2 = (Graphics2D) g;
-      g2.setComposite(
-          AlphaComposite.getInstance(
-              AlphaComposite.SRC_OVER, value));
+      //Graphics2D g2 = (Graphics2D) g;
+   //   g2.setComposite(
+     //     AlphaComposite.getInstance(
+     //         AlphaComposite.SRC_OVER, value));
     }
   }
 
diff --git a/src/jalview/appletgui/IdCanvas.java b/src/jalview/appletgui/IdCanvas.java
index f7f1b20..0f5aad9 100755
--- a/src/jalview/appletgui/IdCanvas.java
+++ b/src/jalview/appletgui/IdCanvas.java
@@ -79,6 +79,9 @@ public class IdCanvas
                   ((i - starty) * charHeight) + ypos +
                   charHeight - (charHeight / 5));
 
+    if (av.hasHiddenRows && av.showHiddenMarkers)
+          drawMarker(i, starty, ypos);
+
   }
 
   public void fastPaint(int vertical)
@@ -163,23 +166,32 @@ public class IdCanvas
     gg.setFont(italic);
 
     gg.fillRect(0, 0, getSize().width, getSize().height);
-    drawIds(av.getStartSeq(), av.endSeq);
+    drawIds(av.startSeq, av.endSeq);
     g.drawImage(image, 0, 0, this);
   }
 
   void drawIds(int starty, int endy)
   {
+    Font italic = new Font(av.getFont().getName(), Font.ITALIC,
+                           av.getFont().getSize());
+
+    gg.setFont(italic);
+
     Color currentColor = Color.white;
     Color currentTextColor = Color.black;
-    Font italic = new Font(av.getFont().getName(), Font.ITALIC,
-                             av.getFont().getSize());
 
     if (av.getWrapAlignment())
     {
+      int maxwidth = av.alignment.getWidth();
+      int alheight = av.alignment.getHeight();
+
+      if (av.hasHiddenColumns)
+        maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
+
       int annotationHeight = 0;
       AnnotationLabels labels = null;
 
-      if(av.showAnnotation)
+      if (av.showAnnotation)
       {
         AnnotationPanel ap = new AnnotationPanel(av);
         annotationHeight = ap.adjustPanelHeight();
@@ -190,52 +202,61 @@ public class IdCanvas
       if (av.scaleAboveWrapped)
         hgap += av.charHeight;
 
-      int cHeight = av.getAlignment().getHeight() * av.charHeight
+      int cHeight = alheight * av.charHeight
           + hgap
           + annotationHeight;
 
-        int rowSize = av.getEndRes() - av.getStartRes();
+      int rowSize = av.getEndRes() - av.getStartRes();
 
-        // Draw the rest of the panels
-        for (int ypos = hgap, row = av.startRes;
-                (ypos <= getSize().height) && (row < av.alignment.getWidth());
-                ypos += cHeight, row += rowSize)
+      // Draw the rest of the panels
+      for (int ypos = hgap, row = av.startRes;
+           (ypos <= getSize().height) && (row < maxwidth);
+           ypos += cHeight, row += rowSize)
+      {
+        for (int i = starty; i < alheight; i++)
         {
-            for (int i = starty; i < av.alignment.getHeight(); i++)
-            {
-                SequenceI s = av.alignment.getSequenceAt(i);
-                gg.setFont(italic);
-                drawIdString(gg, s, i, 0, ypos);
-            }
-
-            if(labels!=null)
-            {
-              gg.translate(0, ypos+(av.getAlignment().getHeight() * av.charHeight));
-              labels.drawComponent(gg, getSize().width);
-              gg.translate(0, -ypos-(av.getAlignment().getHeight() * av.charHeight));
-            }
+          if (av.hasHiddenRows)
+          {
+            setHiddenFont(i);
+          }
+          else
+            gg.setFont(italic);
+
+          SequenceI s = av.alignment.getSequenceAt(i);
+          drawIdString(gg, s, i, 0, ypos);
         }
 
+        if (labels != null)
+        {
+          gg.translate(0, ypos + (alheight * av.charHeight));
+          labels.drawComponent(gg, getSize().width);
+          gg.translate(0, -ypos - (alheight * av.charHeight));
+        }
+
+      }
     }
     else
     {
+      //Now draw the id strings
 
       //Now draw the id strings
       for (int i = starty; i < endy; i++)
       {
-        // Selected sequence colours
+        if (av.hasHiddenRows)
+        {
+          setHiddenFont(i);
+        }
 
-        if (searchResults != null &&
+        // Selected sequence colours
+        if ( (searchResults != null) &&
             searchResults.contains(av.alignment.getSequenceAt(i)))
         {
-          gg.setColor(Color.black);
           currentColor = Color.black;
           currentTextColor = Color.white;
         }
-        else if (av.getSelectionGroup() != null
-                 &&
-                 av.getSelectionGroup().getSequences(false).contains(av.alignment.
-            getSequenceAt(i)))
+        else if ( (av.getSelectionGroup() != null) &&
+                 av.getSelectionGroup().getSequences(false).contains(
+                     av.alignment.getSequenceAt(i)))
         {
           currentColor = Color.lightGray;
           currentTextColor = Color.black;
@@ -248,24 +269,22 @@ public class IdCanvas
 
         gg.setColor(currentColor);
 
-        gg.fillRect(0,
-                    ((i - starty) * av.charHeight),
-                    getSize().width,
+        gg.fillRect(0, (i - starty) * av.charHeight, getSize().width,
                     av.charHeight);
 
         gg.setColor(currentTextColor);
 
-        gg.drawString(av.alignment.getSequenceAt(i)
-            .getDisplayId(av.getShowJVSuffix()), 0,
-                      ((i - starty) * av.charHeight) +
-                      av.charHeight - (av.charHeight / 5));
-      }
+        String string = av.alignment.getSequenceAt(i).getDisplayId(av.
+            getShowJVSuffix());
 
-      // add a border
-      gg.setColor(Color.white);
-      gg.fillRect(getSize().width - 4, 0, 4, getSize().height);
-    }
+        gg.drawString(string, 0,
+                      ( ( (i - starty) * av.charHeight) + av.charHeight) -
+                      (av.charHeight / 5));
 
+        if (av.hasHiddenRows && av.showHiddenMarkers)
+          drawMarker(i, starty, 0);
+      }
+    }
   }
 
   public void setHighlighted(java.util.Vector found)
@@ -273,4 +292,54 @@ public class IdCanvas
     searchResults = found;
     repaint();
   }
+
+  void drawMarker(int i, int starty, int yoffset)
+  {
+    int hiddenIndex = av.adjustForHiddenSeqs(i);
+    int lastIndex = av.adjustForHiddenSeqs(i - 1);
+    int nextIndex = av.adjustForHiddenSeqs(i + 1);
+
+    boolean below = (hiddenIndex > lastIndex + 1);
+    boolean above = (nextIndex>hiddenIndex+1);
+
+      gg.setColor(Color.blue);
+      if(below)
+      {
+        gg.fillPolygon(new int[]
+                       {getSize().width- av.charHeight,
+                       getSize().width- av.charHeight,
+                       getSize().width},
+                       new int[]
+                       {
+                       (i - starty) * av.charHeight +yoffset,
+                       (i - starty) * av.charHeight +yoffset+ av.charHeight / 4,
+                       (i - starty) * av.charHeight+yoffset
+        }, 3);
+      }
+      if(above)
+      {
+        gg.fillPolygon(new int[]
+                      {getSize().width- av.charHeight,
+                      getSize().width - av.charHeight,
+                      getSize().width },
+                      new int[]
+                      {
+                      (i - starty+1) * av.charHeight +yoffset,
+                      (i - starty+1) * av.charHeight +yoffset- av.charHeight / 4,
+                      (i - starty+1) * av.charHeight +yoffset
+       }, 3);
+
+      }
+  }
+
+  void setHiddenFont(int i)
+  {
+  /*  System.out.println(i+" "+av.alignment.getHeight());
+    if (av.alignment.getSequenceAt(i).getHiddenSequences() != null)
+      gg.setFont(new Font(av.getFont().getName(), Font.BOLD,
+                          av.getFont().getSize()));
+    else
+      gg.setFont(new Font(av.getFont().getName(), Font.ITALIC,
+                          av.getFont().getSize()));*/
+  }
 }
diff --git a/src/jalview/appletgui/IdPanel.java b/src/jalview/appletgui/IdPanel.java
index eab849b..27cbce1 100755
--- a/src/jalview/appletgui/IdPanel.java
+++ b/src/jalview/appletgui/IdPanel.java
@@ -50,12 +50,12 @@ public class IdPanel
     idCanvas.addMouseMotionListener(this);
 
     String label, url;
-    if(parent.alignFrame.applet!=null)
+    if(av.applet!=null)
     {
       for (int i = 1; i < 10; i++)
       {
-        label = parent.alignFrame.applet.getParameter("linkLabel_" + i);
-        url = parent.alignFrame.applet.getParameter("linkURL_" + i);
+        label = av.applet.getParameter("linkLabel_" + i);
+        url = av.applet.getParameter("linkURL_" + i);
 
         if (label != null && url != null)
           links.addElement(label + "|" + url);
diff --git a/src/jalview/appletgui/OverviewPanel.java b/src/jalview/appletgui/OverviewPanel.java
index a4b7f06..366f5bc 100755
--- a/src/jalview/appletgui/OverviewPanel.java
+++ b/src/jalview/appletgui/OverviewPanel.java
@@ -56,7 +56,7 @@ public class OverviewPanel
 
     sr = new SequenceRenderer(av);
     sr.graphics = nullFrame.getGraphics();
-    sr.renderGaps( false );
+    sr.renderGaps = false;
     sr.forOverview = true;
     fr = new FeatureRenderer(av);
     fr.overview = true;
@@ -124,9 +124,7 @@ public class OverviewPanel
   {
     boxX = evt.getX();
     boxY = evt.getY();
-
     checkValid();
-    repaint();
   }
 
   public void mouseReleased(MouseEvent evt)
@@ -134,8 +132,6 @@ public class OverviewPanel
     boxX = evt.getX();
     boxY = evt.getY();
     checkValid();
-    ap.setScrollValues( (int) (boxX / scalew / av.getCharWidth()),
-                         (int) (boxY / scaleh / av.getCharHeight()));
   }
 
   public void mouseDragged(MouseEvent evt)
@@ -143,10 +139,6 @@ public class OverviewPanel
     boxX = evt.getX();
     boxY = evt.getY();
     checkValid();
-    ap.setScrollValues( (int) (boxX / scalew / av.getCharWidth()),
-                         (int) (boxY / scaleh / av.getCharHeight()));
-
-    repaint();
     ap.repaint();
   }
 
@@ -154,23 +146,50 @@ public class OverviewPanel
   {
     if (boxY < 0)
     {
-      boxY = 0;
+        boxY = 0;
     }
 
-    if (boxY > sequencesHeight - boxHeight)
+    if (boxY > (sequencesHeight - boxHeight))
     {
-      boxY = sequencesHeight - boxHeight + 1;
+        boxY = sequencesHeight - boxHeight + 1;
     }
 
     if (boxX < 0)
     {
-      boxX = 0;
+        boxX = 0;
     }
 
-    if (boxX > width - boxWidth)
+    if (boxX > (width - boxWidth))
     {
+      if(av.hasHiddenColumns)
+      {
+        //Try smallest possible box
+        boxWidth = (int) ( (av.endRes - av.startRes + 1) *
+                               av.getCharWidth() * scalew);
+      }
       boxX = width - boxWidth;
     }
+
+    int col = (int) (boxX / scalew / av.getCharWidth());
+    int row = (int) (boxY / scaleh / av.getCharHeight());
+
+    if (av.hasHiddenColumns)
+    {
+      if (!av.getColumnSelection().isVisible(col))
+      {
+        return;
+      }
+
+      col = av.getColumnSelection().findColumnPosition(col);
+    }
+
+    if( av.hasHiddenRows )
+    {
+      row = av.alignment.getHiddenSequences().findIndexWithoutHiddenSeqs(row);
+    }
+
+    ap.setScrollValues( col, row );
+
   }
 
   /**
@@ -198,11 +217,10 @@ public class OverviewPanel
       sequencesHeight = getSize().height - graphHeight;
     }
     setSize(new Dimension(width, sequencesHeight + graphHeight));
-    setBoxPosition();
 
     Thread thread = new Thread(this);
     thread.start();
-        repaint();
+    repaint();
   }
 
   // This is set true if the user resizes whilst
@@ -217,10 +235,7 @@ public class OverviewPanel
 
     if (av.showSequenceFeatures)
     {
-      fr.renderOrder = ap.seqPanel.seqCanvas.getFeatureRenderer().renderOrder;
-      fr.featureGroups = ap.seqPanel.seqCanvas.getFeatureRenderer().featureGroups;
-      fr.featureColours = ap.seqPanel.seqCanvas.getFeatureRenderer().featureColours;
-      fr.sequenceFeatures = ap.seqPanel.seqCanvas.getFeatureRenderer().sequenceFeatures;
+      fr.transferSettings( ap.seqPanel.seqCanvas.getFeatureRenderer() );
     }
 
     if (getSize().width > 0 && getSize().height > 0)
@@ -243,57 +258,83 @@ public class OverviewPanel
     float sampleCol = (float) alwidth / (float) width;
     float sampleRow = (float) alheight / (float) sequencesHeight;
 
-    int lastcol=0, lastseq=0;
-    int xstart=0, ystart=0;
+    int lastcol=-1, lastrow=-1;
     Color color = Color.yellow;
-    int col, sameRow = 0, sameCol = 0;
-    jalview.datamodel.SequenceI sequence;
-
-    for (int row = 0; row <= sequencesHeight; row++)
+    int row, col, sameRow = 0, sameCol = 0;
+    jalview.datamodel.SequenceI seq;
+    boolean hiddenRow = false;
+    for (row = 0; row < sequencesHeight; row++)
     {
-      if((int)(row*sampleRow)==lastseq)
+      if((int)(row*sampleRow)==lastrow)
       {
         sameRow ++;
         continue;
       }
 
-      sequence = av.getAlignment().getSequenceAt(lastseq);
+      lastrow = (int)(row*sampleRow);
 
-      for (col = 0; col < width; col++)
+      hiddenRow = false;
+      if (av.hasHiddenRows)
       {
-        if((int)(col*sampleCol) == lastcol)
+        seq = av.alignment.getHiddenSequences().getHiddenSequence(lastrow);
+        if (seq == null)
         {
-          sameCol ++;
-          continue;
-        }
-
-        lastcol = (int)(col*sampleCol);
+          int index =
+             av.alignment.getHiddenSequences().findIndexWithoutHiddenSeqs(lastrow);
 
-        if(sequence.getLength()>lastcol)
-        {
-          color = sr.findSequenceColour(sequence, lastcol);
-
-          if (av.showSequenceFeatures)
-            color = fr.findFeatureColour(color,
-                                        sequence,
-                                        lastcol);
+         seq = av.alignment.getSequenceAt(index);
         }
         else
-          color = color.white;
-
-        mg.setColor(color);
-        if (sameCol == 1 && sameRow == 1)
-          mg.drawLine(xstart, ystart, xstart, ystart);
-        else
-          mg.fillRect(xstart, ystart, sameCol, sameRow);
-
-        xstart = col;
-        sameCol = 1;
+        {
+          hiddenRow = true;
+        }
       }
+      else
+        seq = av.alignment.getSequenceAt(lastrow);
 
+      if(seq==null)
+      {
+        System.out.println(lastrow+" null");
+        continue;
+      }
 
-      lastseq = (int)(row*sampleRow);
-      ystart = row;
+        for (col = 0; col < width; col++)
+        {
+          if ( (int) (col * sampleCol) == lastcol && (int) (row * sampleRow) == lastrow)
+          {
+            sameCol ++;
+            continue;
+          }
+
+          lastcol = (int) (col * sampleCol);
+
+          if (seq.getLength() > lastcol)
+          {
+            color = sr.getResidueBoxColour(
+                seq, lastcol);
+
+            if (av.showSequenceFeatures)
+              color = fr.findFeatureColour(color, seq, lastcol);
+          }
+          else
+          {
+            color = Color.white; //White
+          }
+
+          if (hiddenRow ||
+              (av.hasHiddenColumns && !av.getColumnSelection().isVisible(lastcol)))
+          {
+            color = color.darker().darker();
+          }
+
+          mg.setColor(color);
+          if (sameCol == 1 && sameRow == 1)
+            mg.drawLine(col, row, col, row);
+          else
+            mg.fillRect(col, row, col+sameCol, col+sameRow);
+
+          sameCol = 1;
+      }
       sameRow = 1;
     }
 
@@ -313,9 +354,6 @@ public class OverviewPanel
         }
       }
     }
-
-
-
     System.gc();
 
     resizing = false;
@@ -327,21 +365,50 @@ public class OverviewPanel
       resizeAgain = false;
       updateOverviewImage();
     }
-  }
+}
 
   public void setBoxPosition()
   {
     int fullsizeWidth = av.alignment.getWidth() * av.getCharWidth();
-    int fullsizeHeight = av.alignment.getHeight() * av.getCharHeight();
+    int fullsizeHeight = (av.alignment.getHeight()
+                          + av.alignment.getHiddenSequences().getSize()) *
+        av.getCharHeight();
+
+    int startRes = av.getStartRes();
+    int endRes = av.getEndRes();
+
+    if (av.hasHiddenColumns)
+    {
+      startRes = av.getColumnSelection().adjustForHiddenColumns(startRes);
+      endRes = av.getColumnSelection().adjustForHiddenColumns(endRes);
+    }
+
+    int startSeq = av.startSeq;
+    int endSeq = av.endSeq;
+
+    if (av.hasHiddenRows)
+    {
+      startSeq =
+          av.alignment.getHiddenSequences().adjustForHiddenSeqs(startSeq);
+
+      endSeq =
+          av.alignment.getHiddenSequences().adjustForHiddenSeqs(endSeq);
+
+    }
 
     scalew = (float) width / (float) fullsizeWidth;
     scaleh = (float) sequencesHeight / (float) fullsizeHeight;
 
-    boxX = (int) (av.getStartRes() * av.getCharWidth() * scalew);
-    boxY = (int) (av.getStartSeq() * av.getCharHeight() * scaleh);
-    boxWidth = (int) ( (av.getEndRes() - av.getStartRes() + 1) *
-                      av.getCharWidth() * scalew);
-    boxHeight = (int) (av.getEndSeq() * av.getCharHeight() * scaleh) - boxY;
+    boxX = (int) (startRes * av.getCharWidth() * scalew);
+    boxY = (int) (startSeq * av.getCharHeight() * scaleh);
+
+    if (av.hasHiddenColumns)
+      boxWidth = (int) ( (endRes - startRes + 1) * av.getCharWidth() * scalew);
+    else
+      boxWidth = (int) ( (endRes - startRes + 1) * av.getCharWidth() * scalew);
+
+    boxHeight = (int) ( (endSeq - startSeq) * av.getCharHeight() * scaleh);
+
     repaint();
   }
 
diff --git a/src/jalview/appletgui/PCAPanel.java b/src/jalview/appletgui/PCAPanel.java
index 6465ee8..6559a17 100755
--- a/src/jalview/appletgui/PCAPanel.java
+++ b/src/jalview/appletgui/PCAPanel.java
@@ -36,6 +36,7 @@ public class PCAPanel
   RotatableCanvas rc;
   AlignViewport av;
   SequenceI [] seqs;
+  AlignmentView seqstrings;
 
 
   public PCAPanel(AlignViewport av)
@@ -57,23 +58,28 @@ public class PCAPanel
     }
 
     this.av = av;
-    if (av.getSelectionGroup()!=null && av.getSelectionGroup().getSize(false) > 3)
+    seqstrings = av.getAlignmentView(av.getSelectionGroup()!=null);
+    if(av.getSelectionGroup()==null)
     {
-      seqs = new Sequence[av.getSelectionGroup().getSize(false)];
-      for (int i = 0; i < av.getSelectionGroup().getSize(false); i++)
-      {
-        seqs[i] = av.getSelectionGroup().getSequenceAt(i);
-      }
+      seqs = av.alignment.getSequencesArray();
     }
     else
     {
-      seqs = new Sequence[av.getAlignment().getHeight()];
-      for (int i = 0; i < av.getAlignment().getHeight(); i++)
+      seqs = av.getSelectionGroup().getSequencesInOrder(av.alignment);
+    }
+    SeqCigar sq[]=seqstrings.getSequences();
+    int length = sq[0].getWidth();
+
+    for (int i = 0; i < seqs.length; i++)
+    {
+      if (sq[i].getWidth() != length)
       {
-        seqs[i] = av.getAlignment().getSequenceAt(i);
+        System.out.println("Sequences must be equal length for PCA analysis");
+        return;
       }
     }
 
+
     rc = new RotatableCanvas(av);
     add(rc, BorderLayout.CENTER);
 
@@ -90,7 +96,7 @@ public class PCAPanel
    */
   public void run()
   {
-              pca = null;//new PCA(seqs);
+              pca = new PCA(seqstrings.getSequenceStrings(' '));
               pca.run();
 
               // Now find the component coordinates
@@ -158,7 +164,10 @@ public class PCAPanel
 
   public void actionPerformed(ActionEvent evt)
   {
-    values_actionPerformed();
+    if(evt.getSource()==inputData)
+      showOriginalData();
+    else
+      values_actionPerformed();
   }
 
   public void itemStateChanged(ItemEvent evt)
@@ -198,6 +207,28 @@ public class PCAPanel
       cap.setText(pca.getDetails());
   }
 
+  void showOriginalData()
+  {
+    // decide if av alignment is sufficiently different to original data to warrant a new window to be created
+    // create new alignmnt window with hidden regions (unhiding hidden regions yields unaligned seqs)
+    // or create a selection box around columns in alignment view
+    // test Alignment(SeqCigar[])
+    Object[] alAndColsel = seqstrings.getAlignmentAndColumnSelection(av.
+        getGapCharacter());
+
+
+    if (alAndColsel != null && alAndColsel[0]!=null)
+     {
+       Alignment al = new Alignment( (SequenceI[]) alAndColsel[0]);
+       AlignFrame af = new AlignFrame(al,
+             av.applet,
+             "Original Data for PCA",
+             false);
+
+      af.viewport.setHiddenColumns( (ColumnSelection) alAndColsel[1] );
+     }
+  }
+
   public void labels_itemStateChanged(ItemEvent itemEvent)
   {
     rc.showLabels( labels.getState() );
@@ -216,6 +247,7 @@ public class PCAPanel
   Menu menu2 = new Menu();
   protected CheckboxMenuItem labels = new CheckboxMenuItem();
   MenuItem values = new MenuItem();
+  MenuItem inputData = new MenuItem();
 
   private void jbInit()
       throws Exception
@@ -242,6 +274,7 @@ public class PCAPanel
     labels.addItemListener(this);
     values.setLabel("Output Values...");
     values.addActionListener(this);
+    inputData.setLabel("Input Data...");
     this.add(jPanel2, BorderLayout.SOUTH);
     jPanel2.add(jLabel1, null);
     jPanel2.add(xCombobox, null);
@@ -253,6 +286,8 @@ public class PCAPanel
     menuBar1.add(menu2);
     menu2.add(labels);
     menu1.add(values);
+    menu1.add(inputData);
+    inputData.addActionListener(this);
   }
 
 }
diff --git a/src/jalview/appletgui/PairwiseAlignPanel.java b/src/jalview/appletgui/PairwiseAlignPanel.java
index e58dd76..b8a15d5 100755
--- a/src/jalview/appletgui/PairwiseAlignPanel.java
+++ b/src/jalview/appletgui/PairwiseAlignPanel.java
@@ -42,21 +42,35 @@ public class PairwiseAlignPanel
     catch (Exception e)
     {
       e.printStackTrace();
-  }
+    }
     this.ap = ap;
-    float scores[][] = new float[ap.av.alignment.getHeight()][ap.av.alignment.
-        getHeight()];
+    sequences = new Vector();
+
+    SequenceI[] seqs;
+    String[] seqStrings = ap.av.getViewAsString(true);
+
+    if (ap.av.getSelectionGroup() == null)
+    {
+      seqs = ap.av.alignment.getSequencesArray();
+    }
+    else
+    {
+      seqs = ap.av.getSelectionGroup().getSequencesInOrder(ap.av.alignment);
+    }
+
+    float scores[][] = new float[seqs.length][seqs.length];
     double totscore = 0;
     int count = ap.av.getSelectionGroup().getSize(false);
 
     Sequence seq;
+
     for (int i = 1; i < count; i++)
     {
       for (int j = 0; j < i; j++)
       {
-        AlignSeq as = new AlignSeq(ap.av.getSelectionGroup().getSequenceAt(i),
-                                   ap.av.getSelectionGroup().getSequenceAt(j),
-                                   "pep");
+
+        AlignSeq as = new AlignSeq(seqs[i], seqStrings[i],
+                                   seqs[j], seqStrings[j], "pep");
 
         if (as.s1str.length() == 0 || as.s2str.length() == 0)
         {
@@ -65,29 +79,41 @@ public class PairwiseAlignPanel
 
         as.calcScoreMatrix();
         as.traceAlignment();
+
         as.printAlignment(System.out);
         scores[i][j] = (float) as.getMaxScore() / (float) as.getASeq1().length;
         totscore = totscore + scores[i][j];
 
         textarea.append(as.getOutput());
-
         seq = new Sequence(as.getS1().getName(),
                            as.getAStr1(),
-                           as.getS1().getStart(), as.getS1().getEnd()
+                           as.getS1().getStart(),
+                           as.getS1().getEnd()
             );
         sequences.addElement(seq);
 
         seq = new Sequence(as.getS2().getName(),
                            as.getAStr2(),
-                           as.getS2().getStart(), as.getS2().getEnd()
-            );
-
+                           as.getS2().getStart(),
+                           as.getS2().getEnd());
         sequences.addElement(seq);
       }
     }
 
     if (count > 2)
     {
+      System.out.println(
+          "Pairwise alignment scaled similarity score matrix\n");
+
+      for (int i = 0; i < count; i++)
+      {
+        jalview.util.Format.print(System.out, "%s \n",
+                                  ("" + i) + " " +
+                                  seqs[i].getName());
+      }
+
+      System.out.println("\n");
+
       for (int i = 0; i < count; i++)
       {
         for (int j = 0; j < i; j++)
@@ -96,9 +122,10 @@ public class PairwiseAlignPanel
                                     scores[i][j] / totscore);
         }
       }
+
+      System.out.println("\n");
     }
   }
-
   public void actionPerformed(ActionEvent evt)
   {
     if(evt.getSource()==viewInEditorButton)
@@ -116,7 +143,7 @@ public class PairwiseAlignPanel
     }
 
     new AlignFrame(new Alignment(seq),
-                                   ap.alignFrame.applet,
+                                   ap.av.applet,
                                    "Pairwise Aligned Sequences",
                                    false);
 
diff --git a/src/jalview/appletgui/ScalePanel.java b/src/jalview/appletgui/ScalePanel.java
index 8688486..f72ea7b 100755
--- a/src/jalview/appletgui/ScalePanel.java
+++ b/src/jalview/appletgui/ScalePanel.java
@@ -25,7 +25,7 @@ import java.awt.event.*;
 import jalview.datamodel.*;
 
 public class ScalePanel
-    extends Panel
+    extends Panel implements MouseMotionListener, MouseListener
 {
 
   protected int offy = 4;
@@ -35,6 +35,10 @@ public class ScalePanel
   AlignmentPanel ap;
 
   boolean stretchingGroup = false;
+  int min; //used by mouseDragged to see if user
+  int max; //used by mouseDragged to see if user
+  boolean mouseDragging = false;
+  int [] reveal;
 
   public ScalePanel(AlignViewport av, AlignmentPanel ap)
   {
@@ -42,45 +46,96 @@ public class ScalePanel
     this.av = av;
     this.ap = ap;
 
-    addMouseListener(new MouseAdapter()
+    addMouseListener(this);
+    addMouseMotionListener(this);
+
+  }
+
+  public void mousePressed(MouseEvent evt)
+  {
+    int x = (evt.getX() / av.getCharWidth()) + av.getStartRes();
+    final int res;
+
+    if (av.hasHiddenColumns)
+      res = av.getColumnSelection().adjustForHiddenColumns(x);
+    else
+      res = x;
+
+    min = res;
+    max = res;
+    if (reveal != null
+        && (evt.getModifiers() & InputEvent.BUTTON3_MASK)
+        == InputEvent.BUTTON3_MASK)
     {
-      public void mousePressed(MouseEvent evt)
-      {
-        doMousePressed(evt);
-      }
 
-      public void mouseReleased(MouseEvent evt)
+      MenuItem item = new MenuItem("Reveal");
+      item.addActionListener(new ActionListener()
       {
-        doMouseReleased(evt);
-      }
+        public void actionPerformed(ActionEvent e)
+        {
+          av.showColumn(reveal[0]);
+          reveal = null;
+          ap.repaint();
+          if (ap.overviewPanel != null)
+            ap.overviewPanel.updateOverviewImage();
+        }
+      });
+      PopupMenu pop = new PopupMenu();
+      pop.add(item);
 
-    });
-    addMouseMotionListener(new MouseMotionAdapter()
-    {
-      public void mouseDragged(MouseEvent evt)
+      if (av.getColumnSelection().getHiddenColumns().size() > 1)
       {
-        doMouseDragged(evt);
+        item = new MenuItem("Reveal All");
+        item.addActionListener(new ActionListener()
+        {
+          public void actionPerformed(ActionEvent e)
+          {
+            av.showAllHiddenColumns();
+            reveal = null;
+            ap.repaint();
+            if (ap.overviewPanel != null)
+              ap.overviewPanel.updateOverviewImage();
+          }
+        });
+        pop.add(item);
       }
-    });
-
-  }
-
-  public void doMousePressed(MouseEvent evt)
-  {
-    int x = evt.getX();
-    int res = x / av.getCharWidth() + av.getStartRes();
-    SequenceGroup sg = null;
 
+      this.add(pop);
+      pop.show(this, evt.getX(), evt.getY());
 
-    if (av.getColumnSelection().contains(res))
+    }
+    else if (av.getColumnSelection().contains(res))
     {
-      av.getColumnSelection().removeElement(res);
+      if ( (evt.getModifiers() & InputEvent.BUTTON3_MASK)
+          == InputEvent.BUTTON3_MASK)
+      {
+        MenuItem item = new MenuItem("Hide Columns");
+        item.addActionListener(new ActionListener()
+        {
+          public void actionPerformed(ActionEvent e)
+          {
+            av.hideColumns(res, res);
+            ap.repaint();
+            if (ap.overviewPanel != null)
+              ap.overviewPanel.updateOverviewImage();
+          }
+        });
+        PopupMenu pop = new PopupMenu();
+        pop.add(item);
+        this.add(pop);
+        pop.show(this, evt.getX(), evt.getY());
+      }
+      else
+      {
+        av.getColumnSelection().removeElement(res);
+        av.setSelectionGroup(null);
+      }
     }
     else
     {
       av.getColumnSelection().addElement(res);
+      SequenceGroup sg = new SequenceGroup();
 
-      sg = new SequenceGroup();
       for (int i = 0; i < av.alignment.getSequences().size(); i++)
       {
         sg.addSequence(av.alignment.getSequenceAt(i), false);
@@ -88,76 +143,151 @@ public class ScalePanel
 
       sg.setStartRes(res);
       sg.setEndRes(res);
-
-      ap.annotationPanel.addEditableColumn(res);
+      av.setSelectionGroup(sg);
     }
-    av.setSelectionGroup(sg);
     ap.repaint();
   }
 
-  public void doMouseReleased(MouseEvent evt)
+  public void mouseReleased(MouseEvent evt)
   {
-    if (!stretchingGroup)
-    {
-      return;
-    }
+    mouseDragging = false;
 
-    int x = evt.getX();
-    int res = x / av.getCharWidth() + av.getStartRes();
+    int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
 
     if(res> av.alignment.getWidth())
     {
       res = av.alignment.getWidth()-1;
     }
 
-    if (!av.getColumnSelection().contains(res))
+    if(av.hasHiddenColumns)
+      res = av.getColumnSelection().adjustForHiddenColumns(res);
+
+    if (!stretchingGroup)
     {
-      av.getColumnSelection().addElement(res);
+        ap.repaint();
+
+        return;
     }
 
     SequenceGroup sg = av.getSelectionGroup();
 
     if (res > sg.getStartRes())
     {
-      sg.setEndRes(res);
+        sg.setEndRes(res);
     }
     else if (res < sg.getStartRes())
     {
-      sg.setStartRes(res);
+        sg.setStartRes(res);
     }
 
     stretchingGroup = false;
     ap.repaint();
   }
 
-  public void doMouseDragged(MouseEvent evt)
+  public void mouseDragged(MouseEvent evt)
   {
-    int x = evt.getX();
-    int res = x / av.getCharWidth() + av.getStartRes();
+    mouseDragging = true;
 
-    if(res> av.alignment.getWidth())
+    int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
+    if (res < 0)
+      res = 0;
+
+    if (av.hasHiddenColumns)
+      res = av.getColumnSelection().adjustForHiddenColumns(res);
+
+    if (res > av.alignment.getWidth())
     {
-      res = av.alignment.getWidth()-1;
+      res = av.alignment.getWidth() - 1;
+    }
+
+    if (res < min)
+    {
+      min = res;
+    }
+
+    if (res > max)
+    {
+      max = res;
     }
 
     SequenceGroup sg = av.getSelectionGroup();
+
     if (sg != null)
     {
       stretchingGroup = true;
+
+      if (!av.getColumnSelection().contains(res))
+      {
+        av.getColumnSelection().addElement(res);
+      }
+
       if (res > sg.getStartRes())
       {
         sg.setEndRes(res);
       }
-      else if (res < sg.getStartRes())
+      if (res < sg.getStartRes())
       {
         sg.setStartRes(res);
       }
 
-      ap.annotationPanel.addEditableColumn(res);
+      for (int i = min; i <= max; i++)
+      {
+        if ( (i < sg.getStartRes()) || (i > sg.getEndRes()))
+        {
+          av.getColumnSelection().removeElement(i);
+        }
+        else
+        {
+          av.getColumnSelection().addElement(i);
+        }
+      }
+
       ap.repaint();
     }
   }
 
+
+  public void mouseEntered(MouseEvent evt)
+  {
+    if (mouseDragging)
+      ap.seqPanel.scrollCanvas(null);
+  }
+
+  public void mouseExited(MouseEvent evt)
+  {
+    if (mouseDragging)
+      ap.seqPanel.scrollCanvas(evt);
+  }
+
+  public void mouseClicked(MouseEvent evt)
+  {
+
+  }
+
+  public void mouseMoved(MouseEvent evt)
+  {
+    if (!av.hasHiddenColumns)
+      return;
+
+    int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
+
+    res = av.getColumnSelection().adjustForHiddenColumns(res);
+
+    reveal = null;
+    for (int i = 0; i < av.getColumnSelection().getHiddenColumns().size(); i++)
+    {
+      int[] region = (int[]) av.getColumnSelection().getHiddenColumns().
+          elementAt(i);
+      if (res + 1 == region[0] || res - 1 == region[1])
+      {
+        reveal = region;
+        break;
+      }
+    }
+
+    repaint();
+  }
+
   public void update(Graphics g)
   {
     paint(g);
@@ -175,6 +305,7 @@ public class ScalePanel
   {
     gg.setFont(av.getFont());
 
+
     //Fill in the background
     gg.setColor(Color.white);
     gg.fillRect(0, 0, width, height);
@@ -183,26 +314,32 @@ public class ScalePanel
     //Fill the selected columns
     ColumnSelection cs = av.getColumnSelection();
     gg.setColor(new Color(220, 0, 0));
+
     for (int i = 0; i < cs.size(); i++)
     {
-      int sel = cs.columnAt(i);
-      if (sel >= startx && sel <= endx)
-      {
-        gg.fillRect( (sel - startx) * av.charWidth, 0, av.charWidth,
-                    getSize().height);
-      }
+        int sel = cs.columnAt(i);
+        if(av.hasHiddenColumns)
+          sel = av.getColumnSelection().findColumnPosition(sel);
+
+
+        if ((sel >= startx) && (sel <= endx))
+        {
+            gg.fillRect((sel - startx) * av.charWidth, 0, av.charWidth,
+                getSize().height);
+        }
     }
 
     // Draw the scale numbers
     gg.setColor(Color.black);
+
     int scalestartx = (startx / 10) * 10;
 
     FontMetrics fm = gg.getFontMetrics(av.getFont());
     int y = av.charHeight - fm.getDescent();
 
-    if (scalestartx % 10 == 0)
+    if ((scalestartx % 10) == 0)
     {
-      scalestartx += 5;
+        scalestartx += 5;
     }
 
     String string;
@@ -210,30 +347,67 @@ public class ScalePanel
 
     for (int i = scalestartx; i < endx; i += 5)
     {
-      if (i % 10 == 0)
-      {
-        string = String.valueOf(i);
-        if ( (i - startx - 1) * av.charWidth > maxX)
+        if ((i % 10) == 0)
+        {
+            string = String.valueOf(av.getColumnSelection().adjustForHiddenColumns(i));
+            if ( (i - startx - 1) * av.charWidth > maxX)
+            {
+              gg.drawString(string,
+                            (i - startx - 1) * av.charWidth, y);
+              maxX = (i - startx + 1) * av.charWidth + fm.stringWidth(string);
+            }
+
+            gg.drawLine( (int) ( ( (i - startx - 1) * av.charWidth) +
+                                (av.charWidth / 2)), y + 2,
+                        (int) ( ( (i - startx - 1) * av.charWidth) +
+                               (av.charWidth / 2)),
+                        y + (fm.getDescent() * 2));
+
+        }
+        else
         {
-          gg.drawString(string,
-                        (i - startx - 1) * av.charWidth, y);
-          maxX = (i - startx + 1) * av.charWidth + fm.stringWidth(string);
+            gg.drawLine((int) (((i - startx - 1) * av.charWidth) +
+                (av.charWidth / 2)), y + fm.getDescent(),
+                (int) (((i - startx - 1) * av.charWidth) +
+                (av.charWidth / 2)), y + (fm.getDescent() * 2));
         }
+    }
 
-        gg.drawLine( (int) ( (i - startx - 1) * av.charWidth + av.charWidth / 2),
-                    y + 2,
-                    (int) ( (i - startx - 1) * av.charWidth + av.charWidth / 2),
-                    y + fm.getDescent() * 2);
-      }
-      else
+    if (av.hasHiddenColumns)
+    {
+      gg.setColor(Color.blue);
+      int res;
+      if(av.getShowHiddenMarkers())
       {
-        gg.drawLine( (int) ( (i - startx - 1) * av.charWidth + av.charWidth / 2),
-                    y + fm.getDescent(),
-                    (int) ( (i - startx - 1) * av.charWidth + av.charWidth / 2),
-                    y + fm.getDescent() * 2);
+        for (int i = 0; i < av.getColumnSelection().getHiddenColumns().size();
+             i++)
+        {
+
+          res = av.getColumnSelection().findHiddenRegionPosition(i) -
+              startx;
+
+          if(res < 0 || res > endx-scalestartx)
+            continue;
+
+          gg.fillPolygon(new int[]
+                         {res * av.charWidth - av.charHeight / 4,
+                         res * av.charWidth + av.charHeight / 4,
+                         res * av.charWidth},
+                         new int[]
+                         {
+                         y - av.charHeight / 2, y - av.charHeight / 2,
+                         y + 8
+          }, 3);
+
+        }
       }
 
+      if (reveal != null && reveal[0] > startx && reveal[0] < endx)
+      {
+        gg.drawString("Reveal Columns", reveal[0] * av.charWidth, 0);
+      }
     }
+
   }
 
 }
diff --git a/src/jalview/appletgui/SeqCanvas.java b/src/jalview/appletgui/SeqCanvas.java
index 980be96..e947f7a 100755
--- a/src/jalview/appletgui/SeqCanvas.java
+++ b/src/jalview/appletgui/SeqCanvas.java
@@ -83,14 +83,17 @@ public class SeqCanvas
     // NORTH SCALE
     for (int i = scalestartx; i < endx; i += 10)
     {
-      String string = String.valueOf(i);
-      g.drawString(string, (i - startx - 1) * av.charWidth,
-                   ypos - av.charHeight / 2);
+      int value = i;
+      if(av.hasHiddenColumns)
+          value = av.getColumnSelection().adjustForHiddenColumns(value);
 
-      g.drawLine( (i - startx - 1) * av.charWidth + av.charWidth / 2,
-                 ypos + 2 - av.charHeight / 2,
-                 (i - startx - 1) * av.charWidth + av.charWidth / 2, ypos - 2);
+      g.drawString( String.valueOf(value), (i - startx - 1) * av.charWidth,
+          ypos - (av.charHeight / 2));
 
+      g.drawLine(((i - startx - 1) * av.charWidth) + (av.charWidth / 2),
+          (ypos + 2) - (av.charHeight / 2),
+          ((i - startx - 1) * av.charWidth) + (av.charWidth / 2), ypos -
+                2);
     }
   }
 
@@ -98,60 +101,82 @@ public class SeqCanvas
   {
     FontMetrics fm = getFontMetrics(av.getFont());
     ypos += av.charHeight;
-    // EAST SCALE
-    for (int i = 0; i < av.alignment.getHeight(); i++)
+    if (av.hasHiddenColumns)
     {
-      SequenceI seq = av.alignment.getSequenceAt(i);
-      int index = startx;
-      int value = -1;
-      while (index < endx)
+      startx = av.getColumnSelection().adjustForHiddenColumns(startx);
+      endx = av.getColumnSelection().adjustForHiddenColumns(endx);
+    }
+
+    int maxwidth = av.alignment.getWidth();
+    if (av.hasHiddenColumns)
+        maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
+
+      // WEST SCALE
+      for (int i = 0; i < av.alignment.getHeight(); i++)
       {
-        if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
+        SequenceI seq = av.alignment.getSequenceAt(i);
+        int index = startx;
+        int value = -1;
+
+        while (index < endx)
         {
-          index++;
-          continue;
+          if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
+          {
+            index++;
+
+            continue;
+          }
+
+          value = av.alignment.getSequenceAt(i).findPosition(index);
+
+          break;
         }
 
-        value = av.alignment.getSequenceAt(i).findPosition(index);
-        break;
-      }
-      if (value != -1)
-      {
-        int x = LABEL_WEST - fm.stringWidth(String.valueOf(value))-av.charWidth/2;
-        g.drawString(value + "", x,
-                     ypos + i * av.charHeight - av.charHeight / 5);
+        if (value != -1)
+        {
+          int x = LABEL_WEST - fm.stringWidth(String.valueOf(value)) -
+              av.charWidth / 2;
+          g.drawString(value + "", x,
+                       (ypos + (i * av.charHeight)) - (av.charHeight / 5));
+        }
       }
     }
-  }
-
   void drawEastScale(Graphics g, int startx, int endx, int ypos)
   {
-    ypos += av.charHeight;
-    // EAST SCALE
-    for (int i = 0; i < av.alignment.getHeight(); i++)
-    {
-      SequenceI seq = av.alignment.getSequenceAt(i);
-      int index = endx;
-      int value = -1;
-      while (index > startx)
-      {
-        if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
+        ypos += av.charHeight;
+
+        if(av.hasHiddenColumns)
+                endx = av.getColumnSelection().adjustForHiddenColumns(endx);
+
+        SequenceI seq;
+        // EAST SCALE
+        for (int i = 0; i < av.alignment.getHeight(); i++)
         {
-          index--;
-          continue;
-        }
+            seq = av.alignment.getSequenceAt(i);
+            int index = endx;
+            int value = -1;
 
-        value = seq.findPosition(index);
-        break;
-      }
-      if (value != -1)
-      {
-        g.drawString(value + "", av.charWidth/2,
-                     ypos + i * av.charHeight - av.charHeight / 5);
-      }
-    }
+            while (index > startx)
+            {
+                if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
+                {
+                    index--;
 
-  }
+                    continue;
+                }
+
+                value = seq.findPosition(index);
+
+                break;
+            }
+
+            if (value != -1)
+            {
+                g.drawString(String.valueOf(value), 0,
+                    (ypos + (i * av.charHeight)) - (av.charHeight / 5));
+            }
+        }
+    }
 
   int lastsr=0;
   void fastPaint(int horizontal, int vertical)
@@ -371,14 +396,18 @@ public class SeqCanvas
     int endx;
     int ypos = hgap;
 
+    int maxwidth = av.alignment.getWidth();
+
+    if(av.hasHiddenColumns)
+          maxwidth = av.getColumnSelection().findColumnPosition(maxwidth)-1;
 
-    while ((ypos <= canvasHeight) && (startRes < av.alignment.getWidth()))
+    while ((ypos <= canvasHeight) && (startRes < maxwidth))
     {
       endx = startRes + cWidth -1;
 
-      if (endx > al.getWidth())
+      if (endx > maxwidth)
       {
-        endx = al.getWidth();
+        endx = maxwidth;
       }
 
         g.setColor(Color.black);
@@ -399,7 +428,33 @@ public class SeqCanvas
 
         if (av.scaleAboveWrapped)
         {
-            drawNorthScale(g, startRes, endx, ypos);
+          drawNorthScale(g, startRes, endx, ypos);
+        }
+        if (av.hasHiddenColumns && av.showHiddenMarkers)
+        {
+          g.setColor(Color.blue);
+          int res;
+          for (int i = 0; i < av.getColumnSelection().getHiddenColumns().size();
+               i++)
+          {
+            res = av.getColumnSelection().findHiddenRegionPosition(i) -
+                startRes;
+
+            if (res < 0 || res > endx - startRes)
+              continue;
+
+            gg.fillPolygon(new int[]
+                           {res * av.charWidth - av.charHeight / 4,
+                           res * av.charWidth + av.charHeight / 4,
+                           res * av.charWidth},
+                           new int[]
+                           {
+                           ypos - (av.charHeight / 2),
+                           ypos - (av.charHeight / 2),
+                           ypos - (av.charHeight / 2) + 8
+            }, 3);
+
+          }
         }
 
         if(g.getClip()==null)
@@ -440,212 +495,290 @@ public class SeqCanvas
     return annotations.adjustPanelHeight();
     }
 
-  void drawPanel(Graphics g, int startRes, int endRes, int startSeq, int endSeq, int offset)
-  {
-    g.setFont(av.getFont());
-    sr.renderGaps(av.renderGaps);
+    void drawPanel(Graphics g1, int startRes, int endRes,
+                    int startSeq, int endSeq, int offset)
+    {
+      if(!av.hasHiddenColumns)
+      {
+        draw(g1, startRes, endRes, startSeq, endSeq, offset);
+      }
+      else
+      {
+        java.util.Vector regions = av.getColumnSelection().getHiddenColumns();
 
-    SequenceI nextSeq;
-    /// First draw the sequences
-  /////////////////////////////
-  for (int i = startSeq; i < endSeq; i++)
-  {
-    nextSeq = av.alignment.getSequenceAt(i);
+        int screenY = 0;
+        int blockStart = startRes;
+        int blockEnd = endRes;
+
+        for (int i = 0; i < regions.size(); i++)
+        {
+          int[] region = (int[]) regions.elementAt(i);
+          int hideStart = region[0];
+          int hideEnd = region[1];
 
-    sr.drawSequence(g, nextSeq, av.alignment.findAllGroups(nextSeq), startRes, endRes,
-                    offset + ( (i - startSeq) * av.charHeight));
+          if (hideStart <= blockStart)
+          {
+            blockStart += (hideEnd - hideStart) + 1;
+            continue;
+          }
 
-    if (av.showSequenceFeatures)
-    {
-      fr.drawSequence(g, nextSeq, startRes, endRes,
-                      offset + ((i - startSeq) * av.charHeight),
-                      av.charWidth, av.charHeight);
-    }
-    /// Highlight search Results once all sequences have been drawn
-   //////////////////////////////////////////////////////////
-   if (searchResults != null)
-   {
-     int[] visibleResults = searchResults.getResults(nextSeq, startRes, endRes);
-     if (visibleResults != null)
-       for (int r = 0; r < visibleResults.length; r += 2)
-       {
-         sr.drawHighlightedText(nextSeq, visibleResults[r],
-                                visibleResults[r + 1],
-                                (visibleResults[r] - startRes) * av.charWidth,
-                                offset + ( (i - startSeq) * av.charHeight),
-                                av.charWidth, av.charHeight);
-       }
-   }
+          blockEnd = hideStart - 1;
 
-   if (av.cursorMode && cursorY == i
-       && cursorX >= startRes && cursorX <= endRes)
-   {
-     sr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * av.charWidth,
-                   offset + ( (i - startSeq) * av.charHeight));
-   }
+          g1.translate(screenY * av.charWidth, 0);
 
-  }
+          draw(g1, blockStart, blockEnd, startSeq, endSeq, offset);
 
-  //
-  /////////////////////////////////////
-  // Now outline any areas if necessary
-  /////////////////////////////////////
-  SequenceGroup group = av.getSelectionGroup();
+          if(av.getShowHiddenMarkers())
+          {
+            g1.setColor(Color.blue);
+            g1.drawLine( (blockEnd - blockStart + 1) * av.charWidth - 1,
+                        startSeq + offset,
+                        (blockEnd - blockStart + 1) * av.charWidth - 1,
+                        startSeq + (endSeq - startSeq) * av.charHeight + offset);
+          }
 
-  int sx = -1;
-  int sy = -1;
-  int ex = -1;
-  int groupIndex = -1;
+          g1.translate( -screenY * av.charWidth, 0);
+          screenY += blockEnd - blockStart + 1;
+          blockStart = hideEnd + 1;
+        }
 
-  if ((group == null) && (av.alignment.getGroups().size() > 0))
-  {
-      group = (SequenceGroup) av.alignment.getGroups().elementAt(0);
-      groupIndex = 0;
-  }
+        if (screenY <= (endRes - startRes))
+        {
+          blockEnd = blockStart + (endRes - startRes) - screenY;
+          g1.translate(screenY * av.charWidth, 0);
+          draw(g1, blockStart, blockEnd, startSeq, endSeq, offset);
 
-  if ( group != null )
-  {
-      do
-      {
-          int oldY = -1;
-          int i = 0;
-          boolean inGroup = false;
-          int top = -1;
-          int bottom = -1;
-          int alHeight = av.alignment.getHeight()-1;
-
-          for (i = startSeq; i < endSeq; i++)
-          {
-              sx = (group.getStartRes() - startRes) * av.charWidth;
-              sy = offset + ((i - startSeq) * av.charHeight);
-              ex = (((group.getEndRes() + 1) - group.getStartRes()) * av.charWidth) -
-                  1;
-
-              if(sx+ex<0 || sx>imgWidth)
-              {
-                continue;
-              }
-
-              if ( (sx <= (endRes-startRes)*av.charWidth) &&
-                      group.getSequences(false).contains(av.alignment.getSequenceAt(
-                              i)))
-              {
-                if ( (bottom == -1) &&
-                    (i >= alHeight ||
-                     !group.getSequences(false).contains(
-                         av.alignment.getSequenceAt(i + 1))))
-                {
-                    bottom = sy + av.charHeight;
-                }
+          g1.translate( -screenY * av.charWidth, 0);
+        }
+      }
 
-                  if (!inGroup)
-                  {
-                      if (((top == -1) && (i == 0)) ||
-                              !group.getSequences(false).contains(
-                                  av.alignment.getSequenceAt(i - 1)))
-                      {
-                          top = sy;
-                      }
-
-                      oldY = sy;
-                      inGroup = true;
-
-                      if (group == av.getSelectionGroup())
-                      {
-                          g.setColor(Color.red);
-                      }
-                      else
-                      {
-                          g.setColor(group.getOutlineColour());
-                      }
-                  }
-              }
-              else
-              {
-                if (inGroup)
-                {
-                  if (sx >= 0 && sx < imgWidth)
-                    g.drawLine(sx, oldY, sx, sy);
-
-                  if (sx + ex < imgWidth)
-                    g.drawLine(sx + ex, oldY, sx + ex, sy);
-
-                  if (sx < 0)
-                  {
-                    ex += sx;
-                    sx = 0;
-                  }
-
-                  if (sx + ex > imgWidth)
-                    ex = imgWidth;
-
-                  else if (sx + ex >= (endRes - startRes + 1) * av.charWidth)
-                    ex = (endRes - startRes + 1) * av.charWidth;
-
-                  if (top != -1)
-                  {
-                    g.drawLine(sx, top, sx + ex, top);
-                    top = -1;
-                  }
-
-                  if (bottom != -1)
-                  {
-                    g.drawLine(sx, bottom, sx + ex, bottom);
-                    bottom = -1;
-                  }
-
-                  inGroup = false;
-                  }
-              }
-          }
+    }
 
-          if (inGroup)
-          {
-            sy = offset + ( (i - startSeq) * av.charHeight);
-            if (sx >= 0 && sx < imgWidth)
-              g.drawLine(sx, oldY, sx, sy);
 
-            if (sx + ex < imgWidth)
-              g.drawLine(sx + ex, oldY, sx + ex, sy);
 
-            if (sx < 0)
-            {
-              ex += sx;
-              sx = 0;
-            }
 
-            if (sx + ex > imgWidth)
-              ex = imgWidth;
-            else if (sx + ex >= (endRes - startRes + 1) * av.charWidth)
-              ex = (endRes - startRes + 1) * av.charWidth;
+    //int startRes, int endRes, int startSeq, int endSeq, int x, int y,
+    // int x1, int x2, int y1, int y2, int startx, int starty,
+    void draw(Graphics g,
+                   int startRes, int endRes,
+                   int startSeq, int endSeq,
+                   int offset)
+   {
+      g.setFont(av.getFont());
+      sr.prepare(g, av.renderGaps);
+
+      SequenceI nextSeq;
 
-            if (top != -1)
+        /// First draw the sequences
+        /////////////////////////////
+        for (int i = startSeq; i < endSeq; i++)
+        {
+            nextSeq = av.alignment.getSequenceAt(i);
+
+            sr.drawSequence(nextSeq, av.alignment.findAllGroups(nextSeq),
+                            startRes, endRes,
+                            offset + ( (i - startSeq) * av.charHeight));
+
+            if (av.showSequenceFeatures)
             {
-              g.drawLine(sx, top, sx + ex, top);
-              top = -1;
+                fr.drawSequence(g, nextSeq, startRes, endRes,
+                    offset + ((i - startSeq) * av.charHeight));
             }
 
-            if (bottom != -1)
+            /// Highlight search Results once all sequences have been drawn
+            //////////////////////////////////////////////////////////
+            if (searchResults != null)
             {
-              g.drawLine(sx, bottom - 1, sx + ex, bottom - 1);
-              bottom = -1;
+              int[] visibleResults = searchResults.getResults(nextSeq, startRes, endRes);
+              if (visibleResults != null)
+                for (int r = 0; r < visibleResults.length; r += 2)
+                {
+                  sr.drawHighlightedText(nextSeq, visibleResults[r],
+                                         visibleResults[r + 1],
+                                         (visibleResults[r] - startRes) * av.charWidth,
+                                         offset + ( (i - startSeq) * av.charHeight));
+                }
             }
 
-              inGroup = false;
+            if(av.cursorMode && cursorY==i
+               && cursorX>=startRes && cursorX<=endRes)
+            {
+              sr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * av.charWidth,
+                            offset + ( (i - startSeq) * av.charHeight));
+            }
           }
 
-          groupIndex++;
+          if(av.getSelectionGroup()!=null || av.alignment.getGroups().size()>0)
+            drawGroupsBoundaries(g, startRes, endRes, startSeq, endSeq, offset);
 
-          if (groupIndex >= av.alignment.getGroups().size())
-          {
-              break;
-          }
+   }
 
-          group = (SequenceGroup) av.alignment.getGroups().elementAt(groupIndex);
-      }
-      while (groupIndex < av.alignment.getGroups().size());
-    }
-  }
+   void drawGroupsBoundaries(Graphics g,
+                   int startRes, int endRes,
+                   int startSeq, int endSeq,
+                   int offset)
+   {
+     //
+     /////////////////////////////////////
+     // Now outline any areas if necessary
+     /////////////////////////////////////
+     SequenceGroup group = av.getSelectionGroup();
+
+     int sx = -1;
+     int sy = -1;
+     int ex = -1;
+     int groupIndex = -1;
+
+     if ( (group == null) && (group.getSize(false) > 0))
+     {
+       group = (SequenceGroup) av.alignment.getGroups().elementAt(0);
+       groupIndex = 0;
+     }
+
+     if (group != null)
+     {
+       do
+       {
+         int oldY = -1;
+         int i = 0;
+         boolean inGroup = false;
+         int top = -1;
+         int bottom = -1;
+         int alHeight = av.alignment.getHeight()-1;
+
+         for (i = startSeq; i < endSeq; i++)
+         {
+           sx = (group.getStartRes() - startRes) * av.charWidth;
+           sy = offset + ( (i - startSeq) * av.charHeight);
+           ex = ( ( (group.getEndRes() + 1) - group.getStartRes()) * av.charWidth) -
+               1;
+
+           if (sx + ex < 0 || sx > imgWidth)
+           {
+             continue;
+           }
+
+           if ( (sx <= (endRes - startRes) * av.charWidth) &&
+               group.getSequences(false).
+               contains(av.alignment.getSequenceAt(i)))
+           {
+             if ( (bottom == -1) &&
+             (i >= alHeight ||
+                 !group.getSequences(false).contains(
+                     av.alignment.getSequenceAt(i + 1))))
+             {
+               bottom = sy + av.charHeight;
+             }
+
+             if (!inGroup)
+             {
+               if ( ( (top == -1) && (i == 0)) ||
+                   !group.getSequences(false).contains(
+                       av.alignment.getSequenceAt(i - 1)))
+               {
+                 top = sy;
+               }
+
+               oldY = sy;
+               inGroup = true;
+
+               if (group == av.getSelectionGroup())
+               {
+                 g.setColor(Color.red);
+               }
+               else
+               {
+                 g.setColor(group.getOutlineColour());
+               }
+             }
+           }
+           else
+           {
+             if (inGroup)
+             {
+               if (sx >= 0 && sx < imgWidth)
+                 g.drawLine(sx, oldY, sx, sy);
+
+               if (sx + ex < imgWidth)
+                 g.drawLine(sx + ex, oldY, sx + ex, sy);
+
+               if (sx < 0)
+               {
+                 ex += sx;
+                 sx = 0;
+               }
+
+               if (sx + ex > imgWidth)
+                 ex = imgWidth;
+
+               else if (sx + ex >= (endRes - startRes + 1) * av.charWidth)
+                 ex = (endRes - startRes + 1) * av.charWidth;
+
+               if (top != -1)
+               {
+                 g.drawLine(sx, top, sx + ex, top);
+                 top = -1;
+               }
+
+               if (bottom != -1)
+               {
+                 g.drawLine(sx, bottom, sx + ex, bottom);
+                 bottom = -1;
+               }
+
+               inGroup = false;
+             }
+           }
+         }
+
+         if (inGroup)
+         {
+           sy = offset + ( (i - startSeq) * av.charHeight);
+           if (sx >= 0 && sx < imgWidth)
+             g.drawLine(sx, oldY, sx, sy);
+
+           if (sx + ex < imgWidth)
+             g.drawLine(sx + ex, oldY, sx + ex, sy);
+
+           if (sx < 0)
+           {
+             ex += sx;
+             sx = 0;
+           }
+
+           if (sx + ex > imgWidth)
+             ex = imgWidth;
+           else if (sx + ex >= (endRes - startRes + 1) * av.charWidth)
+             ex = (endRes - startRes + 1) * av.charWidth;
+
+           if (top != -1)
+           {
+             g.drawLine(sx, top, sx + ex, top);
+             top = -1;
+           }
+
+           if (bottom != -1)
+           {
+             g.drawLine(sx, bottom - 1, sx + ex, bottom - 1);
+             bottom = -1;
+           }
+
+           inGroup = false;
+         }
+
+         groupIndex++;
+
+         if (groupIndex >= av.alignment.getGroups().size())
+         {
+           break;
+         }
+
+         group = (SequenceGroup) av.alignment.getGroups().elementAt(groupIndex);
+       }
+       while (groupIndex < av.alignment.getGroups().size());
+
+     }
+   }
 
   public void highlightSearchResults(SearchResults results)
   {
diff --git a/src/jalview/appletgui/SeqPanel.java b/src/jalview/appletgui/SeqPanel.java
index 76ad67b..93bca05 100755
--- a/src/jalview/appletgui/SeqPanel.java
+++ b/src/jalview/appletgui/SeqPanel.java
@@ -424,6 +424,9 @@ public class SeqPanel
       res = (x / av.getCharWidth()) + av.getStartRes();
   }
 
+  if(av.hasHiddenColumns)
+          res = av.getColumnSelection().adjustForHiddenColumns(res);
+
   return res;
 
  }
@@ -527,8 +530,7 @@ public class SeqPanel
     {
       if (obj != "")
       {
-        text.append(obj + " (" +
-                    av.getAlignment().getSequenceAt(seq).findPosition(res) + ")");
+        text.append(obj + " (" + sequence.findPosition(res) + ")");
       }
     }
 
@@ -693,184 +695,221 @@ public class SeqPanel
   }
 
   synchronized void editSequence(boolean insertGap, int startres)
-    {
-      int fixedLeft = -1;
-      int fixedRight = -1;
-      boolean fixedColumns = false;
-      SequenceGroup sg = av.getSelectionGroup();
+  {
+    int fixedLeft = -1;
+    int fixedRight = -1;
+    boolean fixedColumns = false;
+    SequenceGroup sg = av.getSelectionGroup();
 
-      if(groupEditing && sg==null)
-        return;
 
-        SequenceI seq = av.alignment.getSequenceAt(startseq);
-        StringBuffer message = new StringBuffer();
-        if (groupEditing)
-           message.append("Edit group:");
-        else
-            message.append("Edit sequence: "+seq.getName());
+      if (!groupEditing && av.hasHiddenRows)
+      {
+        if (av.alignment.getSequenceAt(startseq).getHiddenSequences() != null)
+        {
+          groupEditing = true;
+        }
+      }
 
-       if(insertGap)
-         message.append(" insert ");
-       else
-         message.append(" delete ");
+      //No group, but the sequence may represent a group
+      if (groupEditing
+          && sg == null
+          && av.alignment.getSequenceAt(startseq).getHiddenSequences() == null)
+      {
+        groupEditing = false;
+      }
+
+      SequenceI seq = av.alignment.getSequenceAt(startseq);
+      StringBuffer message = new StringBuffer();
+      if (groupEditing)
+         message.append("Edit group:");
+      else
+         message.append("Edit sequence: "+seq.getName());
+
+     if(insertGap)
+       message.append(" insert ");
+     else
+       message.append(" delete ");
 
-       message.append(Math.abs(startres-lastres)+" gaps.");
-       ap.alignFrame.statusBar.setText(message.toString());
+     message.append(Math.abs(startres-lastres)+" gaps.");
+     ap.alignFrame.statusBar.setText(message.toString());
 
 
-        //Are we editing within a selection group?
-        if (groupEditing
-            || (sg != null && sg.getSequences(false).contains(seq)))
+      //Are we editing within a selection group?
+      if (groupEditing
+          || (sg != null && sg.getSequences(true).contains(seq)))
+      {
+        fixedColumns = true;
+
+        //sg might be null as the user may only see 1 sequence,
+        //but the sequence represents a group
+        if (sg == null)
         {
-          fixedColumns = true;
+          sg = new SequenceGroup(null, null, false, false, false, 0,
+                                 av.alignment.getWidth()-1);
+          sg.addSequence(av.alignment.getSequenceAt(startseq), false);
+        }
+
+        fixedLeft = sg.getStartRes();
+        fixedRight = sg.getEndRes();
+
+        if (   (startres < fixedLeft && lastres >= fixedLeft)
+            || (startres >= fixedLeft && lastres < fixedLeft)
+            || (startres > fixedRight && lastres <=fixedRight)
+            || (startres <= fixedRight && lastres > fixedRight))
+        {
+          endEditing();
+          return;
+        }
+
+        if (fixedLeft > startres)
+        {
+          fixedRight = fixedLeft - 1;
+          fixedLeft = 0;
+        }
+        else if (fixedRight < startres)
+        {
+          fixedLeft = fixedRight;
+          fixedRight = -1;
+        }
+      }
 
-          fixedLeft = sg.getStartRes();
-          fixedRight = sg.getEndRes();
 
-          if (   (startres < fixedLeft && lastres >= fixedLeft)
-              || (startres >= fixedLeft && lastres < fixedLeft)
-              || (startres > fixedRight && lastres <=fixedRight)
-              || (startres <= fixedRight && lastres > fixedRight))
+      if(av.hasHiddenColumns )
+      {
+          fixedColumns = true;
+          int y1 = av.getColumnSelection().getHiddenBoundaryLeft(startres);
+          int y2 = av.getColumnSelection().getHiddenBoundaryRight(startres);
+
+          if ( (insertGap && startres > y1 && lastres < y1)
+              || (!insertGap && startres < y2 && lastres > y2))
           {
             endEditing();
             return;
           }
 
-          if (fixedLeft > startres)
-          {
-            fixedRight = fixedLeft - 1;
-            fixedLeft = 0;
-          }
-          else if (fixedRight < startres)
+          //System.out.print(y1+" "+y2+" "+fixedLeft+" "+fixedRight+"~~");
+          //Selection spans a hidden region
+          if(fixedLeft<y1 && (fixedRight>y2 || fixedRight==-1))
           {
-            fixedLeft = fixedRight;
-            fixedRight = -1;
+            if(startres>=y2)
+            {
+              fixedLeft = y2;
+            }
+            else
+            {
+             fixedRight = y2 - 1;
+           }
           }
-        }
+      }
 
 
-        if (groupEditing)
+      if (groupEditing)
+      {
+        // drag to right
+        if (insertGap)
         {
-          // drag to right
-          if (insertGap)
-          {
-              //If the user has selected the whole sequence, and is dragging to
-              // the right, we can still extend the alignment and selectionGroup
-              if(sg.getStartRes() == 0 && sg.getEndRes() + 1 == av.alignment.getWidth())
-              {
-                sg.setEndRes(av.alignment.getWidth() + startres - lastres);
-                fixedRight = sg.getEndRes();
-              }
+            //If the user has selected the whole sequence, and is dragging to
+            // the right, we can still extend the alignment and selectionGroup
+            if(   sg.getStartRes() == 0
+                  && sg.getEndRes() == fixedRight
+                  && sg.getEndRes() == av.alignment.getWidth()-1
+               )
+            {
+              sg.setEndRes(av.alignment.getWidth() + startres - lastres);
+              fixedRight = sg.getEndRes();
+            }
 
-            // Is it valid with fixed columns??
-            // Find the next gap before the end
-            // of the visible region boundary
-            boolean blank = false;
-            for (fixedRight = fixedRight;
-                 fixedRight > lastres;
-                 fixedRight--)
+          // Is it valid with fixed columns??
+          // Find the next gap before the end
+          // of the visible region boundary
+          boolean blank = false;
+          for (fixedRight = fixedRight;
+               fixedRight > lastres;
+               fixedRight--)
+          {
+            blank = true;
+            for (int s = 0; s < sg.getSize(true); s++)
             {
-              blank = true;
-              for (int s = 0; s < sg.getSize(false); s++)
+              seq = (SequenceI)sg.getSequences(true).elementAt(s);
+              for (int j = 0; j < startres - lastres; j++)
               {
-                seq = sg.getSequenceAt(s);
-                for (int j = 0; j < startres - lastres; j++)
+                if (!jalview.util.Comparison.isGap(
+                    seq.getCharAt(fixedRight - j)))
                 {
-                  if (!jalview.util.Comparison.isGap(
-                      seq.getCharAt(fixedRight - j)))
-                  {
-                    blank = false;
-                    break;
-                  }
+                  blank = false;
+                  break;
                 }
               }
-              if (blank)
-                break;
             }
+            if (blank)
+              break;
+          }
 
-            if (!blank)
+          if (!blank)
+          {
+            if(sg.getSize(false) == av.alignment.getHeight()  )
             {
-              if(sg.getSize(false) == av.alignment.getHeight())
-              {
-                //We can still insert gaps if the selectionGroup
-                //contains all the sequences
-                sg.setEndRes(sg.getEndRes()+startres-lastres);
-                fixedRight = av.alignment.getWidth()+startres-lastres;
-              }
-              else
+              if((av.hasHiddenColumns
+                  && startres<av.getColumnSelection().getHiddenBoundaryRight(startres)))
               {
                 endEditing();
                 return;
               }
-            }
-          }
-
-
-          // drag to left
-          else if(!insertGap)
-          {
-            /// Are we able to delete?
-            // ie are all columns blank?
 
-            for (int s = 0; s < sg.getSize(false); s++)
-            {
-              seq = sg.getSequenceAt(s);
-
-              for (int j = startres; j < lastres; j++)
+              int alWidth = av.alignment.getWidth();
+              if(av.hasHiddenRows)
               {
-                if (seq.getSequence().length() <= j)
-                {
-                  continue;
-                }
-
-                if (!jalview.util.Comparison.isGap(
-                    seq.getSequence().charAt(j)))
-                {
-                  // Not a gap, block edit not valid
-                  endEditing();
-                  return;
-                }
+                int hwidth = av.alignment.getHiddenSequences().getWidth();
+                if(hwidth>alWidth)
+                  alWidth = hwidth;
               }
+              //We can still insert gaps if the selectionGroup
+              //contains all the sequences
+              sg.setEndRes(sg.getEndRes()+startres-lastres);
+              fixedRight = alWidth+startres-lastres;
+            }
+            else
+            {
+              endEditing();
+              return;
             }
           }
+        }
 
 
-          for (int i = 0; i < sg.getSize(false); i++)
+        // drag to left
+        else if(!insertGap)
+        {
+          /// Are we able to delete?
+          // ie are all columns blank?
+
+          for (int s = 0; s < sg.getSize(true); s++)
           {
-            seq = sg.getSequenceAt(i);
+            seq = (SequenceI)sg.getSequences(true).elementAt(s);
 
-            if (insertGap)
+            for (int j = startres; j < lastres; j++)
             {
-              // dragging to the right
-              for (int j = lastres; j < startres; j++)
+              if (seq.getSequence().length() <= j)
               {
-                if (fixedColumns && fixedRight != -1)
-                {
-                  insertChar(j, seq, fixedRight);
-                }
-                else
-                  insertChar(j, seq);
+                continue;
               }
-            }
-            else
-            {
-              // dragging to the left
-              for (int j = lastres; j > startres; j--)
+
+              if (!jalview.util.Comparison.isGap(
+                  seq.getSequence().charAt(j)))
               {
-                if (fixedColumns && fixedRight != -1)
-                {
-                  deleteChar(startres, seq, fixedRight);
-                }
-                else
-                {
-                  deleteChar(startres, seq);
-                }
+                // Not a gap, block edit not valid
+                endEditing();
+                return;
               }
             }
           }
         }
-        else /////Editing a single sequence///////////
+
+
+        for (int i = 0; i < sg.getSize(true); i++)
         {
+          seq = (SequenceI) sg.getSequences(true).elementAt(i);
+
           if (insertGap)
           {
             // dragging to the right
@@ -878,18 +917,7 @@ public class SeqPanel
             {
               if (fixedColumns && fixedRight != -1)
               {
-                if (sg.getStartRes() == 0
-                    && sg.getEndRes() + 1 == av.alignment.getWidth()
-                    && !jalview.util.Comparison.isGap(seq.getCharAt(fixedRight)))
-                {
-                  //Single sequence edit, whole sequence selected,
-                  //extend the selection group
-                  sg.setEndRes(av.alignment.getWidth() -1 + startres - lastres);
-                  fixedColumns = false;
-                  insertChar(j, seq);
-                }
-                else
-                  insertChar(j, seq, fixedRight);
+                insertChar(j, seq, fixedRight);
               }
               else
                 insertChar(j, seq);
@@ -911,10 +939,42 @@ public class SeqPanel
             }
           }
         }
+      }
+      else /////Editing a single sequence///////////
+      {
+        if (insertGap)
+        {
+          // dragging to the right
+          for (int j = lastres; j < startres; j++)
+          {
+            if (fixedColumns && fixedRight != -1)
+            {
+                insertChar(j, seq, fixedRight);
+            }
+            else
+              insertChar(j, seq);
+          }
+        }
+        else
+        {
+          // dragging to the left
+          for (int j = lastres; j > startres; j--)
+          {
+            if (fixedColumns && fixedRight != -1)
+            {
+              deleteChar(startres, seq, fixedRight);
+            }
+            else
+            {
+              deleteChar(startres, seq);
+            }
+          }
+        }
+      }
 
-        lastres = startres;
-        seqCanvas.repaint();
-    }
+      lastres = startres;
+      seqCanvas.repaint();
+  }
 
 
     /**
@@ -1333,6 +1393,28 @@ public class SeqPanel
     }
   }
 
+  void scrollCanvas(MouseEvent evt)
+  {
+    if(evt==null)
+    {
+      if(scrollThread!=null)
+      {
+        scrollThread.running = false;
+        scrollThread = null;
+      }
+      mouseDragging = false;
+    }
+    else
+    {
+      if (scrollThread == null)
+        scrollThread = new ScrollThread();
+
+      mouseDragging = true;
+      scrollThread.setEvent(evt);
+    }
+
+    }
+
   // this class allows scrolling off the bottom of the visible alignment
   class ScrollThread
       extends Thread
diff --git a/src/jalview/appletgui/SequenceRenderer.java b/src/jalview/appletgui/SequenceRenderer.java
index 9dbb05c..9103c1d 100755
--- a/src/jalview/appletgui/SequenceRenderer.java
+++ b/src/jalview/appletgui/SequenceRenderer.java
@@ -40,10 +40,18 @@ public class SequenceRenderer
     this.av = av;
   }
 
-  public void renderGaps(boolean b)
+  /**
+   * DOCUMENT ME!
+   *
+   * @param b DOCUMENT ME!
+   */
+  public void prepare(Graphics g, boolean renderGaps)
   {
-    renderGaps = b;
-  }
+      graphics = g;
+      fm = g.getFontMetrics();
+
+      this.renderGaps = renderGaps;
+    }
 
   public Color getResidueBoxColour(SequenceI seq, int i)
   {
@@ -88,18 +96,15 @@ public class SequenceRenderer
     return resBoxColour;
   }
 
-  public void drawSequence(Graphics g, SequenceI seq, SequenceGroup[] sg,
+  public void drawSequence(SequenceI seq, SequenceGroup[] sg,
                            int start, int end,  int y1)
   {
     allGroups = sg;
 
-    graphics = g;
-
     drawBoxes(seq, start, end,  y1);
 
     if(av.validCharWidth)
     {
-      fm = g.getFontMetrics();
       drawText(seq, start, end, y1);
     }
   }
@@ -241,13 +246,12 @@ public class SequenceRenderer
     return false;
   }
 
-  public void drawHighlightedText(SequenceI seq, int start, int end, int x1,
-                                  int y1, int width, int height)
+  public void drawHighlightedText(SequenceI seq, int start, int end, int x1, int y1)
   {
-    int pady = height / 5;
+    int pady = av.charHeight / 5;
     int charOffset = 0;
     graphics.setColor(Color.black);
-    graphics.fillRect(x1, y1, width * (end - start + 1), height);
+    graphics.fillRect(x1, y1, av.charWidth * (end - start + 1), av.charHeight);
     graphics.setColor(Color.white);
 
     char s = '~';
@@ -261,10 +265,10 @@ public class SequenceRenderer
           s = seq.getSequence().charAt(i);
         }
 
-        charOffset = (width - fm.charWidth(s)) / 2;
+        charOffset = (av.charWidth - fm.charWidth(s)) / 2;
         graphics.drawString(String.valueOf(s),
-                            charOffset + x1 + width * (i - start),
-                            y1 + height - pady);
+                            charOffset + x1 + av.charWidth * (i - start),
+                            y1 + av.charHeight - pady);
       }
     }
   }
diff --git a/src/jalview/appletgui/TreePanel.java b/src/jalview/appletgui/TreePanel.java
index 9c71a15..b3fc3b3 100755
--- a/src/jalview/appletgui/TreePanel.java
+++ b/src/jalview/appletgui/TreePanel.java
@@ -116,9 +116,31 @@ public class TreePanel extends Frame implements ActionListener, ItemListener
 
   }
 
+  void showOriginalData()
+  {
+    // decide if av alignment is sufficiently different to original data to warrant a new window to be created
+    // create new alignmnt window with hidden regions (unhiding hidden regions yields unaligned seqs)
+    // or create a selection box around columns in alignment view
+    // test Alignment(SeqCigar[])
+    Object[] alAndColsel = tree.seqData.getAlignmentAndColumnSelection(av.
+        getGapCharacter());
+
+    if (alAndColsel != null && alAndColsel[0]!=null)
+     {
+       Alignment al = new Alignment( (SequenceI[]) alAndColsel[0]);
+       AlignFrame af = new AlignFrame(al,
+             av.applet,
+             "Original Data for Tree",
+             false);
+
+      af.viewport.setHiddenColumns( (ColumnSelection) alAndColsel[1] );
+     }
+  }
+
   class TreeLoader extends Thread
   {
     NewickFile newtree;
+    jalview.datamodel.AlignmentView odata=null;
 
     public TreeLoader(NewickFile newtree)
     {
@@ -127,19 +149,20 @@ public class TreePanel extends Frame implements ActionListener, ItemListener
 
     public void run()
     {
-      if (newtree != null)
-        tree = new NJTree(av.alignment.getSequencesArray(),
-                          newtree);
-      else
+      if(newtree!=null)
+      {
+        if (odata == null)
+          tree = new NJTree(av.alignment.getSequencesArray(),
+                            newtree);
+        else
+          tree = new NJTree(av.alignment.getSequencesArray(), odata, newtree);
+
+        }
+        else
         {
           int start, end;
           SequenceI [] seqs;
-          String[] seqStrings = null;
-//          if (av.hasHiddenColumns)
-  //        {
-    //        seqStrings = av.getAlignmentView(av.getSelectionGroup()!=null); // av.getSelectionAsString();
-      //    }
-
+          AlignmentView seqStrings = av.getAlignmentView(av.getSelectionGroup()!=null);
           if(av.getSelectionGroup()==null)
           {
             start = 0;
@@ -153,7 +176,7 @@ public class TreePanel extends Frame implements ActionListener, ItemListener
             seqs = av.getSelectionGroup().getSequencesInOrder(av.alignment);
           }
 
-          tree = new NJTree(seqs, null, type, pwtype, start, end);
+          tree = new NJTree(seqs, seqStrings, type, pwtype, start, end);
         }
 
       tree.reCount(tree.getTopNode());
@@ -181,6 +204,8 @@ public class TreePanel extends Frame implements ActionListener, ItemListener
       newickOutput_actionPerformed();
     else if(evt.getSource()==fontSize)
       fontSize_actionPerformed();
+    else if(evt.getSource()==inputData)
+      showOriginalData();
   }
 
   public void itemStateChanged(ItemEvent evt)
@@ -245,6 +270,7 @@ public class TreePanel extends Frame implements ActionListener, ItemListener
   protected CheckboxMenuItem fitToWindow = new CheckboxMenuItem();
   Menu fileMenu = new Menu();
   MenuItem newickOutput = new MenuItem();
+  MenuItem inputData = new MenuItem();
 
   private void jbInit() throws Exception {
       setLayout(borderLayout1);
@@ -265,6 +291,7 @@ public class TreePanel extends Frame implements ActionListener, ItemListener
       fileMenu.setLabel("File");
       newickOutput.setLabel("Newick Format");
       newickOutput.addActionListener(this);
+    inputData.setLabel("Input Data...");
 
     add(scrollPane, BorderLayout.CENTER);
       jMenuBar1.add(fileMenu);
@@ -275,6 +302,8 @@ public class TreePanel extends Frame implements ActionListener, ItemListener
       jMenu2.add(bootstrapMenu);
       jMenu2.add(placeholdersMenu);
     fileMenu.add(newickOutput);
+    fileMenu.add(inputData);
+    inputData.addActionListener(this);
   }
 
 }
-- 
1.7.10.2