X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FSeqPanel.java;h=52d137bf316b51d7b9b3d79cd71d53eb1d9a5e1f;hb=92a3a0f396a86b2bc0a8d1a311680ceda4abec7b;hp=55bec56139156b54db198696e1010d9c89542289;hpb=99cb058c4b312055ca758890b10d41428105dabe;p=jalview.git

diff --git a/src/jalview/gui/SeqPanel.java b/src/jalview/gui/SeqPanel.java
index 55bec56..52d137b 100755
--- a/src/jalview/gui/SeqPanel.java
+++ b/src/jalview/gui/SeqPanel.java
@@ -1,616 +1,779 @@
+/*
+ * 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 java.util.*;
+
 import java.awt.*;
 import java.awt.event.*;
-import jalview.datamodel.*;
 import javax.swing.*;
-import java.util.*;
-import jalview.schemes.*;
-import jalview.analysis.*;
 
+import jalview.analysis.*;
+import jalview.datamodel.*;
+import jalview.schemes.*;
 
-public class SeqPanel extends JPanel
+public class SeqPanel
+    extends JPanel
 {
-
-  public    SeqCanvas         seqCanvas;
-  public    AlignmentPanel    ap;
-
-  protected int startres;
+  public SeqCanvas seqCanvas;
+  public AlignmentPanel ap;
   protected int lastres;
-  protected int endres;
-
   protected int startseq;
-  protected int padseq;
-
+  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;
 
-  public SeqPanel(AlignViewport avp, AlignmentPanel p) {
-    this.av         = avp;
+  public SeqPanel(AlignViewport avp, AlignmentPanel p)
+  {
+    this.av = avp;
 
-    seqCanvas  = new SeqCanvas(avp);
+    seqCanvas = new SeqCanvas(avp);
     setLayout(new BorderLayout());
     add(seqCanvas, BorderLayout.CENTER);
 
     ap = p;
 
-    addMouseMotionListener( new MouseMotionAdapter()
+    addMouseMotionListener(new MouseMotionAdapter()
     {
       public void mouseMoved(MouseEvent evt)
       {
-       if(av.getWrapAlignment())
-         return;
-        doMouseMoved(evt);    }
+        if (av.getWrapAlignment())
+        {
+          return;
+        }
+
+        doMouseMoved(evt);
+      }
 
       public void mouseDragged(MouseEvent evt)
       {
-        if(av.getWrapAlignment())
-         return;
-        if(evt.isShiftDown() || evt.isAltDown() || evt.isControlDown())
+        if (av.getWrapAlignment())
+        {
+          return;
+        }
+
+        if (editingSeqs)
+        {
           doMouseDragged(evt);
+        }
         else
+        {
           doMouseDraggedDefineMode(evt);
+        }
       }
     });
 
-    addMouseListener( new MouseAdapter()
+    addMouseListener(new MouseAdapter()
     {
       public void mouseReleased(MouseEvent evt)
       {
-        if(av.getWrapAlignment())
-         return;
-        if(evt.isShiftDown() || evt.isAltDown() || evt.isControlDown())
+        if (av.getWrapAlignment())
+        {
+          return;
+        }
+
+        if (editingSeqs)
+        {
           doMouseReleased(evt);
+        }
         else
+        {
           doMouseReleasedDefineMode(evt);
+        }
       }
+
       public void mousePressed(MouseEvent evt)
       {
-        if(av.getWrapAlignment())
-         return;
-        if(evt.isShiftDown() || evt.isAltDown() || evt.isControlDown())
+        if (av.getWrapAlignment())
+        {
+          return;
+        }
+
+        if (evt.isShiftDown() || evt.isAltDown() ||
+            evt.isControlDown())
+        {
+          if (evt.isAltDown() || evt.isControlDown())
+          {
+            groupEditing = true;
+          }
+
+          editingSeqs = true;
           doMousePressed(evt);
+        }
         else
+        {
           doMousePressedDefineMode(evt);
+        }
       }
+
       public void mouseExited(MouseEvent evt)
       {
-        if (av.getWrapAlignment() || evt.isShiftDown() || evt.isAltDown() ||
-                  evt.isControlDown())
-                return;
-              doMouseExitedDefineMode(evt);
+        if (av.getWrapAlignment() || editingSeqs)
+        {
+          return;
+        }
 
+        doMouseExitedDefineMode(evt);
       }
+
       public void mouseEntered(MouseEvent evt)
       {
-        if (av.getWrapAlignment() || evt.isShiftDown() || evt.isAltDown() ||
-            evt.isControlDown())
+        if (av.getWrapAlignment() || editingSeqs)
+        {
           return;
+        }
+
         doMouseEnteredDefineMode(evt);
       }
-
     });
     repaint();
   }
 
-
-  public void doMouseReleased(MouseEvent evt) {
-
-    int x = evt.getX();
-    int res = x/av.getCharWidth() + av.getStartRes();
-
-    endres = res;
+  public void doMouseReleased(MouseEvent evt)
+  {
+    if (seqEditOccurred > -1)
+    {
+      editOccurred(seqEditOccurred);
+    }
 
     startseq = -1;
-    startres = -1;
-    lastres  = -1;
-    if(seqEditOccurred>-1)
-      updateConservation(seqEditOccurred);
-
+    lastres = -1;
     seqEditOccurred = -1;
+    editingSeqs = false;
+    groupEditing = false;
 
-    ap.RefreshPanels();
-    repaint();
-
+    ap.repaint();
   }
 
-  public void doMousePressed(MouseEvent evt) {
-    ap.alignFrame.addHistoryItem("sequence edit");
+  public void doMousePressed(MouseEvent evt)
+  {
+    ap.alignFrame.addHistoryItem(new HistoryItem("Edit Sequence",
+                                                 av.alignment, HistoryItem.EDIT));
+
     int seq;
     int res;
 
     int x = evt.getX();
     int y = evt.getY();
 
-    res = x/av.getCharWidth() + av.getStartRes();
-    seq = y/av.getCharHeight() + av.getStartSeq();
+    res = (x / av.getCharWidth()) + av.getStartRes();
+    seq = (y / av.getCharHeight()) + av.getStartSeq();
 
-    if (seq < av.getAlignment().getHeight() &&
-        res < av.getAlignment().getSequenceAt(seq).getLength())
+    if ( (seq < av.getAlignment().getHeight()) &&
+        (res < av.getAlignment().getSequenceAt(seq).getLength()))
     {
-      //char resstr = align.getSequenceAt(seq).getSequence().charAt(res);
-      // Find the residue's position in the sequence (res is the position
-      // in the alignment
-
       startseq = seq;
-
-      if (startseq == (av.getAlignment().getHeight() - 1))
-        padseq = 1;
-      else
-        padseq = 1;
-
-      startres = res;
       lastres = res;
-
     }
     else
     {
       startseq = -1;
-      startres = -1;
       lastres = -1;
     }
 
+    startEdit = lastres;
+    endEdit = lastres;
+
     return;
   }
 
   public void doMouseMoved(MouseEvent evt)
   {
-    int res=0, seq=0;
+    int res = 0;
+    int seq = 0;
     int x = evt.getX();
     int y = evt.getY();
-    if(av.wrapAlignment)
+
+    if (av.wrapAlignment)
     {
-      y -= 2*av.charHeight;
-      int chunkHeight = (av.getAlignment().getHeight()+2)*av.charHeight;
+      y -= (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();
-
-      //   chunkHeight =  (da.getHeight() + 2)*charHeight;
-      //  startx += chunkWidth;
+      seq = (y / av.getCharHeight()) + av.getStartSeq();
     }
     else
     {
-      res = x / av.getCharWidth()  + av.getStartRes();
-      seq = y / av.getCharHeight() + av.getStartSeq();
+      res = (x / av.getCharWidth()) + av.getStartRes();
+      seq = (y / av.getCharHeight()) + av.getStartSeq();
     }
 
-
-    if(seq>=av.getAlignment().getHeight())
+    if (seq >= av.getAlignment().getHeight())
+    {
       return;
+    }
 
     SequenceI sequence = av.getAlignment().getSequenceAt(seq);
-    if(res>sequence.getLength())
+
+    if (res > sequence.getLength())
+    {
       return;
+    }
 
-    Object obj = ResidueProperties.aa2Triplet.get( sequence.getCharAt(res)+"" ) ;
+    Object obj = ResidueProperties.aa2Triplet.get(sequence.getCharAt(res) +
+                                                  "");
     String aa = "";
-    if(obj!=null)
-         aa = obj.toString();
 
-    StringBuffer text = new StringBuffer("Sequence " +(seq+1)+" ID: "+sequence.getName());
-    if(aa!="")
-      text.append("  Residue: "+aa+" ("+  av.getAlignment().getSequenceAt(seq).findPosition(res)+")");
+    if (obj != null)
+    {
+      aa = obj.toString();
+    }
+
+    StringBuffer text = new StringBuffer("Sequence " + (seq + 1) + " ID: " +
+                                         sequence.getName());
+
+    if (aa != "")
+    {
+      text.append("  Residue: " + aa + " (" +
+                  av.getAlignment().getSequenceAt(seq).findPosition(res) + ")");
+    }
 
     ap.alignFrame.statusBar.setText(text.toString());
 
     // use aa to see if the mouse pointer is on a
-    if(  av.showSequenceFeatures)
+    if (av.showSequenceFeatures)
     {
       Vector features = sequence.getSequenceFeatures();
       Enumeration e = features.elements();
       StringBuffer sbuffer = new StringBuffer();
 
-
       while (e.hasMoreElements())
       {
         SequenceFeature sf = (SequenceFeature) e.nextElement();
-        if (sf.getStart() <= sequence.findPosition(res) &&
-            sf.getEnd() >= sequence.findPosition(res))
+
+        if ( (sf.getStart() <= sequence.findPosition(res)) &&
+            (sf.getEnd() >= sequence.findPosition(res)))
         {
-          if(sbuffer.length()>0)
+          if (sbuffer.length() > 0)
+          {
             sbuffer.append("; ");
+          }
+
           sbuffer.append(sf.getType() + " " + sf.getDescription());
-          if(sf.getStatus().length()>0)
-            sbuffer.append(" ("+sf.getStatus()+")");
-        }
 
+          if (sf.getStatus().length() > 0)
+          {
+            sbuffer.append(" (" + sf.getStatus() + ")");
+          }
+        }
       }
 
       ToolTipManager.sharedInstance().registerComponent(this);
       this.setToolTipText(sbuffer.toString());
     }
-
-
   }
 
-  public void doMouseDragged(MouseEvent evt) {
+  public void doMouseDragged(MouseEvent evt)
+  {
     // If we're dragging we're editing
+    int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
+
+    if (res < 0)
+    {
+      res = 0;
+    }
 
-    if(lastres==-1)
+    if ( (lastres == -1) || (lastres == res))
+    {
       return;
+    }
 
-    int x = evt.getX();
+    boolean dragRight = true;
 
-    int res = x/av.getCharWidth() + av.getStartRes();
-    if (res < 0)
-      res = 0;
+    if ( (res < av.getAlignment().getWidth()) && (res < lastres))
+    {
+      dragRight = false;
+    }
 
     if (res != lastres)
     {
-	// Group editing
-	if (evt.isAltDown() || evt.isControlDown())
+      // Group editing
+      if (groupEditing)
+      {
+        SequenceGroup sg = av.getSelectionGroup();
+
+        if (sg == null)
         {
-	  SequenceGroup sg = av.getAlignment().findGroup(startseq);
-          if (sg != null)
+          lastres = -1;
+
+          return;
+        }
+
+        // drag to right
+        if (dragRight)
+        {
+          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++)
           {
-            boolean deleteAllowed = false;
-            if (res < av.getAlignment().getWidth() && res < lastres)
+            SequenceI seq = sg.getSequenceAt(s);
+
+            for (int j = res; j < lastres; j++)
             {
-              /// Are we able to delete?
-              boolean allGaps = true;
-              for (int i = 0; i < sg.getSize(); i++)
+              if (seq.getSequence().length() <= j)
               {
-                SequenceI s = sg.getSequenceAt(i);
-                for (int j = lastres-1; j >= res && allGaps; j--)
-                {
-                    if (!jalview.util.Comparison.isGap(s.getSequence().charAt(j)))
-                    {
-                      res = j + 1;
-                      allGaps = false;
-                    }
-                }
-
-                if(!deleteAllowed && allGaps)
-                  deleteAllowed = true;
+                continue;
               }
-            }
 
-            // drag to right
-            if (res < av.getAlignment().getWidth() && res > lastres)
-                sg.setEndRes(sg.getEndRes() + 1);
+              if (!jalview.util.Comparison.isGap(
+                  seq.getSequence().charAt(j)))
+              {
+                // Not a gap, block edit not valid
+                res = j + 1;
+                deleteAllowed = false;
 
-            // drag to left
-            else if (deleteAllowed && res < av.getAlignment().getWidth() &&
-                     res < lastres)
-                sg.setEndRes(sg.getEndRes() - 1);
+                continue;
+              }
 
+              deleteAllowed = true;
+            }
+          }
 
+          if (!deleteAllowed)
+          {
+            lastres = -1;
 
+            return;
+          }
 
-            for (int i = 0; i < sg.getSize(); i++)
-            {
-              SequenceI s = sg.getSequenceAt(i);
-              int k = av.alignment.findIndex(s);
+          sg.setEndRes(sg.getEndRes() - (lastres - res));
+        }
 
-              // drag to right
-              if (res < av.getAlignment().getWidth() && res > lastres)
-                for (int j = lastres; j < res; j++)
-                  insertChar(j, k);
+        for (int i = 0; i < sg.getSize(); i++)
+        {
+          SequenceI s = sg.getSequenceAt(i);
+          int k = av.alignment.findIndex(s);
 
-              // drag to left
-              else if (deleteAllowed && res < av.getAlignment().getWidth() && res < lastres)
+          // 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)
               {
-                for (int j = res; j < lastres; j++)
-                {
-                  deleteChar(j, k);
-                  startres = res;
-                }
+                deleteChar(res, k);
               }
             }
           }
         }
-        else /////Editing a single sequence///////////
+      }
+      else /////Editing a single sequence///////////
+      {
+        if ( (res < av.getAlignment().getWidth()) && (res > lastres))
         {
-          if (res < av.getAlignment().getWidth() && res > lastres)
+          // dragging to the right
+          for (int j = lastres; j < res; j++)
           {
-            // dragging to the right
-            for (int j = lastres; j < res; j++)
-              insertChar(j, startseq);
+            insertChar(j, startseq);
           }
-          else if (res < av.getAlignment().getWidth() && res < lastres)
+        }
+        else if ( (res < av.getAlignment().getWidth()) &&
+                 (res < lastres))
+        {
+          // dragging to the left
+          for (int j = lastres; j > res; j--)
           {
-            // dragging to the left
-            for (int j = res; j < lastres; j++)
+            if (jalview.util.Comparison.isGap(
+                av.alignment.getSequenceAt(startseq)
+                .getSequence().charAt(res)))
             {
-              deleteChar(j, startseq);
-              startres = res;
+              deleteChar(res, startseq);
             }
-	  }
-
-	}
-
+            else
+            {
+              break;
+            }
+          }
+        }
+      }
     }
 
+    endEdit = res;
     lastres = res;
     repaint();
   }
 
-  public void drawChars(int seqstart, int seqend, int start) {
-    seqCanvas.drawPanel(seqCanvas.gg, start,av.getEndRes(),seqstart,seqend,av.getStartRes(),av.getStartSeq(),0);
+  public void drawChars(int seqstart, int seqend, int start)
+  {
+    seqCanvas.drawPanel(seqCanvas.gg, start, av.getEndRes(), seqstart,
+                        seqend, av.getStartRes(), av.getStartSeq(), 0);
     repaint();
   }
 
   public void insertChar(int j, int seq)
   {
     av.alignment.getSequenceAt(seq).insertCharAt(j, av.getGapCharacter());
-    seqEditOccurred=seq;
+    seqEditOccurred = seq;
   }
 
   public void deleteChar(int j, int seq)
   {
-
-    if ( jalview.util.Comparison.isGap( av.alignment.getSequenceAt(seq).getSequence().charAt(j)))
-        av.alignment.getSequenceAt(seq).deleteCharAt(j);
+    av.alignment.getSequenceAt(seq).deleteCharAt(j);
+    seqEditOccurred = seq;
 
     av.alignment.getWidth();
     repaint();
-    seqEditOccurred=seq;
   }
 
-
-  void updateConservation(int i)
+  void editOccurred(int i)
   {
-  /*  Alignment al = (Alignment) av.getAlignment();
-    SequenceGroup sg = av.alignment.findGroup( al.getSequenceAt(i));
-    if(sg==null || !(sg.cs instanceof ConservationColourScheme))
-      return;
+    if (endEdit == startEdit)
+    {
+      ap.alignFrame.historyList.pop();
+      ap.alignFrame.updateEditMenuBar();
+    }
+
+    av.updateConservation();
+    av.updateConsensus();
 
-    Conservation c = sg.getConservation();
+    // Y O Y CLUSTALX
+    ColourSchemeI cs = av.getGlobalColourScheme();
 
-    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;*/
+    if (cs instanceof ConservationColourScheme)
+    {
+      ConservationColourScheme ccs = (ConservationColourScheme) cs;
+
+      if (ccs.cs instanceof ClustalxColourScheme)
+      {
+        Conservation c = new Conservation("All",
+                                          ResidueProperties.propHash, 3,
+                                          av.alignment.getSequences(), 0,
+                                          av.alignment.getWidth() - 1);
+        c.calculate();
+        c.verdict(false, av.ConsPercGaps);
+
+        ClustalxColourScheme cxs = (ClustalxColourScheme) ccs.cs;
+        cxs.resetClustalX(av.alignment.getSequences(),
+                          av.alignment.getWidth());
+        ccs = new ConservationColourScheme(c, cxs);
+        av.setGlobalColourScheme(ccs);
+      }
+    }
+
+    if (cs instanceof ClustalxColourScheme)
+    {
+      ( (ClustalxColourScheme) cs).resetClustalX(av.alignment.getSequences(),
+                                                 av.alignment.getWidth());
+      av.setGlobalColourScheme(cs);
+    }
   }
 
