X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FSeqPanel.java;h=48651f99d0ea73aad6f0927a2a8f9d90c880455c;hb=bd56b8fb21d730b15bb759c529990d244cafbe37;hp=5895fe3b150e18a5bd9ea46b6d1bd7cd108ca362;hpb=a49fdebf932bc4dbb55d3aaa9cc35ec2cfb181ff;p=jalview.git

diff --git a/src/jalview/gui/SeqPanel.java b/src/jalview/gui/SeqPanel.java
index 5895fe3..48651f9 100755
--- a/src/jalview/gui/SeqPanel.java
+++ b/src/jalview/gui/SeqPanel.java
@@ -1,277 +1,1490 @@
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer
+ * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
 package jalview.gui;
 
+import jalview.datamodel.*;
+
+import jalview.schemes.*;
+
 import java.awt.*;
 import java.awt.event.*;
-import jalview.datamodel.*;
+
 import javax.swing.*;
-import jalview.schemes.*;
 
 
-public class SeqPanel extends JPanel
+/**
+ * DOCUMENT ME!
+ *
+ * @author $author$
+ * @version $Revision$
+ */
+public class SeqPanel extends JPanel implements MouseListener,
+    MouseMotionListener, MouseWheelListener
+
 {
+    /** DOCUMENT ME!! */
+    public SeqCanvas seqCanvas;
+
+    /** DOCUMENT ME!! */
+    public AlignmentPanel ap;
+    protected int lastres;
+    protected int startseq;
+    protected AlignViewport av;
+
+    // if character is inserted or deleted, we will need to recalculate the conservation
+    boolean seqEditOccurred = false;
+    ScrollThread scrollThread = null;
+    boolean mouseDragging = false;
+    boolean editingSeqs = false;
+    boolean groupEditing = false;
+
+    //////////////////////////////////////////
+    /////Everything below this is for defining the boundary of the rubberband
+    //////////////////////////////////////////
+    int oldSeq = -1;
+    boolean changeEndSeq = false;
+    boolean changeStartSeq = false;
+    boolean changeEndRes = false;
+    boolean changeStartRes = false;
+    SequenceGroup stretchGroup = null;
+    boolean remove = false;
+
+    Point lastMousePress;
+    boolean mouseWheelPressed = false;
+    StringBuffer keyboardNo1;
+    StringBuffer keyboardNo2;
+
+    /**
+     * Creates a new SeqPanel object.
+     *
+     * @param avp DOCUMENT ME!
+     * @param p DOCUMENT ME!
+     */
+    public SeqPanel(AlignViewport avp, AlignmentPanel p)
+    {
+        ToolTipManager.sharedInstance().registerComponent(this);
+        ToolTipManager.sharedInstance().setInitialDelay(0);
+        ToolTipManager.sharedInstance().setDismissDelay(10000);
+        this.av = avp;
+        setBackground(Color.white);
+
+        seqCanvas = new SeqCanvas(avp);
+        setLayout(new BorderLayout());
+        add(seqCanvas, BorderLayout.CENTER);
+
+        ap = p;
+
+        if(!av.isDataset())
+        {
+          addMouseMotionListener(this);
+          addMouseListener(this);
+          addMouseWheelListener(this);
+        }
+    }
+
+    int startWrapBlock=-1;
+    int wrappedBlock=-1;
+    int findRes(MouseEvent evt)
+   {
+     int res = 0;
+     int x = evt.getX();
+
+    if (av.wrapAlignment)
+    {
+
+      int hgap = av.charHeight;
+      if (av.scaleAboveWrapped)
+        hgap += av.charHeight;
+
+      int cHeight = av.getAlignment().getHeight() * av.charHeight
+          + hgap + seqCanvas.getAnnotationHeight();
+
+        int y = evt.getY();
+        y -= hgap;
+        x -= seqCanvas.LABEL_WEST;
+
+
+        int cwidth = seqCanvas.getWrappedCanvasWidth(this.getWidth());
+
+        wrappedBlock = y / cHeight;
+        wrappedBlock += av.getStartRes() / cwidth;
+
+        res = wrappedBlock * cwidth + x / av.getCharWidth();
+
+    }
+    else
+    {
+        res = (x / av.getCharWidth()) + av.getStartRes();
+    }
+
+    if(av.hasHiddenColumns)
+          res = av.getColumnSelection().adjustForHiddenColumns(res);
+
+    return res;
+
+   }
+
+   int findSeq(MouseEvent evt)
+   {
+
+     int seq = 0;
+     int y = evt.getY();
+
+     if (av.wrapAlignment)
+     {
+       int hgap = av.charHeight;
+       if (av.scaleAboveWrapped)
+         hgap += av.charHeight;
+
+       int cHeight = av.getAlignment().getHeight() * av.charHeight
+           + hgap + seqCanvas.getAnnotationHeight();
+
+         y -= hgap;
+
+       seq = ( (y % cHeight) / av.getCharHeight());
+     }
+     else
+     {
+       seq = (y / av.getCharHeight()) + av.getStartSeq();
+     }
+
+     return seq;
+   }
+
+   void endEditing()
+   {
+     startseq = -1;
+     lastres = -1;
+     seqEditOccurred = false;
+     editingSeqs = false;
+     groupEditing = false;
+     keyboardNo1 = null;
+     keyboardNo2 = null;
+    }
+
+    void setCursorRow()
+    {
+      seqCanvas.cursorY = getKeyboardNo(keyboardNo1)-1;
+      scrollToVisible();
+    }
+
+    void setCursorColumn()
+    {
+      seqCanvas.cursorX = getKeyboardNo(keyboardNo1)-1;
+      scrollToVisible();
+    }
+
+    void setCursorRowAndColumn()
+    {
+      if(keyboardNo2==null)
+      {
+        keyboardNo2 = new StringBuffer();
+      }
+      else
+      {
+        seqCanvas.cursorX = getKeyboardNo(keyboardNo1) - 1;
+        seqCanvas.cursorY = getKeyboardNo(keyboardNo2) - 1;
+        scrollToVisible();
+      }
+    }
+
+    void setCursorPosition()
+    {
+      SequenceI sequence =
+          (Sequence) av.getAlignment().getSequenceAt(seqCanvas.cursorY);
+
+      seqCanvas.cursorX = sequence.findIndex(
+          getKeyboardNo(keyboardNo1)-1
+          );
+      scrollToVisible();
+    }
+
+    void moveCursor(int dx, int dy)
+    {
+      seqCanvas.cursorX += dx;
+      seqCanvas.cursorY += dy;
+      scrollToVisible();
+    }
+
+    void scrollToVisible()
+    {
+      if (seqCanvas.cursorX < 0)
+        seqCanvas.cursorX = 0;
+      else if (seqCanvas.cursorX > av.alignment.getWidth() - 1)
+        seqCanvas.cursorX = av.alignment.getWidth() - 1;
+
+      if (seqCanvas.cursorY < 0)
+        seqCanvas.cursorY = 0;
+      else if (seqCanvas.cursorY > av.alignment.getHeight() - 1)
+        seqCanvas.cursorY = av.alignment.getHeight() - 1;
+
+
+      endEditing();
+      if(av.wrapAlignment)
+      {
+        ap.scrollToWrappedVisible(seqCanvas.cursorX);
+      }
+      else
+      {
+        while (seqCanvas.cursorY < av.startSeq)
+        {
+          ap.scrollUp(true);
+        }
+        while (seqCanvas.cursorY + 1 > av.endSeq)
+        {
+          ap.scrollUp(false);
+        }
+        if (!av.wrapAlignment)
+        {
+          while (seqCanvas.cursorX < av.startRes)
+          {
+            if (!ap.scrollRight(false))
+              break;
+          }
+          while (seqCanvas.cursorX > av.endRes)
+          {
+            if (!ap.scrollRight(true))
+              break;
+          }
+        }
+      }
+      setStatusMessage(av.alignment.getSequenceAt(seqCanvas.cursorY),
+                       seqCanvas.cursorX, seqCanvas.cursorY);
+
+      seqCanvas.repaint();
+    }
+
+    void setSelectionAreaAtCursor(boolean topLeft)
+    {
+      SequenceI sequence =
+          (Sequence) av.getAlignment().getSequenceAt(seqCanvas.cursorY);
+
+      if(av.getSelectionGroup()!=null)
+      {
+        SequenceGroup sg = av.selectionGroup;
+        //Find the top and bottom of this group
+        int min = av.alignment.getHeight(), max = 0;
+        for(int i=0; i<sg.getSize(); i++)
+        {
+          int index = av.alignment.findIndex( sg.getSequenceAt(i) );
+          if(index > max)
+            max = index;
+          if(index < min)
+            min = index;
+        }
+
+        max ++;
+
+        if(topLeft)
+        {
+          sg.setStartRes(seqCanvas.cursorX);
+          if(sg.getEndRes()<seqCanvas.cursorX)
+            sg.setEndRes(seqCanvas.cursorX);
+
+          min = seqCanvas.cursorY;
+        }
+        else
+        {
+          sg.setEndRes(seqCanvas.cursorX);
+          if(sg.getStartRes()>seqCanvas.cursorX)
+            sg.setStartRes(seqCanvas.cursorX);
+
+          max = seqCanvas.cursorY+1;
+        }
+
+        if(min>max)
+        {
+          // Only the user can do this
+          av.setSelectionGroup(null);
+        }
+        else
+        {
+          // Now add any sequences between min and max
+          sg.sequences.clear();
+          for (int i = min; i < max; i++)
+          {
+            sg.addSequence(av.alignment.getSequenceAt(i), false);
+          }
+        }
+      }
 
-  public    AlignmentI        align;
-  public    SeqCanvas         seqCanvas;
-  public    AlignmentPanel    parent;
+      if (av.getSelectionGroup() == null)
+      {
+        SequenceGroup sg = new SequenceGroup();
+        sg.setStartRes(seqCanvas.cursorX);
+        sg.setEndRes(seqCanvas.cursorX);
+        sg.addSequence(sequence, false);
+        av.setSelectionGroup(sg);
+      }
 
-  protected int startres;
-  protected int lastres;
-  protected int endres;
 
-  protected int startseq;
-  protected int padseq;
+      ap.repaint();
+    }
 
-  public    boolean editFlag;
-  protected AlignViewport av;
+    void insertGapAtCursor(boolean group)
+    {
+      ap.alignFrame.addHistoryItem(new HistoryItem("Edit Sequence",
+                                                   av.alignment, HistoryItem.EDIT));
+      groupEditing = group;
+      startseq = seqCanvas.cursorY;
+      lastres = seqCanvas.cursorX;
+      editSequence(true, seqCanvas.cursorX+getKeyboardNo(keyboardNo1));
+      editOccurred();
+    }
 
-  public SeqPanel(AlignViewport av, AlignmentPanel p) {
-    this.av         = av;
-    this.align      = av.getAlignment();
+    void deleteGapAtCursor(boolean group)
+    {
+      ap.alignFrame.addHistoryItem(new HistoryItem("Edit Sequence",
+                                                   av.alignment, HistoryItem.EDIT));
+      groupEditing = group;
+      startseq = seqCanvas.cursorY;
+      lastres = seqCanvas.cursorX+getKeyboardNo(keyboardNo1);
+      editSequence(false, seqCanvas.cursorX);
+      editOccurred();
+    }
 
-    seqCanvas  = new SeqCanvas(av);
-    setLayout(new BorderLayout());
-    add(seqCanvas, BorderLayout.CENTER);
+    void numberPressed(char value)
+    {
+      if(keyboardNo1==null)
+        keyboardNo1 = new StringBuffer();
 
-    parent = p;
+      if(keyboardNo2!=null)
+        keyboardNo2.append(value);
+      else
+        keyboardNo1.append(value);
+    }
 
-    addMouseMotionListener( new MouseMotionAdapter()
+    int getKeyboardNo(StringBuffer kb)
     {
-      public void mouseMoved(MouseEvent evt)
-      {  doMouseMoved(evt);   }
-      public void mouseDragged(MouseEvent evt)
-      { doMouseDragged(evt);  }
-    });
+      if(kb==null)
+        return 1;
+      else
+        return Integer.parseInt(kb.toString());
+    }
 
-    addMouseListener( new MouseAdapter()
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void mouseReleased(MouseEvent evt)
     {
-      public void mouseReleased(MouseEvent evt)
-      { doMouseReleased(evt);  }
-      public void mousePressed(MouseEvent evt)
-      { doMousePressed(evt);   }
+      mouseDragging = false;
+      mouseWheelPressed = false;
+
+      if (!editingSeqs)
+      {
+         doMouseReleasedDefineMode(evt);
+         return;
+      }
+
+       editOccurred();
+
+       endEditing();
+       ap.repaint();
+    }
 
-    });
-    repaint();
-  }
 
 
-  public void doMouseReleased(MouseEvent evt) {
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void mousePressed(MouseEvent evt)
+    {
+      lastMousePress = evt.getPoint();
 
-    int x = evt.getX();
-      int res = (int)(x/av.getCharWidth()) + av.getStartRes();
+      if (javax.swing.SwingUtilities.isMiddleMouseButton(evt))
+      {
+        mouseWheelPressed = true;
+        return;
+      }
 
-      endres = res;
+      if (evt.isShiftDown() || evt.isAltDown() ||
+          evt.isControlDown())
+      {
+        if (evt.isAltDown() || evt.isControlDown())
+        {
+          groupEditing = true;
+        }
+        editingSeqs = true;
+      }
+      else
+      {
+        doMousePressedDefineMode(evt);
+        return;
+      }
 
-      // This is to detect edits - we're at the end of an edit if mouse is up
-      editFlag = false;
-      startseq = -1;
-      startres = -1;
-      lastres  = -1;
 
-    parent.RefreshPanels();
-    repaint();
 
-  }
+      int seq = findSeq(evt);
+      int res = findRes(evt);
 
-  public void doMousePressed(MouseEvent evt) {
-    int seq;
-    int res;
+      if(seq<0 || res<0)
+        return;
 
-    int x = evt.getX();
-    int y = evt.getY();
+      ap.alignFrame.addHistoryItem(new HistoryItem("Edit Sequence",
+                                                         av.alignment, HistoryItem.EDIT));
 
-    res = (int)(x/av.getCharWidth()) + av.getStartRes();
-    seq = (y)/av.getCharHeight() + av.getStartSeq();
+        if ((seq < av.getAlignment().getHeight()) &&
+                (res < av.getAlignment().getSequenceAt(seq).getLength()))
+        {
+            startseq = seq;
+            lastres = res;
+        }
+        else
+        {
+            startseq = -1;
+            lastres = -1;
+        }
 
-    if (seq < align.getHeight() && res < align.getSequenceAt(seq).getLength())
+        return;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void mouseMoved(MouseEvent evt)
     {
-      //char resstr = align.getSequenceAt(seq).getSequence().charAt(res);
-      // Find the residue's position in the sequence (res is the position
-      // in the alignment
+      if (editingSeqs)
+      {
+       // This is because MacOSX creates a mouseMoved
+       // If control is down, other platforms will not.
+       mouseDragged(evt);
+      }
+
+      int res = findRes(evt);
+      int seq = findSeq(evt);
+
 
-      startseq = seq;
+      if(res<0 || seq<0 || seq >= av.getAlignment().getHeight())
+            return;
 
-      if (startseq == (align.getHeight()-1)) {
-        padseq = 1;
-      } else {
-        padseq = 1;
+      SequenceI sequence = av.getAlignment().getSequenceAt(seq);
+
+      if (res > sequence.getLength())
+      {
+        return;
+      }
+
+      if(seqCanvas.pdbCanvas!=null && sequence==seqCanvas.pdbCanvas.sequence)
+      {
+        seqCanvas.pdbCanvas.highlightRes(sequence.findPosition(res));
       }
 
-      startres = res;
-      lastres = res;
+      setStatusMessage(sequence, res, seq);
+
+        // use aa to see if the mouse pointer is on a
+        if (av.showSequenceFeatures)
+        {
+            SequenceFeature [] features = sequence.getDatasetSequence().getSequenceFeatures();
+            if(features!=null)
+            {
+              StringBuffer sbuffer = new StringBuffer("<html>");
+
+              for (int i = 0; i < features.length; i++)
+              {
 
-      } else {
-      startseq = -1;
-      startres = -1;
-      lastres = -1;
+                if ( (features[i].getBegin() <= sequence.findPosition(res)) &&
+                    (features[i].getEnd() >= sequence.findPosition(res)))
+                {
+                  if(av.featuresDisplayed==null
+                    || !av.featuresDisplayed.containsKey(features[i].getType()))
+                  continue;
+
+
+                  if (features[i].getType().equals("disulfide bond"))
+                  {
+                    if (features[i].getBegin() == sequence.findPosition(res)
+                        || features[i].getEnd() == sequence.findPosition(res))
+                    {
+                      if (sbuffer.length() > 6)
+                        sbuffer.append("<br>");
+                      sbuffer.append("disulfide bond " + features[i].getBegin() + ":" +
+                                     features[i].getEnd());
+                    }
+                  }
+                  else
+                  {
+                    if (sbuffer.length() > 6)
+                      sbuffer.append("<br>");
+                    if(features[i].featureGroup!=null)
+                      sbuffer.append(features[i].featureGroup+";");
+
+                    sbuffer.append(features[i].getType());
+
+                    if (features[i].getDescription() != null
+                        && !features[i].description.equals(features[i].getType()))
+                      sbuffer.append("; " + features[i].getDescription());
+
+                    if (features[i].getStatus() != null && features[i].getStatus().length()>0)
+                    {
+                      sbuffer.append("; (" + features[i].getStatus() + ")");
+                    }
+                  }
+                }
+
+              }
+
+              sbuffer.append("</html>");
+              if(sbuffer.length()==13) // <html></html>
+                setToolTipText("");
+              else
+               setToolTipText(sbuffer.toString());
+            }
+            else
+              setToolTipText("");
+        }
     }
 
-    return;
-  }
+    void setStatusMessage(SequenceI sequence, int res, int seq)
+    {
+      StringBuffer text = new StringBuffer("Sequence " + (seq + 1) + " ID: " +
+                                           sequence.getName());
+
+      Object obj = null;
+      if (av.alignment.isNucleotide())
+      {
+        obj = ResidueProperties.nucleotideName.get(sequence.getCharAt(res) +
+                                                   "");
+        if (obj != null)
+          text.append(" Nucleotide: ");
+      }
+      else
+      {
+        obj = ResidueProperties.aa2Triplet.get(sequence.getCharAt(res) + "");
+        if (obj != null)
+          text.append("  Residue: ");
+      }
 
-  public void doMouseMoved(MouseEvent evt)
-  {
+      if (obj != null)
+      {
 
-    int res = (int)(evt.getX()/av.getCharWidth()) + av.getStartRes();
-    int seq = (evt.getY())/av.getCharHeight() + av.getStartSeq();
-    if(seq>=av.getAlignment().getHeight())
-      return;
+        if (obj != "")
+        {
+          text.append(obj + " (" + sequence.findPosition(res) +
+                      ")");
+        }
+      }
+      ap.alignFrame.statusBar.setText(text.toString());
 
-    Object obj = ResidueProperties.aa2Triplet.get( av.getAlignment().getSequenceAt(seq).getCharAt(res)+"" ) ;
-    String aa = "";
-    if(obj!=null)
-         aa = obj.toString();
+    }
 
-    StringBuffer text = new StringBuffer("Sequence " +seq+" ID: "+av.getAlignment().getSequenceAt(seq).getName());
-    if(aa!="")
-      text.append("  Residue: "+aa+" ("+  av.getAlignment().getSequenceAt(seq).findPosition(res)+")");
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void mouseDragged(MouseEvent evt)
+    {
+      if (mouseWheelPressed)
+      {
+        int oldWidth = av.charWidth;
 
-    parent.alignFrame.statusBar.setText(text.toString());
+        //Which is bigger, left-right or up-down?
+        if (Math.abs(evt.getY() - lastMousePress.getY())
+            > Math.abs(evt.getX() - lastMousePress.getX()))
+        {
+          int fontSize = av.font.getSize();
 
-  }
+          if (evt.getY() < lastMousePress.getY() && av.charHeight > 1)
+          {
+            fontSize--;
+          }
+          else if (evt.getY() > lastMousePress.getY())
+          {
+            fontSize++;
+          }
 
-  public void doMouseDragged(MouseEvent evt) {
-    // If we're dragging we're editing
-    editFlag = true;
+          av.setFont(new Font(av.font.getName(), av.font.getStyle(), fontSize));
+          av.charWidth = oldWidth;
+          ap.fontChanged();
 
-    int x = evt.getX();
+        }
+        else
+        {
+          if (evt.getX() < lastMousePress.getX() && av.charWidth > 1)
+          {
+            av.charWidth--;
+          }
+          else if (evt.getX() > lastMousePress.getX())
+          {
+            av.charWidth++;
+          }
+
+          ap.repaint();
+        }
+
+        FontMetrics fm = getFontMetrics(av.getFont());
+        av.validCharWidth = fm.charWidth('M') <= av.charWidth;
+
+        lastMousePress = evt.getPoint();
+
+        return;
+      }
+
+      if (!editingSeqs)
+      {
+        doMouseDraggedDefineMode(evt);
+        return;
+      }
 
-    int res = (int)(x/av.getCharWidth()) + av.getStartRes();
-    if (res < 0) {res = 0;}
+        int res = findRes(evt);
 
-    if (res  != lastres) {
-      if (startseq != -1) {
+        if (res < 0)
+        {
+            res = 0;
+        }
 
-	// Group editing
-	if (av.getGroupEdit()) {
-	  SequenceGroup sg = align.findGroup(startseq);
+        if ((lastres == -1) || (lastres == res))
+        {
+            return;
+        }
 
-	  if (res < align.getWidth() && res < lastres) {
-	    boolean flag = false;
-	    for (int i= 0 ; i < sg.getSize(); i++) {
-	      SequenceI s = (SequenceI)sg.getSequenceAt(i);
-	      for (int j=lastres-1; j >= res; j--) {
-		if (!flag) {
-		  if (!s.getSequence().substring(j,j+1).equals(align.getGapCharacter()) &&
-		      !s.getSequence().substring(j,j+1).equals(" ")) {
-		    res = j+1;
-		    System.out.print("\07");
-		    System.out.flush();
-		    flag = true;
-		  }
-		}
-	      }
-	    }
-	  }
+        if ( (res < av.getAlignment().getWidth()) && (res < lastres))
+        {
+          // dragLeft, delete gap
+          editSequence(false, res);
+        }
+        else
+          editSequence(true, res);
 
-	  for (int i= 0 ; i < sg.getSize(); i++)
+        mouseDragging = true;
+        if(scrollThread!=null)
+          scrollThread.setEvent(evt);
+
+    }
+
+    synchronized void editSequence(boolean insertGap, int startres)
+    {
+      int fixedLeft = -1;
+      int fixedRight = -1;
+      boolean fixedColumns = false;
+      SequenceGroup sg = av.getSelectionGroup();
+
+      if(groupEditing && sg==null)
+        return;
+
+        if (!groupEditing && av.hasHiddenRows)
+        {
+          //This needs to check all the sequences in a group edit,m
+          // not just the startseq
+          if (av.alignment.getSequenceAt(startseq).getHiddenSequences() != null)
+          {
+            groupEditing = true;
+          }
+        }
+
+        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());
+
+
+        //Are we editing within a selection group?
+        if (groupEditing
+            || (sg != null && sg.sequences.contains(seq)))
+        {
+          fixedColumns = true;
+
+          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)
           {
-	    SequenceI s = (SequenceI)sg.getSequenceAt(i);
-	    boolean found = false;
-	    int sno = -1;
-	    for (int k = 0; k < align.getHeight(); k++)
+            fixedLeft = fixedRight;
+            fixedRight = -1;
+          }
+        }
+
+
+
+        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(fixedRight<y2 && fixedRight==-1 && y2!=startres)
+            fixedRight = y2 -1;
+          if(y1>fixedLeft && fixedLeft==-1)
+            fixedLeft = y1;
+        }
+
+        if (groupEditing)
+        {
+
+          /*if (av.hasHiddenRows)
+          {
+            //sg might be null as the user may only see 1 sequence
+            if (sg == null)
             {
-	      if (align.getSequenceAt(k) == s)
+              sg = new SequenceGroup();
+              sg.addSequence(av.alignment.getSequenceAt(startseq), false);
+            }
+
+            SequenceGroup tmp = new SequenceGroup();
+
+            //Do any of the sequences have hidden associates?
+            for (int s = 0; s < sg.getSize(); s++)
+            {
+              seq = sg.getSequenceAt(s);
+              tmp.addSequence(seq, false);
+              if (seq.getHiddenSequences() != null)
               {
-		found = true;
-		sno = k;
-		break;
-	      }
-	    }
-	    if (found && sno != -1) {
-	      if (res < align.getWidth() && res > lastres)
+                for (int h = 0; h < seq.getHiddenSequences().getSize(); h++)
+                  tmp.addSequence(seq.getHiddenSequences().getSequenceAt(h),
+                                  false);
+              }
+            }
+
+            sg = tmp;
+          }*/
+          // int blankColumn = -1;
+
+
+          // 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())
               {
-		for (int j = lastres; j < res; j++)
-		  insertChar(j,sno);
+                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--)
+            {
+              blank = true;
+              for (int s = 0; s < sg.getSize(); s++)
+              {
+                seq = sg.getSequenceAt(s);
+                for (int j = 0; j < startres - lastres; j++)
+                {
+                  if (!jalview.util.Comparison.isGap(
+                      seq.getCharAt(fixedRight - j)))
+                  {
+                    blank = false;
+                    break;
+                  }
+                }
+              }
+              if (blank)
+                break;
+            }
+
+            if (!blank)
+            {
+              if(sg.getSize() == 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
+              {
+                endEditing();
+                return;
+              }
+            }
+          }
+
 
-		int index = align.findIndex(s);
-		if (index != -1)
-		  drawChars(index,index+1,lastres);
+          // drag to left
+          else if(!insertGap)
+          {
+            /// Are we able to delete?
+            // ie are all columns blank?
 
+            for (int s = 0; s < sg.getSize(); s++)
+            {
+              seq = sg.getSequenceAt(s);
 
-	      } else if (res < align.getWidth() && res < lastres)
+              for (int j = startres; j < lastres; j++)
               {
-		for (int j = res; j < lastres; j++)
+                if (seq.getSequence().length() <= j)
                 {
-		  deleteChar(j,res,sno);
-		  startres = res;
-		}
-		int index = align.findIndex(s);
-		if (index != -1)
-		  drawChars(index,index+1,res);
+                  continue;
+                }
 
-	      }
-	    }
+                if (!jalview.util.Comparison.isGap(
+                    seq.getSequence().charAt(j)))
+                {
+                  // Not a gap, block edit not valid
+                  endEditing();
+                  return;
+                }
+              }
+            }
+          }
 
-	  }
-	  lastres = res;
-	} else {
 
+          for (int i = 0; i < sg.getSize(); i++)
+          {
+            seq = sg.getSequenceAt(i);
 
-	  if (res < align.getWidth() && res > lastres) {
+            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);
+                }
+              }
+            }
+          }
+        }
+        else /////Editing a single sequence///////////
+        {
+          if (insertGap)
+          {
             // dragging to the right
-	    for (int j = lastres; j < res; j++)
+            for (int j = lastres; j < startres; j++)
+            {
+              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);
+              }
+              else
+                insertChar(j, seq);
+            }
+          }
+          else
+          {
+            // dragging to the left
+            for (int j = lastres; j > startres; j--)
             {
-	      insertChar(j,startseq);
-	    }
-	    drawChars(startseq,startseq+1,lastres);
+              if (fixedColumns && fixedRight != -1)
+              {
+                deleteChar(startres, seq, fixedRight);
+              }
+              else
+              {
+                deleteChar(startres, seq);
+              }
+            }
+          }
+        }
+
+        lastres = startres;
+        seqCanvas.repaint();
+    }
 
