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.getName(), 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 seqName
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(String seqName, 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(seqName);
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 alignedSeq = al.getSequenceAt(sequenceIndex);
1283     SequenceI ds = alignedSeq.getDatasetSequence();
1284     for (SearchResultMatchI m : results.getResults())
1285     {
1286       SequenceI seq = m.getSequence();
1287       if (seq.getDatasetSequence() != null)
1288       {
1289         seq = seq.getDatasetSequence();
1290       }
1291
1292       if (seq == ds)
1293       {
1294         int start = m.getStart();
1295         setStatusMessage(alignedSeq.getName(), sequenceIndex,
1296                 seq.getCharAt(start - 1), start);
1297         return;
1298       }
1299     }
1300   }
1301
1302   /**
1303    * {@inheritDoc}
1304    */
1305   @Override
1306   public void mouseDragged(MouseEvent evt)
1307   {
1308     MousePos pos = findMousePosition(evt);
1309     if (pos.isOverAnnotation() || pos.column == -1)
1310     {
1311       return;
1312     }
1313
1314     if (mouseWheelPressed)
1315     {
1316       boolean inSplitFrame = ap.av.getCodingComplement() != null;
1317       boolean copyChanges = inSplitFrame && av.isProteinFontAsCdna();
1318
1319       int oldWidth = av.getCharWidth();
1320
1321       // Which is bigger, left-right or up-down?
1322       if (Math.abs(evt.getY() - lastMousePress.getY()) > Math
1323               .abs(evt.getX() - lastMousePress.getX()))
1324       {
1325         /*
1326          * on drag up or down, decrement or increment font size
1327          */
1328         int fontSize = av.font.getSize();
1329         boolean fontChanged = false;
1330
1331         if (evt.getY() < lastMousePress.getY())
1332         {
1333           fontChanged = true;
1334           fontSize--;
1335         }
1336         else if (evt.getY() > lastMousePress.getY())
1337         {
1338           fontChanged = true;
1339           fontSize++;
1340         }
1341
1342         if (fontSize < 1)
1343         {
1344           fontSize = 1;
1345         }
1346
1347         if (fontChanged)
1348         {
1349           Font newFont = new Font(av.font.getName(), av.font.getStyle(),
1350                   fontSize);
1351           av.setFont(newFont, true);
1352           av.setCharWidth(oldWidth);
1353           ap.fontChanged();
1354           if (copyChanges)
1355           {
1356             ap.av.getCodingComplement().setFont(newFont, true);
1357             SplitFrame splitFrame = (SplitFrame) ap.alignFrame
1358                     .getSplitViewContainer();
1359             splitFrame.adjustLayout();
1360             splitFrame.repaint();
1361           }
1362         }
1363       }
1364       else
1365       {
1366         /*
1367          * on drag left or right, decrement or increment character width
1368          */
1369         int newWidth = 0;
1370         if (evt.getX() < lastMousePress.getX() && av.getCharWidth() > 1)
1371         {
1372           newWidth = av.getCharWidth() - 1;
1373           av.setCharWidth(newWidth);
1374         }
1375         else if (evt.getX() > lastMousePress.getX())
1376         {
1377           newWidth = av.getCharWidth() + 1;
1378           av.setCharWidth(newWidth);
1379         }
1380         if (newWidth > 0)
1381         {
1382           ap.paintAlignment(false, false);
1383           if (copyChanges)
1384           {
1385             /*
1386              * need to ensure newWidth is set on cdna, regardless of which
1387              * panel the mouse drag happened in; protein will compute its
1388              * character width as 1:1 or 3:1
1389              */
1390             av.getCodingComplement().setCharWidth(newWidth);
1391             SplitFrame splitFrame = (SplitFrame) ap.alignFrame
1392                     .getSplitViewContainer();
1393             splitFrame.adjustLayout();
1394             splitFrame.repaint();
1395           }
1396         }
1397       }
1398
1399       FontMetrics fm = getFontMetrics(av.getFont());
1400       av.validCharWidth = fm.charWidth('M') <= av.getCharWidth();
1401
1402       lastMousePress = evt.getPoint();
1403
1404       return;
1405     }
1406
1407     if (!editingSeqs)
1408     {
1409       dragStretchGroup(evt);
1410       return;
1411     }
1412
1413     int res = pos.column;
1414
1415     if (res < 0)
1416     {
1417       res = 0;
1418     }
1419
1420     if ((editLastRes == -1) || (editLastRes == res))
1421     {
1422       return;
1423     }
1424
1425     if ((res < av.getAlignment().getWidth()) && (res < editLastRes))
1426     {
1427       // dragLeft, delete gap
1428       editSequence(false, false, res);
1429     }
1430     else
1431     {
1432       editSequence(true, false, res);
1433     }
1434
1435     mouseDragging = true;
1436     if (scrollThread != null)
1437     {
1438       scrollThread.setMousePosition(evt.getPoint());
1439     }
1440   }
1441
1442   /**
1443    * Edits the sequence to insert or delete one or more gaps, in response to a
1444    * mouse drag or cursor mode command. The number of inserts/deletes may be
1445    * specified with the cursor command, or else depends on the mouse event
1446    * (normally one column, but potentially more for a fast mouse drag).
1447    * <p>
1448    * Delete gaps is limited to the number of gaps left of the cursor position
1449    * (mouse drag), or at or right of the cursor position (cursor mode).
1450    * <p>
1451    * In group editing mode (Ctrl or Cmd down), the edit acts on all sequences in
1452    * the current selection group.
1453    * <p>
1454    * In locked editing mode (with a selection group present), inserts/deletions
1455    * within the selection group are limited to its boundaries (and edits outside
1456    * the group stop at its border).
1457    *
1458    * @param insertGap
1459    *          true to insert gaps, false to delete gaps
1460    * @param editSeq
1461    *          (unused parameter)
1462    * @param startres
1463    *          the column at which to perform the action; the number of columns
1464    *          affected depends on <code>this.editLastRes</code> (cursor column
1465    *          position)
1466    */
1467   synchronized void editSequence(boolean insertGap, boolean editSeq,
1468           final int startres)
1469   {
1470     int fixedLeft = -1;
1471     int fixedRight = -1;
1472     boolean fixedColumns = false;
1473     SequenceGroup sg = av.getSelectionGroup();
1474
1475     final SequenceI seq = av.getAlignment().getSequenceAt(editStartSeq);
1476
1477     // No group, but the sequence may represent a group
1478     if (!groupEditing && av.hasHiddenRows())
1479     {
1480       if (av.isHiddenRepSequence(seq))
1481       {
1482         sg = av.getRepresentedSequences(seq);
1483         groupEditing = true;
1484       }
1485     }
1486
1487     StringBuilder message = new StringBuilder(64); // for status bar
1488
1489     /*
1490      * make a name for the edit action, for
1491      * status bar message and Undo/Redo menu
1492      */
1493     String label = null;
1494     if (groupEditing)
1495     {
1496         message.append("Edit group:");
1497       label = MessageManager.getString("action.edit_group");
1498     }
1499     else
1500     {
1501         message.append("Edit sequence: " + seq.getName());
1502       label = seq.getName();
1503       if (label.length() > 10)
1504       {
1505         label = label.substring(0, 10);
1506       }
1507       label = MessageManager.formatMessage("label.edit_params",
1508               new String[]
1509               { label });
1510     }
1511
1512     /*
1513      * initialise the edit command if there is not
1514      * already one being extended
1515      */
1516     if (editCommand == null)
1517     {
1518       editCommand = new EditCommand(label);
1519     }
1520
1521     if (insertGap)
1522     {
1523       message.append(" insert ");
1524     }
1525     else
1526     {
1527       message.append(" delete ");
1528     }
1529
1530     message.append(Math.abs(startres - editLastRes) + " gaps.");
1531     ap.alignFrame.setStatus(message.toString());
1532
1533     /*
1534      * is there a selection group containing the sequence being edited?
1535      * if so the boundary of the group is the limit of the edit
1536      * (but the edit may be inside or outside the selection group)
1537      */
1538     boolean inSelectionGroup = sg != null
1539             && sg.getSequences(av.getHiddenRepSequences()).contains(seq);
1540     if (groupEditing || inSelectionGroup)
1541     {
1542       fixedColumns = true;
1543
1544       // sg might be null as the user may only see 1 sequence,
1545       // but the sequence represents a group
1546       if (sg == null)
1547       {
1548         if (!av.isHiddenRepSequence(seq))
1549         {
1550           endEditing();
1551           return;
1552         }
1553         sg = av.getRepresentedSequences(seq);
1554       }
1555
1556       fixedLeft = sg.getStartRes();
1557       fixedRight = sg.getEndRes();
1558
1559       if ((startres < fixedLeft && editLastRes >= fixedLeft)
1560               || (startres >= fixedLeft && editLastRes < fixedLeft)
1561               || (startres > fixedRight && editLastRes <= fixedRight)
1562               || (startres <= fixedRight && editLastRes > fixedRight))
1563       {
1564         endEditing();
1565         return;
1566       }
1567
1568       if (fixedLeft > startres)
1569       {
1570         fixedRight = fixedLeft - 1;
1571         fixedLeft = 0;
1572       }
1573       else if (fixedRight < startres)
1574       {
1575         fixedLeft = fixedRight;
1576         fixedRight = -1;
1577       }
1578     }
1579
1580     if (av.hasHiddenColumns())
1581     {
1582       fixedColumns = true;
1583       int y1 = av.getAlignment().getHiddenColumns()
1584               .getNextHiddenBoundary(true, startres);
1585       int y2 = av.getAlignment().getHiddenColumns()
1586               .getNextHiddenBoundary(false, startres);
1587
1588       if ((insertGap && startres > y1 && editLastRes < y1)
1589               || (!insertGap && startres < y2 && editLastRes > y2))
1590       {
1591         endEditing();
1592         return;
1593       }
1594
1595       // System.out.print(y1+" "+y2+" "+fixedLeft+" "+fixedRight+"~~");
1596       // Selection spans a hidden region
1597       if (fixedLeft < y1 && (fixedRight > y2 || fixedRight == -1))
1598       {
1599         if (startres >= y2)
1600         {
1601           fixedLeft = y2;
1602         }
1603         else
1604         {
1605           fixedRight = y2 - 1;
1606         }
1607       }
1608     }
1609
1610     boolean success = doEditSequence(insertGap, editSeq, startres,
1611             fixedRight, fixedColumns, sg);
1612
1613     /*
1614      * report what actually happened (might be less than
1615      * what was requested), by inspecting the edit commands added
1616      */
1617     String msg = getEditStatusMessage(editCommand);
1618     ap.alignFrame.setStatus(msg == null ? " " : msg);
1619     if (!success)
1620     {
1621       endEditing();
1622     }
1623
1624     editLastRes = startres;
1625     seqCanvas.repaint();
1626   }
1627
1628   /**
1629    * A helper method that performs the requested editing to insert or delete
1630    * gaps (if possible). Answers true if the edit was successful, false if could
1631    * only be performed in part or not at all. Failure may occur in 'locked edit'
1632    * mode, when an insertion requires a matching gapped position (or column) to
1633    * delete, and deletion requires an adjacent gapped position (or column) to
1634    * remove.
1635    *
1636    * @param insertGap
1637    *          true if inserting gap(s), false if deleting
1638    * @param editSeq
1639    *          (unused parameter, currently always false)
1640    * @param startres
1641    *          the column at which to perform the edit
1642    * @param fixedRight
1643    *          fixed right boundary column of a locked edit (within or to the
1644    *          left of a selection group)
1645    * @param fixedColumns
1646    *          true if this is a locked edit
1647    * @param sg
1648    *          the sequence group (if group edit is being performed)
1649    * @return
1650    */
1651   protected boolean doEditSequence(final boolean insertGap,
1652           final boolean editSeq, final int startres, int fixedRight,
1653           final boolean fixedColumns, final SequenceGroup sg)
1654   {
1655     final SequenceI seq = av.getAlignment().getSequenceAt(editStartSeq);
1656     SequenceI[] seqs = new SequenceI[] { seq };
1657
1658     if (groupEditing)
1659     {
1660       List<SequenceI> vseqs = sg.getSequences(av.getHiddenRepSequences());
1661       int g, groupSize = vseqs.size();
1662       SequenceI[] groupSeqs = new SequenceI[groupSize];
1663       for (g = 0; g < groupSeqs.length; g++)
1664       {
1665         groupSeqs[g] = vseqs.get(g);
1666       }
1667
1668       // drag to right
1669       if (insertGap)
1670       {
1671         // If the user has selected the whole sequence, and is dragging to
1672         // the right, we can still extend the alignment and selectionGroup
1673         if (sg.getStartRes() == 0 && sg.getEndRes() == fixedRight
1674                 && sg.getEndRes() == av.getAlignment().getWidth() - 1)
1675         {
1676           sg.setEndRes(
1677                   av.getAlignment().getWidth() + startres - editLastRes);
1678           fixedRight = sg.getEndRes();
1679         }
1680
1681         // Is it valid with fixed columns??
1682         // Find the next gap before the end
1683         // of the visible region boundary
1684         boolean blank = false;
1685         for (; fixedRight > editLastRes; fixedRight--)
1686         {
1687           blank = true;
1688
1689           for (g = 0; g < groupSize; g++)
1690           {
1691             for (int j = 0; j < startres - editLastRes; j++)
1692             {
1693               if (!Comparison
1694                       .isGap(groupSeqs[g].getCharAt(fixedRight - j)))
1695               {
1696                 blank = false;
1697                 break;
1698               }
1699             }
1700           }
1701           if (blank)
1702           {
1703             break;
1704           }
1705         }
1706
1707         if (!blank)
1708         {
1709           if (sg.getSize() == av.getAlignment().getHeight())
1710           {
1711             if ((av.hasHiddenColumns()
1712                     && startres < av.getAlignment().getHiddenColumns()
1713                             .getNextHiddenBoundary(false, startres)))
1714             {
1715               return false;
1716             }
1717
1718             int alWidth = av.getAlignment().getWidth();
1719             if (av.hasHiddenRows())
1720             {
1721               int hwidth = av.getAlignment().getHiddenSequences()
1722                       .getWidth();
1723               if (hwidth > alWidth)
1724               {
1725                 alWidth = hwidth;
1726               }
1727             }
1728             // We can still insert gaps if the selectionGroup
1729             // contains all the sequences
1730             sg.setEndRes(sg.getEndRes() + startres - editLastRes);
1731             fixedRight = alWidth + startres - editLastRes;
1732           }
1733           else
1734           {
1735             return false;
1736           }
1737         }
1738       }
1739
1740       // drag to left
1741       else if (!insertGap)
1742       {
1743         // / Are we able to delete?
1744         // ie are all columns blank?
1745
1746         for (g = 0; g < groupSize; g++)
1747         {
1748           for (int j = startres; j < editLastRes; j++)
1749           {
1750             if (groupSeqs[g].getLength() <= j)
1751             {
1752               continue;
1753             }
1754
1755             if (!Comparison.isGap(groupSeqs[g].getCharAt(j)))
1756             {
1757               // Not a gap, block edit not valid
1758               return false;
1759             }
1760           }
1761         }
1762       }
1763
1764       if (insertGap)
1765       {
1766         // dragging to the right
1767         if (fixedColumns && fixedRight != -1)
1768         {
1769           for (int j = editLastRes; j < startres; j++)
1770           {
1771             insertGap(j, groupSeqs, fixedRight);
1772           }
1773         }
1774         else
1775         {
1776           appendEdit(Action.INSERT_GAP, groupSeqs, startres,
1777                   startres - editLastRes, false);
1778         }
1779       }
1780       else
1781       {
1782         // dragging to the left
1783         if (fixedColumns && fixedRight != -1)
1784         {
1785           for (int j = editLastRes; j > startres; j--)
1786           {
1787             deleteChar(startres, groupSeqs, fixedRight);
1788           }
1789         }
1790         else
1791         {
1792           appendEdit(Action.DELETE_GAP, groupSeqs, startres,
1793                   editLastRes - startres, false);
1794         }
1795       }
1796     }
1797     else
1798     {
1799       /*
1800        * editing a single sequence
1801        */
1802       if (insertGap)
1803       {
1804         // dragging to the right
1805         if (fixedColumns && fixedRight != -1)
1806         {
1807           for (int j = editLastRes; j < startres; j++)
1808           {
1809             if (!insertGap(j, seqs, fixedRight))
1810             {
1811               /*
1812                * e.g. cursor mode command specified
1813                * more inserts than are possible
1814                */
1815               return false;
1816             }
1817           }
1818         }
1819         else
1820         {
1821           appendEdit(Action.INSERT_GAP, seqs, editLastRes,
1822                   startres - editLastRes, false);
1823         }
1824       }
1825       else
1826       {
1827         if (!editSeq)
1828         {
1829           // dragging to the left
1830           if (fixedColumns && fixedRight != -1)
1831           {
1832             for (int j = editLastRes; j > startres; j--)
1833             {
1834               if (!Comparison.isGap(seq.getCharAt(startres)))
1835               {
1836                 return false;
1837               }
1838               deleteChar(startres, seqs, fixedRight);
1839             }
1840           }
1841           else
1842           {
1843             // could be a keyboard edit trying to delete none gaps
1844             int max = 0;
1845             for (int m = startres; m < editLastRes; m++)
1846             {
1847               if (!Comparison.isGap(seq.getCharAt(m)))
1848               {
1849                 break;
1850               }
1851               max++;
1852             }
1853             if (max > 0)
1854             {
1855               appendEdit(Action.DELETE_GAP, seqs, startres, max, false);
1856             }
1857           }
1858         }
1859         else
1860         {// insertGap==false AND editSeq==TRUE;
1861           if (fixedColumns && fixedRight != -1)
1862           {
1863             for (int j = editLastRes; j < startres; j++)
1864             {
1865               insertGap(j, seqs, fixedRight);
1866             }
1867           }
1868           else
1869           {
1870             appendEdit(Action.INSERT_NUC, seqs, editLastRes,
1871                     startres - editLastRes, false);
1872           }
1873         }
1874       }
1875     }
1876
1877     return true;
1878   }
1879
1880   /**
1881    * Constructs an informative status bar message while dragging to insert or
1882    * delete gaps. Answers null if inserts and deletes cancel out.
1883    *
1884    * @param editCommand
1885    *          a command containing the list of individual edits
1886    * @return
1887    */
1888   protected static String getEditStatusMessage(EditCommand editCommand)
1889   {
1890     if (editCommand == null)
1891     {
1892       return null;
1893     }
1894
1895     /*
1896      * add any inserts, and subtract any deletes,
1897      * not counting those auto-inserted when doing a 'locked edit'
1898      * (so only counting edits 'under the cursor')
1899      */
1900     int count = 0;
1901     for (Edit cmd : editCommand.getEdits())
1902     {
1903       if (!cmd.isSystemGenerated())
1904       {
1905         count += cmd.getAction() == Action.INSERT_GAP ? cmd.getNumber()
1906                 : -cmd.getNumber();
1907       }
1908     }
1909
1910     if (count == 0)
1911     {
1912       /*
1913        * inserts and deletes cancel out
1914        */
1915       return null;
1916     }
1917
1918     String msgKey = count > 1 ? "label.insert_gaps"
1919             : (count == 1 ? "label.insert_gap"
1920                     : (count == -1 ? "label.delete_gap"
1921                             : "label.delete_gaps"));
1922     count = Math.abs(count);
1923
1924     return MessageManager.formatMessage(msgKey, String.valueOf(count));
1925   }
1926
1927   /**
1928    * Inserts one gap at column j, deleting the right-most gapped column up to
1929    * (and including) fixedColumn. Returns true if the edit is successful, false
1930    * if no blank column is available to allow the insertion to be balanced by a
1931    * deletion.
1932    *
1933    * @param j
1934    * @param seq
1935    * @param fixedColumn
1936    * @return
1937    */
1938   boolean insertGap(int j, SequenceI[] seq, int fixedColumn)
1939   {
1940     int blankColumn = fixedColumn;
1941     for (int s = 0; s < seq.length; s++)
1942     {
1943       // Find the next gap before the end of the visible region boundary
1944       // If lastCol > j, theres a boundary after the gap insertion
1945
1946       for (blankColumn = fixedColumn; blankColumn > j; blankColumn--)
1947       {
1948         if (Comparison.isGap(seq[s].getCharAt(blankColumn)))
1949         {
1950           // Theres a space, so break and insert the gap
1951           break;
1952         }
1953       }
1954
1955       if (blankColumn <= j)
1956       {
1957         blankColumn = fixedColumn;
1958         endEditing();
1959         return false;
1960       }
1961     }
1962
1963     appendEdit(Action.DELETE_GAP, seq, blankColumn, 1, true);
1964
1965     appendEdit(Action.INSERT_GAP, seq, j, 1, false);
1966
1967     return true;
1968   }
1969
1970   /**
1971    * Helper method to add and perform one edit action
1972    *
1973    * @param action
1974    * @param seq
1975    * @param pos
1976    * @param count
1977    * @param systemGenerated
1978    *          true if the edit is a 'balancing' delete (or insert) to match a
1979    *          user's insert (or delete) in a locked editing region
1980    */
1981   protected void appendEdit(Action action, SequenceI[] seq, int pos,
1982           int count, boolean systemGenerated)
1983   {
1984
1985     final Edit edit = new EditCommand().new Edit(action, seq, pos, count,
1986             av.getAlignment().getGapCharacter());
1987     edit.setSystemGenerated(systemGenerated);
1988
1989     editCommand.appendEdit(edit, av.getAlignment(), true, null);
1990   }
1991
1992   /**
1993    * Deletes the character at column j, and inserts a gap at fixedColumn, in
1994    * each of the given sequences. The caller should ensure that all sequences
1995    * are gapped in column j.
1996    *
1997    * @param j
1998    * @param seqs
1999    * @param fixedColumn
2000    */
2001   void deleteChar(int j, SequenceI[] seqs, int fixedColumn)
2002   {
2003     appendEdit(Action.DELETE_GAP, seqs, j, 1, false);
2004
2005     appendEdit(Action.INSERT_GAP, seqs, fixedColumn, 1, true);
2006   }
2007
2008   /**
2009    * On reentering the panel, stops any scrolling that was started on dragging
2010    * out of the panel
2011    *
2012    * @param e
2013    */
2014   @Override
2015   public void mouseEntered(MouseEvent e)
2016   {
2017     if (oldSeq < 0)
2018     {
2019       oldSeq = 0;
2020     }
2021     stopScrolling();
2022   }
2023
2024   /**
2025    * On leaving the panel, if the mouse is being dragged, starts a thread to
2026    * scroll it until the mouse is released (in unwrapped mode only)
2027    *
2028    * @param e
2029    */
2030   @Override
2031   public void mouseExited(MouseEvent e)
2032   {
2033     lastMousePosition = null;
2034     ap.alignFrame.setStatus(" ");
2035     if (av.getWrapAlignment())
2036     {
2037       return;
2038     }
2039
2040     if (mouseDragging && scrollThread == null)
2041     {
2042       scrollThread = new ScrollThread();
2043     }
2044   }
2045
2046   /**
2047    * Handler for double-click on a position with one or more sequence features.
2048    * Opens the Amend Features dialog to allow feature details to be amended, or
2049    * the feature deleted.
2050    */
2051   @Override
2052   public void mouseClicked(MouseEvent evt)
2053   {
2054     SequenceGroup sg = null;
2055     MousePos pos = findMousePosition(evt);
2056     if (pos.isOverAnnotation() || pos.seqIndex == -1 || pos.column == -1)
2057     {
2058       return;
2059     }
2060
2061     if (evt.getClickCount() > 1 && av.isShowSequenceFeatures())
2062     {
2063       sg = av.getSelectionGroup();
2064       if (sg != null && sg.getSize() == 1
2065               && sg.getEndRes() - sg.getStartRes() < 2)
2066       {
2067         av.setSelectionGroup(null);
2068       }
2069
2070       int column = pos.column;
2071
2072       /*
2073        * find features at the position (if not gapped), or straddling
2074        * the position (if at a gap)
2075        */
2076       SequenceI sequence = av.getAlignment().getSequenceAt(pos.seqIndex);
2077       List<SequenceFeature> features = seqCanvas.getFeatureRenderer()
2078               .findFeaturesAtColumn(sequence, column + 1);
2079
2080       if (!features.isEmpty())
2081       {
2082         /*
2083          * highlight the first feature at the position on the alignment
2084          */
2085         SearchResultsI highlight = new SearchResults();
2086         highlight.addResult(sequence, features.get(0).getBegin(), features
2087                 .get(0).getEnd());
2088         seqCanvas.highlightSearchResults(highlight, false);
2089
2090         /*
2091          * open the Amend Features dialog; clear highlighting afterwards,
2092          * whether changes were made or not
2093          */
2094         List<SequenceI> seqs = Collections.singletonList(sequence);
2095         seqCanvas.getFeatureRenderer().amendFeatures(seqs, features, false,
2096                 ap);
2097         av.setSearchResults(null); // clear highlighting
2098         seqCanvas.repaint(); // draw new/amended features
2099       }
2100     }
2101   }
2102
2103   @Override
2104   public void mouseWheelMoved(MouseWheelEvent e)
2105   {
2106     e.consume();
2107     double wheelRotation = e.getPreciseWheelRotation();
2108     if (wheelRotation > 0)
2109     {
2110       if (e.isShiftDown())
2111       {
2112         av.getRanges().scrollRight(true);
2113
2114       }
2115       else
2116       {
2117         av.getRanges().scrollUp(false);
2118       }
2119     }
2120     else if (wheelRotation < 0)
2121     {
2122       if (e.isShiftDown())
2123       {
2124         av.getRanges().scrollRight(false);
2125       }
2126       else
2127       {
2128         av.getRanges().scrollUp(true);
2129       }
2130     }
2131
2132     /*
2133      * update status bar and tooltip for new position
2134      * (need to synthesize a mouse movement to refresh tooltip)
2135      */
2136     mouseMoved(e);
2137     ToolTipManager.sharedInstance().mouseMoved(e);
2138   }
2139
2140   /**
2141    * DOCUMENT ME!
2142    *
2143    * @param pos
2144    *          DOCUMENT ME!
2145    */
2146   protected void doMousePressedDefineMode(MouseEvent evt, MousePos pos)
2147   {
2148     if (pos.isOverAnnotation() || pos.seqIndex == -1 || pos.column == -1)
2149     {
2150       return;
2151     }
2152
2153     final int res = pos.column;
2154     final int seq = pos.seqIndex;
2155     oldSeq = seq;
2156     updateOverviewAndStructs = false;
2157
2158     startWrapBlock = wrappedBlock;
2159
2160     SequenceI sequence = av.getAlignment().getSequenceAt(seq);
2161
2162     if ((sequence == null) || (res > sequence.getLength()))
2163     {
2164       return;
2165     }
2166
2167     stretchGroup = av.getSelectionGroup();
2168
2169     if (stretchGroup == null || !stretchGroup.contains(sequence, res))
2170     {
2171       stretchGroup = av.getAlignment().findGroup(sequence, res);
2172       if (stretchGroup != null)
2173       {
2174         // only update the current selection if the popup menu has a group to
2175         // focus on
2176         av.setSelectionGroup(stretchGroup);
2177       }
2178     }
2179
2180     if (evt.isPopupTrigger()) // Mac: mousePressed
2181     {
2182       showPopupMenu(evt, pos);
2183       return;
2184     }
2185
2186     /*
2187      * defer right-mouse click handling to mouseReleased on Windows
2188      * (where isPopupTrigger() will answer true)
2189      * NB isRightMouseButton is also true for Cmd-click on Mac
2190      */
2191     if (SwingUtilities.isRightMouseButton(evt) && !Platform.isAMac())
2192     {
2193       return;
2194     }
2195
2196     if (av.cursorMode)
2197     {
2198       seqCanvas.cursorX = res;
2199       seqCanvas.cursorY = seq;
2200       seqCanvas.repaint();
2201       return;
2202     }
2203
2204     if (stretchGroup == null)
2205     {
2206       createStretchGroup(res, sequence);
2207     }
2208
2209     if (stretchGroup != null)
2210     {
2211       stretchGroup.addPropertyChangeListener(seqCanvas);
2212     }
2213
2214     seqCanvas.repaint();
2215   }
2216
2217   private void createStretchGroup(int res, SequenceI sequence)
2218   {
2219     // Only if left mouse button do we want to change group sizes
2220     // define a new group here
2221     SequenceGroup sg = new SequenceGroup();
2222     sg.setStartRes(res);
2223     sg.setEndRes(res);
2224     sg.addSequence(sequence, false);
2225     av.setSelectionGroup(sg);
2226     stretchGroup = sg;
2227
2228     if (av.getConservationSelected())
2229     {
2230       SliderPanel.setConservationSlider(ap, av.getResidueShading(),
2231               ap.getViewName());
2232     }
2233
2234     if (av.getAbovePIDThreshold())
2235     {
2236       SliderPanel.setPIDSliderSource(ap, av.getResidueShading(),
2237               ap.getViewName());
2238     }
2239     // TODO: stretchGroup will always be not null. Is this a merge error ?
2240     // or is there a threading issue here?
2241     if ((stretchGroup != null) && (stretchGroup.getEndRes() == res))
2242     {
2243       // Edit end res position of selected group
2244       changeEndRes = true;
2245     }
2246     else if ((stretchGroup != null) && (stretchGroup.getStartRes() == res))
2247     {
2248       // Edit end res position of selected group
2249       changeStartRes = true;
2250     }
2251     stretchGroup.getWidth();
2252
2253   }
2254
2255   /**
2256    * Build and show a pop-up menu at the right-click mouse position
2257    *
2258    * @param evt
2259    * @param pos
2260    */
2261   void showPopupMenu(MouseEvent evt, MousePos pos)
2262   {
2263     final int column = pos.column;
2264     final int seq = pos.seqIndex;
2265     SequenceI sequence = av.getAlignment().getSequenceAt(seq);
2266     if (sequence != null)
2267     {
2268       PopupMenu pop = new PopupMenu(ap, sequence, column);
2269       pop.show(this, evt.getX(), evt.getY());
2270     }
2271   }
2272
2273   /**
2274    * Update the display after mouse up on a selection or group
2275    *
2276    * @param evt
2277    *          mouse released event details
2278    * @param afterDrag
2279    *          true if this event is happening after a mouse drag (rather than a
2280    *          mouse down)
2281    */
2282   protected void doMouseReleasedDefineMode(MouseEvent evt,
2283           boolean afterDrag)
2284   {
2285     if (stretchGroup == null)
2286     {
2287       return;
2288     }
2289
2290     stretchGroup.removePropertyChangeListener(seqCanvas);
2291
2292     // always do this - annotation has own state
2293     // but defer colourscheme update until hidden sequences are passed in
2294     boolean vischange = stretchGroup.recalcConservation(true);
2295     updateOverviewAndStructs |= vischange && av.isSelectionDefinedGroup()
2296             && afterDrag;
2297     if (stretchGroup.cs != null)
2298     {
2299       if (afterDrag)
2300       {
2301         stretchGroup.cs.alignmentChanged(stretchGroup,
2302                 av.getHiddenRepSequences());
2303       }
2304
2305       ResidueShaderI groupColourScheme = stretchGroup
2306               .getGroupColourScheme();
2307       String name = stretchGroup.getName();
2308       if (stretchGroup.cs.conservationApplied())
2309       {
2310         SliderPanel.setConservationSlider(ap, groupColourScheme, name);
2311       }
2312       if (stretchGroup.cs.getThreshold() > 0)
2313       {
2314         SliderPanel.setPIDSliderSource(ap, groupColourScheme, name);
2315       }
2316     }
2317     PaintRefresher.Refresh(this, av.getSequenceSetId());
2318     // TODO: structure colours only need updating if stretchGroup used to or now
2319     // does contain sequences with structure views
2320     ap.paintAlignment(updateOverviewAndStructs, updateOverviewAndStructs);
2321     updateOverviewAndStructs = false;
2322     changeEndRes = false;
2323     changeStartRes = false;
2324     stretchGroup = null;
2325     av.sendSelection();
2326   }
2327
2328   /**
2329    * Resizes the borders of a selection group depending on the direction of
2330    * mouse drag
2331    *
2332    * @param evt
2333    */
2334   protected void dragStretchGroup(MouseEvent evt)
2335   {
2336     if (stretchGroup == null)
2337     {
2338       return;
2339     }
2340
2341     MousePos pos = findMousePosition(evt);
2342     if (pos.isOverAnnotation() || pos.column == -1 || pos.seqIndex == -1)
2343     {
2344       return;
2345     }
2346
2347     int res = pos.column;
2348     int y = pos.seqIndex;
2349
2350     if (wrappedBlock != startWrapBlock)
2351     {
2352       return;
2353     }
2354
2355     res = Math.min(res, av.getAlignment().getWidth()-1);
2356
2357     if (stretchGroup.getEndRes() == res)
2358     {
2359       // Edit end res position of selected group
2360       changeEndRes = true;
2361     }
2362     else if (stretchGroup.getStartRes() == res)
2363     {
2364       // Edit start res position of selected group
2365       changeStartRes = true;
2366     }
2367
2368     if (res < av.getRanges().getStartRes())
2369     {
2370       res = av.getRanges().getStartRes();
2371     }
2372
2373     if (changeEndRes)
2374     {
2375       if (res > (stretchGroup.getStartRes() - 1))
2376       {
2377         stretchGroup.setEndRes(res);
2378         updateOverviewAndStructs |= av.isSelectionDefinedGroup();
2379       }
2380     }
2381     else if (changeStartRes)
2382     {
2383       if (res < (stretchGroup.getEndRes() + 1))
2384       {
2385         stretchGroup.setStartRes(res);
2386         updateOverviewAndStructs |= av.isSelectionDefinedGroup();
2387       }
2388     }
2389
2390     int dragDirection = 0;
2391
2392     if (y > oldSeq)
2393     {
2394       dragDirection = 1;
2395     }
2396     else if (y < oldSeq)
2397     {
2398       dragDirection = -1;
2399     }
2400
2401     while ((y != oldSeq) && (oldSeq > -1)
2402             && (y < av.getAlignment().getHeight()))
2403     {
2404       // This routine ensures we don't skip any sequences, as the
2405       // selection is quite slow.
2406       Sequence seq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
2407
2408       oldSeq += dragDirection;
2409
2410       if (oldSeq < 0)
2411       {
2412         break;
2413       }
2414
2415       Sequence nextSeq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
2416
2417       if (stretchGroup.getSequences(null).contains(nextSeq))
2418       {
2419         stretchGroup.deleteSequence(seq, false);
2420         updateOverviewAndStructs |= av.isSelectionDefinedGroup();
2421       }
2422       else
2423       {
2424         if (seq != null)
2425         {
2426           stretchGroup.addSequence(seq, false);
2427         }
2428
2429         stretchGroup.addSequence(nextSeq, false);
2430         updateOverviewAndStructs |= av.isSelectionDefinedGroup();
2431       }
2432     }
2433
2434     if (oldSeq < 0)
2435     {
2436       oldSeq = -1;
2437     }
2438
2439     mouseDragging = true;
2440
2441     if (scrollThread != null)
2442     {
2443       scrollThread.setMousePosition(evt.getPoint());
2444     }
2445
2446     /*
2447      * construct a status message showing the range of the selection
2448      */
2449     StringBuilder status = new StringBuilder(64);
2450     List<SequenceI> seqs = stretchGroup.getSequences();
2451     String name = seqs.get(0).getName();
2452     if (name.length() > 20)
2453     {
2454       name = name.substring(0, 20);
2455     }
2456     status.append(name).append(" - ");
2457     name = seqs.get(seqs.size() - 1).getName();
2458     if (name.length() > 20)
2459     {
2460       name = name.substring(0, 20);
2461     }
2462     status.append(name).append(" ");
2463     int startRes = stretchGroup.getStartRes();
2464     status.append(" cols ").append(String.valueOf(startRes + 1))
2465             .append("-");
2466     int endRes = stretchGroup.getEndRes();
2467     status.append(String.valueOf(endRes + 1));
2468     status.append(" (").append(String.valueOf(seqs.size())).append(" x ")
2469             .append(String.valueOf(endRes - startRes + 1)).append(")");
2470     ap.alignFrame.setStatus(status.toString());
2471   }
2472
2473   /**
2474    * Stops the scroll thread if it is running
2475    */
2476   void stopScrolling()
2477   {
2478     if (scrollThread != null)
2479     {
2480       scrollThread.stopScrolling();
2481       scrollThread = null;
2482     }
2483     mouseDragging = false;
2484   }
2485
2486   /**
2487    * Starts a thread to scroll the alignment, towards a given mouse position
2488    * outside the panel bounds
2489    *
2490    * @param mousePos
2491    */
2492   void startScrolling(Point mousePos)
2493   {
2494     if (scrollThread == null)
2495     {
2496       scrollThread = new ScrollThread();
2497     }
2498
2499     mouseDragging = true;
2500     scrollThread.setMousePosition(mousePos);
2501   }
2502
2503   /**
2504    * Performs scrolling of the visible alignment left, right, up or down
2505    */
2506   class ScrollThread extends Thread
2507   {
2508     private Point mousePos;
2509
2510     private volatile boolean threadRunning = true;
2511
2512     /**
2513      * Constructor
2514      */
2515     public ScrollThread()
2516     {
2517       setName("SeqPanel$ScrollThread");
2518       start();
2519     }
2520
2521     /**
2522      * Sets the position of the mouse that determines the direction of the
2523      * scroll to perform
2524      *
2525      * @param p
2526      */
2527     public void setMousePosition(Point p)
2528     {
2529       mousePos = p;
2530     }
2531
2532     /**
2533      * Sets a flag that will cause the thread to exit
2534      */
2535     public void stopScrolling()
2536     {
2537       threadRunning = false;
2538     }
2539
2540     /**
2541      * Scrolls the alignment left or right, and/or up or down, depending on the
2542      * last notified mouse position, until the limit of the alignment is
2543      * reached, or a flag is set to stop the scroll
2544      */
2545     @Override
2546     public void run()
2547     {
2548       while (threadRunning && mouseDragging)
2549       {
2550         if (mousePos != null)
2551         {
2552           boolean scrolled = false;
2553           ViewportRanges ranges = SeqPanel.this.av.getRanges();
2554
2555           /*
2556            * scroll up or down
2557            */
2558           if (mousePos.y < 0)
2559           {
2560             // mouse is above this panel - try scroll up
2561             scrolled = ranges.scrollUp(true);
2562           }
2563           else if (mousePos.y >= getHeight())
2564           {
2565             // mouse is below this panel - try scroll down
2566             scrolled = ranges.scrollUp(false);
2567           }
2568
2569           /*
2570            * scroll left or right
2571            */
2572           if (mousePos.x < 0)
2573           {
2574             scrolled |= ranges.scrollRight(false);
2575           }
2576           else if (mousePos.x >= getWidth())
2577           {
2578             scrolled |= ranges.scrollRight(true);
2579           }
2580           if (!scrolled)
2581           {
2582             /*
2583              * we have reached the limit of the visible alignment - quit
2584              */
2585             threadRunning = false;
2586             SeqPanel.this.ap.repaint();
2587           }
2588         }
2589
2590         try
2591         {
2592           Thread.sleep(20);
2593         } catch (Exception ex)
2594         {
2595         }
2596       }
2597     }
2598   }
2599
2600   /**
2601    * modify current selection according to a received message.
2602    */
2603   @Override
2604   public void selection(SequenceGroup seqsel, ColumnSelection colsel,
2605           HiddenColumns hidden, SelectionSource source)
2606   {
2607     // TODO: fix this hack - source of messages is align viewport, but SeqPanel
2608     // handles selection messages...
2609     // TODO: extend config options to allow user to control if selections may be
2610     // shared between viewports.
2611     boolean iSentTheSelection = (av == source
2612             || (source instanceof AlignViewport
2613                     && ((AlignmentViewport) source).getSequenceSetId()
2614                             .equals(av.getSequenceSetId())));
2615
2616     if (iSentTheSelection)
2617     {
2618       // respond to our own event by updating dependent dialogs
2619       if (ap.getCalculationDialog() != null)
2620       {
2621         ap.getCalculationDialog().validateCalcTypes();
2622       }
2623
2624       return;
2625     }
2626
2627     // process further ?
2628     if (!av.followSelection)
2629     {
2630       return;
2631     }
2632
2633     /*
2634      * Ignore the selection if there is one of our own pending.
2635      */
2636     if (av.isSelectionGroupChanged(false) || av.isColSelChanged(false))
2637     {
2638       return;
2639     }
2640
2641     /*
2642      * Check for selection in a view of which this one is a dna/protein
2643      * complement.
2644      */
2645     if (selectionFromTranslation(seqsel, colsel, hidden, source))
2646     {
2647       return;
2648     }
2649
2650     // do we want to thread this ? (contention with seqsel and colsel locks, I
2651     // suspect)
2652     /*
2653      * only copy colsel if there is a real intersection between
2654      * sequence selection and this panel's alignment
2655      */
2656     boolean repaint = false;
2657     boolean copycolsel = false;
2658
2659     SequenceGroup sgroup = null;
2660     if (seqsel != null && seqsel.getSize() > 0)
2661     {
2662       if (av.getAlignment() == null)
2663       {
2664         Cache.log.warn("alignviewport av SeqSetId=" + av.getSequenceSetId()
2665                 + " ViewId=" + av.getViewId()
2666                 + " 's alignment is NULL! returning immediately.");
2667         return;
2668       }
2669       sgroup = seqsel.intersect(av.getAlignment(),
2670               (av.hasHiddenRows()) ? av.getHiddenRepSequences() : null);
2671       if ((sgroup != null && sgroup.getSize() > 0))
2672       {
2673         copycolsel = true;
2674       }
2675     }
2676     if (sgroup != null && sgroup.getSize() > 0)
2677     {
2678       av.setSelectionGroup(sgroup);
2679     }
2680     else
2681     {
2682       av.setSelectionGroup(null);
2683     }
2684     av.isSelectionGroupChanged(true);
2685     repaint = true;
2686
2687     if (copycolsel)
2688     {
2689       // the current selection is unset or from a previous message
2690       // so import the new colsel.
2691       if (colsel == null || colsel.isEmpty())
2692       {
2693         if (av.getColumnSelection() != null)
2694         {
2695           av.getColumnSelection().clear();
2696           repaint = true;
2697         }
2698       }
2699       else
2700       {
2701         // TODO: shift colSel according to the intersecting sequences
2702         if (av.getColumnSelection() == null)
2703         {
2704           av.setColumnSelection(new ColumnSelection(colsel));
2705         }
2706         else
2707         {
2708           av.getColumnSelection().setElementsFrom(colsel,
2709                   av.getAlignment().getHiddenColumns());
2710         }
2711       }
2712       av.isColSelChanged(true);
2713       repaint = true;
2714     }
2715
2716     if (copycolsel && av.hasHiddenColumns()
2717             && (av.getAlignment().getHiddenColumns() == null))
2718     {
2719       System.err.println("Bad things");
2720     }
2721     if (repaint) // always true!
2722     {
2723       // probably finessing with multiple redraws here
2724       PaintRefresher.Refresh(this, av.getSequenceSetId());
2725       // ap.paintAlignment(false);
2726     }
2727
2728     // lastly, update dependent dialogs
2729     if (ap.getCalculationDialog() != null)
2730     {
2731       ap.getCalculationDialog().validateCalcTypes();
2732     }
2733
2734   }
2735
2736   /**
2737    * If this panel is a cdna/protein translation view of the selection source,
2738    * tries to map the source selection to a local one, and returns true. Else
2739    * returns false.
2740    *
2741    * @param seqsel
2742    * @param colsel
2743    * @param source
2744    */
2745   protected boolean selectionFromTranslation(SequenceGroup seqsel,
2746           ColumnSelection colsel, HiddenColumns hidden,
2747           SelectionSource source)
2748   {
2749     if (!(source instanceof AlignViewportI))
2750     {
2751       return false;
2752     }
2753     final AlignViewportI sourceAv = (AlignViewportI) source;
2754     if (sourceAv.getCodingComplement() != av
2755             && av.getCodingComplement() != sourceAv)
2756     {
2757       return false;
2758     }
2759
2760     /*
2761      * Map sequence selection
2762      */
2763     SequenceGroup sg = MappingUtils.mapSequenceGroup(seqsel, sourceAv, av);
2764     av.setSelectionGroup(sg != null && sg.getSize() > 0 ? sg : null);
2765     av.isSelectionGroupChanged(true);
2766
2767     /*
2768      * Map column selection
2769      */
2770     // ColumnSelection cs = MappingUtils.mapColumnSelection(colsel, sourceAv,
2771     // av);
2772     ColumnSelection cs = new ColumnSelection();
2773     HiddenColumns hs = new HiddenColumns();
2774     MappingUtils.mapColumnSelection(colsel, hidden, sourceAv, av, cs, hs);
2775     av.setColumnSelection(cs);
2776     boolean hiddenChanged = av.getAlignment().setHiddenColumns(hs);
2777
2778     // lastly, update any dependent dialogs
2779     if (ap.getCalculationDialog() != null)
2780     {
2781       ap.getCalculationDialog().validateCalcTypes();
2782     }
2783
2784     /*
2785      * repaint alignment, and also Overview or Structure
2786      * if hidden column selection has changed
2787      */
2788     ap.paintAlignment(hiddenChanged, hiddenChanged);
2789
2790     return true;
2791   }
2792
2793   /**
2794    *
2795    * @return null or last search results handled by this panel
2796    */
2797   public SearchResultsI getLastSearchResults()
2798   {
2799     return lastSearchResults;
2800   }
2801 }