X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FSeqPanel.java;h=bc8f20009598607f32aa1905ab161c11183284b6;hb=519ea38fa40b0d2e7b3979268f19415f14e1e888;hp=7b3fae3d887129f6f949dbd15043504cf47ebeba;hpb=833d51dab7947d82ffe5a826f6282cce358a4d57;p=jalview.git

diff --git a/src/jalview/gui/SeqPanel.java b/src/jalview/gui/SeqPanel.java
index 7b3fae3..bc8f200 100755
--- a/src/jalview/gui/SeqPanel.java
+++ b/src/jalview/gui/SeqPanel.java
@@ -1,472 +1,1017 @@
+/*
+ * 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.analysis.*;
+
+import jalview.datamodel.*;
+
+import jalview.schemes.*;
+
 import java.awt.*;
 import java.awt.event.*;
-import jalview.datamodel.*;
+
+import java.util.*;
+
 import javax.swing.*;
-import jalview.schemes.*;
-import jalview.analysis.*;
 
 
+/**
+ * DOCUMENT ME!
+ *
+ * @author $author$
+ * @version $Revision$
+ */
 public class SeqPanel extends JPanel
 {
+    /** DOCUMENT ME!! */
+    public SeqCanvas seqCanvas;
+
+    /** DOCUMENT ME!! */
+    public AlignmentPanel ap;
+    protected int lastres;
+    protected int startseq;
+    int startEdit = -1;
+    int endEdit = -1;
+    protected AlignViewport av;
+
+    // if character is inserted or deleted, we will need to recalculate the conservation
+    int seqEditOccurred = -1;
+    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;
+
+    boolean mouseWheelPressed = false;
+
+    /**
+     * 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);
 
-  public    SeqCanvas         seqCanvas;
-  public    AlignmentPanel    parent;
-
-  protected int startres;
-  protected int lastres;
-  protected int endres;
+        seqCanvas = new SeqCanvas(avp);
+        setLayout(new BorderLayout());
+        add(seqCanvas, BorderLayout.CENTER);
 
-  protected int startseq;
-  protected int padseq;
+        ap = p;
 
-  protected AlignViewport av;
+        addMouseMotionListener(new MouseMotionAdapter()
+            {
+                public void mouseMoved(MouseEvent evt)
+                {
+                    if (av.getWrapAlignment())
+                    {
+                        return;
+                    }
 
-  // if character is inserted or deleted, we will need to recalculate the conservation
-  int seqEditOccurred = -1;
+                    doMouseMoved(evt);
+                }
 
-  public SeqPanel(AlignViewport avp, AlignmentPanel p) {
-    this.av         = avp;
+                public void mouseDragged(MouseEvent evt)
+                {
+                    if (av.getWrapAlignment())
+                    {
+                        return;
+                    }
 
-    seqCanvas  = new SeqCanvas(avp);
-    setLayout(new BorderLayout());
-    add(seqCanvas, BorderLayout.CENTER);
+                    if (editingSeqs)
+                    {
+                        doMouseDragged(evt);
+                    }
+                    else
+                    {
+                        doMouseDraggedDefineMode(evt);
+                    }
+                }
+            });
 
-    parent = p;
+       addMouseWheelListener(new MouseWheelListener()
+       {
+         public void mouseWheelMoved(MouseWheelEvent e)
+         {
 
-    addMouseMotionListener( new MouseMotionAdapter()
-    {
-      public void mouseMoved(MouseEvent evt)
-      {   doMouseMoved(evt);    }
+           if (mouseWheelPressed)
+           {
+             Font font = av.getFont();
+             int fontSize = font.getSize();
+             if (e.getWheelRotation() > 0 && fontSize < 30)
+               fontSize++;
+             else if (fontSize > 1)
+               fontSize--;
+
+             av.setFont(new Font(font.getName(), font.getStyle(), fontSize));
+             ap.fontChanged();
+           }
+           else
+           {
+             if (e.getWheelRotation() > 0)
+               ap.scrollUp(false);
+             else
+               ap.scrollUp(true);
+           }
 
-      public void mouseDragged(MouseEvent evt)
-      {
-        if(evt.isShiftDown() || evt.isAltDown() || evt.isControlDown())
-          doMouseDragged(evt);
-        else
-          doMouseDraggedDefineMode(evt);
-      }
-    });
+         }
+       });
 
-    addMouseListener( new MouseAdapter()
-    {
-      public void mouseReleased(MouseEvent evt)
-      {
-        if(evt.isShiftDown() || evt.isAltDown() || evt.isControlDown())
-          doMouseReleased(evt);
-        else
-          doMouseReleasedDefineMode(evt);
-      }
-      public void mousePressed(MouseEvent evt)
-      {
-        if(evt.isShiftDown() || evt.isAltDown() || evt.isControlDown())
-          doMousePressed(evt);
-        else
-          doMousePressedDefineMode(evt);
-      }
 
-    });
-    repaint();
-  }
+        addMouseListener(new MouseAdapter()
+            {
+                public void mouseReleased(MouseEvent evt)
+                {
+                    mouseWheelPressed = false;
+                    if (av.getWrapAlignment())
+                    {
+                        return;
+                    }
 
+                    if (editingSeqs)
+                    {
+                        doMouseReleased(evt);
+                    }
+                    else
+                    {
+                        doMouseReleasedDefineMode(evt);
+                    }
+                }
 
-  public void doMouseReleased(MouseEvent evt) {
+                public void mousePressed(MouseEvent evt)
+                {
+                  if( javax.swing.SwingUtilities.isMiddleMouseButton(evt))
+                  {
+                    mouseWheelPressed = true;
+                    return;
+                  }
+                    if (av.getWrapAlignment())
+                    {
+                        return;
+                    }
 
-    int x = evt.getX();
-    int res = x/av.getCharWidth() + av.getStartRes();
+                    if (evt.isShiftDown() || evt.isAltDown() ||
+                            evt.isControlDown())
+                    {
+                        if (evt.isAltDown() || evt.isControlDown())
+                        {
+                            groupEditing = true;
+                        }
 
-    endres = res;
+                        editingSeqs = true;
+                        doMousePressed(evt);
+                    }
+                    else
+                    {
+                        doMousePressedDefineMode(evt);
+                    }
+                }
 
-    startseq = -1;
-    startres = -1;
-    lastres  = -1;
-    if(seqEditOccurred>-1)
-      updateConservation(seqEditOccurred);
+                public void mouseExited(MouseEvent evt)
+                {
+                    if (av.getWrapAlignment() || editingSeqs)
+                    {
+                        return;
+                    }
 
-    seqEditOccurred = -1;
+                    doMouseExitedDefineMode(evt);
+                }
 
-    parent.RefreshPanels();
-    repaint();
+                public void mouseEntered(MouseEvent evt)
+                {
+                    if (av.getWrapAlignment() || editingSeqs)
+                    {
+                        return;
+                    }
 
-  }
+                    doMouseEnteredDefineMode(evt);
+                }
+            });
+    }
 
-  public void doMousePressed(MouseEvent evt) {
-    parent.alignFrame.addHistoryItem("sequence edit");
-    int seq;
-    int res;
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void doMouseReleased(MouseEvent evt)
+    {
+        if (seqEditOccurred > -1)
+        {
+            editOccurred(seqEditOccurred);
+        }
 
-    int x = evt.getX();
-    int y = evt.getY();
+        startseq = -1;
+        lastres = -1;
+        seqEditOccurred = -1;
+        editingSeqs = false;
+        groupEditing = false;
 
-    res = x/av.getCharWidth() + av.getStartRes();
-    seq = y/av.getCharHeight() + av.getStartSeq();
+        ap.repaint();
+    }
 
-    if (seq < av.getAlignment().getHeight() &&
-        res < av.getAlignment().getSequenceAt(seq).getLength())
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void doMousePressed(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
+        ap.alignFrame.addHistoryItem(new HistoryItem("Edit Sequence",
+                av.alignment, HistoryItem.EDIT));
 
-      startseq = seq;
+        int seq;
+        int res;
 
-      if (startseq == (av.getAlignment().getHeight() - 1))
-        padseq = 1;
-      else
-        padseq = 1;
+        int x = evt.getX();
+        int y = evt.getY();
+
+        res = (x / av.getCharWidth()) + av.getStartRes();
+        seq = (y / av.getCharHeight()) + av.getStartSeq();
 
-      startres = res;
-      lastres = res;
+        if ((seq < av.getAlignment().getHeight()) &&
+                (res < av.getAlignment().getSequenceAt(seq).getLength()))
+        {
+            startseq = seq;
+            lastres = res;
+        }
+        else
+        {
+            startseq = -1;
+            lastres = -1;
+        }
 
+        startEdit = lastres;
+        endEdit = lastres;
+
+        return;
     }
-    else
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void doMouseMoved(MouseEvent evt)
     {
-      startseq = -1;
-      startres = -1;
-      lastres = -1;
-    }
+        int res = 0;
+        int seq = 0;
+        int x = evt.getX();
+        int y = evt.getY();
 
-    return;
-  }
+        if (av.wrapAlignment)
+        {
+            y -= (2 * av.charHeight);
 
-  public void doMouseMoved(MouseEvent evt)
-  {
-    int res=0, seq=0;
-    int x = evt.getX();
-    int y = evt.getY();
-    if(av.wrapAlignment)
-    {
-      y -= 2*av.charHeight;
-      int chunkHeight = (av.getAlignment().getHeight()+2)*av.charHeight;
+            int chunkHeight = (av.getAlignment().getHeight() + 2) * av.charHeight;
 
+            res = (int) ((y / chunkHeight) * (getWidth() / av.charWidth)) +
+                (x / av.getCharWidth()) + av.getStartRes();
 
-      res =   (int)((y/chunkHeight)*(getWidth()/av.charWidth)) +  x/av.getCharWidth() + av.getStartRes();
+            y %= chunkHeight;
+            seq = (y / av.getCharHeight()) + av.getStartSeq();
+        }
+        else
+        {
+            res = (x / av.getCharWidth()) + av.getStartRes();
+            seq = (y / av.getCharHeight()) + av.getStartSeq();
+        }
 
-      y %= chunkHeight;
-      seq =     y / av.getCharHeight() + av.getStartSeq();
+        if (seq >= av.getAlignment().getHeight())
+        {
+            return;
+        }
 
-      //   chunkHeight =  (da.getHeight() + 2)*charHeight;
-      //  startx += chunkWidth;
-    }
-    else
-    {
-      res = x / av.getCharWidth()  + av.getStartRes();
-      seq = y / av.getCharHeight() + av.getStartSeq();
-    }
+        SequenceI sequence = av.getAlignment().getSequenceAt(seq);
 
+        if (res > sequence.getLength())
+        {
+            return;
+        }
 
-    if(seq>=av.getAlignment().getHeight())
-      return;
+        Object obj = ResidueProperties.aa2Triplet.get(sequence.getCharAt(res) +
+                "");
+        String aa = "";
 
-    Object obj = ResidueProperties.aa2Triplet.get( av.getAlignment().getSequenceAt(seq).getCharAt(res)+"" ) ;
-    String aa = "";
-    if(obj!=null)
-         aa = obj.toString();
+        if (obj != null)
+        {
+            aa = obj.toString();
+        }
+
+        StringBuffer text = new StringBuffer("Sequence " + (seq + 1) + " ID: " +
+                sequence.getName());
 
-    StringBuffer text = new StringBuffer("Sequence " +(seq+1)+" ID: "+av.getAlignment().getSequenceAt(seq).getName());
-    if(aa!="")
-      text.append("  Residue: "+aa+" ("+  av.getAlignment().getSequenceAt(seq).findPosition(res)+")");
+        if (aa != "")
+        {
+            text.append("  Residue: " + aa + " (" +
+                av.getAlignment().getSequenceAt(seq).findPosition(res) + ")");
+        }
 
-    parent.alignFrame.statusBar.setText(text.toString());
+        ap.alignFrame.statusBar.setText(text.toString());
 
-  }
+        // use aa to see if the mouse pointer is on a
+        if (av.showSequenceFeatures)
+        {
+            Vector features = sequence.getSequenceFeatures();
+            Enumeration e = features.elements();
+            StringBuffer sbuffer = new StringBuffer();
 
-  public void doMouseDragged(MouseEvent evt) {
-    // If we're dragging we're editing
+            while (e.hasMoreElements())
+            {
+                SequenceFeature sf = (SequenceFeature) e.nextElement();
 
-    int x = evt.getX();
+                if ((sf.getStart() <= sequence.findPosition(res)) &&
+                        (sf.getEnd() >= sequence.findPosition(res)))
+                {
+                    if (sbuffer.length() > 0)
+                    {
+                        sbuffer.append("; ");
+                    }
 
-    int res = x/av.getCharWidth() + av.getStartRes();
-    if (res < 0)
-      res = 0;
+                    sbuffer.append(sf.getType() + " " + sf.getDescription());
 
-    if (res != lastres)
+                    if (sf.getStatus().length() > 0)
+                    {
+                        sbuffer.append(" (" + sf.getStatus() + ")");
+                    }
+                }
+            }
+
+            this.setToolTipText(sbuffer.toString());
+        }
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void doMouseDragged(MouseEvent evt)
     {
-	// Group editing
-	if (evt.isAltDown() || evt.isControlDown())
+        // If we're dragging we're editing
+        int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
+
+        if (res < 0)
         {
-	  SequenceGroup sg = av.getAlignment().findGroup(startseq);
-          if (sg != null)
-          {
-            boolean deleteAllowed = false;
-            if (res < av.getAlignment().getWidth() && res < lastres)
+            res = 0;
+        }
+
+        if ((lastres == -1) || (lastres == res))
+        {
+            return;
+        }
+
+        boolean dragRight = true;
+
+        if ((res < av.getAlignment().getWidth()) && (res < lastres))
+        {
+            dragRight = false;
+        }
+
+        if (res != lastres)
+        {
+            // Group editing
+            if (groupEditing)
             {
-              /// Are we able to delete?
-              boolean allGaps = true;
-              for (int i = 0; i < sg.getSize(); i++)
-              {
-                SequenceI s = sg.getSequenceAt(i);
-                for (int j = lastres-1; j >= res && allGaps; j--)
+                SequenceGroup sg = av.getSelectionGroup();
+
+                if (sg == null)
+                {
+                    lastres = -1;
+
+                    return;
+                }
+
+                // drag to right
+                if (dragRight)
                 {
-                    if (!jalview.util.Comparison.isGap(s.getSequence().charAt(j)))
+                    sg.setEndRes(sg.getEndRes() + (res - lastres));
+                }
+
+                // drag to left
+                else
+                {
+                    /// Are we able to delete?
+                    // ie are all columns blank?
+                    boolean deleteAllowed = false;
+
+                    for (int s = 0; s < sg.getSize(); s++)
                     {
-                      res = j + 1;
-                      allGaps = false;
+                        SequenceI seq = sg.getSequenceAt(s);
+
+                        for (int j = res; j < lastres; j++)
+                        {
+                            if (seq.getSequence().length() <= j)
+                            {
+                                continue;
+                            }
+
+                            if (!jalview.util.Comparison.isGap(
+                                        seq.getSequence().charAt(j)))
+                            {
+                                // Not a gap, block edit not valid
+                                res = j + 1;
+                                deleteAllowed = false;
+
+                                continue;
+                            }
+
+                            deleteAllowed = true;
+                        }
                     }
+
+                    if (!deleteAllowed)
+                    {
+                        lastres = -1;
+
+                        return;
+                    }
+
+                    sg.setEndRes(sg.getEndRes() - (lastres - res));
                 }
 
-                if(!deleteAllowed && allGaps)
-                  deleteAllowed = true;
-              }
+                for (int i = 0; i < sg.getSize(); i++)
+                {
+                    SequenceI s = sg.getSequenceAt(i);
+                    int k = av.alignment.findIndex(s);
+
+                    // drag to right
+                    if (dragRight)
+                    {
+                        for (int j = lastres; j < res; j++)
+                        {
+                            insertChar(j, k);
+                        }
+                    }
+
+                    // drag to left
+                    else
+                    {
+                        for (int j = res; j < lastres; j++)
+                        {
+                            if (s.getLength() > j)
+                            {
+                                deleteChar(res, k);
+                            }
+                        }
+                    }
+                }
+            }
+            else /////Editing a single sequence///////////
+            {
+                if ((res < av.getAlignment().getWidth()) && (res > lastres))
+                {
+                    // dragging to the right
+                    for (int j = lastres; j < res; j++)
+                    {
+                        insertChar(j, startseq);
+                    }
+                }
+                else if ((res < av.getAlignment().getWidth()) &&
+                        (res < lastres))
+                {
+                    // dragging to the left
+                    for (int j = lastres; j > res; j--)
+                    {
+                        if (jalview.util.Comparison.isGap(
+                                    av.alignment.getSequenceAt(startseq)
+                                                    .getSequence().charAt(res)))
+                        {
+                            deleteChar(res, startseq);
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                }
             }
+        }
 
-            // drag to right
-            if (res < av.getAlignment().getWidth() && res > lastres)
-                sg.setEndRes(sg.getEndRes() + 1);
+        endEdit = res;
+        lastres = res;
+        seqCanvas.repaint();
+    }
 
-            // drag to left
-            else if (deleteAllowed && res < av.getAlignment().getWidth() &&
-                     res < lastres)
-                sg.setEndRes(sg.getEndRes() - 1);
+    /**
+     * DOCUMENT ME!
+     *
+     * @param seqstart DOCUMENT ME!
+     * @param seqend DOCUMENT ME!
+     * @param start DOCUMENT ME!
+     */
+    public void drawChars(int seqstart, int seqend, int start)
+    {
+        seqCanvas.drawPanel(seqCanvas.gg, start, av.getEndRes(), seqstart,
+            seqend, av.getStartRes(), av.getStartSeq(), 0);
+        seqCanvas.repaint();
+    }
 
+    /**
+     * DOCUMENT ME!
+     *
+     * @param j DOCUMENT ME!
+     * @param seq DOCUMENT ME!
+     */
+    public void insertChar(int j, int seq)
+    {
+        av.alignment.getSequenceAt(seq).insertCharAt(j, av.getGapCharacter());
+        seqEditOccurred = seq;
+    }
 
+    /**
+     * DOCUMENT ME!
+     *
+     * @param j DOCUMENT ME!
+     * @param seq DOCUMENT ME!
+     */
+    public void deleteChar(int j, int seq)
+    {
+        av.alignment.getSequenceAt(seq).deleteCharAt(j);
+        seqEditOccurred = seq;
 
+        av.alignment.getWidth();
+        seqCanvas.repaint();
+    }
 
-            for (int i = 0; i < sg.getSize(); i++)
+    /**
+     * DOCUMENT ME!
+     *
+     * @param i DOCUMENT ME!
+     */
+    void editOccurred(int i)
+    {
+      if (endEdit == startEdit)
+      {
+        ap.alignFrame.historyList.pop();
+        ap.alignFrame.updateEditMenuBar();
+      }
+
+      av.updateConservation();
+      av.updateConsensus();
+
+      //Does the edit affect any groups?
+      //////////////////////////////
+      Vector groupsToUpdate = new Vector();
+      SequenceGroup sg = av.getSelectionGroup();
+
+      int s, g, gSize = av.alignment.getGroups().size();
+      if (sg != null)
+      {
+        groupsToUpdate.addElement(av.getSelectionGroup());
+        int sSize = sg.getSize();
+        for (s = 0; s < sSize; s++)
+        {
+          SequenceI seq = sg.getSequenceAt(s);
+
+          for (g = 0; g < gSize; g++)
+          {
+            SequenceGroup sg2 = (SequenceGroup) av.alignment.getGroups().
+                elementAt(
+                    g);
+            if (sg2.sequences.contains(seq))
             {
-              SequenceI s = sg.getSequenceAt(i);
-              int k = av.alignment.findIndex(s);
-
-              // drag to right
-              if (res < av.getAlignment().getWidth() && res > lastres)
-                for (int j = lastres; j < res; j++)
-                  insertChar(j, k);
-
-              // drag to left
-              else if (deleteAllowed && res < av.getAlignment().getWidth() && res < lastres)
-              {
-                for (int j = res; j < lastres; j++)
-                {
-                  deleteChar(j, k);
-                  startres = res;
-                }
-              }
+              if (!groupsToUpdate.contains(sg2))
+                groupsToUpdate.addElement(sg2);
+              continue;
             }
           }
         }
-        else /////Editing a single sequence///////////
+      }
+      else
+      {
+        SequenceI seq = av.alignment.getSequenceAt(startseq);
+        for (g = 0; g < gSize; g++)
         {
-          if (res < av.getAlignment().getWidth() && res > lastres)
+          SequenceGroup sg2 = (SequenceGroup) av.alignment.getGroups().elementAt(
+              g);
+          if (sg2.sequences.contains(seq))
           {
-            // dragging to the right
-            for (int j = lastres; j < res; j++)
-              insertChar(j, startseq);
+            if (!groupsToUpdate.contains(sg2))
+              groupsToUpdate.addElement(sg2);
+            continue;
           }
-          else if (res < av.getAlignment().getWidth() && res < lastres)
+        }
+      }
+
+      gSize = groupsToUpdate.size();
+      for (g = 0; g < gSize; g++)
+      {
+        ( (SequenceGroup) groupsToUpdate.elementAt(g)).recalcConservation();
+      }
+      ////End of updating groups
+      //////////////////////////////////////////
+
+        // Y O Y CLUSTALX
+        ColourSchemeI cs = av.getGlobalColourScheme();
+        if(cs!=null)
+        {
+          if (cs.conservationApplied())
           {
-            // dragging to the left
-            for (int j = res; j < lastres; j++)
+            Conservation c = new Conservation("All",
+                                              ResidueProperties.propHash, 3,
+                                              av.alignment.getSequences(),
+                                              0, av.alignment.getWidth() - 1);
+            c.calculate();
+            c.verdict(false, av.ConsPercGaps);
+
+            if (cs instanceof ClustalxColourScheme)
+            {
+              ClustalxColourScheme cxs = (ClustalxColourScheme) cs;
+              cxs.resetClustalX(av.alignment.getSequences(),
+                                av.alignment.getWidth());
+              cs.setConservation(c);
+              av.setGlobalColourScheme(cs);
+            }
+            else
             {
-              deleteChar(j, startseq);
-              startres = res;
+              cs.setConservation(c);
+              av.setGlobalColourScheme(cs);
             }
-	  }
 
-	}
+          }
 
+          if (cs instanceof ClustalxColourScheme)
+          {
+            ( (ClustalxColourScheme) cs).resetClustalX(av.alignment.getSequences(),
+                                                       av.alignment.getWidth());
+            av.setGlobalColourScheme(cs);
+          }
+        }
     }
 