-	  } else if (res < align.getWidth() && res < lastres) {
 
-            // dragging to the left
-	    for (int j = res; j < lastres; j++) {
-	      deleteChar(j,res,startseq);
-	      startres = res;
-	    }
-	    drawChars(startseq,startseq+1,res);
-	  }
-	}
+    /**
+     * DOCUMENT ME!
+     *
+     * @param j DOCUMENT ME!
+     * @param seq DOCUMENT ME!
+     */
+    void insertChar(int j, SequenceI seq)
+    {
+        seq.insertCharAt(j, av.getGapCharacter());
+        seqEditOccurred = true;
+    }
+
+    void insertChar(int j, SequenceI seq, int fixedColumn)
+    {
+      //Find the next gap before the end of the visible region boundary
+      //If lastCol > j, theres a boundary after the gap insertion
+      int blankColumn = fixedColumn;
+      for (blankColumn = fixedColumn; blankColumn > j; blankColumn--)
+      {
+        if (jalview.util.Comparison.isGap(seq.getCharAt(blankColumn)))
+        {
+          //Theres a space, so break and insert the gap
+          break;
+        }
+      }
+
+      if (blankColumn <= j)
+      {
+        endEditing();
+        return;
       }
-      lastres = res;
+
+      if (!jalview.util.Comparison.isGap(seq.getCharAt(blankColumn)))
+      {
+        //Just Checking
+        System.out.println("Tried removing residue (INSERT)"+seq.getCharAt(fixedColumn));
+        return;
+      }
+
+      seq.deleteCharAt(blankColumn);
+      seq.insertCharAt(j, av.getGapCharacter());
+      seqEditOccurred = true;
     }
 