-//////////////////////////////////////////
-/////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();
+    int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
+    int seq = (evt.getY() / av.getCharHeight()) + av.getStartSeq();
     oldSeq = seq;
 
     SequenceI sequence = (Sequence) av.getAlignment().getSequenceAt(seq);
 
-    if(sequence==null || res>sequence.getLength())
+    if ( (sequence == null) || (res > sequence.getLength()))
+    {
       return;
+    }
 
     stretchGroup = av.getSelectionGroup();
 
-    if(stretchGroup == null)
-     {
-       stretchGroup = av.alignment.findGroup( sequence );
-       av.setSelectionGroup( stretchGroup );
-     }
-
-    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(stretchGroup==null)
+    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 (stretchGroup == null)
     {
       // define a new group here
       SequenceGroup sg = new SequenceGroup();
       sg.setStartRes(res);
       sg.setEndRes(res);
-      sg.addSequence( sequence );
-      av.setSelectionGroup( sg );
+      sg.addSequence(sequence, false);
+      av.setSelectionGroup(sg);
       stretchGroup = sg;
 
-      if(av.getConservationSelected())
-        Desktop.setConservationSliderSource(ap, av.getGlobalColourScheme(), "Background");
-      else if(av.getGlobalColourScheme()!=null && av.getGlobalColourScheme().canThreshold())
+      if (av.getConservationSelected())
       {
-        ResidueColourScheme rcs = (ResidueColourScheme) av.getGlobalColourScheme();
-        int threshold = rcs.getThreshold();
-        if (threshold > 0)
-          Desktop.setPIDSliderSource(ap, av.getGlobalColourScheme(), "Background");
+        SliderPanel.setConservationSlider(ap,
+                                          av.getGlobalColourScheme(),
+                                          "Background");
       }
 
+      if (av.getAbovePIDThreshold())
+      {
+        SliderPanel.setPIDSliderSource(ap, av.getGlobalColourScheme(),
+                                       "Background");
+      }
     }
