src/jalview/gui/SeqPanel.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
   3  * Copyright (C) 2014 The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.gui;
  22
  23 import jalview.api.AlignViewportI;
  24 import jalview.commands.EditCommand;
  25 import jalview.commands.EditCommand.Action;
  26 import jalview.commands.EditCommand.Edit;
  27 import jalview.datamodel.ColumnSelection;
  28 import jalview.datamodel.SearchResults;
  29 import jalview.datamodel.Sequence;
  30 import jalview.datamodel.SequenceFeature;
  31 import jalview.datamodel.SequenceGroup;
  32 import jalview.datamodel.SequenceI;
  33 import jalview.io.SequenceAnnotationReport;
  34 import jalview.schemes.ResidueProperties;
  35 import jalview.structure.SelectionListener;
  36 import jalview.structure.SelectionSource;
  37 import jalview.structure.SequenceListener;
  38 import jalview.structure.StructureSelectionManager;
  39 import jalview.structure.VamsasSource;
  40 import jalview.util.Comparison;
  41 import jalview.util.MappingUtils;
  42 import jalview.util.MessageManager;
  43 import jalview.viewmodel.AlignmentViewport;
  44
  45 import java.awt.BorderLayout;
  46 import java.awt.Color;
  47 import java.awt.Font;
  48 import java.awt.FontMetrics;
  49 import java.awt.Point;
  50 import java.awt.event.MouseEvent;
  51 import java.awt.event.MouseListener;
  52 import java.awt.event.MouseMotionListener;
  53 import java.awt.event.MouseWheelEvent;
  54 import java.awt.event.MouseWheelListener;
  55 import java.util.List;
  56 import java.util.Vector;
  57
  58 import javax.swing.JOptionPane;
  59 import javax.swing.JPanel;
  60 import javax.swing.ToolTipManager;
  61
  62 /**
  63  * DOCUMENT ME!
  64  *
  65  * @author $author$
  66  * @version $Revision: 1.130 $
  67  */
  68 public class SeqPanel extends JPanel implements MouseListener,
  69         MouseMotionListener, MouseWheelListener, SequenceListener,
  70         SelectionListener
  71
  72 {
  73   /** DOCUMENT ME!! */
  74   public SeqCanvas seqCanvas;
  75
  76   /** DOCUMENT ME!! */
  77   public AlignmentPanel ap;
  78
  79   protected int lastres;
  80
  81   protected int startseq;
  82
  83   protected AlignViewport av;
  84
  85   ScrollThread scrollThread = null;
  86
  87   boolean mouseDragging = false;
  88
  89   boolean editingSeqs = false;
  90
  91   boolean groupEditing = false;
  92
  93   // ////////////////////////////////////////
  94   // ///Everything below this is for defining the boundary of the rubberband
  95   // ////////////////////////////////////////
  96   int oldSeq = -1;
  97
  98   boolean changeEndSeq = false;
  99
 100   boolean changeStartSeq = false;
 101
 102   boolean changeEndRes = false;
 103
 104   boolean changeStartRes = false;
 105
 106   SequenceGroup stretchGroup = null;
 107
 108   boolean remove = false;
 109
 110   Point lastMousePress;
 111
 112   boolean mouseWheelPressed = false;
 113
 114   StringBuffer keyboardNo1;
 115
 116   StringBuffer keyboardNo2;
 117
 118   java.net.URL linkImageURL;
 119
 120   private final SequenceAnnotationReport seqARep;
 121
 122   StringBuffer tooltipText = new StringBuffer();
 123
 124   String tmpString;
 125
 126   EditCommand editCommand;
 127
 128   StructureSelectionManager ssm;
 129
 130   /**
 131    * Creates a new SeqPanel object.
 132    *
 133    * @param avp
 134    *          DOCUMENT ME!
 135    * @param p
 136    *          DOCUMENT ME!
 137    */
 138   public SeqPanel(AlignViewport av, AlignmentPanel ap)
 139   {
 140     linkImageURL = getClass().getResource("/images/link.gif");
 141     seqARep = new SequenceAnnotationReport(linkImageURL.toString());
 142     ToolTipManager.sharedInstance().registerComponent(this);
 143     ToolTipManager.sharedInstance().setInitialDelay(0);
 144     ToolTipManager.sharedInstance().setDismissDelay(10000);
 145     this.av = av;
 146     setBackground(Color.white);
 147
 148     seqCanvas = new SeqCanvas(ap);
 149     setLayout(new BorderLayout());
 150     add(seqCanvas, BorderLayout.CENTER);
 151
 152     this.ap = ap;
 153
 154     if (!av.isDataset())
 155     {
 156       addMouseMotionListener(this);
 157       addMouseListener(this);
 158       addMouseWheelListener(this);
 159       ssm = av.getStructureSelectionManager();
 160       ssm.addStructureViewerListener(this);
 161       ssm.addSelectionListener(this);
 162     }
 163   }
 164
 165   int startWrapBlock = -1;
 166
 167   int wrappedBlock = -1;
 168
 169   int findRes(MouseEvent evt)
 170   {
 171     int res = 0;
 172     int x = evt.getX();
 173
 174     if (av.getWrapAlignment())
 175     {
 176
 177       int hgap = av.getCharHeight();
 178       if (av.getScaleAboveWrapped())
 179       {
 180         hgap += av.getCharHeight();
 181       }
 182
 183       int cHeight = av.getAlignment().getHeight() * av.getCharHeight()
 184               + hgap
 185               + seqCanvas.getAnnotationHeight();
 186
 187       int y = evt.getY();
 188       y -= hgap;
 189       x -= seqCanvas.LABEL_WEST;
 190
 191       int cwidth = seqCanvas.getWrappedCanvasWidth(this.getWidth());
 192       if (cwidth < 1)
 193       {
 194         return 0;
 195       }
 196
 197       wrappedBlock = y / cHeight;
 198       wrappedBlock += av.getStartRes() / cwidth;
 199
 200       res = wrappedBlock * cwidth + x / av.getCharWidth();
 201
 202     }
 203     else
 204     {
 205       if (x > seqCanvas.getWidth() + seqCanvas.getWidth())
 206       {
 207         // make sure we calculate relative to visible alignment, rather than
 208         // right-hand gutter
 209         x = seqCanvas.getX() + seqCanvas.getWidth();
 210       }
 211       res = (x / av.getCharWidth()) + av.getStartRes();
 212     }
 213
 214     if (av.hasHiddenColumns())
 215     {
 216       res = av.getColumnSelection().adjustForHiddenColumns(res);
 217     }
 218
 219     return res;
 220
 221   }
 222
 223   int findSeq(MouseEvent evt)
 224   {
 225     int seq = 0;
 226     int y = evt.getY();
 227
 228     if (av.getWrapAlignment())
 229     {
 230       int hgap = av.getCharHeight();
 231       if (av.getScaleAboveWrapped())
 232       {
 233         hgap += av.getCharHeight();
 234       }
 235
 236       int cHeight = av.getAlignment().getHeight() * av.getCharHeight()
 237               + hgap
 238               + seqCanvas.getAnnotationHeight();
 239
 240       y -= hgap;
 241
 242       seq = Math.min((y % cHeight) / av.getCharHeight(), av.getAlignment()
 243               .getHeight() - 1);
 244     }
 245     else
 246     {
 247       seq = Math.min((y / av.getCharHeight()) + av.getStartSeq(), av
 248               .getAlignment().getHeight() - 1);
 249     }
 250
 251     return seq;
 252   }
 253
 254   /**
 255    * When all of a sequence of edits are complete, put the resulting edit list
 256    * on the history stack (undo list), and reset flags for editing in progress.
 257    */
 258   void endEditing()
 259   {
 260     try
 261     {
 262       if (editCommand != null && editCommand.getSize() > 0)
 263       {
 264         ap.alignFrame.addHistoryItem(editCommand);
 265         av.firePropertyChange("alignment", null, av.getAlignment()
 266                 .getSequences());
 267       }
 268     } finally
 269     {
 270       /*
 271        * Tidy up come what may...
 272        */
 273       startseq = -1;
 274       lastres = -1;
 275       editingSeqs = false;
 276       groupEditing = false;
 277       keyboardNo1 = null;
 278       keyboardNo2 = null;
 279       editCommand = null;
 280     }
 281   }
 282
 283   void setCursorRow()
 284   {
 285     seqCanvas.cursorY = getKeyboardNo1() - 1;
 286     scrollToVisible();
 287   }
 288
 289   void setCursorColumn()
 290   {
 291     seqCanvas.cursorX = getKeyboardNo1() - 1;
 292     scrollToVisible();
 293   }
 294
 295   void setCursorRowAndColumn()
 296   {
 297     if (keyboardNo2 == null)
 298     {
 299       keyboardNo2 = new StringBuffer();
 300     }
 301     else
 302     {
 303       seqCanvas.cursorX = getKeyboardNo1() - 1;
 304       seqCanvas.cursorY = getKeyboardNo2() - 1;
 305       scrollToVisible();
 306     }
 307   }
 308
 309   void setCursorPosition()
 310   {
 311     SequenceI sequence = av.getAlignment().getSequenceAt(seqCanvas.cursorY);
 312
 313     seqCanvas.cursorX = sequence.findIndex(getKeyboardNo1()) - 1;
 314     scrollToVisible();
 315   }
 316
 317   void moveCursor(int dx, int dy)
 318   {
 319     seqCanvas.cursorX += dx;
 320     seqCanvas.cursorY += dy;
 321     if (av.hasHiddenColumns()
 322             && !av.getColumnSelection().isVisible(seqCanvas.cursorX))
 323     {
 324       int original = seqCanvas.cursorX - dx;
 325       int maxWidth = av.getAlignment().getWidth();
 326
 327       while (!av.getColumnSelection().isVisible(seqCanvas.cursorX)
 328               && seqCanvas.cursorX < maxWidth && seqCanvas.cursorX > 0)
 329       {
 330         seqCanvas.cursorX += dx;
 331       }
 332
 333       if (seqCanvas.cursorX >= maxWidth
 334               || !av.getColumnSelection().isVisible(seqCanvas.cursorX))
 335       {
 336         seqCanvas.cursorX = original;
 337       }
 338     }
 339
 340     scrollToVisible();
 341   }
 342
 343   void scrollToVisible()
 344   {
 345     if (seqCanvas.cursorX < 0)
 346     {
 347       seqCanvas.cursorX = 0;
 348     }
 349     else if (seqCanvas.cursorX > av.getAlignment().getWidth() - 1)
 350     {
 351       seqCanvas.cursorX = av.getAlignment().getWidth() - 1;
 352     }
 353
 354     if (seqCanvas.cursorY < 0)
 355     {
 356       seqCanvas.cursorY = 0;
 357     }
 358     else if (seqCanvas.cursorY > av.getAlignment().getHeight() - 1)
 359     {
 360       seqCanvas.cursorY = av.getAlignment().getHeight() - 1;
 361     }
 362
 363     endEditing();
 364     if (av.getWrapAlignment())
 365     {
 366       ap.scrollToWrappedVisible(seqCanvas.cursorX);
 367     }
 368     else
 369     {
 370       while (seqCanvas.cursorY < av.startSeq)
 371       {
 372         ap.scrollUp(true);
 373       }
 374       while (seqCanvas.cursorY + 1 > av.endSeq)
 375       {
 376         ap.scrollUp(false);
 377       }
 378       if (!av.getWrapAlignment())
 379       {
 380         while (seqCanvas.cursorX < av.getColumnSelection()
 381                 .adjustForHiddenColumns(av.startRes))
 382         {
 383           if (!ap.scrollRight(false))
 384           {
 385             break;
 386           }
 387         }
 388         while (seqCanvas.cursorX > av.getColumnSelection()
 389                 .adjustForHiddenColumns(av.endRes))
 390         {
 391           if (!ap.scrollRight(true))
 392           {
 393             break;
 394           }
 395         }
 396       }
 397     }
 398     setStatusMessage(av.getAlignment().getSequenceAt(seqCanvas.cursorY),
 399             seqCanvas.cursorX, seqCanvas.cursorY);
 400
 401     seqCanvas.repaint();
 402   }
 403
 404   void setSelectionAreaAtCursor(boolean topLeft)
 405   {
 406     SequenceI sequence = av.getAlignment().getSequenceAt(seqCanvas.cursorY);
 407
 408     if (av.getSelectionGroup() != null)
 409     {
 410       SequenceGroup sg = av.getSelectionGroup();
 411       // Find the top and bottom of this group
 412       int min = av.getAlignment().getHeight(), max = 0;
 413       for (int i = 0; i < sg.getSize(); i++)
 414       {
 415         int index = av.getAlignment().findIndex(sg.getSequenceAt(i));
 416         if (index > max)
 417         {
 418           max = index;
 419         }
 420         if (index < min)
 421         {
 422           min = index;
 423         }
 424       }
 425
 426       max++;
 427
 428       if (topLeft)
 429       {
 430         sg.setStartRes(seqCanvas.cursorX);
 431         if (sg.getEndRes() < seqCanvas.cursorX)
 432         {
 433           sg.setEndRes(seqCanvas.cursorX);
 434         }
 435
 436         min = seqCanvas.cursorY;
 437       }
 438       else
 439       {
 440         sg.setEndRes(seqCanvas.cursorX);
 441         if (sg.getStartRes() > seqCanvas.cursorX)
 442         {
 443           sg.setStartRes(seqCanvas.cursorX);
 444         }
 445
 446         max = seqCanvas.cursorY + 1;
 447       }
 448
 449       if (min > max)
 450       {
 451         // Only the user can do this
 452         av.setSelectionGroup(null);
 453       }
 454       else
 455       {
 456         // Now add any sequences between min and max
 457         sg.getSequences(null).clear();
 458         for (int i = min; i < max; i++)
 459         {
 460           sg.addSequence(av.getAlignment().getSequenceAt(i), false);
 461         }
 462       }
 463     }
 464
 465     if (av.getSelectionGroup() == null)
 466     {
 467       SequenceGroup sg = new SequenceGroup();
 468       sg.setStartRes(seqCanvas.cursorX);
 469       sg.setEndRes(seqCanvas.cursorX);
 470       sg.addSequence(sequence, false);
 471       av.setSelectionGroup(sg);
 472     }
 473
 474     ap.paintAlignment(false);
 475     av.sendSelection();
 476   }
 477
 478   void insertGapAtCursor(boolean group)
 479   {
 480     groupEditing = group;
 481     startseq = seqCanvas.cursorY;
 482     lastres = seqCanvas.cursorX;
 483     editSequence(true, false, seqCanvas.cursorX + getKeyboardNo1());
 484     endEditing();
 485   }
 486
 487   void deleteGapAtCursor(boolean group)
 488   {
 489     groupEditing = group;
 490     startseq = seqCanvas.cursorY;
 491     lastres = seqCanvas.cursorX + getKeyboardNo1();
 492     editSequence(false, false, seqCanvas.cursorX);
 493     endEditing();
 494   }
 495
 496   void insertNucAtCursor(boolean group, String nuc)
 497   {
 498     groupEditing = group;
 499     startseq = seqCanvas.cursorY;
 500     lastres = seqCanvas.cursorX;
 501     editSequence(false, true, seqCanvas.cursorX + getKeyboardNo1());
 502     endEditing();
 503   }
 504
 505   void numberPressed(char value)
 506   {
 507     if (keyboardNo1 == null)
 508     {
 509       keyboardNo1 = new StringBuffer();
 510     }
 511
 512     if (keyboardNo2 != null)
 513     {
 514       keyboardNo2.append(value);
 515     }
 516     else
 517     {
 518       keyboardNo1.append(value);
 519     }
 520   }
 521
 522   int getKeyboardNo1()
 523   {
 524     try
 525     {
 526       if (keyboardNo1 != null)
 527       {
 528         int value = Integer.parseInt(keyboardNo1.toString());
 529         keyboardNo1 = null;
 530         return value;
 531       }
 532     } catch (Exception x)
 533     {
 534     }
 535     keyboardNo1 = null;
 536     return 1;
 537   }
 538
 539   int getKeyboardNo2()
 540   {
 541     try
 542     {
 543       if (keyboardNo2 != null)
 544       {
 545         int value = Integer.parseInt(keyboardNo2.toString());
 546         keyboardNo2 = null;
 547         return value;
 548       }
 549     } catch (Exception x)
 550     {
 551     }
 552     keyboardNo2 = null;
 553     return 1;
 554   }
 555
 556   /**
 557    * DOCUMENT ME!
 558    *
 559    * @param evt
 560    *          DOCUMENT ME!
 561    */
 562   @Override
 563   public void mouseReleased(MouseEvent evt)
 564   {
 565     mouseDragging = false;
 566     mouseWheelPressed = false;
 567
 568     if (!editingSeqs)
 569     {
 570       doMouseReleasedDefineMode(evt);
 571       return;
 572     }
 573
 574     endEditing();
 575   }
 576
 577   /**
 578    * DOCUMENT ME!
 579    *
 580    * @param evt
 581    *          DOCUMENT ME!
 582    */
 583   @Override
 584   public void mousePressed(MouseEvent evt)
 585   {
 586     lastMousePress = evt.getPoint();
 587
 588     if (javax.swing.SwingUtilities.isMiddleMouseButton(evt))
 589     {
 590       mouseWheelPressed = true;
 591       return;
 592     }
 593
 594     if (evt.isShiftDown() || evt.isAltDown() || evt.isControlDown())
 595     {
 596       if (evt.isAltDown() || evt.isControlDown())
 597       {
 598         groupEditing = true;
 599       }
 600       editingSeqs = true;
 601     }
 602     else
 603     {
 604       doMousePressedDefineMode(evt);
 605       return;
 606     }
 607
 608     int seq = findSeq(evt);
 609     int res = findRes(evt);
 610
 611     if (seq < 0 || res < 0)
 612     {
 613       return;
 614     }
 615
 616     if ((seq < av.getAlignment().getHeight())
 617             && (res < av.getAlignment().getSequenceAt(seq).getLength()))
 618     {
 619       startseq = seq;
 620       lastres = res;
 621     }
 622     else
 623     {
 624       startseq = -1;
 625       lastres = -1;
 626     }
 627
 628     return;
 629   }
 630
 631   String lastMessage;
 632
 633   @Override
 634   public void mouseOverSequence(SequenceI sequence, int index, int pos)
 635   {
 636     String tmp = sequence.hashCode() + " " + index + " " + pos;
 637
 638     if (lastMessage == null || !lastMessage.equals(tmp))
 639     {
 640       // System.err.println("mouseOver Sequence: "+tmp);
 641       ssm.mouseOverSequence(sequence, index, pos, av);
 642     }
 643     lastMessage = tmp;
 644   }
 645
 646   @Override
 647   public void highlightSequence(SearchResults results)
 648   {
 649     if (av.followHighlight)
 650     {
 651       if (ap.scrollToPosition(results, false))
 652       {
 653         seqCanvas.revalidate();
 654       }
 655     }
 656     seqCanvas.highlightSearchResults(results);
 657   }
 658
 659   @Override
 660   public VamsasSource getVamsasSource()
 661   {
 662     return this.ap == null ? null : this.ap.av;
 663   }
 664   @Override
 665   public void updateColours(SequenceI seq, int index)
 666   {
 667     System.out.println("update the seqPanel colours");
 668     // repaint();
 669   }
 670
 671   /**
 672    * DOCUMENT ME!
 673    *
 674    * @param evt
 675    *          DOCUMENT ME!
 676    */
 677   @Override
 678   public void mouseMoved(MouseEvent evt)
 679   {
 680     if (editingSeqs)
 681     {
 682       // This is because MacOSX creates a mouseMoved
 683       // If control is down, other platforms will not.
 684       mouseDragged(evt);
 685     }
 686
 687     int res = findRes(evt);
 688     int seq = findSeq(evt);
 689     int pos;
 690     if (res < 0 || seq < 0 || seq >= av.getAlignment().getHeight())
 691     {
 692       return;
 693     }
 694
 695     SequenceI sequence = av.getAlignment().getSequenceAt(seq);
 696
 697     if (res >= sequence.getLength())
 698     {
 699       return;
 700     }
 701
 702     pos = setStatusMessage(sequence, res, seq);
 703     if (ssm != null && pos > -1)
 704     {
 705       mouseOverSequence(sequence, res, pos);
 706     }
 707
 708     tooltipText.setLength(6); // Cuts the buffer back to <html>
 709
 710     SequenceGroup[] groups = av.getAlignment().findAllGroups(sequence);
 711     if (groups != null)
 712     {
 713       for (int g = 0; g < groups.length; g++)
 714       {
 715         if (groups[g].getStartRes() <= res && groups[g].getEndRes() >= res)
 716         {
 717           if (!groups[g].getName().startsWith("JTreeGroup")
 718                   && !groups[g].getName().startsWith("JGroup"))
 719           {
 720             tooltipText.append(groups[g].getName());
 721           }
 722
 723           if (groups[g].getDescription() != null)
 724           {
 725             tooltipText.append(": " + groups[g].getDescription());
 726           }
 727         }
 728       }
 729     }
 730
 731     // use aa to see if the mouse pointer is on a
 732     if (av.isShowSequenceFeatures())
 733     {
 734       int rpos;
 735       List<SequenceFeature> features = ap.getFeatureRenderer().findFeaturesAtRes(
 736               sequence.getDatasetSequence(),
 737               rpos = sequence.findPosition(res));
 738       seqARep.appendFeatures(tooltipText, rpos, features,
 739               this.ap.getSeqPanel().seqCanvas.fr.getMinMax());
 740     }
 741     if (tooltipText.length() == 6) // <html></html>
 742     {
 743       setToolTipText(null);
 744       lastTooltip = null;
 745     }
 746     else
 747     {
 748       if (lastTooltip == null
 749               || !lastTooltip.equals(tooltipText.toString()))
 750       {
 751         String formatedTooltipText = JvSwingUtils.wrapTooltip(true,
 752                 tooltipText.toString());
 753         // String formatedTooltipText = tooltipText.toString();
 754         setToolTipText(formatedTooltipText);
 755         lastTooltip = tooltipText.toString();
 756       }
 757
 758     }
 759
 760   }
 761
 762   private Point lastp = null;
 763
 764   /*
 765    * (non-Javadoc)
 766    *
 767    * @see javax.swing.JComponent#getToolTipLocation(java.awt.event.MouseEvent)
 768    */
 769   public Point getToolTipLocation(MouseEvent event)
 770   {
 771     int x = event.getX(), w = getWidth();
 772     int wdth = (w - x < 200) ? -(w / 2) : 5; // switch sides when tooltip is too
 773     // close to edge
 774     Point p = lastp;
 775     if (!event.isShiftDown() || p == null)
 776     {
 777       p = (tooltipText != null && tooltipText.length() > 6) ? new Point(
 778               event.getX() + wdth, event.getY() - 20) : null;
 779     }
 780     /*
 781      * TODO: try to modify position region is not obcured by tooltip
 782      */
 783     return lastp = p;
 784   }
 785
 786   String lastTooltip;
 787
 788   /**
 789    * Set status message in alignment panel
 790    *
 791    * @param sequence
 792    *          aligned sequence object
 793    * @param res
 794    *          alignment column
 795    * @param seq
 796    *          index of sequence in alignment
 797    * @return position of res in sequence
 798    */
 799   int setStatusMessage(SequenceI sequence, int res, int seq)
 800   {
 801     int pos = -1;
 802     StringBuilder text = new StringBuilder(32);
 803     text.append("Sequence " + (seq + 1) + " ID: " + sequence.getName());
 804
 805     String residue = null;
 806     /*
 807      * Try to translate the display character to residue name (null for gap).
 808      */
 809     final String displayChar = String.valueOf(sequence.getCharAt(res));
 810     if (av.getAlignment().isNucleotide())
 811     {
 812       residue = ResidueProperties.nucleotideName.get(displayChar);
 813       if (residue != null)
 814       {
 815         text.append(" Nucleotide: ").append(residue);
 816       }
 817     }
 818     else
 819     {
 820       residue = "X".equalsIgnoreCase(displayChar) ? "STOP"
 821               : ResidueProperties.aa2Triplet.get(displayChar);
 822       if (residue != null)
 823       {
 824         text.append(" Residue: ").append(residue);
 825       }
 826     }
 827
 828     if (residue != null)
 829     {
 830       pos = sequence.findPosition(res);
 831       text.append(" (").append(Integer.toString(pos)).append(")");
 832     }
 833     ap.alignFrame.statusBar.setText(text.toString());
 834     return pos;
 835   }
 836
 837   /**
 838    * DOCUMENT ME!
 839    *
 840    * @param evt
 841    *          DOCUMENT ME!
 842    */
 843   @Override
 844   public void mouseDragged(MouseEvent evt)
 845   {
 846     if (mouseWheelPressed)
 847     {
 848       int oldWidth = av.getCharWidth();
 849
 850       // Which is bigger, left-right or up-down?
 851       if (Math.abs(evt.getY() - lastMousePress.getY()) > Math.abs(evt
 852               .getX() - lastMousePress.getX()))
 853       {
 854         int fontSize = av.font.getSize();
 855
 856         if (evt.getY() < lastMousePress.getY())
 857         {
 858           fontSize--;
 859         }
 860         else if (evt.getY() > lastMousePress.getY())
 861         {
 862           fontSize++;
 863         }
 864
 865         if (fontSize < 1)
 866         {
 867           fontSize = 1;
 868         }
 869
 870         av.setFont(
 871                 new Font(av.font.getName(), av.font.getStyle(), fontSize),
 872                 true);
 873         av.setCharWidth(oldWidth);
 874         ap.fontChanged();
 875       }
 876       else
 877       {
 878         if (evt.getX() < lastMousePress.getX() && av.getCharWidth() > 1)
 879         {
 880           av.setCharWidth(av.getCharWidth() - 1);
 881         }
 882         else if (evt.getX() > lastMousePress.getX())
 883         {
 884           av.setCharWidth(av.getCharWidth() + 1);
 885         }
 886
 887         ap.paintAlignment(false);
 888       }
 889
 890       FontMetrics fm = getFontMetrics(av.getFont());
 891       av.validCharWidth = fm.charWidth('M') <= av.getCharWidth();
 892
 893       lastMousePress = evt.getPoint();
 894
 895       return;
 896     }
 897
 898     if (!editingSeqs)
 899     {
 900       doMouseDraggedDefineMode(evt);
 901       return;
 902     }
 903
 904     int res = findRes(evt);
 905
 906     if (res < 0)
 907     {
 908       res = 0;
 909     }
 910
 911     if ((lastres == -1) || (lastres == res))
 912     {
 913       return;
 914     }
 915
 916     if ((res < av.getAlignment().getWidth()) && (res < lastres))
 917     {
 918       // dragLeft, delete gap
 919       editSequence(false, false, res);
 920     }
 921     else
 922     {
 923       editSequence(true, false, res);
 924     }
 925
 926     mouseDragging = true;
 927     if (scrollThread != null)
 928     {
 929       scrollThread.setEvent(evt);
 930     }
 931   }
 932
 933   // TODO: Make it more clever than many booleans
 934   synchronized void editSequence(boolean insertGap, boolean editSeq,
 935           int startres)
 936   {
 937     int fixedLeft = -1;
 938     int fixedRight = -1;
 939     boolean fixedColumns = false;
 940     SequenceGroup sg = av.getSelectionGroup();
 941
 942     SequenceI seq = av.getAlignment().getSequenceAt(startseq);
 943
 944     // No group, but the sequence may represent a group
 945     if (!groupEditing && av.hasHiddenRows())
 946     {
 947       if (av.isHiddenRepSequence(seq))
 948       {
 949         sg = av.getRepresentedSequences(seq);
 950         groupEditing = true;
 951       }
 952     }
 953
 954     StringBuilder message = new StringBuilder(64);
 955     if (groupEditing)
 956     {
 957       message.append("Edit group:");
 958       if (editCommand == null)
 959       {
 960         editCommand = new EditCommand(MessageManager.getString("action.edit_group"));
 961       }
 962     }
 963     else
 964     {
 965       message.append("Edit sequence: " + seq.getName());
 966       String label = seq.getName();
 967       if (label.length() > 10)
 968       {
 969         label = label.substring(0, 10);
 970       }
 971       if (editCommand == null)
 972       {
 973         editCommand = new EditCommand(MessageManager.formatMessage("label.edit_params", new String[]{label}));
 974       }
 975     }
 976
 977     if (insertGap)
 978     {
 979       message.append(" insert ");
 980     }
 981     else
 982     {
 983       message.append(" delete ");
 984     }
 985
 986     message.append(Math.abs(startres - lastres) + " gaps.");
 987     ap.alignFrame.statusBar.setText(message.toString());
 988
 989     // Are we editing within a selection group?
 990     if (groupEditing
 991             || (sg != null && sg.getSequences(av.getHiddenRepSequences())
 992                     .contains(seq)))
 993     {
 994       fixedColumns = true;
 995
 996       // sg might be null as the user may only see 1 sequence,
 997       // but the sequence represents a group
 998       if (sg == null)
 999       {
1000         if (!av.isHiddenRepSequence(seq))
1001         {
1002           endEditing();
1003           return;
1004         }
1005         sg = av.getRepresentedSequences(seq);
1006       }
1007
1008       fixedLeft = sg.getStartRes();
1009       fixedRight = sg.getEndRes();
1010
1011       if ((startres < fixedLeft && lastres >= fixedLeft)
1012               || (startres >= fixedLeft && lastres < fixedLeft)
1013               || (startres > fixedRight && lastres <= fixedRight)
1014               || (startres <= fixedRight && lastres > fixedRight))
1015       {
1016         endEditing();
1017         return;
1018       }
1019
1020       if (fixedLeft > startres)
1021       {
1022         fixedRight = fixedLeft - 1;
1023         fixedLeft = 0;
1024       }
1025       else if (fixedRight < startres)
1026       {
1027         fixedLeft = fixedRight;
1028         fixedRight = -1;
1029       }
1030     }
1031
1032     if (av.hasHiddenColumns())
1033     {
1034       fixedColumns = true;
1035       int y1 = av.getColumnSelection().getHiddenBoundaryLeft(startres);
1036       int y2 = av.getColumnSelection().getHiddenBoundaryRight(startres);
1037
1038       if ((insertGap && startres > y1 && lastres < y1)
1039               || (!insertGap && startres < y2 && lastres > y2))
1040       {
1041         endEditing();
1042         return;
1043       }
1044
1045       // System.out.print(y1+" "+y2+" "+fixedLeft+" "+fixedRight+"~~");
1046       // Selection spans a hidden region
1047       if (fixedLeft < y1 && (fixedRight > y2 || fixedRight == -1))
1048       {
1049         if (startres >= y2)
1050         {
1051           fixedLeft = y2;
1052         }
1053         else
1054         {
1055           fixedRight = y2 - 1;
1056         }
1057       }
1058     }
1059
1060     if (groupEditing)
1061     {
1062       List<SequenceI> vseqs = sg.getSequences(av.getHiddenRepSequences());
1063       int g, groupSize = vseqs.size();
1064       SequenceI[] groupSeqs = new SequenceI[groupSize];
1065       for (g = 0; g < groupSeqs.length; g++)
1066       {
1067         groupSeqs[g] = vseqs.get(g);
1068       }
1069
1070       // drag to right
1071       if (insertGap)
1072       {
1073         // If the user has selected the whole sequence, and is dragging to
1074         // the right, we can still extend the alignment and selectionGroup
1075         if (sg.getStartRes() == 0 && sg.getEndRes() == fixedRight
1076                 && sg.getEndRes() == av.getAlignment().getWidth() - 1)
1077         {
1078           sg.setEndRes(av.getAlignment().getWidth() + startres - lastres);
1079           fixedRight = sg.getEndRes();
1080         }
1081
1082         // Is it valid with fixed columns??
1083         // Find the next gap before the end
1084         // of the visible region boundary
1085         boolean blank = false;
1086         for (fixedRight = fixedRight; fixedRight > lastres; fixedRight--)
1087         {
1088           blank = true;
1089
1090           for (g = 0; g < groupSize; g++)
1091           {
1092             for (int j = 0; j < startres - lastres; j++)
1093             {
1094               if (!jalview.util.Comparison.isGap(groupSeqs[g]
1095                       .getCharAt(fixedRight - j)))
1096               {
1097                 blank = false;
1098                 break;
1099               }
1100             }
1101           }
1102           if (blank)
1103           {
1104             break;
1105           }
1106         }
1107
1108         if (!blank)
1109         {
1110           if (sg.getSize() == av.getAlignment().getHeight())
1111           {
1112             if ((av.hasHiddenColumns() && startres < av
1113                     .getColumnSelection().getHiddenBoundaryRight(startres)))
1114             {
1115               endEditing();
1116               return;
1117             }
1118
1119             int alWidth = av.getAlignment().getWidth();
1120             if (av.hasHiddenRows())
1121             {
1122               int hwidth = av.getAlignment().getHiddenSequences()
1123                       .getWidth();
1124               if (hwidth > alWidth)
1125               {
1126                 alWidth = hwidth;
1127               }
1128             }
1129             // We can still insert gaps if the selectionGroup
1130             // contains all the sequences
1131             sg.setEndRes(sg.getEndRes() + startres - lastres);
1132             fixedRight = alWidth + startres - lastres;
1133           }
1134           else
1135           {
1136             endEditing();
1137             return;
1138           }
1139         }
1140       }
1141
1142       // drag to left
1143       else if (!insertGap)
1144       {
1145         // / Are we able to delete?
1146         // ie are all columns blank?
1147
1148         for (g = 0; g < groupSize; g++)
1149         {
1150           for (int j = startres; j < lastres; j++)
1151           {
1152             if (groupSeqs[g].getLength() <= j)
1153             {
1154               continue;
1155             }
1156
1157             if (!jalview.util.Comparison.isGap(groupSeqs[g].getCharAt(j)))
1158             {
1159               // Not a gap, block edit not valid
1160               endEditing();
1161               return;
1162             }
1163           }
1164         }
1165       }
1166
1167       if (insertGap)
1168       {
1169         // dragging to the right
1170         if (fixedColumns && fixedRight != -1)
1171         {
1172           for (int j = lastres; j < startres; j++)
1173           {
1174             insertChar(j, groupSeqs, fixedRight);
1175           }
1176         }
1177         else
1178         {
1179           appendEdit(Action.INSERT_GAP, groupSeqs, startres, startres
1180                   - lastres);
1181         }
1182       }
1183       else
1184       {
1185         // dragging to the left
1186         if (fixedColumns && fixedRight != -1)
1187         {
1188           for (int j = lastres; j > startres; j--)
1189           {
1190             deleteChar(startres, groupSeqs, fixedRight);
1191           }
1192         }
1193         else
1194         {
1195           appendEdit(Action.DELETE_GAP, groupSeqs, startres, lastres
1196                   - startres);
1197         }
1198
1199       }
1200     }
1201     else
1202     // ///Editing a single sequence///////////
1203     {
1204       if (insertGap)
1205       {
1206         // dragging to the right
1207         if (fixedColumns && fixedRight != -1)
1208         {
1209           for (int j = lastres; j < startres; j++)
1210           {
1211             insertChar(j, new SequenceI[]
1212             { seq }, fixedRight);
1213           }
1214         }
1215         else
1216         {
1217           appendEdit(Action.INSERT_GAP, new SequenceI[]
1218           { seq }, lastres, startres - lastres);
1219         }
1220       }
1221       else
1222       {
1223         if (!editSeq)
1224         {
1225           // dragging to the left
1226           if (fixedColumns && fixedRight != -1)
1227           {
1228             for (int j = lastres; j > startres; j--)
1229             {
1230               if (!Comparison.isGap(seq.getCharAt(startres)))
1231               {
1232                 endEditing();
1233                 break;
1234               }
1235               deleteChar(startres, new SequenceI[]
1236               { seq }, fixedRight);
1237             }
1238           }
1239           else
1240           {
1241             // could be a keyboard edit trying to delete none gaps
1242             int max = 0;
1243             for (int m = startres; m < lastres; m++)
1244             {
1245               if (!Comparison.isGap(seq.getCharAt(m)))
1246               {
1247                 break;
1248               }
1249               max++;
1250             }
1251
1252             if (max > 0)
1253             {
1254               appendEdit(Action.DELETE_GAP, new SequenceI[]
1255               { seq }, startres, max);
1256             }
1257           }
1258         }
1259         else
1260         {// insertGap==false AND editSeq==TRUE;
1261           if (fixedColumns && fixedRight != -1)
1262           {
1263             for (int j = lastres; j < startres; j++)
1264             {
1265               insertChar(j, new SequenceI[]
1266               { seq }, fixedRight);
1267             }
1268           }
1269           else
1270           {
1271             appendEdit(Action.INSERT_NUC, new SequenceI[]
1272             { seq }, lastres, startres - lastres);
1273           }
1274         }
1275       }
1276     }
1277
1278     lastres = startres;
1279     seqCanvas.repaint();
1280   }
1281
1282   void insertChar(int j, SequenceI[] seq, int fixedColumn)
1283   {
1284     int blankColumn = fixedColumn;
1285     for (int s = 0; s < seq.length; s++)
1286     {
1287       // Find the next gap before the end of the visible region boundary
1288       // If lastCol > j, theres a boundary after the gap insertion
1289
1290       for (blankColumn = fixedColumn; blankColumn > j; blankColumn--)
1291       {
1292         if (jalview.util.Comparison.isGap(seq[s].getCharAt(blankColumn)))
1293         {
1294           // Theres a space, so break and insert the gap
1295           break;
1296         }
1297       }
1298
1299       if (blankColumn <= j)
1300       {
1301         blankColumn = fixedColumn;
1302         endEditing();
1303         return;
1304       }
1305     }
1306
1307     appendEdit(Action.DELETE_GAP, seq, blankColumn, 1);
1308
1309     appendEdit(Action.INSERT_GAP, seq, j, 1);
1310
1311   }
1312
1313   /**
1314    * Helper method to add and perform one edit action.
1315    *
1316    * @param action
1317    * @param seq
1318    * @param pos
1319    * @param count
1320    */
1321   protected void appendEdit(Action action, SequenceI[] seq, int pos,
1322           int count)
1323   {
1324
1325     final Edit edit = new EditCommand().new Edit(action, seq, pos, count,
1326             av.getAlignment().getGapCharacter());
1327
1328     editCommand.appendEdit(edit, av.getAlignment(),
1329             true, null);
1330   }
1331
1332   void deleteChar(int j, SequenceI[] seq, int fixedColumn)
1333   {
1334
1335     appendEdit(Action.DELETE_GAP, seq, j, 1);
1336
1337     appendEdit(Action.INSERT_GAP, seq, fixedColumn, 1);
1338   }
1339
1340   /**
1341    * DOCUMENT ME!
1342    *
1343    * @param e
1344    *          DOCUMENT ME!
1345    */
1346   @Override
1347   public void mouseEntered(MouseEvent e)
1348   {
1349     if (oldSeq < 0)
1350     {
1351       oldSeq = 0;
1352     }
1353
1354     if (scrollThread != null)
1355     {
1356       scrollThread.running = false;
1357       scrollThread = null;
1358     }
1359   }
1360
1361   /**
1362    * DOCUMENT ME!
1363    *
1364    * @param e
1365    *          DOCUMENT ME!
1366    */
1367   @Override
1368   public void mouseExited(MouseEvent e)
1369   {
1370     if (av.getWrapAlignment())
1371     {
1372       return;
1373     }
1374
1375     if (mouseDragging)
1376     {
1377       scrollThread = new ScrollThread();
1378     }
1379   }
1380
1381   @Override
1382   public void mouseClicked(MouseEvent evt)
1383   {
1384     SequenceGroup sg = null;
1385     SequenceI sequence = av.getAlignment().getSequenceAt(findSeq(evt));
1386     if (evt.getClickCount() > 1)
1387     {
1388       sg = av.getSelectionGroup();
1389       if (sg != null && sg.getSize() == 1
1390               && sg.getEndRes() - sg.getStartRes() < 2)
1391       {
1392         av.setSelectionGroup(null);
1393       }
1394
1395       List<SequenceFeature> features = seqCanvas.getFeatureRenderer().findFeaturesAtRes(
1396               sequence.getDatasetSequence(),
1397               sequence.findPosition(findRes(evt)));
1398
1399       if (features != null && features.size()> 0)
1400       {
1401         SearchResults highlight = new SearchResults();
1402         highlight.addResult(sequence, features.get(0).getBegin(),
1403                 features.get(0).getEnd());
1404         seqCanvas.highlightSearchResults(highlight);
1405       }
1406       if (features != null && features.size()> 0)
1407       {
1408         seqCanvas.getFeatureRenderer().amendFeatures(new SequenceI[]
1409         { sequence }, features.toArray(new SequenceFeature[features.size()]), false, ap);
1410
1411         seqCanvas.highlightSearchResults(null);
1412       }
1413     }
1414   }
1415
1416   @Override
1417   public void mouseWheelMoved(MouseWheelEvent e)
1418   {
1419     e.consume();
1420     if (e.getWheelRotation() > 0)
1421     {
1422       if (e.isShiftDown())
1423       {
1424         ap.scrollRight(true);
1425
1426       }
1427       else
1428       {
1429         ap.scrollUp(false);
1430       }
1431     }
1432     else
1433     {
1434       if (e.isShiftDown())
1435       {
1436         ap.scrollRight(false);
1437       }
1438       else
1439       {
1440         ap.scrollUp(true);
1441       }
1442     }
1443     // TODO Update tooltip for new position.
1444   }
1445
1446   /**
1447    * DOCUMENT ME!
1448    *
1449    * @param evt
1450    *          DOCUMENT ME!
1451    */
1452   public void doMousePressedDefineMode(MouseEvent evt)
1453   {
1454     int res = findRes(evt);
1455     int seq = findSeq(evt);
1456     oldSeq = seq;
1457
1458     startWrapBlock = wrappedBlock;
1459
1460     if (av.getWrapAlignment() && seq > av.getAlignment().getHeight())
1461     {
1462       JOptionPane.showInternalMessageDialog(Desktop.desktop, MessageManager
1463               .getString("label.cannot_edit_annotations_in_wrapped_view"),
1464               MessageManager.getString("label.wrapped_view_no_edit"),
1465               JOptionPane.WARNING_MESSAGE);
1466       return;
1467     }
1468
1469     if (seq < 0 || res < 0)
1470     {
1471       return;
1472     }
1473
1474     SequenceI sequence = av.getAlignment().getSequenceAt(seq);
1475
1476     if ((sequence == null) || (res > sequence.getLength()))
1477     {
1478       return;
1479     }
1480
1481     stretchGroup = av.getSelectionGroup();
1482
1483     if (stretchGroup == null)
1484     {
1485       stretchGroup = av.getAlignment().findGroup(sequence);
1486
1487       if ((stretchGroup != null) && (res > stretchGroup.getStartRes())
1488               && (res < stretchGroup.getEndRes()))
1489       {
1490         av.setSelectionGroup(stretchGroup);
1491       }
1492       else
1493       {
1494         stretchGroup = null;
1495       }
1496     }
1497     else if (!stretchGroup.getSequences(null).contains(sequence)
1498             || (stretchGroup.getStartRes() > res)
1499             || (stretchGroup.getEndRes() < res))
1500     {
1501       stretchGroup = null;
1502
1503       SequenceGroup[] allGroups = av.getAlignment().findAllGroups(sequence);
1504
1505       if (allGroups != null)
1506       {
1507         for (int i = 0; i < allGroups.length; i++)
1508         {
1509           if ((allGroups[i].getStartRes() <= res)
1510                   && (allGroups[i].getEndRes() >= res))
1511           {
1512             stretchGroup = allGroups[i];
1513             break;
1514           }
1515         }
1516       }
1517
1518       av.setSelectionGroup(stretchGroup);
1519
1520     }
1521
1522     if (javax.swing.SwingUtilities.isRightMouseButton(evt))
1523     {
1524       List<SequenceFeature> allFeatures = ap.getFeatureRenderer().findFeaturesAtRes(
1525               sequence.getDatasetSequence(), sequence.findPosition(res));
1526       Vector links = new Vector();
1527       for (SequenceFeature sf:allFeatures)
1528       {
1529         if (sf.links != null)
1530         {
1531           for (int j = 0; j < sf.links.size(); j++)
1532           {
1533             links.addElement(sf.links.elementAt(j));
1534           }
1535         }
1536       }
1537
1538       jalview.gui.PopupMenu pop = new jalview.gui.PopupMenu(ap, null, links);
1539       pop.show(this, evt.getX(), evt.getY());
1540       return;
1541     }
1542
1543     if (av.cursorMode)
1544     {
1545       seqCanvas.cursorX = findRes(evt);
1546       seqCanvas.cursorY = findSeq(evt);
1547       seqCanvas.repaint();
1548       return;
1549     }
1550
1551     if (stretchGroup == null)
1552     {
1553       // Only if left mouse button do we want to change group sizes
1554
1555       // define a new group here
1556       SequenceGroup sg = new SequenceGroup();
1557       sg.setStartRes(res);
1558       sg.setEndRes(res);
1559       sg.addSequence(sequence, false);
1560       av.setSelectionGroup(sg);
1561
1562       stretchGroup = sg;
1563
1564       if (av.getConservationSelected())
1565       {
1566         SliderPanel.setConservationSlider(ap, av.getGlobalColourScheme(),
1567                 "Background");
1568       }
1569
1570       if (av.getAbovePIDThreshold())
1571       {
1572         SliderPanel.setPIDSliderSource(ap, av.getGlobalColourScheme(),
1573                 "Background");
1574       }
1575       if ((stretchGroup != null) && (stretchGroup.getEndRes() == res))
1576       {
1577         // Edit end res position of selected group
1578         changeEndRes = true;
1579       }
1580       else if ((stretchGroup != null)
1581               && (stretchGroup.getStartRes() == res))
1582       {
1583         // Edit end res position of selected group
1584         changeStartRes = true;
1585       }
1586       stretchGroup.getWidth();
1587     }
1588
1589     seqCanvas.repaint();
1590   }
1591
1592   /**
1593    * DOCUMENT ME!
1594    *
1595    * @param evt
1596    *          DOCUMENT ME!
1597    */
1598   public void doMouseReleasedDefineMode(MouseEvent evt)
1599   {
1600     if (stretchGroup == null)
1601     {
1602       return;
1603     }
1604
1605     stretchGroup.recalcConservation(); // always do this - annotation has own
1606                                        // state
1607     if (stretchGroup.cs != null)
1608     {
1609       stretchGroup.cs.alignmentChanged(stretchGroup,
1610               av.getHiddenRepSequences());
1611
1612       if (stretchGroup.cs.conservationApplied())
1613       {
1614         SliderPanel.setConservationSlider(ap, stretchGroup.cs,
1615                 stretchGroup.getName());
1616       }
1617       else
1618       {
1619         SliderPanel.setPIDSliderSource(ap, stretchGroup.cs,
1620                 stretchGroup.getName());
1621       }
1622     }
1623     PaintRefresher.Refresh(this, av.getSequenceSetId());
1624     ap.paintAlignment(true);
1625
1626     changeEndRes = false;
1627     changeStartRes = false;
1628     stretchGroup = null;
1629     av.sendSelection();
1630   }
1631
1632   /**
1633    * DOCUMENT ME!
1634    *
1635    * @param evt
1636    *          DOCUMENT ME!
1637    */
1638   public void doMouseDraggedDefineMode(MouseEvent evt)
1639   {
1640     int res = findRes(evt);
1641     int y = findSeq(evt);
1642
1643     if (wrappedBlock != startWrapBlock)
1644     {
1645       return;
1646     }
1647
1648     if (stretchGroup == null)
1649     {
1650       return;
1651     }
1652
1653     if (res >= av.getAlignment().getWidth())
1654     {
1655       res = av.getAlignment().getWidth() - 1;
1656     }
1657
1658     if (stretchGroup.getEndRes() == res)
1659     {
1660       // Edit end res position of selected group
1661       changeEndRes = true;
1662     }
1663     else if (stretchGroup.getStartRes() == res)
1664     {
1665       // Edit start res position of selected group
1666       changeStartRes = true;
1667     }
1668
1669     if (res < av.getStartRes())
1670     {
1671       res = av.getStartRes();
1672     }
1673
1674     if (changeEndRes)
1675     {
1676       if (res > (stretchGroup.getStartRes() - 1))
1677       {
1678         stretchGroup.setEndRes(res);
1679       }
1680     }
1681     else if (changeStartRes)
1682     {
1683       if (res < (stretchGroup.getEndRes() + 1))
1684       {
1685         stretchGroup.setStartRes(res);
1686       }
1687     }
1688
1689     int dragDirection = 0;
1690
1691     if (y > oldSeq)
1692     {
1693       dragDirection = 1;
1694     }
1695     else if (y < oldSeq)
1696     {
1697       dragDirection = -1;
1698     }
1699
1700     while ((y != oldSeq) && (oldSeq > -1)
1701             && (y < av.getAlignment().getHeight()))
1702     {
1703       // This routine ensures we don't skip any sequences, as the
1704       // selection is quite slow.
1705       Sequence seq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
1706
1707       oldSeq += dragDirection;
1708
1709       if (oldSeq < 0)
1710       {
1711         break;
1712       }
1713
1714       Sequence nextSeq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
1715
1716       if (stretchGroup.getSequences(null).contains(nextSeq))
1717       {
1718         stretchGroup.deleteSequence(seq, false);
1719       }
1720       else
1721       {
1722         if (seq != null)
1723         {
1724           stretchGroup.addSequence(seq, false);
1725         }
1726
1727         stretchGroup.addSequence(nextSeq, false);
1728       }
1729     }
1730
1731     if (oldSeq < 0)
1732     {
1733       oldSeq = -1;
1734     }
1735
1736     mouseDragging = true;
1737
1738     if (scrollThread != null)
1739     {
1740       scrollThread.setEvent(evt);
1741     }
1742
1743     seqCanvas.repaint();
1744   }
1745
1746   void scrollCanvas(MouseEvent evt)
1747   {
1748     if (evt == null)
1749     {
1750       if (scrollThread != null)
1751       {
1752         scrollThread.running = false;
1753         scrollThread = null;
1754       }
1755       mouseDragging = false;
1756     }
1757     else
1758     {
1759       if (scrollThread == null)
1760       {
1761         scrollThread = new ScrollThread();
1762       }
1763
1764       mouseDragging = true;
1765       scrollThread.setEvent(evt);
1766     }
1767
1768   }
1769
1770   // this class allows scrolling off the bottom of the visible alignment
1771   class ScrollThread extends Thread
1772   {
1773     MouseEvent evt;
1774
1775     boolean running = false;
1776
1777     public ScrollThread()
1778     {
1779       start();
1780     }
1781
1782     public void setEvent(MouseEvent e)
1783     {
1784       evt = e;
1785     }
1786
1787     public void stopScrolling()
1788     {
1789       running = false;
1790     }
1791
1792     @Override
1793     public void run()
1794     {
1795       running = true;
1796
1797       while (running)
1798       {
1799         if (evt != null)
1800         {
1801           if (mouseDragging && (evt.getY() < 0) && (av.getStartSeq() > 0))
1802           {
1803             running = ap.scrollUp(true);
1804           }
1805
1806           if (mouseDragging && (evt.getY() >= getHeight())
1807                   && (av.getAlignment().getHeight() > av.getEndSeq()))
1808           {
1809             running = ap.scrollUp(false);
1810           }
1811
1812           if (mouseDragging && (evt.getX() < 0))
1813           {
1814             running = ap.scrollRight(false);
1815           }
1816           else if (mouseDragging && (evt.getX() >= getWidth()))
1817           {
1818             running = ap.scrollRight(true);
1819           }
1820         }
1821
1822         try
1823         {
1824           Thread.sleep(20);
1825         } catch (Exception ex)
1826         {
1827         }
1828       }
1829     }
1830   }
1831
1832   /**
1833    * modify current selection according to a received message.
1834    */
1835   @Override
1836   public void selection(SequenceGroup seqsel, ColumnSelection colsel,
1837           SelectionSource source)
1838   {
1839     // TODO: fix this hack - source of messages is align viewport, but SeqPanel
1840     // handles selection messages...
1841     // TODO: extend config options to allow user to control if selections may be
1842     // shared between viewports.
1843     boolean iSentTheSelection = (av == source
1844             || (source instanceof AlignViewport && ((AlignmentViewport) source)
1845             .getSequenceSetId().equals(av.getSequenceSetId())));
1846     if (iSentTheSelection || !av.followSelection)
1847     {
1848       return;
1849     }
1850
1851     /*
1852      * Ignore the selection if there is one of our own pending.
1853      */
1854     if (av.isSelectionGroupChanged(false) || av.isColSelChanged(false))
1855     {
1856       return;
1857     }
1858
1859     /*
1860      * Check for selection in a view of which this one is a dna/protein
1861      * complement.
1862      */
1863     if (selectionFromTranslation(seqsel, colsel, source))
1864     {
1865       return;
1866     }
1867
1868     // do we want to thread this ? (contention with seqsel and colsel locks, I
1869     // suspect)
1870     // rules are: colsel is copied if there is a real intersection between
1871     // sequence selection
1872     boolean repaint = false;
1873     boolean copycolsel = true;
1874
1875     SequenceGroup sgroup = null;
1876     if (seqsel != null && seqsel.getSize() > 0)
1877     {
1878       if (av.getAlignment() == null)
1879       {
1880         jalview.bin.Cache.log.warn("alignviewport av SeqSetId="
1881                 + av.getSequenceSetId() + " ViewId=" + av.getViewId()
1882                 + " 's alignment is NULL! returning immediately.");
1883         return;
1884       }
1885       sgroup = seqsel.intersect(av.getAlignment(),
1886               (av.hasHiddenRows()) ? av.getHiddenRepSequences() : null);
1887       if ((sgroup == null || sgroup.getSize() == 0)
1888               || (colsel == null || colsel.size() == 0))
1889       {
1890         // don't copy columns if the region didn't intersect.
1891         copycolsel = false;
1892       }
1893     }
1894     if (sgroup != null && sgroup.getSize() > 0)
1895     {
1896       av.setSelectionGroup(sgroup);
1897     }
1898     else
1899     {
1900       av.setSelectionGroup(null);
1901     }
1902     av.isSelectionGroupChanged(true);
1903     repaint = true;
1904
1905     if (copycolsel)
1906     {
1907       // the current selection is unset or from a previous message
1908       // so import the new colsel.
1909       if (colsel == null || colsel.size() == 0)
1910       {
1911         if (av.getColumnSelection() != null)
1912         {
1913           av.getColumnSelection().clear();
1914           repaint = true;
1915         }
1916       }
1917       else
1918       {
1919         // TODO: shift colSel according to the intersecting sequences
1920         if (av.getColumnSelection() == null)
1921         {
1922           av.setColumnSelection(new ColumnSelection(colsel));
1923         }
1924         else
1925         {
1926           av.getColumnSelection().setElementsFrom(colsel);
1927         }
1928       }
1929       av.isColSelChanged(true);
1930       repaint = true;
1931     }
1932
1933     if (copycolsel
1934             && av.hasHiddenColumns()
1935             && (av.getColumnSelection() == null || av.getColumnSelection()
1936                     .getHiddenColumns() == null))
1937     {
1938       System.err.println("Bad things");
1939     }
1940     if (repaint) // always true!
1941     {
1942       // probably finessing with multiple redraws here
1943       PaintRefresher.Refresh(this, av.getSequenceSetId());
1944       // ap.paintAlignment(false);
1945     }
1946   }
1947
1948   /**
1949    * If this panel is a cdna/protein translation view of the selection source,
1950    * tries to map the source selection to a local one, and returns true. Else
1951    * returns false.
1952    *
1953    * @param seqsel
1954    * @param colsel
1955    * @param source
1956    */
1957   protected boolean selectionFromTranslation(SequenceGroup seqsel,
1958           ColumnSelection colsel, SelectionSource source)
1959   {
1960     if (!(source instanceof AlignViewportI)) {
1961       return false;
1962     }
1963     final AlignViewportI sourceAv = (AlignViewportI) source;
1964     if (sourceAv.getCodingComplement() != av && av.getCodingComplement() != sourceAv)
1965     {
1966       return false;
1967     }
1968
1969     /*
1970      * Map sequence selection
1971      */
1972     SequenceGroup sg = MappingUtils.mapSequenceGroup(seqsel, sourceAv, av);
1973     av.setSelectionGroup(sg);
1974     av.isSelectionGroupChanged(true);
1975
1976     /*
1977      * Map column selection
1978      */
1979     ColumnSelection cs = MappingUtils.mapColumnSelection(colsel, sourceAv,
1980             av);
1981     av.setColumnSelection(cs);
1982     av.isColSelChanged(true);
1983
1984     PaintRefresher.Refresh(this, av.getSequenceSetId());
1985
1986     return true;
1987   }
1988 }