src/jalview/appletgui/SeqPanel.java

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