JAL-629 test fixing
[jalview.git] / test / jalview / gui / SeqPanelTest.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 static org.testng.Assert.assertEquals;
24 import static org.testng.Assert.assertNull;
25 import static org.testng.Assert.assertTrue;
26
27 import java.awt.EventQueue;
28 import java.awt.FontMetrics;
29 import java.awt.event.MouseEvent;
30 import java.lang.reflect.InvocationTargetException;
31
32 import javax.swing.JLabel;
33
34 import org.testng.annotations.AfterMethod;
35 import org.testng.annotations.BeforeClass;
36 import org.testng.annotations.Test;
37
38 import jalview.api.AlignViewportI;
39 import jalview.bin.Cache;
40 import jalview.bin.Jalview;
41 import jalview.commands.EditCommand;
42 import jalview.commands.EditCommand.Action;
43 import jalview.commands.EditCommand.Edit;
44 import jalview.datamodel.Alignment;
45 import jalview.datamodel.AlignmentAnnotation;
46 import jalview.datamodel.AlignmentI;
47 import jalview.datamodel.SearchResults;
48 import jalview.datamodel.SearchResultsI;
49 import jalview.datamodel.Sequence;
50 import jalview.datamodel.SequenceI;
51 import jalview.gui.SeqPanel.MousePos;
52 import jalview.io.DataSourceType;
53 import jalview.io.FileLoader;
54 import jalview.util.MessageManager;
55 import jalview.viewmodel.ViewportRanges;
56 import junit.extensions.PA;
57
58 public class SeqPanelTest
59 {
60   AlignFrame af;
61
62   @BeforeClass(alwaysRun = true)
63   public void setUpJvOptionPane()
64   {
65     JvOptionPane.setInteractiveMode(false);
66     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
67   }
68
69   @Test(groups = "Functional")
70   public void testSetStatusReturnsNearestResiduePosition()
71   {
72     SequenceI seq1 = new Sequence("Seq1", "AACDE");
73     SequenceI seq2 = new Sequence("Seq2", "AA--E");
74     AlignmentI al = new Alignment(new SequenceI[] { seq1, seq2 });
75     AlignFrame alignFrame = new AlignFrame(al, al.getWidth(),
76             al.getHeight());
77     AlignmentI visAl = alignFrame.getViewport().getAlignment();
78
79     // Test either side of gap
80     assertEquals(alignFrame.alignPanel.getSeqPanel()
81             .setStatusMessage(visAl.getSequenceAt(1), 1, 1), 2);
82     assertEquals(((JLabel) PA.getValue(alignFrame, "statusBar")).getText(),
83             "Sequence 2 ID: Seq2 Residue: ALA (2)");
84     assertEquals(alignFrame.alignPanel.getSeqPanel()
85             .setStatusMessage(visAl.getSequenceAt(1), 4, 1), 3);
86     assertEquals(((JLabel) PA.getValue(alignFrame, "statusBar")).getText(),
87             "Sequence 2 ID: Seq2 Residue: GLU (3)");
88     // no status message at a gap, returns next residue position to the right
89     assertEquals(alignFrame.alignPanel.getSeqPanel()
90             .setStatusMessage(visAl.getSequenceAt(1), 2, 1), 3);
91     assertEquals(((JLabel) PA.getValue(alignFrame, "statusBar")).getText(),
92             "Sequence 2 ID: Seq2");
93     assertEquals(alignFrame.alignPanel.getSeqPanel()
94             .setStatusMessage(visAl.getSequenceAt(1), 3, 1), 3);
95     assertEquals(((JLabel) PA.getValue(alignFrame, "statusBar")).getText(),
96             "Sequence 2 ID: Seq2");
97   }
98
99   @Test(groups = "Functional")
100   public void testAmbiguousAminoAcidGetsStatusMessage()
101   {
102     SequenceI seq1 = new Sequence("Seq1", "ABCDE");
103     SequenceI seq2 = new Sequence("Seq2", "AB--E");
104     AlignmentI al = new Alignment(new SequenceI[] { seq1, seq2 });
105     AlignFrame alignFrame = new AlignFrame(al, al.getWidth(),
106             al.getHeight());
107     AlignmentI visAl = alignFrame.getViewport().getAlignment();
108
109     assertEquals(alignFrame.alignPanel.getSeqPanel()
110             .setStatusMessage(visAl.getSequenceAt(1), 1, 1), 2);
111     assertEquals(((JLabel) PA.getValue(alignFrame, "statusBar")).getText(),
112             "Sequence 2 ID: Seq2 Residue: B (2)");
113   }
114
115   @Test(groups = "Functional")
116   public void testGetEditStatusMessage()
117   {
118     assertNull(SeqPanel.getEditStatusMessage(null));
119
120     EditCommand edit = new EditCommand(); // empty
121     assertNull(SeqPanel.getEditStatusMessage(edit));
122
123     SequenceI[] seqs = new SequenceI[] { new Sequence("a", "b") };
124
125     // 1 gap
126     edit.addEdit(edit.new Edit(Action.INSERT_GAP, seqs, 1, 1, '-'));
127     String expected = MessageManager.formatMessage("label.insert_gap", "1");
128     assertEquals(SeqPanel.getEditStatusMessage(edit), expected);
129
130     // 3 more gaps makes +4
131     edit.addEdit(edit.new Edit(Action.INSERT_GAP, seqs, 1, 3, '-'));
132     expected = MessageManager.formatMessage("label.insert_gaps", "4");
133     assertEquals(SeqPanel.getEditStatusMessage(edit), expected);
134
135     // 2 deletes makes + 2
136     edit.addEdit(edit.new Edit(Action.DELETE_GAP, seqs, 1, 2, '-'));
137     expected = MessageManager.formatMessage("label.insert_gaps", "2");
138     assertEquals(SeqPanel.getEditStatusMessage(edit), expected);
139
140     // 2 more deletes makes 0 - no text
141     edit.addEdit(edit.new Edit(Action.DELETE_GAP, seqs, 1, 2, '-'));
142     assertNull(SeqPanel.getEditStatusMessage(edit));
143
144     // 1 more delete makes 1 delete
145     edit.addEdit(edit.new Edit(Action.DELETE_GAP, seqs, 1, 1, '-'));
146     expected = MessageManager.formatMessage("label.delete_gap", "1");
147     assertEquals(SeqPanel.getEditStatusMessage(edit), expected);
148
149     // 1 more delete makes 2 deletes
150     edit.addEdit(edit.new Edit(Action.DELETE_GAP, seqs, 1, 1, '-'));
151     expected = MessageManager.formatMessage("label.delete_gaps", "2");
152     assertEquals(SeqPanel.getEditStatusMessage(edit), expected);
153   }
154
155   /**
156    * Tests that simulate 'locked editing', where an inserted gap is balanced by
157    * a gap deletion in the selection group, and vice versa
158    */
159   @Test(groups = "Functional")
160   public void testGetEditStatusMessage_lockedEditing()
161   {
162     EditCommand edit = new EditCommand(); // empty
163     SequenceI[] seqs = new SequenceI[] { new Sequence("a", "b") };
164
165     // 1 gap inserted, balanced by 1 delete
166     Edit e1 = edit.new Edit(Action.INSERT_GAP, seqs, 1, 1, '-');
167     edit.addEdit(e1);
168     Edit e2 = edit.new Edit(Action.DELETE_GAP, seqs, 5, 1, '-');
169     e2.setSystemGenerated(true);
170     edit.addEdit(e2);
171     String expected = MessageManager.formatMessage("label.insert_gap", "1");
172     assertEquals(SeqPanel.getEditStatusMessage(edit), expected);
173
174     // 2 more gaps makes +3
175     Edit e3 = edit.new Edit(Action.INSERT_GAP, seqs, 1, 2, '-');
176     edit.addEdit(e3);
177     Edit e4 = edit.new Edit(Action.DELETE_GAP, seqs, 5, 2, '-');
178     e4.setSystemGenerated(true);
179     edit.addEdit(e4);
180     expected = MessageManager.formatMessage("label.insert_gaps", "3");
181     assertEquals(SeqPanel.getEditStatusMessage(edit), expected);
182
183     // 2 deletes makes + 1
184     Edit e5 = edit.new Edit(Action.DELETE_GAP, seqs, 1, 2, '-');
185     edit.addEdit(e5);
186     Edit e6 = edit.new Edit(Action.INSERT_GAP, seqs, 5, 2, '-');
187     e6.setSystemGenerated(true);
188     edit.addEdit(e6);
189     expected = MessageManager.formatMessage("label.insert_gap", "1");
190     assertEquals(SeqPanel.getEditStatusMessage(edit), expected);
191
192     // 1 more delete makes 0 - no text
193     Edit e7 = edit.new Edit(Action.DELETE_GAP, seqs, 1, 1, '-');
194     edit.addEdit(e7);
195     Edit e8 = edit.new Edit(Action.INSERT_GAP, seqs, 5, 1, '-');
196     e8.setSystemGenerated(true);
197     edit.addEdit(e8);
198     expected = MessageManager.formatMessage("label.insert_gaps", "2");
199     assertNull(SeqPanel.getEditStatusMessage(edit));
200
201     // 1 more delete makes 1 delete
202     Edit e9 = edit.new Edit(Action.DELETE_GAP, seqs, 1, 1, '-');
203     edit.addEdit(e9);
204     Edit e10 = edit.new Edit(Action.INSERT_GAP, seqs, 5, 1, '-');
205     e10.setSystemGenerated(true);
206     edit.addEdit(e10);
207     expected = MessageManager.formatMessage("label.delete_gap", "1");
208     assertEquals(SeqPanel.getEditStatusMessage(edit), expected);
209
210     // 2 more deletes makes 3 deletes
211     Edit e11 = edit.new Edit(Action.DELETE_GAP, seqs, 1, 2, '-');
212     edit.addEdit(e11);
213     Edit e12 = edit.new Edit(Action.INSERT_GAP, seqs, 5, 2, '-');
214     e12.setSystemGenerated(true);
215     edit.addEdit(e12);
216     expected = MessageManager.formatMessage("label.delete_gaps", "3");
217     assertEquals(SeqPanel.getEditStatusMessage(edit), expected);
218   }
219
220   public void testFindMousePosition_unwrapped()
221   {
222     String seqData = ">Seq1\nAACDE\n>Seq2\nAA--E\n";
223     AlignFrame alignFrame = new FileLoader().LoadFileWaitTillLoaded(seqData,
224             DataSourceType.PASTE);
225     AlignViewportI av = alignFrame.getViewport();
226     av.setShowAnnotation(true);
227     av.setWrapAlignment(false);
228     final int charHeight = av.getCharHeight();
229     final int charWidth = av.getCharWidth();
230     // sanity checks:
231     assertTrue(charHeight > 0);
232     assertTrue(charWidth > 0);
233     assertTrue(alignFrame.alignPanel.getSeqPanel().getWidth() > 0);
234
235     SeqPanel testee = alignFrame.alignPanel.getSeqPanel();
236     int x = 0;
237     int y = 0;
238
239     /*
240      * mouse at top left of unwrapped panel
241      */
242     MouseEvent evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0,
243             x, y, 0, 0, 0, false, 0);
244     MousePos pos = testee.findMousePosition(evt);
245     assertEquals(pos.column, 0);
246     assertEquals(pos.seqIndex, 0);
247     assertEquals(pos.annotationIndex, -1);
248   }
249
250   @AfterMethod(alwaysRun = true)
251   public void tearDown()
252   {
253     Desktop.instance.closeAll_actionPerformed(null);
254   }
255
256   @Test(groups = "Functional")
257   public void testFindMousePosition_wrapped_annotations()
258   {
259     Cache.applicationProperties.setProperty("SHOW_ANNOTATIONS", "true");
260     Cache.applicationProperties.setProperty("WRAP_ALIGNMENT", "true");
261     AlignFrame alignFrame = new FileLoader().LoadFileWaitTillLoaded(
262             "examples/uniref50.fa", DataSourceType.FILE);
263     AlignViewportI av = alignFrame.getViewport();
264     av.setScaleAboveWrapped(false);
265     av.setScaleLeftWrapped(false);
266     av.setScaleRightWrapped(false);
267
268     alignFrame.alignPanel.updateLayout();
269
270     final int charHeight = av.getCharHeight();
271     final int charWidth = av.getCharWidth();
272     final int alignmentHeight = av.getAlignment().getHeight();
273
274     // sanity checks:
275     assertTrue(charHeight > 0);
276     assertTrue(charWidth > 0);
277     assertTrue(alignFrame.alignPanel.getSeqPanel().getWidth() > 0);
278
279     SeqPanel testee = alignFrame.alignPanel.getSeqPanel();
280     int x = 0;
281     int y = 0;
282
283     /*
284      * mouse at top left of wrapped panel; there is a gap of charHeight
285      * above the alignment
286      */
287     MouseEvent evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0,
288             x, y, 0, 0, 0, false, 0);
289     MousePos pos = testee.findMousePosition(evt);
290     assertEquals(pos.column, 0);
291     assertEquals(pos.seqIndex, -1); // above sequences
292     assertEquals(pos.annotationIndex, -1);
293
294     /*
295      * cursor at bottom of gap above
296      */
297     y = charHeight - 1;
298     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
299             0, false, 0);
300     pos = testee.findMousePosition(evt);
301     assertEquals(pos.seqIndex, -1);
302     assertEquals(pos.annotationIndex, -1);
303
304     /*
305      * cursor over top of first sequence
306      */
307     y = charHeight;
308     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
309             0, false, 0);
310     pos = testee.findMousePosition(evt);
311     assertEquals(pos.seqIndex, 0);
312     assertEquals(pos.annotationIndex, -1);
313
314     /*
315      * cursor at bottom of first sequence
316      */
317     y = 2 * charHeight - 1;
318     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
319             0, false, 0);
320     pos = testee.findMousePosition(evt);
321     assertEquals(pos.seqIndex, 0);
322     assertEquals(pos.annotationIndex, -1);
323
324     /*
325      * cursor at top of second sequence
326      */
327     y = 2 * charHeight;
328     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
329             0, false, 0);
330     pos = testee.findMousePosition(evt);
331     assertEquals(pos.seqIndex, 1);
332     assertEquals(pos.annotationIndex, -1);
333
334     /*
335      * cursor at bottom of second sequence
336      */
337     y = 3 * charHeight - 1;
338     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
339             0, false, 0);
340     pos = testee.findMousePosition(evt);
341     assertEquals(pos.seqIndex, 1);
342     assertEquals(pos.annotationIndex, -1);
343
344     /*
345      * cursor at bottom of last sequence
346      */
347     y = charHeight * (1 + alignmentHeight) - 1;
348     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
349             0, false, 0);
350     pos = testee.findMousePosition(evt);
351     assertEquals(pos.seqIndex, alignmentHeight - 1);
352     assertEquals(pos.annotationIndex, -1);
353
354     /*
355      * cursor below sequences, in 3-pixel gap above annotations
356      * method reports index of nearest sequence above
357      */
358     y += 1;
359     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
360             0, false, 0);
361     pos = testee.findMousePosition(evt);
362     assertEquals(pos.seqIndex, alignmentHeight - 1);
363     assertEquals(pos.annotationIndex, -1);
364
365     /*
366      * cursor still in the gap above annotations, now at the bottom of it
367      */
368     y += SeqCanvas.SEQS_ANNOTATION_GAP - 1; // 3-1 = 2
369     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
370             0, false, 0);
371     pos = testee.findMousePosition(evt);
372     assertEquals(pos.seqIndex, alignmentHeight - 1);
373     assertEquals(pos.annotationIndex, -1);
374
375     AlignmentAnnotation[] annotationRows = av.getAlignment()
376             .getAlignmentAnnotation();
377     for (int n = 0; n < annotationRows.length; n++)
378     {
379       /*
380        * cursor at the top of the n'th annotation  
381        */
382       y += 1;
383       evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0,
384               0, 0, false, 0);
385       pos = testee.findMousePosition(evt);
386       assertEquals(pos.seqIndex, alignmentHeight - 1);
387       assertEquals(pos.annotationIndex, n); // over n'th annotation
388
389       /*
390        * cursor at the bottom of the n'th annotation  
391        */
392       y += annotationRows[n].height - 1;
393       evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0,
394               0, 0, false, 0);
395       pos = testee.findMousePosition(evt);
396       assertEquals(pos.seqIndex, alignmentHeight - 1);
397       assertEquals(pos.annotationIndex, n);
398     }
399
400     /*
401      * cursor in gap between wrapped widths  
402      */
403     y += 1;
404     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
405             0, false, 0);
406     pos = testee.findMousePosition(evt);
407     assertEquals(pos.seqIndex, -1);
408     assertEquals(pos.annotationIndex, -1);
409
410     /*
411      * cursor at bottom of gap between wrapped widths  
412      */
413     y += charHeight - 1;
414     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
415             0, false, 0);
416     pos = testee.findMousePosition(evt);
417     assertEquals(pos.seqIndex, -1);
418     assertEquals(pos.annotationIndex, -1);
419
420     /*
421      * cursor at top of first sequence, second wrapped width  
422      */
423     y += 1;
424     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
425             0, false, 0);
426     pos = testee.findMousePosition(evt);
427     assertEquals(pos.seqIndex, 0);
428     assertEquals(pos.annotationIndex, -1);
429   }
430
431   @Test(groups = "Functional")
432   public void testFindMousePosition_wrapped_scaleAbove()
433   {
434     Cache.applicationProperties.setProperty("SHOW_ANNOTATIONS", "true");
435     Cache.applicationProperties.setProperty("WRAP_ALIGNMENT", "true");
436     AlignFrame alignFrame = new FileLoader().LoadFileWaitTillLoaded(
437             "examples/uniref50.fa", DataSourceType.FILE);
438     AlignViewportI av = alignFrame.getViewport();
439     av.setScaleAboveWrapped(true);
440     av.setScaleLeftWrapped(false);
441     av.setScaleRightWrapped(false);
442     alignFrame.alignPanel.updateLayout();
443
444     final int charHeight = av.getCharHeight();
445     final int charWidth = av.getCharWidth();
446     final int alignmentHeight = av.getAlignment().getHeight();
447
448     // sanity checks:
449     assertTrue(charHeight > 0);
450     assertTrue(charWidth > 0);
451     assertTrue(alignFrame.alignPanel.getSeqPanel().getWidth() > 0);
452
453     SeqPanel testee = alignFrame.alignPanel.getSeqPanel();
454     int x = 0;
455     int y = 0;
456
457     /*
458      * mouse at top left of wrapped panel; there is a gap of charHeight
459      * above the alignment
460      */
461     MouseEvent evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0,
462             x, y, 0, 0, 0, false, 0);
463     MousePos pos = testee.findMousePosition(evt);
464     assertEquals(pos.column, 0);
465     assertEquals(pos.seqIndex, -1); // above sequences
466     assertEquals(pos.annotationIndex, -1);
467
468     /*
469      * cursor at bottom of gap above
470      * two charHeights including scale panel
471      */
472     y = 2 * charHeight - 1;
473     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
474             0, false, 0);
475     pos = testee.findMousePosition(evt);
476     assertEquals(pos.seqIndex, -1);
477     assertEquals(pos.annotationIndex, -1);
478
479     /*
480      * cursor over top of first sequence
481      */
482     y += 1;
483     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
484             0, false, 0);
485     pos = testee.findMousePosition(evt);
486     assertEquals(pos.seqIndex, 0);
487     assertEquals(pos.annotationIndex, -1);
488
489     /*
490      * cursor at bottom of first sequence
491      */
492     y += charHeight - 1;
493     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
494             0, false, 0);
495     pos = testee.findMousePosition(evt);
496     assertEquals(pos.seqIndex, 0);
497     assertEquals(pos.annotationIndex, -1);
498
499     /*
500      * cursor at top of second sequence
501      */
502     y += 1;
503     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
504             0, false, 0);
505     pos = testee.findMousePosition(evt);
506     assertEquals(pos.seqIndex, 1);
507     assertEquals(pos.annotationIndex, -1);
508
509     /*
510      * cursor at bottom of second sequence
511      */
512     y += charHeight - 1;
513     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
514             0, false, 0);
515     pos = testee.findMousePosition(evt);
516     assertEquals(pos.seqIndex, 1);
517     assertEquals(pos.annotationIndex, -1);
518
519     /*
520      * cursor at bottom of last sequence
521      * (scale + gap + sequences)
522      */
523     y = charHeight * (2 + alignmentHeight) - 1;
524     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
525             0, false, 0);
526     pos = testee.findMousePosition(evt);
527     assertEquals(pos.seqIndex, alignmentHeight - 1);
528     assertEquals(pos.annotationIndex, -1);
529
530     /*
531      * cursor below sequences, in 3-pixel gap above annotations
532      */
533     y += 1;
534     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
535             0, false, 0);
536     pos = testee.findMousePosition(evt);
537     assertEquals(pos.seqIndex, alignmentHeight - 1);
538     assertEquals(pos.annotationIndex, -1);
539
540     /*
541      * cursor still in the gap above annotations, now at the bottom of it
542      * method reports index of nearest sequence above  
543      */
544     y += SeqCanvas.SEQS_ANNOTATION_GAP - 1; // 3-1 = 2
545     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
546             0, false, 0);
547     pos = testee.findMousePosition(evt);
548     assertEquals(pos.seqIndex, alignmentHeight - 1);
549     assertEquals(pos.annotationIndex, -1);
550
551     AlignmentAnnotation[] annotationRows = av.getAlignment()
552             .getAlignmentAnnotation();
553     for (int n = 0; n < annotationRows.length; n++)
554     {
555       /*
556        * cursor at the top of the n'th annotation  
557        */
558       y += 1;
559       evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0,
560               0, 0, false, 0);
561       pos = testee.findMousePosition(evt);
562       assertEquals(pos.seqIndex, alignmentHeight - 1);
563       assertEquals(pos.annotationIndex, n); // over n'th annotation
564
565       /*
566        * cursor at the bottom of the n'th annotation  
567        */
568       y += annotationRows[n].height - 1;
569       evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0,
570               0, 0, false, 0);
571       pos = testee.findMousePosition(evt);
572       SeqCanvas sc = testee.seqCanvas;
573       assertEquals(pos.seqIndex, alignmentHeight - 1,
574               String.format("%s n=%d y=%d %d, %d, %d, %d",
575                       annotationRows[n].label, n, y, sc.getWidth(),
576                       sc.getHeight(), sc.wrappedRepeatHeightPx,
577                       sc.wrappedSpaceAboveAlignment));
578       assertEquals(pos.annotationIndex, n);
579     }
580
581     /*
582      * cursor in gap between wrapped widths  
583      */
584     y += 1;
585     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
586             0, false, 0);
587     pos = testee.findMousePosition(evt);
588     assertEquals(pos.seqIndex, -1);
589     assertEquals(pos.annotationIndex, -1);
590
591     /*
592      * cursor at bottom of gap between wrapped widths  
593      */
594     y += charHeight - 1;
595     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
596             0, false, 0);
597     pos = testee.findMousePosition(evt);
598     assertEquals(pos.seqIndex, -1);
599     assertEquals(pos.annotationIndex, -1);
600
601     /*
602      * cursor at top of scale, second wrapped width  
603      */
604     y += 1;
605     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
606             0, false, 0);
607     pos = testee.findMousePosition(evt);
608     assertEquals(pos.seqIndex, -1);
609     assertEquals(pos.annotationIndex, -1);
610
611     /*
612      * cursor at bottom of scale, second wrapped width  
613      */
614     y += charHeight - 1;
615     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
616             0, false, 0);
617     pos = testee.findMousePosition(evt);
618     assertEquals(pos.seqIndex, -1);
619     assertEquals(pos.annotationIndex, -1);
620
621     /*
622      * cursor at top of first sequence, second wrapped width  
623      */
624     y += 1;
625     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
626             0, false, 0);
627     pos = testee.findMousePosition(evt);
628     assertEquals(pos.seqIndex, 0);
629     assertEquals(pos.annotationIndex, -1);
630   }
631
632   @Test(groups = "Functional")
633   public void testFindMousePosition_wrapped_noAnnotations()
634   {
635     Cache.applicationProperties.setProperty("SHOW_ANNOTATIONS", "false");
636     Cache.applicationProperties.setProperty("WRAP_ALIGNMENT", "true");
637     Cache.applicationProperties.setProperty("FONT_SIZE", "10");
638     AlignFrame alignFrame = new FileLoader().LoadFileWaitTillLoaded(
639             "examples/uniref50.fa", DataSourceType.FILE);
640     AlignViewportI av = alignFrame.getViewport();
641     av.setScaleAboveWrapped(false);
642     av.setScaleLeftWrapped(false);
643     av.setScaleRightWrapped(false);
644     alignFrame.alignPanel.updateLayout();
645
646     final int charHeight = av.getCharHeight();
647     final int charWidth = av.getCharWidth();
648     final int alignmentHeight = av.getAlignment().getHeight();
649
650     // sanity checks:
651     assertTrue(charHeight > 0);
652     assertTrue(charWidth > 0);
653     assertTrue(alignFrame.alignPanel.getSeqPanel().getWidth() > 0);
654
655     SeqPanel testee = alignFrame.alignPanel.getSeqPanel();
656     int x = 0;
657     int y = 0;
658
659     /*
660      * mouse at top left of wrapped panel; there is a gap of charHeight
661      * above the alignment
662      */
663     MouseEvent evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0,
664             x, y, 0, 0, 0, false, 0);
665     MousePos pos = testee.findMousePosition(evt);
666     assertEquals(pos.column, 0);
667     assertEquals(pos.seqIndex, -1); // above sequences
668     assertEquals(pos.annotationIndex, -1);
669
670     /*
671      * cursor over top of first sequence
672      */
673     y = charHeight;
674     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
675             0, false, 0);
676     pos = testee.findMousePosition(evt);
677     assertEquals(pos.seqIndex, 0);
678     assertEquals(pos.annotationIndex, -1);
679
680     /*
681      * cursor at bottom of last sequence
682      */
683     y = charHeight * (1 + alignmentHeight) - 1;
684     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
685             0, false, 0);
686     pos = testee.findMousePosition(evt);
687     assertEquals(pos.seqIndex, alignmentHeight - 1);
688     assertEquals(pos.annotationIndex, -1);
689
690     /*
691      * cursor below sequences, at top of charHeight gap between widths
692      */
693     y += 1;
694     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
695             0, false, 0);
696     pos = testee.findMousePosition(evt);
697     assertEquals(pos.seqIndex, -1);
698     assertEquals(pos.annotationIndex, -1);
699
700     /*
701      * cursor below sequences, at top of charHeight gap between widths
702      */
703     y += charHeight - 1;
704     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
705             0, false, 0);
706     pos = testee.findMousePosition(evt);
707     assertEquals(pos.seqIndex, -1);
708     assertEquals(pos.annotationIndex, -1);
709
710     /*
711      * cursor at the top of the first sequence, second width  
712      */
713     y += 1;
714     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
715             0, false, 0);
716     pos = testee.findMousePosition(evt);
717     assertEquals(pos.seqIndex, 0);
718     assertEquals(pos.annotationIndex, -1);
719   }
720
721   @Test(groups = "Functional")
722   public void testFindColumn_unwrapped()
723   {
724     Cache.applicationProperties.setProperty("WRAP_ALIGNMENT", "false");
725     AlignFrame alignFrame = new FileLoader().LoadFileWaitTillLoaded(
726             "examples/uniref50.fa", DataSourceType.FILE);
727     SeqPanel testee = alignFrame.alignPanel.getSeqPanel();
728     int x = 0;
729     final int charWidth = alignFrame.getViewport().getCharWidth();
730     assertTrue(charWidth > 0); // sanity check
731     ViewportRanges ranges = alignFrame.getViewport().getRanges();
732     assertEquals(ranges.getStartRes(), 0);
733
734     /*
735      * mouse at top left of unwrapped panel
736      */
737     MouseEvent evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0,
738             x, 0, 0, 0, 0, false, 0);
739     assertEquals(testee.findColumn(evt), 0);
740
741     /*
742      * not quite one charWidth across
743      */
744     x = charWidth - 1;
745     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, 0, 0, 0,
746             0, false, 0);
747     assertEquals(testee.findColumn(evt), 0);
748
749     /*
750      * one charWidth across
751      */
752     x = charWidth;
753     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, 0, 0, 0,
754             0, false, 0);
755     assertEquals(testee.findColumn(evt), 1);
756
757     /*
758      * two charWidths across
759      */
760     x = 2 * charWidth;
761     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, 0, 0, 0,
762             0, false, 0);
763     assertEquals(testee.findColumn(evt), 2);
764
765     /*
766      * limited to last column of seqcanvas
767      */
768     x = 20000;
769     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, 0, 0, 0,
770             0, false, 0);
771     SeqCanvas seqCanvas = alignFrame.alignPanel.getSeqPanel().seqCanvas;
772     int w = seqCanvas.getWidth();
773     // limited to number of whole columns, base 0,
774     // and to end of visible range
775     int expected = w / charWidth;
776     expected = Math.min(expected, ranges.getEndRes());
777     assertEquals(testee.findColumn(evt), expected);
778
779     /*
780      * hide columns 5-10 (base 1)
781      */
782     alignFrame.getViewport().hideColumns(4, 9);
783     x = 5 * charWidth + 2;
784     // x is in 6th visible column, absolute column 12, or 11 base 0
785     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, 0, 0, 0,
786             0, false, 0);
787     assertEquals(testee.findColumn(evt), 11);
788   }
789
790   @Test(groups = "Functional")
791   public void testFindColumn_wrapped()
792   {
793     Cache.applicationProperties.setProperty("WRAP_ALIGNMENT", "true");
794     AlignFrame alignFrame = new FileLoader().LoadFileWaitTillLoaded(
795             "examples/uniref50.fa", DataSourceType.FILE);
796     AlignViewport av = alignFrame.getViewport();
797     av.setScaleAboveWrapped(false);
798     av.setScaleLeftWrapped(false);
799     av.setScaleRightWrapped(false);
800     alignFrame.alignPanel.updateLayout();
801     SeqPanel testee = alignFrame.alignPanel.getSeqPanel();
802     int x = 0;
803     final int charWidth = av.getCharWidth();
804     assertTrue(charWidth > 0); // sanity check
805     assertEquals(av.getRanges().getStartRes(), 0);
806
807     /*
808      * mouse at top left of wrapped panel, no West (left) scale
809      */
810     MouseEvent evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0,
811             x, 0, 0, 0, 0, false, 0);
812     assertEquals(testee.findColumn(evt), 0);
813
814     /*
815      * not quite one charWidth across
816      */
817     x = charWidth - 1;
818     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, 0, 0, 0,
819             0, false, 0);
820     assertEquals(testee.findColumn(evt), 0);
821
822     /*
823      * one charWidth across
824      */
825     x = charWidth;
826     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, 0, 0, 0,
827             0, false, 0);
828     assertEquals(testee.findColumn(evt), 1);
829
830     /*
831      * x over scale left (before drawn columns) results in -1
832      */
833     av.setScaleLeftWrapped(true);
834     alignFrame.alignPanel.updateLayout();
835     SeqCanvas seqCanvas = testee.seqCanvas;
836     int labelWidth = (int) PA.getValue(seqCanvas, "labelWidthWest");
837     assertTrue(labelWidth > 0);
838     x = labelWidth - 1;
839     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, 0, 0, 0,
840             0, false, 0);
841     assertEquals(testee.findColumn(evt), -1);
842
843     x = labelWidth;
844     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, 0, 0, 0,
845             0, false, 0);
846     assertEquals(testee.findColumn(evt), 0);
847
848     /*
849      * x over right edge of last residue (including scale left)
850      */
851     int residuesWide = av.getRanges().getViewportWidth();
852     assertTrue(residuesWide > 0);
853     x = labelWidth + charWidth * residuesWide - 1;
854     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, 0, 0, 0,
855             0, false, 0);
856     assertEquals(testee.findColumn(evt), residuesWide - 1);
857
858     /*
859      * x over scale right (beyond drawn columns) results in -1
860      */
861     av.setScaleRightWrapped(true);
862     alignFrame.alignPanel.updateLayout();
863     labelWidth = (int) PA.getValue(seqCanvas, "labelWidthEast");
864     assertTrue(labelWidth > 0);
865     int residuesWide2 = av.getRanges().getViewportWidth();
866     assertTrue(residuesWide2 > 0);
867     assertTrue(residuesWide2 < residuesWide); // available width reduced
868     x += 1; // just over left edge of scale right
869     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, 0, 0, 0,
870             0, false, 0);
871     assertEquals(testee.findColumn(evt), -1);
872
873     // todo add startRes offset, hidden columns
874
875   }
876
877   @BeforeClass(alwaysRun = true)
878   public static void setUpBeforeClass() throws Exception
879   {
880     /*
881      * use read-only test properties file
882      */
883     Cache.loadProperties("test/jalview/io/testProps.jvprops");
884     Jalview.main(new String[] { "-nonews" });
885   }
886
887   /**
888    * waits for Swing event dispatch queue to empty
889    */
890   synchronized void waitForSwing()
891   {
892     try
893     {
894       EventQueue.invokeAndWait(new Runnable()
895       {
896         @Override
897         public void run()
898         {
899         }
900       });
901     } catch (InterruptedException | InvocationTargetException e)
902     {
903       e.printStackTrace();
904     }
905   }
906
907   @Test(groups = "Functional")
908   public void testFindMousePosition_wrapped_scales_longSequence()
909   {
910     Cache.applicationProperties.setProperty("SHOW_ANNOTATIONS", "false");
911     Cache.applicationProperties.setProperty("WRAP_ALIGNMENT", "true");
912     Cache.applicationProperties.setProperty("FONT_SIZE", "14");
913     Cache.applicationProperties.setProperty("FONT_NAME", "SansSerif");
914     Cache.applicationProperties.setProperty("FONT_STYLE", "0");
915     // sequence of 50 bases, doubled 10 times, = 51200 bases
916     String dna = "ATGGCCATTGGGCCCAAATTTCCCAAAGGGTTTCCCTGAGGTCAGTCAGA";
917     for (int i = 0; i < 10; i++)
918     {
919       dna += dna;
920     }
921     assertEquals(dna.length(), 51200);
922     AlignFrame alignFrame = new FileLoader()
923             .LoadFileWaitTillLoaded("dna "+dna, DataSourceType.PASTE);
924     SeqPanel testee = alignFrame.alignPanel.getSeqPanel();
925     AlignViewport av = alignFrame.getViewport();
926     av.setScaleAboveWrapped(true);
927     av.setScaleLeftWrapped(true);
928     av.setScaleRightWrapped(true);
929     alignFrame.alignPanel.updateLayout();
930
931     try
932     {
933       Thread.sleep(200);
934     } catch (InterruptedException e)
935     {
936     }
937
938     final int charHeight = av.getCharHeight();
939     final int charWidth = av.getCharWidth();
940     assertEquals(charHeight, 17);
941     assertEquals(charWidth, 12);
942
943     FontMetrics fm = testee.getFontMetrics(av.getFont());
944     int labelWidth = fm.stringWidth("00000") + charWidth;
945     assertEquals(labelWidth, 57); // 5 x 9 + charWidth
946     assertEquals(testee.seqCanvas.getLabelWidthWest(), labelWidth);
947
948     int x = 0;
949     int y = 0;
950
951     /*
952      * mouse at top left of wrapped panel; there is a gap of 2 * charHeight
953      * above the alignment
954      */
955     MouseEvent evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0,
956             x, y, 0, 0, 0, false, 0);
957     MousePos pos = testee.findMousePosition(evt);
958     assertEquals(pos.column, -1); // over scale left, not an alignment column
959     assertEquals(pos.seqIndex, -1); // above sequences
960     assertEquals(pos.annotationIndex, -1);
961
962     /*
963      * cursor over scale above first sequence
964      */
965     y += charHeight;
966     x = labelWidth;
967     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
968             0, false, 0);
969     pos = testee.findMousePosition(evt);
970     assertEquals(pos.seqIndex, -1);
971     assertEquals(pos.column, 0);
972     assertEquals(pos.annotationIndex, -1);
973
974     /*
975      * cursor over scale left of first sequence
976      */
977     y += charHeight;
978     x = 0;
979     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
980             0, false, 0);
981     pos = testee.findMousePosition(evt);
982     assertEquals(pos.seqIndex, 0);
983     assertEquals(pos.column, -1);
984     assertEquals(pos.annotationIndex, -1);
985
986     /*
987      * cursor over start of first sequence
988      */
989     x = labelWidth;
990     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
991             0, false, 0);
992     pos = testee.findMousePosition(evt);
993     assertEquals(pos.seqIndex, 0);
994     assertEquals(pos.column, 0);
995     assertEquals(pos.annotationIndex, -1);
996
997     /*
998      * move one character right, to bottom pixel of same row
999      */
1000     x += charWidth;
1001     y += charHeight - 1;
1002     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
1003             0, false, 0);
1004     pos = testee.findMousePosition(evt);
1005     assertEquals(pos.seqIndex, 0);
1006     assertEquals(pos.column, 1);
1007
1008     /*
1009      * move down one pixel - now in the no man's land between rows
1010      */
1011     y += 1;
1012     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
1013             0, false, 0);
1014     pos = testee.findMousePosition(evt);
1015     assertEquals(pos.seqIndex, -1);
1016     assertEquals(pos.column, 1);
1017
1018     /*
1019      * move down two char heights less one pixel - still in the no man's land
1020      * (scale above + spacer line)
1021      */
1022     y += (2 * charHeight - 1);
1023     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
1024             0, false, 0);
1025     pos = testee.findMousePosition(evt);
1026     assertEquals(pos.seqIndex, -1);
1027     assertEquals(pos.column, 1);
1028
1029     /*
1030      * move down one more pixel - now on the next row of the sequence
1031      */
1032     y += 1;
1033     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
1034             0, false, 0);
1035     pos = testee.findMousePosition(evt);
1036     assertEquals(pos.seqIndex, 0);
1037     assertEquals(pos.column, 1 + av.getWrappedWidth());
1038
1039     /*
1040      * scroll to near the end of the sequence
1041      */
1042     SearchResultsI sr = new SearchResults();
1043     int scrollTo = dna.length() - 1000;
1044     sr.addResult(av.getAlignment().getSequenceAt(0), scrollTo, scrollTo);
1045     alignFrame.alignPanel.scrollToPosition(sr);
1046
1047     /*
1048      * place the mouse on the first column of the 6th sequence, and
1049      * verify that (computed) findMousePosition matches (actual) ViewportRanges
1050      */
1051     x = labelWidth;
1052     y = 17 * charHeight; // 17 = 6 times two header rows and 5 sequence rows
1053     evt = new MouseEvent(testee, MouseEvent.MOUSE_MOVED, 0L, 0, x, y, 0, 0,
1054             0, false, 0);
1055     pos = testee.findMousePosition(evt);
1056     assertEquals(pos.seqIndex, 0);
1057     int expected = av.getRanges().getStartRes() + 5 * av.getWrappedWidth();
1058     assertEquals(pos.column, expected);
1059   }
1060 }