-    repaint();
-    return;
-  }
+    void deleteChar(int j, SequenceI seq, int fixedColumn)
+    {
+      if (!jalview.util.Comparison.isGap(seq.getCharAt(j)))
+      {
+        ap.alignFrame.statusBar.setText(
+            "End editing: Tried removing residue " + seq.getCharAt(j));
+        return;
+      }
 
-  public void drawChars(int seqstart, int seqend, int start) {
-    seqCanvas.drawPanel(seqCanvas.gg, start,av.getEndRes(),seqstart,seqend,av.getStartRes(),av.getStartSeq(),0);
-    repaint();
-  }
+      seq.deleteCharAt(j);
+      seq.insertCharAt(fixedColumn, av.getGapCharacter());
+      seqEditOccurred = true;
+    }
 
-  public void insertChar(int j, int seq)
-  {
-    align.getSequenceAt(seq).insertCharAt(j, av.getGapCharacter().charAt(0));
-  }
+    /**
+     * DOCUMENT ME!
+     *
+     * @param j DOCUMENT ME!
+     * @param seq DOCUMENT ME!
+     */
+    void deleteChar(int j, SequenceI seq)
+    {
+      if (!jalview.util.Comparison.isGap(seq.getCharAt(j)))
+      {
+        ap.alignFrame.statusBar.setText(
+            "End editing: Tried removing residue " + seq.getCharAt(j));
+        return;
+      }
 
-  public void deleteChar(int j, int res, int sno)
-  {
+        seq.deleteCharAt(j);
+        seqEditOccurred = true;
+        seqCanvas.repaint();
+    }
+    /**
+     * DOCUMENT ME!
+     *
+     * @param e DOCUMENT ME!
+     */
+    public void mouseEntered(MouseEvent e)
+    {
+        if(oldSeq < 0)
+          oldSeq = 0;
+
+        if (scrollThread != null)
+        {
+            scrollThread.running = false;
+            scrollThread = null;
+        }
+    }
 
-    if (align.getSequenceAt(sno).getSequence().substring(j,j+1).equals(".") ||
-        align.getSequenceAt(sno).getSequence().substring(j,j+1).equals("-") ||
-        align.getSequenceAt(sno).getSequence().substring(j,j+1).equals(" ") )
+    /**
+     * DOCUMENT ME!
+     *
+     * @param e DOCUMENT ME!
+     */
+    public void mouseExited(MouseEvent e)
     {
-        align.getSequenceAt(sno).deleteCharAt(j);
+        if (av.getWrapAlignment())
+        {
+            return;
+        }
+
+        if (mouseDragging)
+        {
+            scrollThread = new ScrollThread();
+        }
     }
 
-    align.getWidth();
-    repaint();
-  }
+    public void mouseClicked(MouseEvent evt)
+    {}
 
