/*
 * 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 javax.swing.*;


/**
 * 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;

    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);

        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;
     keyboardGaps = null;
    }


    void moveCursor(int dx, int dy)
    {
      seqCanvas.cursorX += dx;
      seqCanvas.cursorY += dy;

      if(seqCanvas.cursorX<0)
        seqCanvas.cursorX = 0;
      else if(seqCanvas.cursorX>av.alignment.getWidth()-1)
        seqCanvas.cursorX = av.alignment.getWidth()-1;
      if(seqCanvas.cursorX<av.startRes)
        ap.scrollRight(false);
      else if(seqCanvas.cursorX>av.endRes)
        ap.scrollRight(true);

      if(seqCanvas.cursorY<0)
        seqCanvas.cursorY=0;
      else if(seqCanvas.cursorY>av.alignment.getHeight()-1)
        seqCanvas.cursorY = av.alignment.getHeight()-1;
      if(seqCanvas.cursorY<av.startSeq)
        ap.scrollUp(true);
      else if(seqCanvas.cursorY+1>av.endSeq)
        ap.scrollUp(false);

      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);
          }
        }
      }

      if (av.getSelectionGroup() == null)
      {
        SequenceGroup sg = new SequenceGroup();
        sg.setStartRes(seqCanvas.cursorX);
        sg.setEndRes(seqCanvas.cursorX);
        sg.addSequence(sequence, false);
        av.setSelectionGroup(sg);
      }


      ap.repaint();
    }

    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+getKeyboardGaps());
      editOccurred();
    }

    void deleteGapAtCursor(boolean group)
    {
      ap.alignFrame.addHistoryItem(new HistoryItem("Edit Sequence",
                                                   av.alignment, HistoryItem.EDIT));
      groupEditing = group;
      startseq = seqCanvas.cursorY;
      lastres = seqCanvas.cursorX+getKeyboardGaps();
      editSequence(false, seqCanvas.cursorX);
      editOccurred();
    }

    void numberPressed(char value)
    {
      if(keyboardGaps==null)
        keyboardGaps = new StringBuffer();

      keyboardGaps.append(value);
    }

    StringBuffer keyboardGaps;
    int getKeyboardGaps()
    {
      if(keyboardGaps==null)
        return 1;
      else
        return Integer.parseInt(keyboardGaps.toString());
    }


    /**
     * DOCUMENT ME!
     *
     * @param evt DOCUMENT ME!
     */
    public void mouseReleased(MouseEvent evt)
    {
      mouseDragging = false;
      mouseWheelPressed = false;

      if (!editingSeqs)
      {
         doMouseReleasedDefineMode(evt);
         return;
      }

       editOccurred();

       endEditing();
       ap.repaint();
    }



    /**
     * DOCUMENT ME!
     *
     * @param evt DOCUMENT ME!
     */
    public void mousePressed(MouseEvent evt)
    {
      if (javax.swing.SwingUtilities.isMiddleMouseButton(evt))
      {
        mouseWheelPressed = true;
        return;
      }

      if (evt.isShiftDown() || evt.isAltDown() ||
          evt.isControlDown())
      {
        if (evt.isAltDown() || evt.isControlDown())
        {
          groupEditing = true;
        }
        editingSeqs = true;
      }
      else
      {
        doMousePressedDefineMode(evt);
        return;
      }



      int seq = findSeq(evt);
      int res = findRes(evt);

      if(seq<0 || res<0)
        return;

      ap.alignFrame.addHistoryItem(new HistoryItem("Edit Sequence",
                                                         av.alignment, HistoryItem.EDIT));

        if ((seq < av.getAlignment().getHeight()) &&
                (res < av.getAlignment().getSequenceAt(seq).getLength()))
        {
            startseq = seq;
            lastres = res;
        }
        else
        {
            startseq = -1;
            lastres = -1;
        }

        return;
    }

    /**
     * DOCUMENT ME!
     *
     * @param evt DOCUMENT ME!
     */
    public void mouseMoved(MouseEvent evt)
    {
      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);


      if(res<0 || seq<0 || seq >= av.getAlignment().getHeight())
            return;

      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));
      }

      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++)
              {

                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("");
        }
    }

    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: ");
      }

      if (obj != null)
      {

        if (obj != "")
        {
          text.append(obj + " (" + sequence.findPosition(res) +
                      ")");
        }
      }
      ap.alignFrame.statusBar.setText(text.toString());

    }

    /**
     * DOCUMENT ME!
     *
     * @param evt DOCUMENT ME!
     */
    public void mouseDragged(MouseEvent evt)
    {
      if (!editingSeqs)
      {
        doMouseDraggedDefineMode(evt);
        return;
      }

        int res = findRes(evt);

        if (res < 0)
        {
            res = 0;
        }

        if ((lastres == -1) || (lastres == res))
        {
            return;
        }

        if ( (res < av.getAlignment().getWidth()) && (res < lastres))
        {
          // dragLeft, delete gap
          editSequence(false, res);
        }
        else
          editSequence(true, res);

        mouseDragging = true;
        if(scrollThread!=null)
          scrollThread.setEvent(evt);

    }

    void editSequence(boolean insertGap, int startres)
    {
      int fixedLeft = -1;
      int fixedRight = -1;
      boolean fixedColumns = false;

       if(insertGap && av.hasHiddenColumns)
        {
          //Stop editing if the user has dragged beyond hiddenBoundary
          fixedRight = av.getColumnSelection().getHiddenRegionBoundary(lastres);
          if( fixedRight < lastres)
          {
            if(lastres!=fixedRight)
            {
              endEditing();
              return;
            }
          }
        }

        if (!groupEditing && av.hasHiddenRows)
        {
          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
            || (av.getSelectionGroup() != null &&
                av.getSelectionGroup().sequences.contains(seq)))
        {
          fixedColumns = true;

          fixedLeft = av.getSelectionGroup().getStartRes();
          fixedRight = av.getSelectionGroup().getEndRes();

          if (   (startres < fixedLeft && lastres >= fixedLeft)
              || (startres >= fixedLeft && lastres < fixedLeft)
              || (startres > fixedRight && lastres <=fixedRight)
              || (startres <= fixedRight && lastres > fixedRight))
          {
            endEditing();
            return;
          }

          if (fixedLeft > startres)
          {
            fixedRight = fixedLeft - 1;
            fixedLeft = 0;
          }
          else if (fixedRight < startres)
          {
            fixedLeft = fixedRight;
            fixedRight = -1;
          }
        }

        if (groupEditing)
        {
          SequenceGroup sg = av.getSelectionGroup();
          if(fixedLeft>sg.getEndRes()
          ||fixedRight<sg.getStartRes())
       {
         endEditing();
         return;
       }

          if (av.hasHiddenRows)
          {
            //sg might be null as the user may only see 1 sequence
            if (sg == null)
            {
              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)
              {
                for (int h = 0; h < seq.getHiddenSequences().getSize(); h++)
                  tmp.addSequence(seq.getHiddenSequences().getSequenceAt(h),
                                  false);
              }
            }

            sg = tmp;
          }

          if (sg == null)
          {
            endEditing();
            return;
          }

         // int blankColumn = -1;

          // drag to right
          if (insertGap)
          {
            // Is it valid??
            // Find the next gap before the end
            // of the visible region boundary
            if (av.hasHiddenColumns)
            {
             // int lastCol = av.getColumnSelection().
             //     getHiddenRegionBoundary(res);

            }

              if (fixedRight != startres && fixedRight<av.alignment.getWidth()-1)
              {
                for (fixedRight = fixedRight;
                     fixedRight > lastres;
                     fixedRight --)
                {
                  boolean blank = true;
                  for (int s = 0; s < sg.getSize(); s++)
                  {
                    seq = sg.getSequenceAt(s);

                    if (seq.getSequence().length() <= fixedRight)
                    {
                      continue;
                    }

                    if (!jalview.util.Comparison.isGap(
                        seq.getCharAt(fixedRight)))
                    {
                      blank = false;
                      continue;
                    }
                  }
                  if (blank)
                    break;
                }
              }

              if (fixedRight <= startres)
              {
                endEditing();
                return;
              }
            }


          // drag to left
          else
          {
            /// Are we able to delete?
            // ie are all columns blank?

            for (int s = 0; s < sg.getSize(); s++)
            {
              seq = sg.getSequenceAt(s);

              for (int j = startres; 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
                  endEditing();
                  return;
                }
              }
            }
          }


          for (int i = 0; i < sg.getSize(); i++)
          {
            seq = sg.getSequenceAt(i);

            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 < startres; j++)
            {
              if (fixedColumns && fixedRight != -1)
                insertChar(j, seq, fixedRight);
              else
                insertChar(j, seq);
            }
          }
          else
          {
            // dragging to the left
            for (int j = lastres; j > startres; j--)
            {
              if (fixedColumns && fixedRight != -1)
              {
                deleteChar(startres, seq, fixedRight);
              }
              else
              {
                deleteChar(startres, seq);
              }
            }
          }
        }

        lastres = startres;
        seqCanvas.repaint();
    }


    /**
     * 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;
      }

      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;
    }

    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;
      }

      seq.deleteCharAt(j);
      seq.insertCharAt(fixedColumn, av.getGapCharacter());
      seqEditOccurred = true;
    }

    /**
     * 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;
      }

        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;
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param e DOCUMENT ME!
     */
    public void mouseExited(MouseEvent e)
    {
        if (av.getWrapAlignment())
        {
            return;
        }

        if (mouseDragging)
        {
            scrollThread = new ScrollThread();
        }
    }

    public void mouseClicked(MouseEvent evt)
    {}

    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--;

        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 (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();
    }



    // 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)
                {
                }
            }
        }
    }
}