-    lastres = res;
-    repaint();
-  }
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void doMousePressedDefineMode(MouseEvent evt)
+    {
+        int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
+        int seq = (evt.getY() / av.getCharHeight()) + av.getStartSeq();
+        oldSeq = seq;
 
-  public void drawChars(int seqstart, int seqend, int start) {
-    seqCanvas.drawPanel(seqCanvas.gg, start,av.getEndRes(),seqstart,seqend,av.getStartRes(),av.getStartSeq(),0);
-    repaint();
-  }
+        SequenceI sequence = (Sequence) av.getAlignment().getSequenceAt(seq);
 
-  public void insertChar(int j, int seq)
-  {
-    av.alignment.getSequenceAt(seq).insertCharAt(j, av.getGapCharacter());
-    seqEditOccurred=seq;
-  }
+        if ((sequence == null) || (res > sequence.getLength()))
+        {
+            return;
+        }
 
-  public void deleteChar(int j, int seq)
-  {
+        stretchGroup = av.getSelectionGroup();
 
-    if ( jalview.util.Comparison.isGap( av.alignment.getSequenceAt(seq).getSequence().charAt(j)))
-        av.alignment.getSequenceAt(seq).deleteCharAt(j);
+        if (stretchGroup == null)
+        {
+            stretchGroup = av.alignment.findGroup(sequence);
 
-    av.alignment.getWidth();
-    repaint();
-    seqEditOccurred=seq;
-  }
-
-
-  void updateConservation(int i)
-  {
-  /*  Alignment al = (Alignment) av.getAlignment();
-    SequenceGroup sg = av.alignment.findGroup( al.getSequenceAt(i));
-    if(sg==null || !(sg.cs instanceof ConservationColourScheme))
-      return;
-
-    Conservation c = sg.getConservation();
-
-    c = new Conservation("All", al.cons,
-                         ResidueProperties.propHash, 3, sg.sequences, 0,
-                         al.getWidth());
-    c.calculate();
-    c.verdict(false, 100);
-    sg.setConservation(c);
-    ConservationColourScheme ccs = (ConservationColourScheme)sg.cs;
-    ccs.conserve = c;*/
-  }
-
-//////////////////////////////////////////
-/////Everything below this is for defining the boundary of the rubberband
-//////////////////////////////////////////
-  int oldSeq = -1;
-  public void doMousePressedDefineMode(MouseEvent evt)
-  {
-    int res = evt.getX()/av.getCharWidth() + av.getStartRes();
-    int seq = evt.getY()/av.getCharHeight() + av.getStartSeq();
-    oldSeq = seq;
-
-    stretchGroup = av.getRubberbandGroup();
-
-    if(stretchGroup == null)
-     {
-       stretchGroup = av.alignment.findGroup( (Sequence) av.getAlignment().
-                                             getSequenceAt(seq));
-       av.setRubberbandGroup( stretchGroup );
-     }
-
-    else if(!stretchGroup.sequences.contains((Sequence)av.getAlignment().getSequenceAt(seq))
-            || stretchGroup.getStartRes()>res
-            || stretchGroup.getEndRes()<res)
-     {
-       stretchGroup = null;
-
-       SequenceGroup[] allGroups = av.alignment.findAllGroups( (Sequence) av.
-           getAlignment().
-           getSequenceAt(seq));
-
-       if (allGroups != null)
-         for (int i = 0; i < allGroups.length; i++)
-           if (allGroups[i].getStartRes() <= res &&
-               allGroups[i].getEndRes() >= res)
-           {
-             stretchGroup = allGroups[i];
-             av.setRubberbandGroup(stretchGroup);
-             break;
-           }
-     }
+            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;
 
-    if(stretchGroup==null)
-    {
-      // define a new group here
-      SequenceGroup sg = new SequenceGroup();
-      sg.setStartRes(res);
-      sg.setEndRes(res);
-      sg.addSequence( (Sequence)av.getAlignment().getSequenceAt(seq) );
-      av.setRubberbandGroup( sg );
-      stretchGroup = sg;
+            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 (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();
     }
-    else if( javax.swing.SwingUtilities.isRightMouseButton(evt))
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void doMouseReleasedDefineMode(MouseEvent evt)
     {
-        jalview.gui.PopupMenu pop = new jalview.gui.PopupMenu( parent , null);
-        pop.show(this, evt.getX(), evt.getY());
+        if (mouseDragging)
+        {
+            stretchGroup.recalcConservation();
+            mouseDragging = false;
+        }
 
-    // edit the properties of existing group
+        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());
+          }
+          else
+          {
+            SliderPanel.setPIDSliderSource(ap, stretchGroup.cs,
+                                           stretchGroup.getName());
+          }
+        }
+        changeEndRes = false;
+        changeStartRes = false;
+        stretchGroup = null;
+        PaintRefresher.Refresh(av.alignment);
     }
 
-    if(stretchGroup!=null && stretchGroup.getEndRes()==res)
-      // Edit end res position of selected group
-      changeEndRes = true;
+    /**
+     * DOCUMENT ME!
+     *
+     * @param evt DOCUMENT ME!
+     */
+    public void doMouseDraggedDefineMode(MouseEvent evt)
+    {
+        int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
+        int y = (evt.getY() / av.getCharHeight()) + av.getStartSeq();
 
-   else if(stretchGroup!=null && stretchGroup.getStartRes()==res)
-      // Edit end res position of selected group
-      changeStartRes = true;
+        if (stretchGroup == null)
+        {
+            return;
+        }
 
+        if (res > av.alignment.getWidth())
+        {
+            res = av.alignment.getWidth() - 1;
+        }
 
-    seqCanvas.paintFlag = true;
-    repaint();
+        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();
+        }
+        else if (res > av.getEndRes())
+        {
+            res = av.getEndRes();
+        }
 
-  boolean changeEndSeq = false;
-  boolean changeStartSeq = false;
-  boolean changeEndRes = false;
-  boolean changeStartRes = false;
-  SequenceGroup stretchGroup = null;
+        if (changeEndRes)
+        {
+            if (res > (stretchGroup.getStartRes() - 1))
+            {
+                stretchGroup.setEndRes(res);
+            }
+        }
+        else if (changeStartRes)
+        {
+            if (res < (stretchGroup.getEndRes() + 1))
+            {
+                stretchGroup.setStartRes(res);
+            }
+        }
+
+        int dragDirection = 0;
 
-  public void doMouseReleasedDefineMode(MouseEvent evt)
-  {
-    changeEndRes = false;
-    changeStartRes = false;
-    stretchGroup = null;
-  }
+        if (y > oldSeq)
+        {
+            dragDirection = 1;
+        }
+        else if (y < oldSeq)
+        {
+            dragDirection = -1;
+        }
 
+        while ((y != oldSeq) && (oldSeq > 0) && (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);
 
-  boolean remove = false;
-  public void doMouseDraggedDefineMode(MouseEvent evt)
-  {
-    int res = evt.getX()/av.getCharWidth() + av.getStartRes();
-    int y = evt.getY()/av.getCharHeight() + av.getStartSeq();
+            oldSeq += dragDirection;
 
+            Sequence nextSeq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
 
-    if(stretchGroup.getEndRes()==res)
-      // Edit end res position of selected group
-      changeEndRes = true;
+            if (stretchGroup.sequences.contains(nextSeq))
+            {
+                stretchGroup.deleteSequence(seq, false);
+            }
+            else
+            {
+                if (seq != null)
+                {
+                    stretchGroup.addSequence(seq, false);
+                }
 
-    else if(stretchGroup.getStartRes()==res)
-      // Edit end res position of selected group
-      changeStartRes = true;
+                stretchGroup.addSequence(nextSeq, false);
+            }
+        }
 
+        oldSeq = y;
+        mouseDragging = true;
 
-    if(res<av.getStartRes())
-      res = av.getStartRes();
-    else if(res>av.getEndRes())
-      res = av.getEndRes();
+        if (scrollThread != null)
+        {
+            scrollThread.setEvent(evt);
+        }
 
-    if(changeEndRes)
-    {
-      if(res>stretchGroup.getStartRes()-1)
-        stretchGroup.setEndRes( res );
+        seqCanvas.repaint();
     }
-    else if(changeStartRes)
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param e DOCUMENT ME!
+     */
+    public void doMouseEnteredDefineMode(MouseEvent e)
     {
-      if(res<stretchGroup.getEndRes()+1)
-        stretchGroup.setStartRes( res );
+        if (scrollThread != null)
+        {
+            scrollThread.running = false;
+        }
     }
 
+    /**
+     * DOCUMENT ME!
+     *
+     * @param e DOCUMENT ME!
+     */
+    public void doMouseExitedDefineMode(MouseEvent e)
+    {
+        if (av.getWrapAlignment())
+        {
+            return;
+        }
 
-    int dragDirection = 0;
-    if (y > oldSeq)
-      dragDirection = 1;
-    else if (y < oldSeq)
-      dragDirection = -1;
+        if (mouseDragging)
+        {
+            scrollThread = new ScrollThread();
+        }
+    }
 
-    while (y != oldSeq)
+    // this class allows scrolling off the bottom of the visible alignment
+    class ScrollThread extends Thread
     {
-      // This routine ensures we don't skip any sequences, as the
-      // selection is quite slow.
-      Sequence seq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
-
-      oldSeq += dragDirection;
-      Sequence nextSeq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
+        MouseEvent evt;
+        boolean running = false;
 
-      if (stretchGroup.sequences.contains(nextSeq))
-      {
-        stretchGroup.deleteSequence(seq);
-        stretchGroup.deleteSequence(nextSeq);
-      }
-      else
-      {
-        stretchGroup.addSequence(seq);
-        stretchGroup.addSequence(nextSeq);
-      }
-    }
-    oldSeq = y;
+        public ScrollThread()
+        {
+            start();
+        }
 
-    seqCanvas.paintFlag = true;
-    repaint();
-  }
+        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(true);
+                    }
+                    else if (mouseDragging && (evt.getX() >= getWidth()))
+                    {
+                        running = ap.scrollRight(false);
+                    }
+                }
 
+                try
+                {
+                    Thread.sleep(75);
+                }
+                catch (Exception ex)
+                {
+                }
+            }
+        }
+    }
+}