-    else if( javax.swing.SwingUtilities.isRightMouseButton(evt))
+    else if (javax.swing.SwingUtilities.isRightMouseButton(evt))
     {
-        jalview.gui.PopupMenu pop = new jalview.gui.PopupMenu( ap , null);
-        pop.show(this, evt.getX(), evt.getY());
+      jalview.gui.PopupMenu pop = new jalview.gui.PopupMenu(ap, null);
+      pop.show(this, evt.getX(), evt.getY());
 
-    // edit the properties of existing group
+      // edit the properties of existing group
     }
 
-    if(stretchGroup!=null && stretchGroup.getEndRes()==res)
+    if ( (stretchGroup != null) && (stretchGroup.getEndRes() == res))
+    {
       // Edit end res position of selected group
       changeEndRes = true;
-
-   else if(stretchGroup!=null && stretchGroup.getStartRes()==res)
+    }
+    else if ( (stretchGroup != null) && (stretchGroup.getStartRes() == res))
+    {
       // Edit end res position of selected group
       changeStartRes = true;
+    }
 
+    stretchGroup.getWidth();
 
-    seqCanvas.paintFlag = true;
     repaint();
-
   }
 
-  boolean changeEndSeq = false;
-  boolean changeStartSeq = false;
-  boolean changeEndRes = false;
-  boolean changeStartRes = false;
-  SequenceGroup stretchGroup = null;
-
   public void doMouseReleasedDefineMode(MouseEvent evt)
   {
     mouseDragging = false;
 
-    if(stretchGroup==null)
+    if (stretchGroup == null)
+    {
       return;
+    }
 
-    if(stretchGroup.cs instanceof ClustalxColourScheme)
+    stretchGroup.recalcConservation();
+
+    if (stretchGroup.cs instanceof ClustalxColourScheme)
     {
-      stretchGroup.cs = new ClustalxColourScheme(stretchGroup.sequences, av.alignment.getWidth());
-      seqCanvas.paintFlag = true;
-      repaint();
+      stretchGroup.cs = new ClustalxColourScheme(stretchGroup.sequences,
+                                                 av.alignment.getWidth());
     }
-
-    else if(stretchGroup.cs instanceof ConservationColourScheme)
+    else if (stretchGroup.cs instanceof ConservationColourScheme)
     {
-      ConservationColourScheme ccs = (ConservationColourScheme)stretchGroup.cs;
-
-      Conservation c = new Conservation("Group",
-                                        ResidueProperties.propHash, 3, stretchGroup.sequences, 0,
-                                        av.alignment.getWidth() );
-
-       c.calculate();
-       c.verdict(false, 100);
-       ccs = new ConservationColourScheme(c, ccs.cs);
+      ConservationColourScheme ccs = (ConservationColourScheme) stretchGroup.cs;
+      stretchGroup.cs = ccs;
+      SliderPanel.setConservationSlider(ap, stretchGroup.cs,
+                                        stretchGroup.getName());
 
-       stretchGroup.cs = ccs;
-
-
-       Desktop.setConservationSliderSource(ap, stretchGroup.cs, stretchGroup.getName()) ;
-
-       seqCanvas.paintFlag = true;
-       repaint();
     }
     else
     {
-      if(stretchGroup.cs !=null && stretchGroup.cs.canThreshold())
-      {
-        ResidueColourScheme rcs =  (ResidueColourScheme) stretchGroup.cs;
-        int threshold = rcs.getThreshold();
-        if(threshold>0)
-          Desktop.setPIDSliderSource(ap, stretchGroup.cs, stretchGroup.getName());
-      }
-
+      SliderPanel.setPIDSliderSource(ap, stretchGroup.cs,
+                                     stretchGroup.getName());
     }
 
-
     changeEndRes = false;
     changeStartRes = false;
     stretchGroup = null;
+    repaint();
     ap.idPanel.repaint();
   }
 
