Clover icon

Coverage Report

  1. Project Clover database Thu Dec 4 2025 14:43:25 GMT
  2. Package jalview.gui

File SeqPanelTest.java

 

Code metrics

8
519
16
1
1,077
716
22
0.04
32.44
16
1.38

Classes

Class Line # Actions
SeqPanelTest 59 519 22
0.9539594795.4%
 

Contributing tests

This file is covered by 10 tests. .

Source view

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