-  public void setColourScheme(ColourSchemeI cs)
-  {
-   seqCanvas.cs = cs;
-   seqCanvas.paintFlag = true;
-   repaint();
-  }
+    public void mouseWheelMoved(MouseWheelEvent e)
+    {
+      e.consume();
+     /* if (mouseWheelPressed)
+      {
+        Font font = av.getFont();
+        int fontSize = font.getSize();
+        if (e.getWheelRotation() > 0 && fontSize < 51)
+          fontSize++;
+        else if (fontSize > 1)
+          fontSize--;
 
-  public ColourSchemeI getColourScheme()
-  {
-    return seqCanvas.cs;
-  }
 
 
-}
+        av.setFont(new Font(font.getName(), font.getStyle(), fontSize));
+
+        ap.fontChanged();
+      }
+      else*/
+      {
+        if (e.getWheelRotation() > 0)
+          ap.scrollUp(false);
+        else
+          ap.scrollUp(true);
+      }
+
+    }
+
+
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param i DOCUMENT ME!
+     */
+    void editOccurred()
+    {
+      if (!seqEditOccurred)
+      {
+        ap.alignFrame.historyList.pop();
+        ap.alignFrame.updateEditMenuBar();
+      }
 
+      endEditing();
 
+      av.firePropertyChange("alignment", null,av.getAlignment().getSequences());
 
+    }
 
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void doMousePressedDefineMode(MouseEvent evt)
+    {
+      int res = findRes(evt);
+      int seq = findSeq(evt);
+      oldSeq = seq;
+
+      startWrapBlock=wrappedBlock;
+
+      if(av.wrapAlignment && seq>av.alignment.getHeight())
+      {
+          JOptionPane.showInternalMessageDialog(Desktop.desktop,
+              "Cannot edit annotations in wrapped view.",
+              "Wrapped view - no edit",
+              JOptionPane.WARNING_MESSAGE);
+        return;
+      }
+
+      if(seq<0 || res<0)
+            return;
+
+        SequenceI sequence = (Sequence) av.getAlignment().getSequenceAt(seq);
+
+        if ((sequence == null) || (res > sequence.getLength()))
+        {
+            return;
+        }
+
+        stretchGroup = av.getSelectionGroup();
+
+        if (stretchGroup == null)
+        {
+            stretchGroup = av.alignment.findGroup(sequence);
+
+            if ((stretchGroup != null) && (res > stretchGroup.getStartRes()) &&
+                    (res < stretchGroup.getEndRes()))
+            {
+                av.setSelectionGroup(stretchGroup);
+            }
+            else
+            {
+                stretchGroup = null;
+            }
+        }
+        else if (!stretchGroup.sequences.contains(sequence) ||
+                (stretchGroup.getStartRes() > res) ||
+                (stretchGroup.getEndRes() < res))
+        {
+            stretchGroup = null;
+
+            SequenceGroup[] allGroups = av.alignment.findAllGroups(sequence);
+
+            if (allGroups != null)
+            {
+                for (int i = 0; i < allGroups.length; i++)
+                {
+                    if ((allGroups[i].getStartRes() <= res) &&
+                            (allGroups[i].getEndRes() >= res))
+                    {
+                        stretchGroup = allGroups[i];
+                        av.setSelectionGroup(stretchGroup);
+
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (av.cursorMode)
+        {
+          seqCanvas.cursorX = findRes(evt);
+          seqCanvas.cursorY = findSeq(evt);
+          seqCanvas.repaint();
+          return;
+        }
+
+
+        if (stretchGroup == null)
+        {
+            // define a new group here
+            SequenceGroup sg = new SequenceGroup();
+            sg.setStartRes(res);
+            sg.setEndRes(res);
+            sg.addSequence(sequence, false);
+            av.setSelectionGroup(sg);
+            stretchGroup = sg;
+
+            if (av.getConservationSelected())
+            {
+                SliderPanel.setConservationSlider(ap,
+                    av.getGlobalColourScheme(), "Background");
+            }
+
+            if (av.getAbovePIDThreshold())
+            {
+                SliderPanel.setPIDSliderSource(ap, av.getGlobalColourScheme(),
+                    "Background");
+            }
+        }
+        else if (javax.swing.SwingUtilities.isRightMouseButton(evt))
+        {
+            jalview.gui.PopupMenu pop = new jalview.gui.PopupMenu(ap, null);
+            pop.show(this, evt.getX(), evt.getY());
+
+            // edit the properties of existing group
+        }
+
+        if ((stretchGroup != null) && (stretchGroup.getEndRes() == res))
+        {
+            // Edit end res position of selected group
+            changeEndRes = true;
+        }
+        else if ((stretchGroup != null) && (stretchGroup.getStartRes() == res))
+        {
+            // Edit end res position of selected group
+            changeStartRes = true;
+        }
+
+        stretchGroup.getWidth();
+
+        seqCanvas.repaint();
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void doMouseReleasedDefineMode(MouseEvent evt)
+    {
+        if (stretchGroup == null)
+        {
+            return;
+        }
+
+
+        if(stretchGroup.cs!=null)
+        {
+          if (stretchGroup.cs instanceof ClustalxColourScheme)
+          {
+            ( (ClustalxColourScheme) stretchGroup.cs).resetClustalX(stretchGroup.
+                sequences,
+                stretchGroup.getWidth());
+          }
+
+          if (stretchGroup.cs.conservationApplied())
+          {
+            SliderPanel.setConservationSlider(ap, stretchGroup.cs,
+                                              stretchGroup.getName());
+            stretchGroup.recalcConservation();
+          }
+          else
+          {
+            SliderPanel.setPIDSliderSource(ap, stretchGroup.cs,
+                                           stretchGroup.getName());
+          }
+        }
+        changeEndRes = false;
+        changeStartRes = false;
+        stretchGroup = null;
+        PaintRefresher.Refresh(av.alignment);
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void doMouseDraggedDefineMode(MouseEvent evt)
+    {
+      int res = findRes(evt);
+      int y = findSeq(evt);
+
+      if(wrappedBlock!=startWrapBlock)
+        return;
+
+       if (stretchGroup == null)
+       {
+            return;
+       }
+
+
+        if(y > av.alignment.getHeight())
+        {
+          y = av.alignment.getHeight() -1;
+        }
+        if(res> av.alignment.getWidth())
+        {
+          res = av.alignment.getWidth()-1;
+        }
+
+        if (stretchGroup.getEndRes() == res)
+        {
+            // Edit end res position of selected group
+            changeEndRes = true;
+        }
+        else if (stretchGroup.getStartRes() == res)
+        {
+            // Edit start res position of selected group
+            changeStartRes = true;
+        }
+
+        if (res < av.getStartRes())
+        {
+            res = av.getStartRes();
+        }
+
+        if (changeEndRes)
+        {
+            if (res > (stretchGroup.getStartRes() - 1))
+            {
+                stretchGroup.setEndRes(res);
+            }
+        }
+        else if (changeStartRes)
+        {
+            if (res < (stretchGroup.getEndRes() + 1))
+            {
+                stretchGroup.setStartRes(res);
+            }
+        }
+
+        int dragDirection = 0;
+
+        if (y > oldSeq)
+        {
+            dragDirection = 1;
+        }
+        else if (y < oldSeq)
+        {
+            dragDirection = -1;
+        }
+
+
+        while ((y != oldSeq) && (oldSeq > -1) && (y < av.alignment.getHeight()))
+        {
+            // This routine ensures we don't skip any sequences, as the
+            // selection is quite slow.
+            Sequence seq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
+
+            oldSeq += dragDirection;
+
+            if(oldSeq<0)
+              break;
+
+            Sequence nextSeq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
+
+            if (stretchGroup.sequences.contains(nextSeq))
+            {
+                stretchGroup.deleteSequence(seq, false);
+            }
+            else
+            {
+                if (seq != null)
+                {
+                    stretchGroup.addSequence(seq, false);
+                }
+
+                stretchGroup.addSequence(nextSeq, false);
+            }
+        }
+
+        if(oldSeq < 0)
+          oldSeq = -1;
+
+        mouseDragging = true;
+
+        if (scrollThread != null)
+        {
+            scrollThread.setEvent(evt);
+        }
+
+        seqCanvas.repaint();
+    }
+
+    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
+    {
+        MouseEvent evt;
+        boolean running = false;
+
+        public ScrollThread()
+        {
+            start();
+        }
+
+        public void setEvent(MouseEvent e)
+        {
+            evt = e;
+        }
+
+        public void stopScrolling()
+        {
+            running = false;
+        }
+
+        public void run()
+        {
+            running = true;
+
+            while (running)
+            {
+                if (evt != null)
+                {
+                    if (mouseDragging && (evt.getY() < 0) &&
+                            (av.getStartSeq() > 0))
+                    {
+                        running = ap.scrollUp(true);
+                    }
+
+                    if (mouseDragging && (evt.getY() >= getHeight()) &&
+                            (av.alignment.getHeight() > av.getEndSeq()))
+                    {
+                        running = ap.scrollUp(false);
+                    }
+
+                    if (mouseDragging && (evt.getX() < 0))
+                    {
+                        running = ap.scrollRight(false);
+                    }
+                    else if (mouseDragging && (evt.getX() >= getWidth()))
+                    {
+                        running = ap.scrollRight(true);
+                    }
+                }
+
+                try
+                {
+                    Thread.sleep(20);
+                }
+                catch (Exception ex)
+                {
+                }
+            }
+        }
+    }
+}