-
-  boolean remove = false;
   public void doMouseDraggedDefineMode(MouseEvent evt)
   {
-    int res = evt.getX()/av.getCharWidth() + av.getStartRes();
-    int y = evt.getY()/av.getCharHeight() + av.getStartSeq();
+    int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
+    int y = (evt.getY() / av.getCharHeight()) + av.getStartSeq();
 
-    if(stretchGroup==null)
+    if (stretchGroup == null)
+    {
       return;
+    }
+
+    if (res > av.alignment.getWidth())
+    {
+      res = av.alignment.getWidth() - 1;
+    }
 
-    if(stretchGroup.getEndRes()==res)
+    if (stretchGroup.getEndRes() == res)
+    {
       // Edit end res position of selected group
       changeEndRes = true;
-
-    else if(stretchGroup.getStartRes()==res)
+    }
+    else if (stretchGroup.getStartRes() == res)
+    {
       // Edit start res position of selected group
       changeStartRes = true;
+    }
 
-
-    if(res<av.getStartRes())
+    if (res < av.getStartRes())
+    {
       res = av.getStartRes();
-    else if(res>av.getEndRes())
+    }
+    else if (res > av.getEndRes())
+    {
       res = av.getEndRes();
+    }
 
-    if(changeEndRes)
+    if (changeEndRes)
     {
-      if(res>stretchGroup.getStartRes()-1)
-        stretchGroup.setEndRes( res );
+      if (res > (stretchGroup.getStartRes() - 1))
+      {
+        stretchGroup.setEndRes(res);
+      }
     }
-    else if(changeStartRes)
+    else if (changeStartRes)
     {
-      if(res<stretchGroup.getEndRes()+1)
-        stretchGroup.setStartRes( res );
+      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>0)
+    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);
 
       oldSeq += dragDirection;
