src/jalview/gui/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.gui;
  22
  23 import java.awt.BorderLayout;
  24 import java.awt.Color;
  25 import java.awt.Font;
  26 import java.awt.FontMetrics;
  27 import java.awt.Point;
  28 import java.awt.event.MouseEvent;
  29 import java.awt.event.MouseListener;
  30 import java.awt.event.MouseMotionListener;
  31 import java.awt.event.MouseWheelEvent;
  32 import java.awt.event.MouseWheelListener;
  33 import java.util.ArrayList;
  34 import java.util.Collections;
  35 import java.util.List;
  36
  37 import javax.swing.JPanel;
  38 import javax.swing.SwingUtilities;
  39 import javax.swing.ToolTipManager;
  40
  41 import jalview.api.AlignViewportI;
  42 import jalview.bin.Cache;
  43 import jalview.commands.EditCommand;
  44 import jalview.commands.EditCommand.Action;
  45 import jalview.commands.EditCommand.Edit;
  46 import jalview.datamodel.AlignmentAnnotation;
  47 import jalview.datamodel.AlignmentI;
  48 import jalview.datamodel.ColumnSelection;
  49 import jalview.datamodel.HiddenColumns;
  50 import jalview.datamodel.MappedFeatures;
  51 import jalview.datamodel.SearchResultMatchI;
  52 import jalview.datamodel.SearchResults;
  53 import jalview.datamodel.SearchResultsI;
  54 import jalview.datamodel.Sequence;
  55 import jalview.datamodel.SequenceFeature;
  56 import jalview.datamodel.SequenceGroup;
  57 import jalview.datamodel.SequenceI;
  58 import jalview.io.SequenceAnnotationReport;
  59 import jalview.renderer.ResidueShaderI;
  60 import jalview.schemes.ResidueProperties;
  61 import jalview.structure.SelectionListener;
  62 import jalview.structure.SelectionSource;
  63 import jalview.structure.SequenceListener;
  64 import jalview.structure.StructureSelectionManager;
  65 import jalview.structure.VamsasSource;
  66 import jalview.util.Comparison;
  67 import jalview.util.MappingUtils;
  68 import jalview.util.MessageManager;
  69 import jalview.util.Platform;
  70 import jalview.viewmodel.AlignmentViewport;
  71 import jalview.viewmodel.ViewportRanges;
  72 import jalview.viewmodel.seqfeatures.FeatureRendererModel;
  73
  74 /**
  75  * DOCUMENT ME!
  76  *
  77  * @author $author$
  78  * @version $Revision: 1.130 $
  79  */
  80 public class SeqPanel extends JPanel
  81         implements MouseListener, MouseMotionListener, MouseWheelListener,
  82         SequenceListener, SelectionListener
  83 {
  84   /*
  85    * a class that holds computed mouse position
  86    * - column of the alignment (0...)
  87    * - sequence offset (0...)
  88    * - annotation row offset (0...)
  89    * where annotation offset is -1 unless the alignment is shown
  90    * in wrapped mode, annotations are shown, and the mouse is
  91    * over an annnotation row
  92    */
  93   static class MousePos
  94   {
  95     /*
  96      * alignment column position of cursor (0...)
  97      */
  98     final int column;
  99
 100     /*
 101      * index in alignment of sequence under cursor,
 102      * or nearest above if cursor is not over a sequence
 103      */
 104     final int seqIndex;
 105
 106     /*
 107      * index in annotations array of annotation under the cursor
 108      * (only possible in wrapped mode with annotations shown),
 109      * or -1 if cursor is not over an annotation row
 110      */
 111     final int annotationIndex;
 112
 113     MousePos(int col, int seq, int ann)
 114     {
 115       column = col;
 116       seqIndex = seq;
 117       annotationIndex = ann;
 118     }
 119
 120     boolean isOverAnnotation()
 121     {
 122       return annotationIndex != -1;
 123     }
 124
 125     @Override
 126     public boolean equals(Object obj)
 127     {
 128       if (obj == null || !(obj instanceof MousePos))
 129       {
 130         return false;
 131       }
 132       MousePos o = (MousePos) obj;
 133       boolean b = (column == o.column && seqIndex == o.seqIndex
 134               && annotationIndex == o.annotationIndex);
 135       // System.out.println(obj + (b ? "= " : "!= ") + this);
 136       return b;
 137     }
 138
 139     /**
 140      * A simple hashCode that ensures that instances that satisfy equals() have
 141      * the same hashCode
 142      */
 143     @Override
 144     public int hashCode()
 145     {
 146       return column + seqIndex + annotationIndex;
 147     }
 148
 149     /**
 150      * toString method for debug output purposes only
 151      */
 152     @Override
 153     public String toString()
 154     {
 155       return String.format("c%d:s%d:a%d", column, seqIndex,
 156               annotationIndex);
 157     }
 158   }
 159
 160   private static final int MAX_TOOLTIP_LENGTH = 300;
 161
 162   public SeqCanvas seqCanvas;
 163
 164   public AlignmentPanel ap;
 165
 166   /*
 167    * last position for mouseMoved event
 168    */
 169   private MousePos lastMousePosition;
 170
 171   protected int editLastRes;
 172
 173   protected int editStartSeq;
 174
 175   protected AlignViewport av;
 176
 177   ScrollThread scrollThread = null;
 178
 179   boolean mouseDragging = false;
 180
 181   boolean editingSeqs = false;
 182
 183   boolean groupEditing = false;
 184
 185   // ////////////////////////////////////////
 186   // ///Everything below this is for defining the boundary of the rubberband
 187   // ////////////////////////////////////////
 188   int oldSeq = -1;
 189
 190   boolean changeEndSeq = false;
 191
 192   boolean changeStartSeq = false;
 193
 194   boolean changeEndRes = false;
 195
 196   boolean changeStartRes = false;
 197
 198   SequenceGroup stretchGroup = null;
 199
 200   boolean remove = false;
 201
 202   Point lastMousePress;
 203
 204   boolean mouseWheelPressed = false;
 205
 206   StringBuffer keyboardNo1;
 207
 208   StringBuffer keyboardNo2;
 209
 210   private final SequenceAnnotationReport seqARep;
 211
 212   StringBuilder tooltipText = new StringBuilder();
 213
 214   String tmpString;
 215
 216   EditCommand editCommand;
 217
 218   StructureSelectionManager ssm;
 219
 220   SearchResultsI lastSearchResults;
 221
 222   /**
 223    * Creates a new SeqPanel object
 224    *
 225    * @param viewport
 226    * @param alignPanel
 227    */
 228   public SeqPanel(AlignViewport viewport, AlignmentPanel alignPanel)
 229   {
 230     seqARep = new SequenceAnnotationReport(true);
 231     ToolTipManager.sharedInstance().registerComponent(this);
 232     ToolTipManager.sharedInstance().setInitialDelay(0);
 233     ToolTipManager.sharedInstance().setDismissDelay(10000);
 234     this.av = viewport;
 235     setBackground(Color.white);
 236
 237     seqCanvas = new SeqCanvas(alignPanel);
 238     setLayout(new BorderLayout());
 239     add(seqCanvas, BorderLayout.CENTER);
 240
 241     this.ap = alignPanel;
 242
 243     if (!viewport.isDataset())
 244     {
 245       addMouseMotionListener(this);
 246       addMouseListener(this);
 247       addMouseWheelListener(this);
 248       ssm = viewport.getStructureSelectionManager();
 249       ssm.addStructureViewerListener(this);
 250       ssm.addSelectionListener(this);
 251     }
 252   }
 253
 254   int startWrapBlock = -1;
 255
 256   int wrappedBlock = -1;
 257
 258   /**
 259    * Computes the column and sequence row (and possibly annotation row when in
 260    * wrapped mode) for the given mouse position
 261    *
 262    * @param evt
 263    * @return
 264    */
 265   MousePos findMousePosition(MouseEvent evt)
 266   {
 267     int col = findColumn(evt);
 268     int seqIndex = -1;
 269     int annIndex = -1;
 270     int y = evt.getY();
 271
 272     int charHeight = av.getCharHeight();
 273     int alignmentHeight = av.getAlignment().getHeight();
 274     if (av.getWrapAlignment())
 275     {
 276       seqCanvas.calculateWrappedGeometry(seqCanvas.getWidth(),
 277               seqCanvas.getHeight());
 278
 279       /*
 280        * yPos modulo height of repeating width
 281        */
 282       int yOffsetPx = y % seqCanvas.wrappedRepeatHeightPx;
 283
 284       /*
 285        * height of sequences plus space / scale above,
 286        * plus gap between sequences and annotations
 287        */
 288       int alignmentHeightPixels = seqCanvas.wrappedSpaceAboveAlignment
 289               + alignmentHeight * charHeight
 290               + SeqCanvas.SEQS_ANNOTATION_GAP;
 291       if (yOffsetPx >= alignmentHeightPixels)
 292       {
 293         /*
 294          * mouse is over annotations; find annotation index, also set
 295          * last sequence above (for backwards compatible behaviour)
 296          */
 297         AlignmentAnnotation[] anns = av.getAlignment()
 298                 .getAlignmentAnnotation();
 299         int rowOffsetPx = yOffsetPx - alignmentHeightPixels;
 300         annIndex = AnnotationPanel.getRowIndex(rowOffsetPx, anns);
 301         seqIndex = alignmentHeight - 1;
 302       }
 303       else
 304       {
 305         /*
 306          * mouse is over sequence (or the space above sequences)
 307          */
 308         yOffsetPx -= seqCanvas.wrappedSpaceAboveAlignment;
 309         if (yOffsetPx >= 0)
 310         {
 311           seqIndex = Math.min(yOffsetPx / charHeight, alignmentHeight - 1);
 312         }
 313       }
 314     }
 315     else
 316     {
 317       ViewportRanges ranges = av.getRanges();
 318       seqIndex = Math.min((y / charHeight) + ranges.getStartSeq(),
 319               alignmentHeight - 1);
 320       seqIndex = Math.min(seqIndex, ranges.getEndSeq());
 321     }
 322
 323     return new MousePos(col, seqIndex, annIndex);
 324   }
 325   /**
 326    * Returns the aligned sequence position (base 0) at the mouse position, or
 327    * the closest visible one
 328    *
 329    * @param evt
 330    * @return
 331    */
 332   int findColumn(MouseEvent evt)
 333   {
 334     int res = 0;
 335     int x = evt.getX();
 336
 337     final int startRes = av.getRanges().getStartRes();
 338     final int charWidth = av.getCharWidth();
 339
 340     if (av.getWrapAlignment())
 341     {
 342       int hgap = av.getCharHeight();
 343       if (av.getScaleAboveWrapped())
 344       {
 345         hgap += av.getCharHeight();
 346       }
 347
 348       int cHeight = av.getAlignment().getHeight() * av.getCharHeight()
 349               + hgap + seqCanvas.getAnnotationHeight();
 350
 351       int y = evt.getY();
 352       y = Math.max(0, y - hgap);
 353       x -= seqCanvas.getLabelWidthWest();
 354       if (x < 0)
 355       {
 356         // mouse is over left scale
 357         return -1;
 358       }
 359
 360       int cwidth = seqCanvas.getWrappedCanvasWidth(this.getWidth());
 361       if (cwidth < 1)
 362       {
 363         return 0;
 364       }
 365       if (x >= cwidth * charWidth)
 366       {
 367         // mouse is over right scale
 368         return -1;
 369       }
 370
 371       wrappedBlock = y / cHeight;
 372       wrappedBlock += startRes / cwidth;
 373       // allow for wrapped view scrolled right (possible from Overview)
 374       int startOffset = startRes % cwidth;
 375       res = wrappedBlock * cwidth + startOffset
 376               + Math.min(cwidth - 1, x / charWidth);
 377     }
 378     else
 379     {
 380       /*
 381        * make sure we calculate relative to visible alignment,
 382        * rather than right-hand gutter
 383        */
 384       x = Math.min(x, seqCanvas.getX() + seqCanvas.getWidth());
 385       res = (x / charWidth) + startRes;
 386       res = Math.min(res, av.getRanges().getEndRes());
 387     }
 388
 389     if (av.hasHiddenColumns())
 390     {
 391       res = av.getAlignment().getHiddenColumns()
 392               .visibleToAbsoluteColumn(res);
 393     }
 394
 395     return res;
 396   }
 397
 398   /**
 399    * When all of a sequence of edits are complete, put the resulting edit list
 400    * on the history stack (undo list), and reset flags for editing in progress.
 401    */
 402   void endEditing()
 403   {
 404     try
 405     {
 406       if (editCommand != null && editCommand.getSize() > 0)
 407       {
 408         ap.alignFrame.addHistoryItem(editCommand);
 409         av.firePropertyChange("alignment", null,
 410                 av.getAlignment().getSequences());
 411       }
 412     } finally
 413     {
 414       /*
 415        * Tidy up come what may...
 416        */
 417       editStartSeq = -1;
 418       editLastRes = -1;
 419       editingSeqs = false;
 420       groupEditing = false;
 421       keyboardNo1 = null;
 422       keyboardNo2 = null;
 423       editCommand = null;
 424     }
 425   }
 426
 427   void setCursorRow()
 428   {
 429     seqCanvas.cursorY = getKeyboardNo1() - 1;
 430     scrollToVisible(true);
 431   }
 432
 433   void setCursorColumn()
 434   {
 435     seqCanvas.cursorX = getKeyboardNo1() - 1;
 436     scrollToVisible(true);
 437   }
 438
 439   void setCursorRowAndColumn()
 440   {
 441     if (keyboardNo2 == null)
 442     {
 443       keyboardNo2 = new StringBuffer();
 444     }
 445     else
 446     {
 447       seqCanvas.cursorX = getKeyboardNo1() - 1;
 448       seqCanvas.cursorY = getKeyboardNo2() - 1;
 449       scrollToVisible(true);
 450     }
 451   }
 452
 453   void setCursorPosition()
 454   {
 455     SequenceI sequence = av.getAlignment().getSequenceAt(seqCanvas.cursorY);
 456
 457     seqCanvas.cursorX = sequence.findIndex(getKeyboardNo1()) - 1;
 458     scrollToVisible(true);
 459   }
 460
 461   void moveCursor(int dx, int dy)
 462   {
 463     seqCanvas.cursorX += dx;
 464     seqCanvas.cursorY += dy;
 465
 466     HiddenColumns hidden = av.getAlignment().getHiddenColumns();
 467
 468     if (av.hasHiddenColumns() && !hidden.isVisible(seqCanvas.cursorX))
 469     {
 470       int original = seqCanvas.cursorX - dx;
 471       int maxWidth = av.getAlignment().getWidth();
 472
 473       if (!hidden.isVisible(seqCanvas.cursorX))
 474       {
 475         int visx = hidden.absoluteToVisibleColumn(seqCanvas.cursorX - dx);
 476         int[] region = hidden.getRegionWithEdgeAtRes(visx);
 477
 478         if (region != null) // just in case
 479         {
 480           if (dx == 1)
 481           {
 482             // moving right
 483             seqCanvas.cursorX = region[1] + 1;
 484           }
 485           else if (dx == -1)
 486           {
 487             // moving left
 488             seqCanvas.cursorX = region[0] - 1;
 489           }
 490         }
 491         seqCanvas.cursorX = (seqCanvas.cursorX < 0) ? 0 : seqCanvas.cursorX;
 492       }
 493
 494       if (seqCanvas.cursorX >= maxWidth
 495               || !hidden.isVisible(seqCanvas.cursorX))
 496       {
 497         seqCanvas.cursorX = original;
 498       }
 499     }
 500
 501     scrollToVisible(false);
 502   }
 503
 504   /**
 505    * Scroll to make the cursor visible in the viewport.
 506    *
 507    * @param jump
 508    *          just jump to the location rather than scrolling
 509    */
 510   void scrollToVisible(boolean jump)
 511   {
 512     if (seqCanvas.cursorX < 0)
 513     {
 514       seqCanvas.cursorX = 0;
 515     }
 516     else if (seqCanvas.cursorX > av.getAlignment().getWidth() - 1)
 517     {
 518       seqCanvas.cursorX = av.getAlignment().getWidth() - 1;
 519     }
 520
 521     if (seqCanvas.cursorY < 0)
 522     {
 523       seqCanvas.cursorY = 0;
 524     }
 525     else if (seqCanvas.cursorY > av.getAlignment().getHeight() - 1)
 526     {
 527       seqCanvas.cursorY = av.getAlignment().getHeight() - 1;
 528     }
 529
 530     endEditing();
 531
 532     boolean repaintNeeded = true;
 533     if (jump)
 534     {
 535       // only need to repaint if the viewport did not move, as otherwise it will
 536       // get a repaint
 537       repaintNeeded = !av.getRanges().setViewportLocation(seqCanvas.cursorX,
 538               seqCanvas.cursorY);
 539     }
 540     else
 541     {
 542       if (av.getWrapAlignment())
 543       {
 544         // scrollToWrappedVisible expects x-value to have hidden cols subtracted
 545         int x = av.getAlignment().getHiddenColumns()
 546                 .absoluteToVisibleColumn(seqCanvas.cursorX);
 547         av.getRanges().scrollToWrappedVisible(x);
 548       }
 549       else
 550       {
 551         av.getRanges().scrollToVisible(seqCanvas.cursorX,
 552                 seqCanvas.cursorY);
 553       }
 554     }
 555
 556     if (av.getAlignment().getHiddenColumns().isVisible(seqCanvas.cursorX))
 557     {
 558       setStatusMessage(av.getAlignment().getSequenceAt(seqCanvas.cursorY),
 559             seqCanvas.cursorX, seqCanvas.cursorY);
 560     }
 561
 562     if (repaintNeeded)
 563     {
 564       seqCanvas.repaint();
 565     }
 566   }
 567
 568
 569   void setSelectionAreaAtCursor(boolean topLeft)
 570   {
 571     SequenceI sequence = av.getAlignment().getSequenceAt(seqCanvas.cursorY);
 572
 573     if (av.getSelectionGroup() != null)
 574     {
 575       SequenceGroup sg = av.getSelectionGroup();
 576       // Find the top and bottom of this group
 577       int min = av.getAlignment().getHeight(), max = 0;
 578       for (int i = 0; i < sg.getSize(); i++)
 579       {
 580         int index = av.getAlignment().findIndex(sg.getSequenceAt(i));
 581         if (index > max)
 582         {
 583           max = index;
 584         }
 585         if (index < min)
 586         {
 587           min = index;
 588         }
 589       }
 590
 591       max++;
 592
 593       if (topLeft)
 594       {
 595         sg.setStartRes(seqCanvas.cursorX);
 596         if (sg.getEndRes() < seqCanvas.cursorX)
 597         {
 598           sg.setEndRes(seqCanvas.cursorX);
 599         }
 600
 601         min = seqCanvas.cursorY;
 602       }
 603       else
 604       {
 605         sg.setEndRes(seqCanvas.cursorX);
 606         if (sg.getStartRes() > seqCanvas.cursorX)
 607         {
 608           sg.setStartRes(seqCanvas.cursorX);
 609         }
 610
 611         max = seqCanvas.cursorY + 1;
 612       }
 613
 614       if (min > max)
 615       {
 616         // Only the user can do this
 617         av.setSelectionGroup(null);
 618       }
 619       else
 620       {
 621         // Now add any sequences between min and max
 622         sg.getSequences(null).clear();
 623         for (int i = min; i < max; i++)
 624         {
 625           sg.addSequence(av.getAlignment().getSequenceAt(i), false);
 626         }
 627       }
 628     }
 629
 630     if (av.getSelectionGroup() == null)
 631     {
 632       SequenceGroup sg = new SequenceGroup();
 633       sg.setStartRes(seqCanvas.cursorX);
 634       sg.setEndRes(seqCanvas.cursorX);
 635       sg.addSequence(sequence, false);
 636       av.setSelectionGroup(sg);
 637     }
 638
 639     ap.paintAlignment(false, false);
 640     av.sendSelection();
 641   }
 642
 643   void insertGapAtCursor(boolean group)
 644   {
 645     groupEditing = group;
 646     editStartSeq = seqCanvas.cursorY;
 647     editLastRes = seqCanvas.cursorX;
 648     editSequence(true, false, seqCanvas.cursorX + getKeyboardNo1());
 649     endEditing();
 650   }
 651
 652   void deleteGapAtCursor(boolean group)
 653   {
 654     groupEditing = group;
 655     editStartSeq = seqCanvas.cursorY;
 656     editLastRes = seqCanvas.cursorX + getKeyboardNo1();
 657     editSequence(false, false, seqCanvas.cursorX);
 658     endEditing();
 659   }
 660
 661   void insertNucAtCursor(boolean group, String nuc)
 662   {
 663     // TODO not called - delete?
 664     groupEditing = group;
 665     editStartSeq = seqCanvas.cursorY;
 666     editLastRes = seqCanvas.cursorX;
 667     editSequence(false, true, seqCanvas.cursorX + getKeyboardNo1());
 668     endEditing();
 669   }
 670
 671   void numberPressed(char value)
 672   {
 673     if (keyboardNo1 == null)
 674     {
 675       keyboardNo1 = new StringBuffer();
 676     }
 677
 678     if (keyboardNo2 != null)
 679     {
 680       keyboardNo2.append(value);
 681     }
 682     else
 683     {
 684       keyboardNo1.append(value);
 685     }
 686   }
 687
 688   int getKeyboardNo1()
 689   {
 690     try
 691     {
 692       if (keyboardNo1 != null)
 693       {
 694         int value = Integer.parseInt(keyboardNo1.toString());
 695         keyboardNo1 = null;
 696         return value;
 697       }
 698     } catch (Exception x)
 699     {
 700     }
 701     keyboardNo1 = null;
 702     return 1;
 703   }
 704
 705   int getKeyboardNo2()
 706   {
 707     try
 708     {
 709       if (keyboardNo2 != null)
 710       {
 711         int value = Integer.parseInt(keyboardNo2.toString());
 712         keyboardNo2 = null;
 713         return value;
 714       }
 715     } catch (Exception x)
 716     {
 717     }
 718     keyboardNo2 = null;
 719     return 1;
 720   }
 721
 722   /**
 723    * DOCUMENT ME!
 724    *
 725    * @param evt
 726    *          DOCUMENT ME!
 727    */
 728   @Override
 729   public void mouseReleased(MouseEvent evt)
 730   {
 731     MousePos pos = findMousePosition(evt);
 732     if (pos.isOverAnnotation() || pos.seqIndex == -1 || pos.column == -1)
 733     {
 734       return;
 735     }
 736
 737     boolean didDrag = mouseDragging; // did we come here after a drag
 738     mouseDragging = false;
 739     mouseWheelPressed = false;
 740
 741     if (evt.isPopupTrigger()) // Windows: mouseReleased
 742     {
 743       showPopupMenu(evt, pos);
 744       evt.consume();
 745       return;
 746     }
 747
 748     if (editingSeqs)
 749     {
 750       endEditing();
 751     }
 752     else
 753     {
 754       doMouseReleasedDefineMode(evt, didDrag);
 755     }
 756   }
 757
 758   /**
 759    * DOCUMENT ME!
 760    *
 761    * @param evt
 762    *          DOCUMENT ME!
 763    */
 764   @Override
 765   public void mousePressed(MouseEvent evt)
 766   {
 767     lastMousePress = evt.getPoint();
 768     MousePos pos = findMousePosition(evt);
 769     if (pos.isOverAnnotation() || pos.seqIndex == -1 || pos.column == -1)
 770     {
 771       return;
 772     }
 773
 774     if (SwingUtilities.isMiddleMouseButton(evt))
 775     {
 776       mouseWheelPressed = true;
 777       return;
 778     }
 779
 780     boolean isControlDown = Platform.isControlDown(evt);
 781     if (evt.isShiftDown() || isControlDown)
 782     {
 783       editingSeqs = true;
 784       if (isControlDown)
 785       {
 786         groupEditing = true;
 787       }
 788     }
 789     else
 790     {
 791       doMousePressedDefineMode(evt, pos);
 792       return;
 793     }
 794
 795     int seq = pos.seqIndex;
 796     int res = pos.column;
 797
 798     if ((seq < av.getAlignment().getHeight())
 799             && (res < av.getAlignment().getSequenceAt(seq).getLength()))
 800     {
 801       editStartSeq = seq;
 802       editLastRes = res;
 803     }
 804     else
 805     {
 806       editStartSeq = -1;
 807       editLastRes = -1;
 808     }
 809
 810     return;
 811   }
 812
 813   String lastMessage;
 814
 815   @Override
 816   public void mouseOverSequence(SequenceI sequence, int index, int pos)
 817   {
 818     String tmp = sequence.hashCode() + " " + index + " " + pos;
 819
 820     if (lastMessage == null || !lastMessage.equals(tmp))
 821     {
 822       // System.err.println("mouseOver Sequence: "+tmp);
 823       ssm.mouseOverSequence(sequence, index, pos, av);
 824     }
 825     lastMessage = tmp;
 826   }
 827
 828   /**
 829    * Highlight the mapped region described by the search results object (unless
 830    * unchanged). This supports highlight of protein while mousing over linked
 831    * cDNA and vice versa. The status bar is also updated to show the location of
 832    * the start of the highlighted region.
 833    */
 834   @Override
 835   public String highlightSequence(SearchResultsI results)
 836   {
 837     if (results == null || results.equals(lastSearchResults))
 838     {
 839       return null;
 840     }
 841     lastSearchResults = results;
 842
 843     boolean wasScrolled = false;
 844
 845     if (av.isFollowHighlight())
 846     {
 847       // don't allow highlight of protein/cDNA to also scroll a complementary
 848       // panel,as this sets up a feedback loop (scrolling panel 1 causes moused
 849       // over residue to change abruptly, causing highlighted residue in panel 2
 850       // to change, causing a scroll in panel 1 etc)
 851       ap.setToScrollComplementPanel(false);
 852       wasScrolled = ap.scrollToPosition(results);
 853       if (wasScrolled)
 854       {
 855         seqCanvas.revalidate();
 856       }
 857       ap.setToScrollComplementPanel(true);
 858     }
 859
 860     boolean noFastPaint = wasScrolled && av.getWrapAlignment();
 861     if (seqCanvas.highlightSearchResults(results, noFastPaint))
 862     {
 863       setStatusMessage(results);
 864     }
 865     // JAL-3303 feature suppressed for now pending review
 866     return null; // results.isEmpty() ? null : getHighlightInfo(results);
 867   }
 868
 869   /**
 870    * temporary hack: answers a message suitable to show on structure hover
 871    * label. This is normally null. It is a peptide variation description if
 872    * <ul>
 873    * <li>results are a single residue in a protein alignment</li>
 874    * <li>there is a mapping to a coding sequence (codon)</li>
 875    * <li>there are one or more SNP variant features on the codon</li>
 876    * </ul>
 877    * in which case the answer is of the format (e.g.) "p.Glu388Asp"
 878    *
 879    * @param results
 880    * @return
 881    */
 882   private String getHighlightInfo(SearchResultsI results)
 883   {
 884     /*
 885      * ideally, just find mapped CDS (as we don't care about render style here);
 886      * for now, go via split frame complement's FeatureRenderer
 887      */
 888     AlignViewportI complement = ap.getAlignViewport().getCodingComplement();
 889     if (complement == null)
 890     {
 891       return null;
 892     }
 893     AlignFrame af = Desktop.getAlignFrameFor(complement);
 894     FeatureRendererModel fr2 = af.getFeatureRenderer();
 895
 896     int j = results.getSize();
 897     List<String> infos = new ArrayList<>();
 898     for (int i = 0; i < j; i++)
 899     {
 900       SearchResultMatchI match = results.getResults().get(i);
 901       int pos = match.getStart();
 902       if (pos == match.getEnd())
 903       {
 904         SequenceI seq = match.getSequence();
 905         SequenceI ds = seq.getDatasetSequence() == null ? seq
 906                 : seq.getDatasetSequence();
 907         MappedFeatures mf = fr2
 908                 .findComplementFeaturesAtResidue(ds, pos);
 909         if (mf != null)
 910         {
 911           for (SequenceFeature sf : mf.features)
 912           {
 913             String pv = mf.findProteinVariants(sf);
 914             if (pv.length() > 0 && !infos.contains(pv))
 915             {
 916               infos.add(pv);
 917             }
 918           }
 919         }
 920       }
 921     }
 922
 923     if (infos.isEmpty())
 924     {
 925       return null;
 926     }
 927     StringBuilder sb = new StringBuilder();
 928     for (String info : infos)
 929     {
 930       if (sb.length() > 0)
 931       {
 932         sb.append("|");
 933       }
 934       sb.append(info);
 935     }
 936     return sb.toString();
 937   }
 938
 939   @Override
 940   public VamsasSource getVamsasSource()
 941   {
 942     return this.ap == null ? null : this.ap.av;
 943   }
 944
 945   @Override
 946   public void updateColours(SequenceI seq, int index)
 947   {
 948     System.out.println("update the seqPanel colours");
 949     // repaint();
 950   }
 951
 952   /**
 953    * Action on mouse movement is to update the status bar to show the current
 954    * sequence position, and (if features are shown) to show any features at the
 955    * position in a tooltip. Does nothing if the mouse move does not change
 956    * residue position.
 957    *
 958    * @param evt
 959    */
 960   @Override
 961   public void mouseMoved(MouseEvent evt)
 962   {
 963     if (editingSeqs)
 964     {
 965       // This is because MacOSX creates a mouseMoved
 966       // If control is down, other platforms will not.
 967       mouseDragged(evt);
 968     }
 969
 970     final MousePos mousePos = findMousePosition(evt);
 971     if (mousePos.equals(lastMousePosition))
 972     {
 973       /*
 974        * just a pixel move without change of 'cell'
 975        */
 976       return;
 977     }
 978     lastMousePosition = mousePos;
 979
 980     if (mousePos.isOverAnnotation())
 981     {
 982       mouseMovedOverAnnotation(mousePos);
 983       return;
 984     }
 985     final int seq = mousePos.seqIndex;
 986
 987     final int column = mousePos.column;
 988     if (column < 0 || seq < 0 || seq >= av.getAlignment().getHeight())
 989     {
 990       lastMousePosition = null;
 991       setToolTipText(null);
 992       lastTooltip = null;
 993       ap.alignFrame.setStatus("");
 994       return;
 995     }
 996
 997     SequenceI sequence = av.getAlignment().getSequenceAt(seq);
 998
 999     if (column >= sequence.getLength())
1000     {
1001       return;
1002     }
1003
1004     /*
1005      * set status bar message, returning residue position in sequence
1006      */
1007     boolean isGapped = Comparison.isGap(sequence.getCharAt(column));
1008     final int pos = setStatusMessage(sequence, column, seq);
1009     if (ssm != null && !isGapped)
1010     {
1011       mouseOverSequence(sequence, column, pos);
1012     }
1013
1014     tooltipText.setLength(6); // Cuts the buffer back to <html>
1015
1016     SequenceGroup[] groups = av.getAlignment().findAllGroups(sequence);
1017     if (groups != null)
1018     {
1019       for (int g = 0; g < groups.length; g++)
1020       {
1021         if (groups[g].getStartRes() <= column
1022                 && groups[g].getEndRes() >= column)
1023         {
1024           if (!groups[g].getName().startsWith("JTreeGroup")
1025                   && !groups[g].getName().startsWith("JGroup"))
1026           {
1027             tooltipText.append(groups[g].getName());
1028           }
1029
1030           if (groups[g].getDescription() != null)
1031           {
1032             tooltipText.append(": " + groups[g].getDescription());
1033           }
1034         }
1035       }
1036     }
1037
1038     /*
1039      * add any features at the position to the tooltip; if over a gap, only
1040      * add features that straddle the gap (pos may be the residue before or
1041      * after the gap)
1042      */
1043     int unshownFeatures = 0;
1044     if (av.isShowSequenceFeatures())
1045     {
1046       List<SequenceFeature> features = ap.getFeatureRenderer()
1047               .findFeaturesAtColumn(sequence, column + 1);
1048       unshownFeatures = seqARep.appendFeatures(tooltipText, pos,
1049               features, this.ap.getSeqPanel().seqCanvas.fr,
1050               MAX_TOOLTIP_LENGTH);
1051
1052       /*
1053        * add features in CDS/protein complement at the corresponding
1054        * position if configured to do so
1055        */
1056       if (av.isShowComplementFeatures())
1057       {
1058         if (!Comparison.isGap(sequence.getCharAt(column)))
1059         {
1060           AlignViewportI complement = ap.getAlignViewport()
1061                   .getCodingComplement();
1062           AlignFrame af = Desktop.getAlignFrameFor(complement);
1063           FeatureRendererModel fr2 = af.getFeatureRenderer();
1064           MappedFeatures mf = fr2.findComplementFeaturesAtResidue(sequence,
1065                   pos);
1066           if (mf != null)
1067           {
1068             unshownFeatures = seqARep.appendFeatures(tooltipText,
1069                     pos, mf, fr2, MAX_TOOLTIP_LENGTH);
1070           }
1071         }
1072       }
1073     }
1074     if (tooltipText.length() == 6) // "<html>"
1075     {
1076       setToolTipText(null);
1077       lastTooltip = null;
1078     }
1079     else
1080     {
1081       if (tooltipText.length() > MAX_TOOLTIP_LENGTH)
1082       {
1083         tooltipText.setLength(MAX_TOOLTIP_LENGTH);
1084         tooltipText.append("...");
1085       }
1086       if (unshownFeatures > 0)
1087       {
1088         tooltipText.append("<br/>").append("... ").append("<i>")
1089                 .append(MessageManager.formatMessage(
1090                         "label.features_not_shown", unshownFeatures))
1091                 .append("</i>");
1092       }
1093       String textString = tooltipText.toString();
1094       if (lastTooltip == null || !lastTooltip.equals(textString))
1095       {
1096         String formattedTooltipText = JvSwingUtils.wrapTooltip(true,
1097                 textString);
1098         setToolTipText(formattedTooltipText);
1099         lastTooltip = textString;
1100       }
1101     }
1102   }
1103
1104   /**
1105    * When the view is in wrapped mode, and the mouse is over an annotation row,
1106    * shows the corresponding tooltip and status message (if any)
1107    *
1108    * @param pos
1109    * @param column
1110    */
1111   protected void mouseMovedOverAnnotation(MousePos pos)
1112   {
1113     final int column = pos.column;
1114     final int rowIndex = pos.annotationIndex;
1115
1116     if (column < 0 || !av.getWrapAlignment() || !av.isShowAnnotation()
1117             || rowIndex < 0)
1118     {
1119       return;
1120     }
1121     AlignmentAnnotation[] anns = av.getAlignment().getAlignmentAnnotation();
1122
1123     String tooltip = AnnotationPanel.buildToolTip(anns[rowIndex], column,
1124             anns);
1125     setToolTipText(tooltip);
1126     lastTooltip = tooltip;
1127
1128     String msg = AnnotationPanel.getStatusMessage(av.getAlignment(), column,
1129             anns[rowIndex]);
1130     ap.alignFrame.setStatus(msg);
1131   }
1132
1133   private Point lastp = null;
1134
1135   /*
1136    * (non-Javadoc)
1137    *
1138    * @see javax.swing.JComponent#getToolTipLocation(java.awt.event.MouseEvent)
1139    */
1140   @Override
1141   public Point getToolTipLocation(MouseEvent event)
1142   {
1143     if (tooltipText == null || tooltipText.length() <= 6)
1144     {
1145       lastp = null;
1146       return null;
1147     }
1148
1149     int x = event.getX();
1150     int w = getWidth();
1151     // switch sides when tooltip is too close to edge
1152     int wdth = (w - x < 200) ? -(w / 2) : 5;
1153     Point p = lastp;
1154     if (!event.isShiftDown() || p == null)
1155     {
1156       p = new Point(event.getX() + wdth, event.getY() - 20);
1157       lastp = p;
1158     }
1159     /*
1160      * TODO: try to set position so region is not obscured by tooltip
1161      */
1162     return p;
1163   }
1164
1165   String lastTooltip;
1166
1167   /**
1168    * set when the current UI interaction has resulted in a change that requires
1169    * shading in overviews and structures to be recalculated. this could be
1170    * changed to a something more expressive that indicates what actually has
1171    * changed, so selective redraws can be applied (ie. only structures, only
1172    * overview, etc)
1173    */
1174   private boolean updateOverviewAndStructs = false; // TODO: refactor to avcontroller
1175
1176   /**
1177    * set if av.getSelectionGroup() refers to a group that is defined on the
1178    * alignment view, rather than a transient selection
1179    */
1180   // private boolean editingDefinedGroup = false; // TODO: refactor to
1181   // avcontroller or viewModel
1182
1183   /**
1184    * Sets the status message in alignment panel, showing the sequence number
1185    * (index) and id, and residue and residue position if not at a gap, for the
1186    * given sequence and column position. Returns the residue position returned
1187    * by Sequence.findPosition. Note this may be for the nearest adjacent residue
1188    * if at a gapped position.
1189    *
1190    * @param sequence
1191    *          aligned sequence object
1192    * @param column
1193    *          alignment column
1194    * @param seqIndex
1195    *          index of sequence in alignment
1196    * @return sequence position of residue at column, or adjacent residue if at a
1197    *         gap
1198    */
1199   int setStatusMessage(SequenceI sequence, final int column, int seqIndex)
1200   {
1201     char sequenceChar = sequence.getCharAt(column);
1202     int pos = sequence.findPosition(column);
1203     setStatusMessage(sequence, seqIndex, sequenceChar, pos);
1204
1205     return pos;
1206   }
1207
1208   /**
1209    * Builds the status message for the current cursor location and writes it to
1210    * the status bar, for example
1211    *
1212    * <pre>
1213    * Sequence 3 ID: FER1_SOLLC
1214    * Sequence 5 ID: FER1_PEA Residue: THR (4)
1215    * Sequence 5 ID: FER1_PEA Residue: B (3)
1216    * Sequence 6 ID: O.niloticus.3 Nucleotide: Uracil (2)
1217    * </pre>
1218    *
1219    * @param sequence
1220    * @param seqIndex
1221    *          sequence position in the alignment (1..)
1222    * @param sequenceChar
1223    *          the character under the cursor
1224    * @param residuePos
1225    *          the sequence residue position (if not over a gap)
1226    */
1227   protected void setStatusMessage(SequenceI sequence, int seqIndex,
1228           char sequenceChar, int residuePos)
1229   {
1230     StringBuilder text = new StringBuilder(32);
1231
1232     /*
1233      * Sequence number (if known), and sequence name.
1234      */
1235     String seqno = seqIndex == -1 ? "" : " " + (seqIndex + 1);
1236     text.append("Sequence").append(seqno).append(" ID: ")
1237             .append(sequence.getName());
1238
1239     String residue = null;
1240
1241     /*
1242      * Try to translate the display character to residue name (null for gap).
1243      */
1244     boolean isGapped = Comparison.isGap(sequenceChar);
1245
1246     if (!isGapped)
1247     {
1248       boolean nucleotide = av.getAlignment().isNucleotide();
1249       String displayChar = String.valueOf(sequenceChar);
1250       if (nucleotide)
1251       {
1252         residue = ResidueProperties.nucleotideName.get(displayChar);
1253       }
1254       else
1255       {
1256         residue = "X".equalsIgnoreCase(displayChar) ? "X"
1257                 : ("*".equals(displayChar) ? "STOP"
1258                         : ResidueProperties.aa2Triplet.get(displayChar));
1259       }
1260       text.append(" ").append(nucleotide ? "Nucleotide" : "Residue")
1261               .append(": ").append(residue == null ? displayChar : residue);
1262
1263       text.append(" (").append(Integer.toString(residuePos)).append(")");
1264     }
1265     ap.alignFrame.setStatus(text.toString());
1266   }
1267
1268   /**
1269    * Set the status bar message to highlight the first matched position in
1270    * search results.
1271    *
1272    * @param results
1273    */
1274   private void setStatusMessage(SearchResultsI results)
1275   {
1276     AlignmentI al = this.av.getAlignment();
1277     int sequenceIndex = al.findIndex(results);
1278     if (sequenceIndex == -1)
1279     {
1280       return;
1281     }
1282     SequenceI ds = al.getSequenceAt(sequenceIndex).getDatasetSequence();
1283     for (SearchResultMatchI m : results.getResults())
1284     {
1285       SequenceI seq = m.getSequence();
1286       if (seq.getDatasetSequence() != null)
1287       {
1288         seq = seq.getDatasetSequence();
1289       }
1290
1291       if (seq == ds)
1292       {
1293         int start = m.getStart();
1294         setStatusMessage(seq, sequenceIndex, seq.getCharAt(start - 1),
1295                 start);
1296         return;
1297       }
1298     }
1299   }
1300
1301   /**
1302    * {@inheritDoc}
1303    */
1304   @Override
1305   public void mouseDragged(MouseEvent evt)
1306   {
1307     MousePos pos = findMousePosition(evt);
1308     if (pos.isOverAnnotation() || pos.column == -1)
1309     {
1310       return;
1311     }
1312
1313     if (mouseWheelPressed)
1314     {
1315       boolean inSplitFrame = ap.av.getCodingComplement() != null;
1316       boolean copyChanges = inSplitFrame && av.isProteinFontAsCdna();
1317
1318       int oldWidth = av.getCharWidth();
1319
1320       // Which is bigger, left-right or up-down?
1321       if (Math.abs(evt.getY() - lastMousePress.getY()) > Math
1322               .abs(evt.getX() - lastMousePress.getX()))
1323       {
1324         /*
1325          * on drag up or down, decrement or increment font size
1326          */
1327         int fontSize = av.font.getSize();
1328         boolean fontChanged = false;
1329
1330         if (evt.getY() < lastMousePress.getY())
1331         {
1332           fontChanged = true;
1333           fontSize--;
1334         }
1335         else if (evt.getY() > lastMousePress.getY())
1336         {
1337           fontChanged = true;
1338           fontSize++;
1339         }
1340
1341         if (fontSize < 1)
1342         {
1343           fontSize = 1;
1344         }
1345
1346         if (fontChanged)
1347         {
1348           Font newFont = new Font(av.font.getName(), av.font.getStyle(),
1349                   fontSize);
1350           av.setFont(newFont, true);
1351           av.setCharWidth(oldWidth);
1352           ap.fontChanged();
1353           if (copyChanges)
1354           {
1355             ap.av.getCodingComplement().setFont(newFont, true);
1356             SplitFrame splitFrame = (SplitFrame) ap.alignFrame
1357                     .getSplitViewContainer();
1358             splitFrame.adjustLayout();
1359             splitFrame.repaint();
1360           }
1361         }
1362       }
1363       else
1364       {
1365         /*
1366          * on drag left or right, decrement or increment character width
1367          */
1368         int newWidth = 0;
1369         if (evt.getX() < lastMousePress.getX() && av.getCharWidth() > 1)
1370         {
1371           newWidth = av.getCharWidth() - 1;
1372           av.setCharWidth(newWidth);
1373         }
1374         else if (evt.getX() > lastMousePress.getX())
1375         {
1376           newWidth = av.getCharWidth() + 1;
1377           av.setCharWidth(newWidth);
1378         }
1379         if (newWidth > 0)
1380         {
1381           ap.paintAlignment(false, false);
1382           if (copyChanges)
1383           {
1384             /*
1385              * need to ensure newWidth is set on cdna, regardless of which
1386              * panel the mouse drag happened in; protein will compute its
1387              * character width as 1:1 or 3:1
1388              */
1389             av.getCodingComplement().setCharWidth(newWidth);
1390             SplitFrame splitFrame = (SplitFrame) ap.alignFrame
1391                     .getSplitViewContainer();
1392             splitFrame.adjustLayout();
1393             splitFrame.repaint();
1394           }
1395         }
1396       }
1397
1398       FontMetrics fm = getFontMetrics(av.getFont());
1399       av.validCharWidth = fm.charWidth('M') <= av.getCharWidth();
1400
1401       lastMousePress = evt.getPoint();
1402
1403       return;
1404     }
1405
1406     if (!editingSeqs)
1407     {
1408       dragStretchGroup(evt);
1409       return;
1410     }
1411
1412     int res = pos.column;
1413
1414     if (res < 0)
1415     {
1416       res = 0;
1417     }
1418
1419     if ((editLastRes == -1) || (editLastRes == res))
1420     {
1421       return;
1422     }
1423
1424     if ((res < av.getAlignment().getWidth()) && (res < editLastRes))
1425     {
1426       // dragLeft, delete gap
1427       editSequence(false, false, res);
1428     }
1429     else
1430     {
1431       editSequence(true, false, res);
1432     }
1433
1434     mouseDragging = true;
1435     if (scrollThread != null)
1436     {
1437       scrollThread.setMousePosition(evt.getPoint());
1438     }
1439   }
1440
1441   /**
1442    * Edits the sequence to insert or delete one or more gaps, in response to a
1443    * mouse drag or cursor mode command. The number of inserts/deletes may be
1444    * specified with the cursor command, or else depends on the mouse event
1445    * (normally one column, but potentially more for a fast mouse drag).
1446    * <p>
1447    * Delete gaps is limited to the number of gaps left of the cursor position
1448    * (mouse drag), or at or right of the cursor position (cursor mode).
1449    * <p>
1450    * In group editing mode (Ctrl or Cmd down), the edit acts on all sequences in
1451    * the current selection group.
1452    * <p>
1453    * In locked editing mode (with a selection group present), inserts/deletions
1454    * within the selection group are limited to its boundaries (and edits outside
1455    * the group stop at its border).
1456    *
1457    * @param insertGap
1458    *          true to insert gaps, false to delete gaps
1459    * @param editSeq
1460    *          (unused parameter)
1461    * @param startres
1462    *          the column at which to perform the action; the number of columns
1463    *          affected depends on <code>this.editLastRes</code> (cursor column
1464    *          position)
1465    */
1466   synchronized void editSequence(boolean insertGap, boolean editSeq,
1467           final int startres)
1468   {
1469     int fixedLeft = -1;
1470     int fixedRight = -1;
1471     boolean fixedColumns = false;
1472     SequenceGroup sg = av.getSelectionGroup();
1473
1474     final SequenceI seq = av.getAlignment().getSequenceAt(editStartSeq);
1475
1476     // No group, but the sequence may represent a group
1477     if (!groupEditing && av.hasHiddenRows())
1478     {
1479       if (av.isHiddenRepSequence(seq))
1480       {
1481         sg = av.getRepresentedSequences(seq);
1482         groupEditing = true;
1483       }
1484     }
1485
1486     StringBuilder message = new StringBuilder(64); // for status bar
1487
1488     /*
1489      * make a name for the edit action, for
1490      * status bar message and Undo/Redo menu
1491      */
1492     String label = null;
1493     if (groupEditing)
1494     {
1495         message.append("Edit group:");
1496       label = MessageManager.getString("action.edit_group");
1497     }
1498     else
1499     {
1500         message.append("Edit sequence: " + seq.getName());
1501       label = seq.getName();
1502       if (label.length() > 10)
1503       {
1504         label = label.substring(0, 10);
1505       }
1506       label = MessageManager.formatMessage("label.edit_params",
1507               new String[]
1508               { label });
1509     }
1510
1511     /*
1512      * initialise the edit command if there is not
1513      * already one being extended
1514      */
1515     if (editCommand == null)
1516     {
1517       editCommand = new EditCommand(label);
1518     }
1519
1520     if (insertGap)
1521     {
1522       message.append(" insert ");
1523     }
1524     else
1525     {
1526       message.append(" delete ");
1527     }
1528
1529     message.append(Math.abs(startres - editLastRes) + " gaps.");
1530     ap.alignFrame.setStatus(message.toString());
1531
1532     /*
1533      * is there a selection group containing the sequence being edited?
1534      * if so the boundary of the group is the limit of the edit
1535      * (but the edit may be inside or outside the selection group)
1536      */
1537     boolean inSelectionGroup = sg != null
1538             && sg.getSequences(av.getHiddenRepSequences()).contains(seq);
1539     if (groupEditing || inSelectionGroup)
1540     {
1541       fixedColumns = true;
1542
1543       // sg might be null as the user may only see 1 sequence,
1544       // but the sequence represents a group
1545       if (sg == null)
1546       {
1547         if (!av.isHiddenRepSequence(seq))
1548         {
1549           endEditing();
1550           return;
1551         }
1552         sg = av.getRepresentedSequences(seq);
1553       }
1554
1555       fixedLeft = sg.getStartRes();
1556       fixedRight = sg.getEndRes();
1557
1558       if ((startres < fixedLeft && editLastRes >= fixedLeft)
1559               || (startres >= fixedLeft && editLastRes < fixedLeft)
1560               || (startres > fixedRight && editLastRes <= fixedRight)
1561               || (startres <= fixedRight && editLastRes > fixedRight))
1562       {
1563         endEditing();
1564         return;
1565       }
1566
1567       if (fixedLeft > startres)
1568       {
1569         fixedRight = fixedLeft - 1;
1570         fixedLeft = 0;
1571       }
1572       else if (fixedRight < startres)
1573       {
1574         fixedLeft = fixedRight;
1575         fixedRight = -1;
1576       }
1577     }
1578
1579     if (av.hasHiddenColumns())
1580     {
1581       fixedColumns = true;
1582       int y1 = av.getAlignment().getHiddenColumns()
1583               .getNextHiddenBoundary(true, startres);
1584       int y2 = av.getAlignment().getHiddenColumns()
1585               .getNextHiddenBoundary(false, startres);
1586
1587       if ((insertGap && startres > y1 && editLastRes < y1)
1588               || (!insertGap && startres < y2 && editLastRes > y2))
1589       {
1590         endEditing();
1591         return;
1592       }
1593
1594       // System.out.print(y1+" "+y2+" "+fixedLeft+" "+fixedRight+"~~");
1595       // Selection spans a hidden region
1596       if (fixedLeft < y1 && (fixedRight > y2 || fixedRight == -1))
1597       {
1598         if (startres >= y2)
1599         {
1600           fixedLeft = y2;
1601         }
1602         else
1603         {
1604           fixedRight = y2 - 1;
1605         }
1606       }
1607     }
1608
1609     boolean success = doEditSequence(insertGap, editSeq, startres,
1610             fixedRight, fixedColumns, sg);
1611
1612     /*
1613      * report what actually happened (might be less than
1614      * what was requested), by inspecting the edit commands added
1615      */
1616     String msg = getEditStatusMessage(editCommand);
1617     ap.alignFrame.setStatus(msg == null ? " " : msg);
1618     if (!success)
1619     {
1620       endEditing();
1621     }
1622
1623     editLastRes = startres;
1624     seqCanvas.repaint();
1625   }
1626
1627   /**
1628    * A helper method that performs the requested editing to insert or delete
1629    * gaps (if possible). Answers true if the edit was successful, false if could
1630    * only be performed in part or not at all. Failure may occur in 'locked edit'
1631    * mode, when an insertion requires a matching gapped position (or column) to
1632    * delete, and deletion requires an adjacent gapped position (or column) to
1633    * remove.
1634    *
1635    * @param insertGap
1636    *          true if inserting gap(s), false if deleting
1637    * @param editSeq
1638    *          (unused parameter, currently always false)
1639    * @param startres
1640    *          the column at which to perform the edit
1641    * @param fixedRight
1642    *          fixed right boundary column of a locked edit (within or to the
1643    *          left of a selection group)
1644    * @param fixedColumns
1645    *          true if this is a locked edit
1646    * @param sg
1647    *          the sequence group (if group edit is being performed)
1648    * @return
1649    */
1650   protected boolean doEditSequence(final boolean insertGap,
1651           final boolean editSeq, final int startres, int fixedRight,
1652           final boolean fixedColumns, final SequenceGroup sg)
1653   {
1654     final SequenceI seq = av.getAlignment().getSequenceAt(editStartSeq);
1655     SequenceI[] seqs = new SequenceI[] { seq };
1656
1657     if (groupEditing)
1658     {
1659       List<SequenceI> vseqs = sg.getSequences(av.getHiddenRepSequences());
1660       int g, groupSize = vseqs.size();
1661       SequenceI[] groupSeqs = new SequenceI[groupSize];
1662       for (g = 0; g < groupSeqs.length; g++)
1663       {
1664         groupSeqs[g] = vseqs.get(g);
1665       }
1666
1667       // drag to right
1668       if (insertGap)
1669       {
1670         // If the user has selected the whole sequence, and is dragging to
1671         // the right, we can still extend the alignment and selectionGroup
1672         if (sg.getStartRes() == 0 && sg.getEndRes() == fixedRight
1673                 && sg.getEndRes() == av.getAlignment().getWidth() - 1)
1674         {
1675           sg.setEndRes(
1676                   av.getAlignment().getWidth() + startres - editLastRes);
1677           fixedRight = sg.getEndRes();
1678         }
1679
1680         // Is it valid with fixed columns??
1681         // Find the next gap before the end
1682         // of the visible region boundary
1683         boolean blank = false;
1684         for (; fixedRight > editLastRes; fixedRight--)
1685         {
1686           blank = true;
1687
1688           for (g = 0; g < groupSize; g++)
1689           {
1690             for (int j = 0; j < startres - editLastRes; j++)
1691             {
1692               if (!Comparison
1693                       .isGap(groupSeqs[g].getCharAt(fixedRight - j)))
1694               {
1695                 blank = false;
1696                 break;
1697               }
1698             }
1699           }
1700           if (blank)
1701           {
1702             break;
1703           }
1704         }
1705
1706         if (!blank)
1707         {
1708           if (sg.getSize() == av.getAlignment().getHeight())
1709           {
1710             if ((av.hasHiddenColumns()
1711                     && startres < av.getAlignment().getHiddenColumns()
1712                             .getNextHiddenBoundary(false, startres)))
1713             {
1714               return false;
1715             }
1716
1717             int alWidth = av.getAlignment().getWidth();
1718             if (av.hasHiddenRows())
1719             {
1720               int hwidth = av.getAlignment().getHiddenSequences()
1721                       .getWidth();
1722               if (hwidth > alWidth)
1723               {
1724                 alWidth = hwidth;
1725               }
1726             }
1727             // We can still insert gaps if the selectionGroup
1728             // contains all the sequences
1729             sg.setEndRes(sg.getEndRes() + startres - editLastRes);
1730             fixedRight = alWidth + startres - editLastRes;
1731           }
1732           else
1733           {
1734             return false;
1735           }
1736         }
1737       }
1738
1739       // drag to left
1740       else if (!insertGap)
1741       {
1742         // / Are we able to delete?
1743         // ie are all columns blank?
1744
1745         for (g = 0; g < groupSize; g++)
1746         {
1747           for (int j = startres; j < editLastRes; j++)
1748           {
1749             if (groupSeqs[g].getLength() <= j)
1750             {
1751               continue;
1752             }
1753
1754             if (!Comparison.isGap(groupSeqs[g].getCharAt(j)))
1755             {
1756               // Not a gap, block edit not valid
1757               return false;
1758             }
1759           }
1760         }
1761       }
1762
1763       if (insertGap)
1764       {
1765         // dragging to the right
1766         if (fixedColumns && fixedRight != -1)
1767         {
1768           for (int j = editLastRes; j < startres; j++)
1769           {
1770             insertGap(j, groupSeqs, fixedRight);
1771           }
1772         }
1773         else
1774         {
1775           appendEdit(Action.INSERT_GAP, groupSeqs, startres,
1776                   startres - editLastRes, false);
1777         }
1778       }
1779       else
1780       {
1781         // dragging to the left
1782         if (fixedColumns && fixedRight != -1)
1783         {
1784           for (int j = editLastRes; j > startres; j--)
1785           {
1786             deleteChar(startres, groupSeqs, fixedRight);
1787           }
1788         }
1789         else
1790         {
1791           appendEdit(Action.DELETE_GAP, groupSeqs, startres,
1792                   editLastRes - startres, false);
1793         }
1794       }
1795     }
1796     else
1797     {
1798       /*
1799        * editing a single sequence
1800        */
1801       if (insertGap)
1802       {
1803         // dragging to the right
1804         if (fixedColumns && fixedRight != -1)
1805         {
1806           for (int j = editLastRes; j < startres; j++)
1807           {
1808             if (!insertGap(j, seqs, fixedRight))
1809             {
1810               /*
1811                * e.g. cursor mode command specified
1812                * more inserts than are possible
1813                */
1814               return false;
1815             }
1816           }
1817         }
1818         else
1819         {
1820           appendEdit(Action.INSERT_GAP, seqs, editLastRes,
1821                   startres - editLastRes, false);
1822         }
1823       }
1824       else
1825       {
1826         if (!editSeq)
1827         {
1828           // dragging to the left
1829           if (fixedColumns && fixedRight != -1)
1830           {
1831             for (int j = editLastRes; j > startres; j--)
1832             {
1833               if (!Comparison.isGap(seq.getCharAt(startres)))
1834               {
1835                 return false;
1836               }
1837               deleteChar(startres, seqs, fixedRight);
1838             }
1839           }
1840           else
1841           {
1842             // could be a keyboard edit trying to delete none gaps
1843             int max = 0;
1844             for (int m = startres; m < editLastRes; m++)
1845             {
1846               if (!Comparison.isGap(seq.getCharAt(m)))
1847               {
1848                 break;
1849               }
1850               max++;
1851             }
1852             if (max > 0)
1853             {
1854               appendEdit(Action.DELETE_GAP, seqs, startres, max, false);
1855             }
1856           }
1857         }
1858         else
1859         {// insertGap==false AND editSeq==TRUE;
1860           if (fixedColumns && fixedRight != -1)
1861           {
1862             for (int j = editLastRes; j < startres; j++)
1863             {
1864               insertGap(j, seqs, fixedRight);
1865             }
1866           }
1867           else
1868           {
1869             appendEdit(Action.INSERT_NUC, seqs, editLastRes,
1870                     startres - editLastRes, false);
1871           }
1872         }
1873       }
1874     }
1875
1876     return true;
1877   }
1878
1879   /**
1880    * Constructs an informative status bar message while dragging to insert or
1881    * delete gaps. Answers null if inserts and deletes cancel out.
1882    *
1883    * @param editCommand
1884    *          a command containing the list of individual edits
1885    * @return
1886    */
1887   protected static String getEditStatusMessage(EditCommand editCommand)
1888   {
1889     if (editCommand == null)
1890     {
1891       return null;
1892     }
1893
1894     /*
1895      * add any inserts, and subtract any deletes,
1896      * not counting those auto-inserted when doing a 'locked edit'
1897      * (so only counting edits 'under the cursor')
1898      */
1899     int count = 0;
1900     for (Edit cmd : editCommand.getEdits())
1901     {
1902       if (!cmd.isSystemGenerated())
1903       {
1904         count += cmd.getAction() == Action.INSERT_GAP ? cmd.getNumber()
1905                 : -cmd.getNumber();
1906       }
1907     }
1908
1909     if (count == 0)
1910     {
1911       /*
1912        * inserts and deletes cancel out
1913        */
1914       return null;
1915     }
1916
1917     String msgKey = count > 1 ? "label.insert_gaps"
1918             : (count == 1 ? "label.insert_gap"
1919                     : (count == -1 ? "label.delete_gap"
1920                             : "label.delete_gaps"));
1921     count = Math.abs(count);
1922
1923     return MessageManager.formatMessage(msgKey, String.valueOf(count));
1924   }
1925
1926   /**
1927    * Inserts one gap at column j, deleting the right-most gapped column up to
1928    * (and including) fixedColumn. Returns true if the edit is successful, false
1929    * if no blank column is available to allow the insertion to be balanced by a
1930    * deletion.
1931    *
1932    * @param j
1933    * @param seq
1934    * @param fixedColumn
1935    * @return
1936    */
1937   boolean insertGap(int j, SequenceI[] seq, int fixedColumn)
1938   {
1939     int blankColumn = fixedColumn;
1940     for (int s = 0; s < seq.length; s++)
1941     {
1942       // Find the next gap before the end of the visible region boundary
1943       // If lastCol > j, theres a boundary after the gap insertion
1944
1945       for (blankColumn = fixedColumn; blankColumn > j; blankColumn--)
1946       {
1947         if (Comparison.isGap(seq[s].getCharAt(blankColumn)))
1948         {
1949           // Theres a space, so break and insert the gap
1950           break;
1951         }
1952       }
1953
1954       if (blankColumn <= j)
1955       {
1956         blankColumn = fixedColumn;
1957         endEditing();
1958         return false;
1959       }
1960     }
1961
1962     appendEdit(Action.DELETE_GAP, seq, blankColumn, 1, true);
1963
1964     appendEdit(Action.INSERT_GAP, seq, j, 1, false);
1965
1966     return true;
1967   }
1968
1969   /**
1970    * Helper method to add and perform one edit action
1971    *
1972    * @param action
1973    * @param seq
1974    * @param pos
1975    * @param count
1976    * @param systemGenerated
1977    *          true if the edit is a 'balancing' delete (or insert) to match a
1978    *          user's insert (or delete) in a locked editing region
1979    */
1980   protected void appendEdit(Action action, SequenceI[] seq, int pos,
1981           int count, boolean systemGenerated)
1982   {
1983
1984     final Edit edit = new EditCommand().new Edit(action, seq, pos, count,
1985             av.getAlignment().getGapCharacter());
1986     edit.setSystemGenerated(systemGenerated);
1987
1988     editCommand.appendEdit(edit, av.getAlignment(), true, null);
1989   }
1990
1991   /**
1992    * Deletes the character at column j, and inserts a gap at fixedColumn, in
1993    * each of the given sequences. The caller should ensure that all sequences
1994    * are gapped in column j.
1995    *
1996    * @param j
1997    * @param seqs
1998    * @param fixedColumn
1999    */
2000   void deleteChar(int j, SequenceI[] seqs, int fixedColumn)
2001   {
2002     appendEdit(Action.DELETE_GAP, seqs, j, 1, false);
2003
2004     appendEdit(Action.INSERT_GAP, seqs, fixedColumn, 1, true);
2005   }
2006
2007   /**
2008    * On reentering the panel, stops any scrolling that was started on dragging
2009    * out of the panel
2010    *
2011    * @param e
2012    */
2013   @Override
2014   public void mouseEntered(MouseEvent e)
2015   {
2016     if (oldSeq < 0)
2017     {
2018       oldSeq = 0;
2019     }
2020     stopScrolling();
2021   }
2022
2023   /**
2024    * On leaving the panel, if the mouse is being dragged, starts a thread to
2025    * scroll it until the mouse is released (in unwrapped mode only)
2026    *
2027    * @param e
2028    */
2029   @Override
2030   public void mouseExited(MouseEvent e)
2031   {
2032     lastMousePosition = null;
2033     ap.alignFrame.setStatus(" ");
2034     if (av.getWrapAlignment())
2035     {
2036       return;
2037     }
2038
2039     if (mouseDragging && scrollThread == null)
2040     {
2041       scrollThread = new ScrollThread();
2042     }
2043   }
2044
2045   /**
2046    * Handler for double-click on a position with one or more sequence features.
2047    * Opens the Amend Features dialog to allow feature details to be amended, or
2048    * the feature deleted.
2049    */
2050   @Override
2051   public void mouseClicked(MouseEvent evt)
2052   {
2053     SequenceGroup sg = null;
2054     MousePos pos = findMousePosition(evt);
2055     if (pos.isOverAnnotation() || pos.seqIndex == -1 || pos.column == -1)
2056     {
2057       return;
2058     }
2059
2060     if (evt.getClickCount() > 1 && av.isShowSequenceFeatures())
2061     {
2062       sg = av.getSelectionGroup();
2063       if (sg != null && sg.getSize() == 1
2064               && sg.getEndRes() - sg.getStartRes() < 2)
2065       {
2066         av.setSelectionGroup(null);
2067       }
2068
2069       int column = pos.column;
2070
2071       /*
2072        * find features at the position (if not gapped), or straddling
2073        * the position (if at a gap)
2074        */
2075       SequenceI sequence = av.getAlignment().getSequenceAt(pos.seqIndex);
2076       List<SequenceFeature> features = seqCanvas.getFeatureRenderer()
2077               .findFeaturesAtColumn(sequence, column + 1);
2078
2079       if (!features.isEmpty())
2080       {
2081         /*
2082          * highlight the first feature at the position on the alignment
2083          */
2084         SearchResultsI highlight = new SearchResults();
2085         highlight.addResult(sequence, features.get(0).getBegin(), features
2086                 .get(0).getEnd());
2087         seqCanvas.highlightSearchResults(highlight, false);
2088
2089         /*
2090          * open the Amend Features dialog; clear highlighting afterwards,
2091          * whether changes were made or not
2092          */
2093         List<SequenceI> seqs = Collections.singletonList(sequence);
2094         seqCanvas.getFeatureRenderer().amendFeatures(seqs, features, false,
2095                 ap);
2096         av.setSearchResults(null); // clear highlighting
2097         seqCanvas.repaint(); // draw new/amended features
2098       }
2099     }
2100   }
2101
2102   @Override
2103   public void mouseWheelMoved(MouseWheelEvent e)
2104   {
2105     e.consume();
2106     double wheelRotation = e.getPreciseWheelRotation();
2107     if (wheelRotation > 0)
2108     {
2109       if (e.isShiftDown())
2110       {
2111         av.getRanges().scrollRight(true);
2112
2113       }
2114       else
2115       {
2116         av.getRanges().scrollUp(false);
2117       }
2118     }
2119     else if (wheelRotation < 0)
2120     {
2121       if (e.isShiftDown())
2122       {
2123         av.getRanges().scrollRight(false);
2124       }
2125       else
2126       {
2127         av.getRanges().scrollUp(true);
2128       }
2129     }
2130
2131     /*
2132      * update status bar and tooltip for new position
2133      * (need to synthesize a mouse movement to refresh tooltip)
2134      */
2135     mouseMoved(e);
2136     ToolTipManager.sharedInstance().mouseMoved(e);
2137   }
2138
2139   /**
2140    * DOCUMENT ME!
2141    *
2142    * @param pos
2143    *          DOCUMENT ME!
2144    */
2145   protected void doMousePressedDefineMode(MouseEvent evt, MousePos pos)
2146   {
2147     if (pos.isOverAnnotation() || pos.seqIndex == -1 || pos.column == -1)
2148     {
2149       return;
2150     }
2151
2152     final int res = pos.column;
2153     final int seq = pos.seqIndex;
2154     oldSeq = seq;
2155     updateOverviewAndStructs = false;
2156
2157     startWrapBlock = wrappedBlock;
2158
2159     SequenceI sequence = av.getAlignment().getSequenceAt(seq);
2160
2161     if ((sequence == null) || (res > sequence.getLength()))
2162     {
2163       return;
2164     }
2165
2166     stretchGroup = av.getSelectionGroup();
2167
2168     if (stretchGroup == null || !stretchGroup.contains(sequence, res))
2169     {
2170       stretchGroup = av.getAlignment().findGroup(sequence, res);
2171       if (stretchGroup != null)
2172       {
2173         // only update the current selection if the popup menu has a group to
2174         // focus on
2175         av.setSelectionGroup(stretchGroup);
2176       }
2177     }
2178
2179     if (evt.isPopupTrigger()) // Mac: mousePressed
2180     {
2181       showPopupMenu(evt, pos);
2182       return;
2183     }
2184
2185     /*
2186      * defer right-mouse click handling to mouseReleased on Windows
2187      * (where isPopupTrigger() will answer true)
2188      * NB isRightMouseButton is also true for Cmd-click on Mac
2189      */
2190     if (SwingUtilities.isRightMouseButton(evt) && !Platform.isAMac())
2191     {
2192       return;
2193     }
2194
2195     if (av.cursorMode)
2196     {
2197       seqCanvas.cursorX = res;
2198       seqCanvas.cursorY = seq;
2199       seqCanvas.repaint();
2200       return;
2201     }
2202
2203     if (stretchGroup == null)
2204     {
2205       createStretchGroup(res, sequence);
2206     }
2207
2208     if (stretchGroup != null)
2209     {
2210       stretchGroup.addPropertyChangeListener(seqCanvas);
2211     }
2212
2213     seqCanvas.repaint();
2214   }
2215
2216   private void createStretchGroup(int res, SequenceI sequence)
2217   {
2218     // Only if left mouse button do we want to change group sizes
2219     // define a new group here
2220     SequenceGroup sg = new SequenceGroup();
2221     sg.setStartRes(res);
2222     sg.setEndRes(res);
2223     sg.addSequence(sequence, false);
2224     av.setSelectionGroup(sg);
2225     stretchGroup = sg;
2226
2227     if (av.getConservationSelected())
2228     {
2229       SliderPanel.setConservationSlider(ap, av.getResidueShading(),
2230               ap.getViewName());
2231     }
2232
2233     if (av.getAbovePIDThreshold())
2234     {
2235       SliderPanel.setPIDSliderSource(ap, av.getResidueShading(),
2236               ap.getViewName());
2237     }
2238     // TODO: stretchGroup will always be not null. Is this a merge error ?
2239     // or is there a threading issue here?
2240     if ((stretchGroup != null) && (stretchGroup.getEndRes() == res))
2241     {
2242       // Edit end res position of selected group
2243       changeEndRes = true;
2244     }
2245     else if ((stretchGroup != null) && (stretchGroup.getStartRes() == res))
2246     {
2247       // Edit end res position of selected group
2248       changeStartRes = true;
2249     }
2250     stretchGroup.getWidth();
2251
2252   }
2253
2254   /**
2255    * Build and show a pop-up menu at the right-click mouse position
2256    *
2257    * @param evt
2258    * @param pos
2259    */
2260   void showPopupMenu(MouseEvent evt, MousePos pos)
2261   {
2262     final int column = pos.column;
2263     final int seq = pos.seqIndex;
2264     SequenceI sequence = av.getAlignment().getSequenceAt(seq);
2265     if (sequence != null)
2266     {
2267       PopupMenu pop = new PopupMenu(ap, sequence, column);
2268       pop.show(this, evt.getX(), evt.getY());
2269     }
2270   }
2271
2272   /**
2273    * Update the display after mouse up on a selection or group
2274    *
2275    * @param evt
2276    *          mouse released event details
2277    * @param afterDrag
2278    *          true if this event is happening after a mouse drag (rather than a
2279    *          mouse down)
2280    */
2281   protected void doMouseReleasedDefineMode(MouseEvent evt,
2282           boolean afterDrag)
2283   {
2284     if (stretchGroup == null)
2285     {
2286       return;
2287     }
2288
2289     stretchGroup.removePropertyChangeListener(seqCanvas);
2290
2291     // always do this - annotation has own state
2292     // but defer colourscheme update until hidden sequences are passed in
2293     boolean vischange = stretchGroup.recalcConservation(true);
2294     updateOverviewAndStructs |= vischange && av.isSelectionDefinedGroup()
2295             && afterDrag;
2296     if (stretchGroup.cs != null)
2297     {
2298       if (afterDrag)
2299       {
2300         stretchGroup.cs.alignmentChanged(stretchGroup,
2301                 av.getHiddenRepSequences());
2302       }
2303
2304       ResidueShaderI groupColourScheme = stretchGroup
2305               .getGroupColourScheme();
2306       String name = stretchGroup.getName();
2307       if (stretchGroup.cs.conservationApplied())
2308       {
2309         SliderPanel.setConservationSlider(ap, groupColourScheme, name);
2310       }
2311       if (stretchGroup.cs.getThreshold() > 0)
2312       {
2313         SliderPanel.setPIDSliderSource(ap, groupColourScheme, name);
2314       }
2315     }
2316     PaintRefresher.Refresh(this, av.getSequenceSetId());
2317     // TODO: structure colours only need updating if stretchGroup used to or now
2318     // does contain sequences with structure views
2319     ap.paintAlignment(updateOverviewAndStructs, updateOverviewAndStructs);
2320     updateOverviewAndStructs = false;
2321     changeEndRes = false;
2322     changeStartRes = false;
2323     stretchGroup = null;
2324     av.sendSelection();
2325   }
2326
2327   /**
2328    * Resizes the borders of a selection group depending on the direction of
2329    * mouse drag
2330    *
2331    * @param evt
2332    */
2333   protected void dragStretchGroup(MouseEvent evt)
2334   {
2335     if (stretchGroup == null)
2336     {
2337       return;
2338     }
2339
2340     MousePos pos = findMousePosition(evt);
2341     if (pos.isOverAnnotation() || pos.column == -1 || pos.seqIndex == -1)
2342     {
2343       return;
2344     }
2345
2346     int res = pos.column;
2347     int y = pos.seqIndex;
2348
2349     if (wrappedBlock != startWrapBlock)
2350     {
2351       return;
2352     }
2353
2354     res = Math.min(res, av.getAlignment().getWidth()-1);
2355
2356     if (stretchGroup.getEndRes() == res)
2357     {
2358       // Edit end res position of selected group
2359       changeEndRes = true;
2360     }
2361     else if (stretchGroup.getStartRes() == res)
2362     {
2363       // Edit start res position of selected group
2364       changeStartRes = true;
2365     }
2366
2367     if (res < av.getRanges().getStartRes())
2368     {
2369       res = av.getRanges().getStartRes();
2370     }
2371
2372     if (changeEndRes)
2373     {
2374       if (res > (stretchGroup.getStartRes() - 1))
2375       {
2376         stretchGroup.setEndRes(res);
2377         updateOverviewAndStructs |= av.isSelectionDefinedGroup();
2378       }
2379     }
2380     else if (changeStartRes)
2381     {
2382       if (res < (stretchGroup.getEndRes() + 1))
2383       {
2384         stretchGroup.setStartRes(res);
2385         updateOverviewAndStructs |= av.isSelectionDefinedGroup();
2386       }
2387     }
2388
2389     int dragDirection = 0;
2390
2391     if (y > oldSeq)
2392     {
2393       dragDirection = 1;
2394     }
2395     else if (y < oldSeq)
2396     {
2397       dragDirection = -1;
2398     }
2399
2400     while ((y != oldSeq) && (oldSeq > -1)
2401             && (y < av.getAlignment().getHeight()))
2402     {
2403       // This routine ensures we don't skip any sequences, as the
2404       // selection is quite slow.
2405       Sequence seq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
2406
2407       oldSeq += dragDirection;
2408
2409       if (oldSeq < 0)
2410       {
2411         break;
2412       }
2413
2414       Sequence nextSeq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
2415
2416       if (stretchGroup.getSequences(null).contains(nextSeq))
2417       {
2418         stretchGroup.deleteSequence(seq, false);
2419         updateOverviewAndStructs |= av.isSelectionDefinedGroup();
2420       }
2421       else
2422       {
2423         if (seq != null)
2424         {
2425           stretchGroup.addSequence(seq, false);
2426         }
2427
2428         stretchGroup.addSequence(nextSeq, false);
2429         updateOverviewAndStructs |= av.isSelectionDefinedGroup();
2430       }
2431     }
2432
2433     if (oldSeq < 0)
2434     {
2435       oldSeq = -1;
2436     }
2437
2438     mouseDragging = true;
2439
2440     if (scrollThread != null)
2441     {
2442       scrollThread.setMousePosition(evt.getPoint());
2443     }
2444
2445     /*
2446      * construct a status message showing the range of the selection
2447      */
2448     StringBuilder status = new StringBuilder(64);
2449     List<SequenceI> seqs = stretchGroup.getSequences();
2450     String name = seqs.get(0).getName();
2451     if (name.length() > 20)
2452     {
2453       name = name.substring(0, 20);
2454     }
2455     status.append(name).append(" - ");
2456     name = seqs.get(seqs.size() - 1).getName();
2457     if (name.length() > 20)
2458     {
2459       name = name.substring(0, 20);
2460     }
2461     status.append(name).append(" ");
2462     int startRes = stretchGroup.getStartRes();
2463     status.append(" cols ").append(String.valueOf(startRes + 1))
2464             .append("-");
2465     int endRes = stretchGroup.getEndRes();
2466     status.append(String.valueOf(endRes + 1));
2467     status.append(" (").append(String.valueOf(seqs.size())).append(" x ")
2468             .append(String.valueOf(endRes - startRes + 1)).append(")");
2469     ap.alignFrame.setStatus(status.toString());
2470   }
2471
2472   /**
2473    * Stops the scroll thread if it is running
2474    */
2475   void stopScrolling()
2476   {
2477     if (scrollThread != null)
2478     {
2479       scrollThread.stopScrolling();
2480       scrollThread = null;
2481     }
2482     mouseDragging = false;
2483   }
2484
2485   /**
2486    * Starts a thread to scroll the alignment, towards a given mouse position
2487    * outside the panel bounds
2488    *
2489    * @param mousePos
2490    */
2491   void startScrolling(Point mousePos)
2492   {
2493     if (scrollThread == null)
2494     {
2495       scrollThread = new ScrollThread();
2496     }
2497
2498     mouseDragging = true;
2499     scrollThread.setMousePosition(mousePos);
2500   }
2501
2502   /**
2503    * Performs scrolling of the visible alignment left, right, up or down
2504    */
2505   class ScrollThread extends Thread
2506   {
2507     private Point mousePos;
2508
2509     private volatile boolean threadRunning = true;
2510
2511     /**
2512      * Constructor
2513      */
2514     public ScrollThread()
2515     {
2516       setName("SeqPanel$ScrollThread");
2517       start();
2518     }
2519
2520     /**
2521      * Sets the position of the mouse that determines the direction of the
2522      * scroll to perform
2523      *
2524      * @param p
2525      */
2526     public void setMousePosition(Point p)
2527     {
2528       mousePos = p;
2529     }
2530
2531     /**
2532      * Sets a flag that will cause the thread to exit
2533      */
2534     public void stopScrolling()
2535     {
2536       threadRunning = false;
2537     }
2538
2539     /**
2540      * Scrolls the alignment left or right, and/or up or down, depending on the
2541      * last notified mouse position, until the limit of the alignment is
2542      * reached, or a flag is set to stop the scroll
2543      */
2544     @Override
2545     public void run()
2546     {
2547       while (threadRunning && mouseDragging)
2548       {
2549         if (mousePos != null)
2550         {
2551           boolean scrolled = false;
2552           ViewportRanges ranges = SeqPanel.this.av.getRanges();
2553
2554           /*
2555            * scroll up or down
2556            */
2557           if (mousePos.y < 0)
2558           {
2559             // mouse is above this panel - try scroll up
2560             scrolled = ranges.scrollUp(true);
2561           }
2562           else if (mousePos.y >= getHeight())
2563           {
2564             // mouse is below this panel - try scroll down
2565             scrolled = ranges.scrollUp(false);
2566           }
2567
2568           /*
2569            * scroll left or right
2570            */
2571           if (mousePos.x < 0)
2572           {
2573             scrolled |= ranges.scrollRight(false);
2574           }
2575           else if (mousePos.x >= getWidth())
2576           {
2577             scrolled |= ranges.scrollRight(true);
2578           }
2579           if (!scrolled)
2580           {
2581             /*
2582              * we have reached the limit of the visible alignment - quit
2583              */
2584             threadRunning = false;
2585             SeqPanel.this.ap.repaint();
2586           }
2587         }
2588
2589         try
2590         {
2591           Thread.sleep(20);
2592         } catch (Exception ex)
2593         {
2594         }
2595       }
2596     }
2597   }
2598
2599   /**
2600    * modify current selection according to a received message.
2601    */
2602   @Override
2603   public void selection(SequenceGroup seqsel, ColumnSelection colsel,
2604           HiddenColumns hidden, SelectionSource source)
2605   {
2606     // TODO: fix this hack - source of messages is align viewport, but SeqPanel
2607     // handles selection messages...
2608     // TODO: extend config options to allow user to control if selections may be
2609     // shared between viewports.
2610     boolean iSentTheSelection = (av == source
2611             || (source instanceof AlignViewport
2612                     && ((AlignmentViewport) source).getSequenceSetId()
2613                             .equals(av.getSequenceSetId())));
2614
2615     if (iSentTheSelection)
2616     {
2617       // respond to our own event by updating dependent dialogs
2618       if (ap.getCalculationDialog() != null)
2619       {
2620         ap.getCalculationDialog().validateCalcTypes();
2621       }
2622
2623       return;
2624     }
2625
2626     // process further ?
2627     if (!av.followSelection)
2628     {
2629       return;
2630     }
2631
2632     /*
2633      * Ignore the selection if there is one of our own pending.
2634      */
2635     if (av.isSelectionGroupChanged(false) || av.isColSelChanged(false))
2636     {
2637       return;
2638     }
2639
2640     /*
2641      * Check for selection in a view of which this one is a dna/protein
2642      * complement.
2643      */
2644     if (selectionFromTranslation(seqsel, colsel, hidden, source))
2645     {
2646       return;
2647     }
2648
2649     // do we want to thread this ? (contention with seqsel and colsel locks, I
2650     // suspect)
2651     /*
2652      * only copy colsel if there is a real intersection between
2653      * sequence selection and this panel's alignment
2654      */
2655     boolean repaint = false;
2656     boolean copycolsel = false;
2657
2658     SequenceGroup sgroup = null;
2659     if (seqsel != null && seqsel.getSize() > 0)
2660     {
2661       if (av.getAlignment() == null)
2662       {
2663         Cache.log.warn("alignviewport av SeqSetId=" + av.getSequenceSetId()
2664                 + " ViewId=" + av.getViewId()
2665                 + " 's alignment is NULL! returning immediately.");
2666         return;
2667       }
2668       sgroup = seqsel.intersect(av.getAlignment(),
2669               (av.hasHiddenRows()) ? av.getHiddenRepSequences() : null);
2670       if ((sgroup != null && sgroup.getSize() > 0))
2671       {
2672         copycolsel = true;
2673       }
2674     }
2675     if (sgroup != null && sgroup.getSize() > 0)
2676     {
2677       av.setSelectionGroup(sgroup);
2678     }
2679     else
2680     {
2681       av.setSelectionGroup(null);
2682     }
2683     av.isSelectionGroupChanged(true);
2684     repaint = true;
2685
2686     if (copycolsel)
2687     {
2688       // the current selection is unset or from a previous message
2689       // so import the new colsel.
2690       if (colsel == null || colsel.isEmpty())
2691       {
2692         if (av.getColumnSelection() != null)
2693         {
2694           av.getColumnSelection().clear();
2695           repaint = true;
2696         }
2697       }
2698       else
2699       {
2700         // TODO: shift colSel according to the intersecting sequences
2701         if (av.getColumnSelection() == null)
2702         {
2703           av.setColumnSelection(new ColumnSelection(colsel));
2704         }
2705         else
2706         {
2707           av.getColumnSelection().setElementsFrom(colsel,
2708                   av.getAlignment().getHiddenColumns());
2709         }
2710       }
2711       av.isColSelChanged(true);
2712       repaint = true;
2713     }
2714
2715     if (copycolsel && av.hasHiddenColumns()
2716             && (av.getAlignment().getHiddenColumns() == null))
2717     {
2718       System.err.println("Bad things");
2719     }
2720     if (repaint) // always true!
2721     {
2722       // probably finessing with multiple redraws here
2723       PaintRefresher.Refresh(this, av.getSequenceSetId());
2724       // ap.paintAlignment(false);
2725     }
2726
2727     // lastly, update dependent dialogs
2728     if (ap.getCalculationDialog() != null)
2729     {
2730       ap.getCalculationDialog().validateCalcTypes();
2731     }
2732
2733   }
2734
2735   /**
2736    * If this panel is a cdna/protein translation view of the selection source,
2737    * tries to map the source selection to a local one, and returns true. Else
2738    * returns false.
2739    *
2740    * @param seqsel
2741    * @param colsel
2742    * @param source
2743    */
2744   protected boolean selectionFromTranslation(SequenceGroup seqsel,
2745           ColumnSelection colsel, HiddenColumns hidden,
2746           SelectionSource source)
2747   {
2748     if (!(source instanceof AlignViewportI))
2749     {
2750       return false;
2751     }
2752     final AlignViewportI sourceAv = (AlignViewportI) source;
2753     if (sourceAv.getCodingComplement() != av
2754             && av.getCodingComplement() != sourceAv)
2755     {
2756       return false;
2757     }
2758
2759     /*
2760      * Map sequence selection
2761      */
2762     SequenceGroup sg = MappingUtils.mapSequenceGroup(seqsel, sourceAv, av);
2763     av.setSelectionGroup(sg != null && sg.getSize() > 0 ? sg : null);
2764     av.isSelectionGroupChanged(true);
2765
2766     /*
2767      * Map column selection
2768      */
2769     // ColumnSelection cs = MappingUtils.mapColumnSelection(colsel, sourceAv,
2770     // av);
2771     ColumnSelection cs = new ColumnSelection();
2772     HiddenColumns hs = new HiddenColumns();
2773     MappingUtils.mapColumnSelection(colsel, hidden, sourceAv, av, cs, hs);
2774     av.setColumnSelection(cs);
2775     boolean hiddenChanged = av.getAlignment().setHiddenColumns(hs);
2776
2777     // lastly, update any dependent dialogs
2778     if (ap.getCalculationDialog() != null)
2779     {
2780       ap.getCalculationDialog().validateCalcTypes();
2781     }
2782
2783     /*
2784      * repaint alignment, and also Overview or Structure
2785      * if hidden column selection has changed
2786      */
2787     ap.paintAlignment(hiddenChanged, hiddenChanged);
2788
2789     return true;
2790   }
2791
2792   /**
2793    *
2794    * @return null or last search results handled by this panel
2795    */
2796   public SearchResultsI getLastSearchResults()
2797   {
2798     return lastSearchResults;
2799   }
2800 }