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