+
       Sequence nextSeq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
 
       if (stretchGroup.sequences.contains(nextSeq))
       {
-        stretchGroup.deleteSequence(seq);
-        stretchGroup.deleteSequence(nextSeq);
+        stretchGroup.deleteSequence(seq, false);
+        stretchGroup.deleteSequence(nextSeq, false);
       }
       else
       {
-        stretchGroup.addSequence(seq);
-        stretchGroup.addSequence(nextSeq);
+        if (seq != null)
+        {
+          stretchGroup.addSequence(seq, false);
+        }
+
+        stretchGroup.addSequence(nextSeq, false);
       }
     }
+
     oldSeq = y;
     mouseDragging = true;
-    if(scrollThread!=null)
+
+    if (scrollThread != null)
+    {
       scrollThread.setEvent(evt);
+    }
 
-    seqCanvas.paintFlag = true;
     repaint();
   }
 
   public void doMouseEnteredDefineMode(MouseEvent e)
   {
     if (scrollThread != null)
+    {
       scrollThread.running = false;
+    }
   }
 
   public void doMouseExitedDefineMode(MouseEvent e)
   {
     if (av.getWrapAlignment())
+    {
       return;
+    }
 
-    if(mouseDragging)
+    if (mouseDragging)
+    {
       scrollThread = new ScrollThread();
-
+    }
   }
+
   // this class allows scrolling off the bottom of the visible alignment
-  class ScrollThread extends Thread
+  class ScrollThread
+      extends Thread
   {
     MouseEvent evt;
     boolean running = false;
+
     public ScrollThread()
     {
       start();
@@ -629,40 +792,41 @@ public class SeqPanel extends JPanel
     public void run()
     {
       running = true;
+
       while (running)
       {
-        if(evt!=null)
+        if (evt != null)
         {
-
-          if (mouseDragging && evt.getY() < 0 && av.getStartSeq() > 0)
+          if (mouseDragging && (evt.getY() < 0) &&
+              (av.getStartSeq() > 0))
+          {
             running = ap.scrollUp(true);
+          }
 
-          if (mouseDragging && evt.getY() >= getHeight() &&
-              av.alignment.getHeight() > av.getEndSeq())
+          if (mouseDragging && (evt.getY() >= getHeight()) &&
+              (av.alignment.getHeight() > av.getEndSeq()))
+          {
             running = ap.scrollUp(false);
+          }
 
-          if (mouseDragging && evt.getX() < 0)
+          if (mouseDragging && (evt.getX() < 0))
+          {
             running = ap.scrollRight(true);
-
-          else if (mouseDragging && evt.getX() >= getWidth())
+          }
+          else if (mouseDragging && (evt.getX() >= getWidth()))
+          {
             running = ap.scrollRight(false);
+          }
         }
 
-        ap.repaint();
         try
         {
           Thread.sleep(75);
         }
         catch (Exception ex)
-        {}
+        {
+        }
       }
     }
+  }
 }
-
-
-
-}
-
-
-
-