1. Project Clover database Fri Dec 6 2024 13:47:14 GMT
  2. Package jalview.viewmodel

File OverviewDimensionsHideHiddenTest.java

 

Code metrics

4
496
26
1
1,059
707
28
0.06
19.08
26
1.08

Classes

Class
Line #
Actions
OverviewDimensionsHideHiddenTest 45 496 28
1.0100%
 

Contributing tests

This file is covered by 17 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.viewmodel;
22   
23    import static org.testng.Assert.assertEquals;
24    import static org.testng.Assert.assertFalse;
25    import static org.testng.Assert.assertTrue;
26   
27    import jalview.analysis.AlignmentGenerator;
28    import jalview.datamodel.Alignment;
29    import jalview.datamodel.AlignmentI;
30    import jalview.datamodel.ColumnSelection;
31    import jalview.datamodel.HiddenColumns;
32    import jalview.datamodel.Sequence;
33    import jalview.datamodel.SequenceCollectionI;
34    import jalview.datamodel.SequenceGroup;
35    import jalview.datamodel.SequenceI;
36   
37    import java.util.Hashtable;
38   
39    import org.testng.annotations.AfterClass;
40    import org.testng.annotations.BeforeClass;
41    import org.testng.annotations.BeforeMethod;
42    import org.testng.annotations.Test;
43   
44    @Test(singleThreaded = true)
 
45    public class OverviewDimensionsHideHiddenTest
46    {
47    AlignmentI al;
48   
49    OverviewDimensionsHideHidden od;
50   
51    // cached widths and heights
52    int boxWidth;
53   
54    int boxHeight;
55   
56    int viewHeight;
57   
58    int viewWidth;
59   
60    int alheight;
61   
62    int alwidth;
63   
64    ViewportRanges vpranges;
65   
66    Hashtable<SequenceI, SequenceCollectionI> hiddenRepSequences = new Hashtable<>();
67   
68    HiddenColumns hiddenCols = new HiddenColumns();
69   
 
70  1 toggle @BeforeClass(alwaysRun = true)
71    public void setUpAlignment()
72    {
73    // create random alignment
74  1 AlignmentGenerator gen = new AlignmentGenerator(false);
75  1 al = gen.generate(157, 525, 123, 5, 5);
76    }
77   
 
78  17 toggle @BeforeMethod(alwaysRun = true)
79    public void setUp()
80    {
81  17 if (!hiddenRepSequences.isEmpty())
82    {
83  15 al.getHiddenSequences().showAll(hiddenRepSequences);
84    }
85  17 ColumnSelection colsel = new ColumnSelection();
86  17 hiddenCols.revealAllHiddenColumns(colsel);
87   
88  17 vpranges = new ViewportRanges(al);
89  17 vpranges.setViewportStartAndHeight(0, 18);
90  17 vpranges.setViewportStartAndWidth(0, 63);
91   
92  17 viewHeight = vpranges.getEndSeq() - vpranges.getStartSeq() + 1;
93  17 viewWidth = vpranges.getEndRes() - vpranges.getStartRes() + 1;
94   
95  17 HiddenColumns hiddenCols = new HiddenColumns();
96   
97  17 od = new OverviewDimensionsHideHidden(vpranges, true);
98    // Initial box sizing - default path through code
99  17 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
100   
101  17 mouseClick(od, 0, 0);
102  17 moveViewport(0, 0);
103   
104    // calculate with visible values
105  17 alheight = vpranges.getVisibleAlignmentHeight();
106  17 alwidth = vpranges.getVisibleAlignmentWidth();
107   
108  17 boxWidth = Math.round(
109    (float) (vpranges.getEndRes() - vpranges.getStartRes() + 1)
110    * od.getWidth() / alwidth);
111  17 boxHeight = Math.round(
112    (float) (vpranges.getEndSeq() - vpranges.getStartSeq() + 1)
113    * od.getSequencesHeight() / alheight);
114    }
115   
 
116  1 toggle @AfterClass(alwaysRun = true)
117    public void cleanUp()
118    {
119  1 al = null;
120    }
121   
122    /**
123    * Test that the OverviewDimensions constructor sets width and height
124    * correctly
125    */
 
126  1 toggle @Test(groups = { "Functional" })
127    public void testConstructor()
128    {
129  1 SequenceI seqa = new Sequence("Seq1", "ABC");
130  1 SequenceI seqb = new Sequence("Seq2", "ABC");
131  1 SequenceI seqc = new Sequence("Seq3", "ABC");
132  1 SequenceI seqd = new Sequence("Seq4", "ABC");
133  1 SequenceI seqe = new Sequence("Seq5",
134    "ABCABCABCABCABCABCABCABCBACBACBACBAC");
135   
136  1 int defaultGraphHeight = 20;
137  1 int maxWidth = 400;
138  1 int minWidth = 120;
139  1 int maxSeqHeight = 300;
140  1 int minSeqHeight = 40;
141   
142    // test for alignment with width > height
143  1 SequenceI[] seqs1 = new SequenceI[] { seqa, seqb };
144  1 Alignment al1 = new Alignment(seqs1);
145  1 ViewportRanges props = new ViewportRanges(al1);
146   
147  1 OverviewDimensions od = new OverviewDimensionsHideHidden(props, true);
148  1 int scaledHeight = 267;
149  1 assertEquals(od.getGraphHeight(), defaultGraphHeight);
150  1 assertEquals(od.getSequencesHeight(), scaledHeight);
151  1 assertEquals(od.getWidth(), maxWidth);
152  1 assertEquals(od.getHeight(), scaledHeight + defaultGraphHeight);
153   
154    // test for alignment with width < height
155  1 SequenceI[] seqs2 = new SequenceI[] { seqa, seqb, seqc, seqd };
156  1 Alignment al2 = new Alignment(seqs2);
157  1 props = new ViewportRanges(al2);
158   
159  1 od = new OverviewDimensionsHideHidden(props, true);
160  1 int scaledWidth = 300;
161  1 assertEquals(od.getGraphHeight(), defaultGraphHeight);
162  1 assertEquals(od.getSequencesHeight(), maxSeqHeight);
163  1 assertEquals(od.getWidth(), scaledWidth);
164  1 assertEquals(od.getHeight(), scaledWidth + defaultGraphHeight);
165   
166    // test for alignment with width > height and sequence height scaled below
167    // min value
168  1 SequenceI[] seqs3 = new SequenceI[] { seqe };
169  1 Alignment al3 = new Alignment(seqs3);
170  1 props = new ViewportRanges(al3);
171   
172  1 od = new OverviewDimensionsHideHidden(props, true);
173  1 assertEquals(od.getGraphHeight(), defaultGraphHeight);
174  1 assertEquals(od.getSequencesHeight(), minSeqHeight);
175  1 assertEquals(od.getWidth(), maxWidth);
176  1 assertEquals(od.getHeight(), minSeqHeight + defaultGraphHeight);
177   
178    // test for alignment with width < height and width scaled below min value
179  1 SequenceI[] seqs4 = new SequenceI[] { seqa, seqb, seqc, seqd, seqa,
180    seqb, seqc, seqd, seqa, seqb, seqc, seqd, seqa, seqb, seqc, seqd };
181  1 Alignment al4 = new Alignment(seqs4);
182  1 props = new ViewportRanges(al4);
183   
184  1 od = new OverviewDimensionsHideHidden(props, true);
185  1 assertEquals(od.getGraphHeight(), defaultGraphHeight);
186  1 assertEquals(od.getSequencesHeight(), maxSeqHeight);
187  1 assertEquals(od.getWidth(), minWidth);
188  1 assertEquals(od.getHeight(), maxSeqHeight + defaultGraphHeight);
189   
190  1 Alignment al5 = new Alignment(seqs4);
191  1 props = new ViewportRanges(al5);
192   
193  1 od = new OverviewDimensionsHideHidden(props, false);
194  1 assertEquals(od.getGraphHeight(), 0);
195  1 assertEquals(od.getSequencesHeight(), maxSeqHeight);
196  1 assertEquals(od.getWidth(), minWidth);
197  1 assertEquals(od.getHeight(), maxSeqHeight);
198    }
199   
200    /**
201    * Test that validation after mouse adjustments to boxX and boxY sets box
202    * dimensions and scroll values correctly, when there are no hidden rows or
203    * columns.
204    */
 
205  1 toggle @Test(groups = { "Functional" })
206    public void testSetBoxFromMouseClick()
207    {
208  1 od.updateViewportFromMouse(0, 0, al.getHiddenSequences(), hiddenCols);
209  1 assertEquals(od.getBoxX(), 0);
210  1 assertEquals(od.getBoxY(), 0);
211  1 assertEquals(od.getBoxWidth(), boxWidth);
212  1 assertEquals(vpranges.getStartRes(), 0);
213  1 assertEquals(vpranges.getStartSeq(), 0);
214   
215    // negative boxX value reset to 0
216  1 mouseClick(od, -5, 10);
217  1 assertEquals(od.getBoxX(), 0);
218  1 assertEquals(od.getBoxWidth(), boxWidth);
219  1 assertEquals(od.getBoxHeight(), boxHeight);
220  1 assertEquals(vpranges.getStartSeq() + vpranges.getViewportHeight() / 2,
221    Math.round((float) 10 * alheight / od.getSequencesHeight()));
222  1 assertEquals(vpranges.getStartRes(), 0);
223   
224    // negative boxY value reset to 0
225  1 mouseClick(od, 6, -2);
226  1 assertEquals(od.getBoxY(), 0);
227  1 assertEquals(od.getBoxWidth(), boxWidth);
228  1 assertEquals(od.getBoxHeight(), boxHeight);
229  1 assertEquals(vpranges.getStartRes(), 0);
230  1 assertEquals(vpranges.getStartSeq(), 0);
231   
232    // overly large boxX value reset to width-boxWidth
233  1 mouseClick(od, 101, 6);
234  1 assertEquals(od.getBoxX(), od.getWidth() - od.getBoxWidth());
235  1 assertEquals(od.getBoxY(), 1);
236  1 assertEquals(od.getBoxWidth(), boxWidth);
237  1 assertEquals(od.getBoxHeight(), boxHeight);
238  1 assertEquals(vpranges.getStartRes(),
239    Math.round((float) od.getBoxX() * alwidth / od.getWidth()));
240  1 assertEquals(vpranges.getStartSeq(), Math.round(
241    (float) od.getBoxY() * alheight / od.getSequencesHeight()));
242   
243    // overly large boxY value reset to sequenceHeight - boxHeight
244  1 mouseClick(od, 10, 520);
245  1 assertEquals(od.getBoxX(), 0);
246  1 assertEquals(od.getBoxY(), od.getSequencesHeight() - od.getBoxHeight());
247  1 assertEquals(od.getBoxWidth(), boxWidth);
248  1 assertEquals(od.getBoxHeight(), boxHeight);
249  1 assertEquals(vpranges.getStartRes(),
250    Math.round((float) od.getBoxX() * alwidth / od.getWidth()));
251   
252    // here (float) od.getBoxY() * alheight / od.getSequencesHeight() = 507.5
253    // and round rounds to 508; however we get 507 working with row values
254    // hence the subtraction of 1
255  1 assertEquals(vpranges.getStartSeq(), Math.round(
256    (float) od.getBoxY() * alheight / od.getSequencesHeight()) - 1);
257   
258    // click past end of alignment, as above
259  1 mouseClick(od, 3000, 5);
260  1 assertEquals(od.getBoxX(), od.getWidth() - od.getBoxWidth());
261  1 assertEquals(od.getBoxWidth(), boxWidth);
262  1 assertEquals(od.getBoxHeight(), boxHeight);
263  1 assertEquals(vpranges.getStartRes(),
264    Math.round((float) od.getBoxX() * alwidth / od.getWidth()));
265  1 assertEquals(vpranges.getStartSeq(), Math.round(
266    (float) od.getBoxY() * alheight / od.getSequencesHeight()));
267   
268    // move viewport so startRes non-zero and then mouseclick
269  1 moveViewportH(20);
270   
271    // click at viewport position
272  1 int oldboxx = od.getBoxX();
273  1 int oldboxy = od.getBoxY();
274  1 mouseClick(od, od.getBoxX() + od.getBoxWidth() / 2 + 6,
275    od.getBoxY() + od.getBoxHeight() / 2 + 3);
276  1 assertEquals(od.getBoxX(), oldboxx + 6);
277  1 assertEquals(od.getBoxWidth(), boxWidth);
278  1 assertEquals(od.getBoxHeight(), boxHeight);
279  1 assertEquals(vpranges.getStartRes(),
280    Math.round((float) od.getBoxX() * alwidth / od.getWidth()));
281  1 assertEquals(od.getBoxY(), oldboxy + 3);
282  1 assertEquals(vpranges.getStartSeq(), Math.round(
283    (float) od.getBoxY() * alheight / od.getSequencesHeight()));
284   
285    // click at top corner
286  1 mouseClick(od, 0, 0);
287  1 assertEquals(od.getBoxX(), 0);
288  1 assertEquals(vpranges.getStartRes(), 0);
289  1 assertEquals(od.getBoxY(), 0);
290  1 assertEquals(vpranges.getStartSeq(), 0);
291  1 assertEquals(od.getBoxWidth(), boxWidth);
292  1 assertEquals(od.getBoxHeight(), boxHeight);
293    }
294   
295    /**
296    * Test setting of the box position, when there are hidden cols at the start
297    * of the alignment
298    */
 
299  1 toggle @Test(groups = { "Functional" })
300    public void testFromMouseWithHiddenColsAtStart()
301    {
302  1 od.updateViewportFromMouse(0, 0, al.getHiddenSequences(), hiddenCols);
303  1 assertEquals(od.getBoxX(), 0);
304  1 assertEquals(od.getBoxY(), 0);
305  1 assertEquals(od.getBoxWidth(), boxWidth);
306  1 assertEquals(vpranges.getStartRes(), 0);
307  1 assertEquals(vpranges.getStartSeq(), 0);
308   
309    // hide cols at start and check updated box position is correct
310  1 int lastHiddenCol = 30;
311  1 hiddenCols.hideColumns(0, lastHiddenCol);
312   
313  1 testBoxIsAtClickPoint(boxWidth / 2, boxHeight / 2);
314   
315    // click to right of hidden columns, box moves to click point
316  1 testBoxIsAtClickPoint(41 + boxWidth / 2, boxHeight / 2);
317  1 assertEquals(vpranges.getStartSeq(), 0);
318  1 assertEquals(vpranges.getStartRes(),
319    Math.round((float) 41 * alwidth / od.getWidth()));
320   
321    // click to right of hidden columns such that box runs over right hand side
322    // of alignment
323    // box position is adjusted away from the edge
324    // overly large boxX value reset to width-boxWidth
325  1 int xpos = 100 + boxWidth / 2;
326  1 mouseClick(od, xpos, boxHeight / 2);
327  1 assertEquals(od.getBoxX(), Math.round(od.getWidth()) - boxWidth);
328  1 assertEquals(od.getBoxY(), 0);
329  1 assertEquals(od.getBoxWidth(), boxWidth);
330  1 assertEquals(od.getBoxHeight(), boxHeight);
331  1 assertEquals(vpranges.getStartRes(),
332    Math.round((float) od.getBoxX() * alwidth / od.getWidth()));
333  1 assertEquals(vpranges.getStartSeq(), 0);
334    }
335   
336    /**
337    * Test setting of the box position, when there are hidden cols in the middle
338    * of the alignment
339    */
 
340  1 toggle @Test(groups = { "Functional" })
341    public void testFromMouseWithHiddenColsInMiddle()
342    {
343  1 od.updateViewportFromMouse(0, 0, al.getHiddenSequences(), hiddenCols);
344  1 testBoxIsAtClickPoint(boxWidth / 2, boxHeight / 2);
345  1 assertEquals(od.getBoxX(), 0);
346  1 assertEquals(od.getBoxY(), 0);
347  1 assertEquals(od.getBoxWidth(), boxWidth);
348  1 assertEquals(vpranges.getStartRes(), 0);
349  1 assertEquals(vpranges.getStartSeq(), 0);
350   
351    // hide columns 63-73, no change to box position or dimensions
352  1 int firstHidden = 63;
353  1 int lastHidden = 73;
354  1 hiddenCols.hideColumns(firstHidden, lastHidden);
355   
356  1 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
357  1 testBoxIsAtClickPoint(boxWidth / 2, boxHeight / 2);
358  1 assertEquals(od.getBoxX(), 0);
359  1 assertEquals(od.getBoxY(), 0);
360  1 assertEquals(od.getBoxWidth(), boxWidth);
361  1 assertEquals(vpranges.getStartRes(), 0);
362  1 assertEquals(vpranges.getStartSeq(), 0);
363   
364    // move box so that it overlaps with hidden cols on one side
365    // box width, boxX and scrollCol as for unhidden case
366  1 int xpos = 54 - boxWidth / 2; // 54 is position in overview approx halfway
367    // between cols 60 and 70
368  1 mouseClick(od, xpos, boxHeight / 2);
369  1 testBoxIsAtClickPoint(xpos, boxHeight / 2);
370  1 assertEquals(vpranges.getStartRes(), 1 + // rounding
371    Math.round((xpos - boxWidth / 2) * alwidth / od.getWidth()));
372  1 assertEquals(vpranges.getStartSeq(), 0);
373   
374    // move box so that it completely covers hidden cols
375    // box width, boxX and scrollCol as for unhidden case
376  1 xpos = 33;
377  1 mouseClick(od, xpos, boxHeight / 2);
378  1 testBoxIsAtClickPoint(xpos, boxHeight / 2);
379  1 assertEquals(vpranges.getStartRes(), Math.round(
380    (float) (xpos - boxWidth / 2) * alwidth / od.getWidth()));
381  1 assertEquals(vpranges.getStartSeq(), 0);
382   
383    // move box so boxX is in hidden cols, box overhangs at right
384    // boxX and scrollCol at left of hidden area, box width unchanged
385  1 xpos = Math.round((float) 50 * od.getWidth() / alwidth) + boxWidth / 2;
386  1 mouseClick(od, xpos, boxHeight / 2);
387  1 assertEquals(od.getBoxX() + od.getBoxWidth() / 2, xpos);
388  1 assertEquals(od.getBoxY(), 0);
389  1 assertEquals(od.getBoxWidth(), boxWidth);
390  1 assertEquals(od.getBoxHeight(), boxHeight);
391  1 assertEquals(vpranges.getStartRes(), 50);
392  1 assertEquals(vpranges.getStartSeq(), 0);
393   
394    // move box so boxX is to right of hidden cols, but does not go beyond full
395    // width of alignment
396    // box width, boxX and scrollCol all as for non-hidden case
397  1 xpos = Math.round((float) 75 * od.getWidth() / alwidth) + boxWidth / 2;
398  1 mouseClick(od, xpos, boxHeight / 2);
399  1 assertEquals(od.getBoxX() + od.getBoxWidth() / 2, xpos);
400  1 assertEquals(od.getBoxY(), 0);
401  1 assertEquals(od.getBoxWidth(), boxWidth);
402  1 assertEquals(od.getBoxHeight(), boxHeight);
403  1 assertEquals(vpranges.getStartSeq(), 0);
404  1 assertEquals(vpranges.getStartRes(), 75);
405   
406    // move box so it goes beyond full width of alignment
407    // boxX, scrollCol adjusted back, box width normal
408  1 xpos = 3000;
409  1 mouseClick(od, xpos, boxHeight / 2);
410  1 assertEquals(od.getBoxX(), Math.round(od.getWidth()) - boxWidth);
411  1 assertEquals(od.getBoxY(), 0);
412  1 assertEquals(od.getBoxWidth(), boxWidth);
413  1 assertEquals(od.getBoxHeight(), boxHeight);
414  1 assertEquals(vpranges.getStartRes(),
415    Math.round((float) od.getBoxX() * alwidth / od.getWidth()));
416  1 assertEquals(vpranges.getStartSeq(), 0);
417   
418    }
419   
420    /**
421    * Test setting of the box position, when there are hidden cols at the end of
422    * the alignment
423    */
 
424  1 toggle @Test(groups = { "Functional" })
425    public void testFromMouseWithHiddenColsAtEnd()
426    {
427  1 od.updateViewportFromMouse(0, 0, al.getHiddenSequences(), hiddenCols);
428  1 assertEquals(od.getBoxX(), 0);
429  1 assertEquals(od.getBoxY(), 0);
430  1 assertEquals(od.getBoxWidth(), boxWidth);
431  1 assertEquals(vpranges.getStartRes(), 0);
432  1 assertEquals(vpranges.getStartSeq(), 0);
433   
434    // hide columns 140-164, no change to box position or dimensions
435  1 int firstHidden = 140;
436  1 int lastHidden = 164;
437  1 hiddenCols.hideColumns(firstHidden, lastHidden);
438  1 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
439  1 assertEquals(od.getBoxX(), 0);
440  1 assertEquals(od.getBoxY(), 0);
441  1 assertEquals(od.getBoxWidth(), boxWidth);
442  1 assertEquals(vpranges.getStartRes(), 0);
443  1 assertEquals(vpranges.getStartSeq(), 0);
444   
445    // click to left of hidden cols, without overlapping
446    // boxX, scrollCol and width as normal
447  1 int xpos = 30;
448  1 int ypos = 6;
449  1 testBoxIsAtClickPoint(xpos, ypos);
450  1 assertEquals(vpranges.getStartSeq(), Math.round(
451    (float) (ypos - boxHeight / 2) * alheight / od.getHeight()));
452  1 assertEquals(vpranges.getStartRes(), Math.round(
453    (float) (xpos - boxWidth / 2) * alwidth / od.getWidth()));
454   
455    // click to left of hidden cols, with overlap
456    // boxX and scrollCol adjusted for hidden cols, width normal
457  1 xpos = Math.round((float) 144 * od.getWidth() / alwidth) - boxWidth;
458  1 mouseClick(od, xpos, boxHeight / 2);
459  1 testBoxIsAtClickPoint(xpos, boxHeight / 2);
460  1 assertEquals(vpranges.getStartRes(), Math.round(
461    (float) (xpos - boxWidth / 2) * alwidth / od.getWidth()));
462  1 assertEquals(vpranges.getStartSeq(), 0);
463   
464    // click off end of alignment
465    // boxX and scrollCol adjusted backwards, width normal
466  1 xpos = 3000;
467  1 mouseClick(od, xpos, 0);
468  1 assertEquals(od.getBoxX(), Math.round(od.getWidth()) - boxWidth);
469  1 assertEquals(od.getBoxY(), 0);
470  1 assertEquals(od.getBoxWidth(), boxWidth);
471  1 assertEquals(od.getBoxHeight(), boxHeight);
472  1 assertEquals(vpranges.getStartRes(),
473    Math.round((float) od.getBoxX() * alwidth / od.getWidth()));
474  1 assertEquals(vpranges.getStartSeq(), 0);
475    }
476   
477    /**
478    * Test that the box position is set correctly when set from the viewport,
479    * with no hidden rows or columns
480    */
 
481  1 toggle @Test(groups = { "Functional" })
482    public void testSetBoxFromViewport()
483    {
484    // move viewport to start of alignment
485  1 moveViewport(0, 0);
486  1 assertEquals(od.getBoxX(), 0);
487  1 assertEquals(od.getBoxY(), 0);
488  1 assertEquals(od.getBoxWidth(), boxWidth);
489  1 assertEquals(od.getBoxHeight(), boxHeight);
490   
491    // move viewport to right
492  1 moveViewportH(70);
493  1 assertEquals(od.getBoxX(),
494    Math.round((float) 70 * od.getWidth() / alwidth));
495  1 assertEquals(od.getBoxY(), 0);
496  1 assertEquals(od.getBoxWidth(), boxWidth);
497  1 assertEquals(od.getBoxHeight(), boxHeight);
498   
499    // move viewport down
500  1 moveViewportV(100);
501  1 assertEquals(od.getBoxX(),
502    Math.round((float) 70 * od.getWidth() / alwidth));
503  1 assertEquals(od.getBoxY(),
504    Math.round(100 * od.getSequencesHeight() / alheight));
505  1 assertEquals(od.getBoxWidth(), boxWidth);
506  1 assertEquals(od.getBoxHeight(), boxHeight);
507   
508    // move viewport to bottom right
509  1 moveViewport(98, 508);
510  1 assertEquals(od.getBoxX(),
511    Math.round((float) 98 * od.getWidth() / alwidth));
512  1 assertEquals(od.getBoxY(),
513    Math.round((float) 508 * od.getSequencesHeight() / alheight));
514  1 assertEquals(od.getBoxWidth(), boxWidth);
515  1 assertEquals(od.getBoxHeight(), boxHeight);
516    }
517   
518    /**
519    * Test that the box position is set correctly when there are hidden columns
520    * at the start
521    */
 
522  1 toggle @Test(groups = { "Functional" })
523    public void testSetBoxFromViewportHiddenColsAtStart()
524    {
525  1 int firstHidden = 0;
526  1 int lastHidden = 20;
527  1 hiddenCols.hideColumns(firstHidden, lastHidden);
528   
529    // move viewport to start of alignment
530  1 moveViewport(0, 0);
531  1 assertEquals(od.getBoxX(), 0);
532  1 assertEquals(od.getBoxY(), 0);
533  1 assertEquals(od.getBoxWidth(), boxWidth);
534  1 assertEquals(od.getBoxHeight(), boxHeight);
535   
536    // move viewport to end of alignment - need to make startRes by removing
537    // hidden cols because of how viewport/overview are implemented
538  1 moveViewport(98 - lastHidden - 1, 0);
539  1 assertEquals(od.getBoxX(), Math.round(
540    (float) (98 - lastHidden - 1) * od.getWidth() / alwidth));
541  1 assertEquals(od.getBoxY(), 0);
542  1 assertEquals(od.getBoxWidth(), boxWidth);
543  1 assertEquals(od.getBoxHeight(), boxHeight);
544    }
545   
546    /**
547    * Test that the box position is set correctly when there are hidden columns
548    * in the middle
549    */
 
550  1 toggle @Test(groups = { "Functional" })
551    public void testSetBoxFromViewportHiddenColsInMiddle()
552    {
553  1 int firstHidden = 68;
554  1 int lastHidden = 78;
555  1 hiddenCols.hideColumns(firstHidden, lastHidden);
556   
557    // move viewport before hidden columns
558  1 moveViewport(3, 0);
559   
560  1 assertEquals(od.getBoxX(),
561    Math.round((float) 3 * od.getWidth() / alwidth));
562  1 assertEquals(od.getBoxY(), 0);
563  1 assertEquals(od.getBoxWidth(), boxWidth);
564  1 assertEquals(od.getBoxHeight(), boxHeight);
565   
566    // move viewport to left of hidden columns with overlap
567  1 moveViewport(10, 0);
568  1 assertEquals(od.getBoxX(),
569    Math.round((float) 10 * od.getWidth() / alwidth));
570  1 assertEquals(od.getBoxY(), 0);
571  1 assertEquals(od.getBoxWidth(), boxWidth);
572  1 assertEquals(od.getBoxHeight(), boxHeight);
573   
574    // move viewport to straddle hidden columns
575  1 moveViewport(63, 0);
576  1 assertEquals(od.getBoxX(),
577    Math.round((float) 63 * od.getWidth() / alwidth));
578  1 assertEquals(od.getBoxY(), 0);
579  1 assertEquals(od.getBoxWidth(), boxWidth);
580  1 assertEquals(od.getBoxHeight(), boxHeight);
581   
582    // move viewport to right of hidden columns, no overlap
583  1 moveViewport(80 - (lastHidden - firstHidden + 1), 0);
584  1 assertEquals(od.getBoxX(),
585    Math.round((float) (80 - (lastHidden - firstHidden + 1))
586    * od.getWidth() / alwidth));
587  1 assertEquals(od.getBoxY(), 0);
588  1 assertEquals(od.getBoxWidth(), boxWidth);
589  1 assertEquals(od.getBoxHeight(), boxHeight);
590   
591    }
592   
593    /**
594    * Test that the box position is set correctly when there are hidden columns
595    * at the end
596    */
 
597  1 toggle @Test(groups = { "Functional" })
598    public void testSetBoxFromViewportHiddenColsAtEnd()
599    {
600  1 int firstHidden = 152;
601  1 int lastHidden = 164;
602  1 hiddenCols.hideColumns(firstHidden, lastHidden);
603   
604    // move viewport before hidden columns
605  1 moveViewport(3, 0);
606  1 assertEquals(od.getBoxX(),
607    Math.round((float) 3 * od.getWidth() / alwidth));
608  1 assertEquals(od.getBoxY(), 0);
609  1 assertEquals(od.getBoxWidth(), boxWidth);
610  1 assertEquals(od.getBoxHeight(), boxHeight);
611   
612    // move viewport to hidden columns
613    // viewport can't actually extend into hidden cols,
614    // so move to the far right edge of the viewport
615  1 moveViewport(firstHidden - viewWidth, 0);
616  1 assertEquals(od.getBoxX(), Math.round(
617    (float) (firstHidden - viewWidth) * od.getWidth() / alwidth));
618  1 assertEquals(od.getBoxY(), 0);
619  1 assertEquals(od.getBoxWidth(), boxWidth);
620  1 assertEquals(od.getBoxHeight(), boxHeight);
621    }
622   
623    /**
624    * Test that the box position is set correctly when there are hidden rows at
625    * the start
626    */
 
627  1 toggle @Test(groups = { "Functional" })
628    public void testSetBoxFromViewportHiddenRowsAtStart()
629    {
630  1 int firstHidden = 0;
631  1 int lastHidden = 20;
632  1 hideSequences(firstHidden, lastHidden);
633   
634    // calculate with visible values
635  1 alheight = vpranges.getVisibleAlignmentHeight();
636  1 alwidth = vpranges.getVisibleAlignmentWidth();
637   
638  1 boxWidth = Math.round(
639    (float) (vpranges.getEndRes() - vpranges.getStartRes() + 1)
640    * od.getWidth() / alwidth);
641  1 boxHeight = Math.round(
642    (float) (vpranges.getEndSeq() - vpranges.getStartSeq() + 1)
643    * od.getSequencesHeight() / alheight);
644   
645    // move viewport to start of alignment:
646    // box moves to below hidden rows, height remains same
647  1 moveViewport(0, 0);
648  1 assertEquals(od.getBoxX(), 0);
649  1 assertEquals(od.getBoxY(), 0);
650  1 assertEquals(od.getBoxWidth(), boxWidth);
651  1 assertEquals(od.getBoxHeight(), boxHeight);
652   
653    // move viewport to end of alignment
654  1 moveViewport(0, 525 - viewHeight - lastHidden - 1);
655  1 assertEquals(od.getBoxX(), 0);
656  1 assertEquals(od.getBoxY(),
657    Math.round((float) (525 - viewHeight - lastHidden - 1)
658    * od.getSequencesHeight() / alheight));
659  1 assertEquals(od.getBoxWidth(), boxWidth);
660  1 assertEquals(od.getBoxHeight(), boxHeight);
661    }
662   
663    /**
664    * Test that the box position is set correctly when there are hidden rows in
665    * the middle
666    */
 
667  1 toggle @Test(groups = { "Functional" })
668    public void testSetBoxFromViewportHiddenRowsInMiddle()
669    {
670  1 int firstHidden = 200;
671  1 int lastHidden = 210;
672  1 hideSequences(firstHidden, lastHidden);
673   
674    // calculate with visible values
675  1 alheight = vpranges.getVisibleAlignmentHeight();
676  1 alwidth = vpranges.getVisibleAlignmentWidth();
677   
678  1 boxWidth = Math.round(
679    (float) (vpranges.getEndRes() - vpranges.getStartRes() + 1)
680    * od.getWidth() / alwidth);
681  1 boxHeight = Math.round(
682    (float) (vpranges.getEndSeq() - vpranges.getStartSeq() + 1)
683    * od.getSequencesHeight() / alheight);
684   
685    // move viewport to start of alignment:
686    // box, height etc as in non-hidden case
687  1 moveViewport(0, 0);
688  1 assertEquals(od.getBoxX(), 0);
689  1 assertEquals(od.getBoxY(), 0);
690  1 assertEquals(od.getBoxWidth(), boxWidth);
691  1 assertEquals(od.getBoxHeight(), boxHeight);
692   
693    // move viewport to straddle hidden rows
694  1 moveViewport(0, 198);
695  1 assertEquals(od.getBoxX(), 0);
696  1 assertEquals(od.getBoxY(),
697    Math.round((float) 198 * od.getSequencesHeight() / alheight));
698  1 assertEquals(od.getBoxWidth(), boxWidth);
699  1 assertEquals(od.getBoxHeight(), boxHeight);
700    }
701   
702    /**
703    * Test that the box position is set correctly when there are hidden rows at
704    * the bottom
705    */
 
706  1 toggle @Test(groups = { "Functional" })
707    public void testSetBoxFromViewportHiddenRowsAtEnd()
708    {
709  1 int firstHidden = 500;
710  1 int lastHidden = 524;
711  1 hideSequences(firstHidden, lastHidden);
712   
713    // calculate with visible values
714  1 alheight = vpranges.getVisibleAlignmentHeight();
715  1 alwidth = vpranges.getVisibleAlignmentWidth();
716   
717  1 boxWidth = Math.round(
718    (float) (vpranges.getEndRes() - vpranges.getStartRes() + 1)
719    * od.getWidth() / alwidth);
720  1 boxHeight = Math.round(
721    (float) (vpranges.getEndSeq() - vpranges.getStartSeq() + 1)
722    * od.getSequencesHeight() / alheight);
723   
724    // move viewport to start of alignment:
725    // box, height etc as in non-hidden case
726  1 moveViewport(0, 0);
727  1 assertEquals(od.getBoxX(), 0);
728  1 assertEquals(od.getBoxY(), 0);
729  1 assertEquals(od.getBoxWidth(), boxWidth);
730  1 assertEquals(od.getBoxHeight(), boxHeight);
731   
732    // move viewport to end of alignment
733    // viewport sits above hidden rows and does not include them
734  1 moveViewport(0, firstHidden - viewHeight - 1);
735  1 assertEquals(od.getBoxX(), 0);
736  1 assertEquals(od.getBoxY(),
737    Math.round((float) (firstHidden - viewHeight - 1)
738    * od.getSequencesHeight() / alheight));
739  1 assertEquals(od.getBoxWidth(), boxWidth);
740  1 assertEquals(od.getBoxHeight(), boxHeight);
741   
742    }
743   
744    /**
745    * Test setting of the box position, when there are hidden rows at the start
746    * of the alignment
747    */
 
748  1 toggle @Test(groups = { "Functional" })
749    public void testFromMouseWithHiddenRowsAtStart()
750    {
751  1 od.updateViewportFromMouse(0, 0, al.getHiddenSequences(), hiddenCols);
752  1 assertEquals(od.getBoxX(), 0);
753  1 assertEquals(od.getBoxY(), 0);
754  1 assertEquals(od.getBoxHeight(), boxHeight);
755  1 assertEquals(od.getBoxWidth(), boxWidth);
756  1 assertEquals(vpranges.getStartRes(), 0);
757  1 assertEquals(vpranges.getStartSeq(), 0);
758   
759    // hide rows at start and check updated box position is correct
760  1 int lastHiddenRow = 30;
761  1 hideSequences(0, lastHiddenRow);
762   
763    // calculate with visible values
764  1 alheight = vpranges.getVisibleAlignmentHeight();
765  1 alwidth = vpranges.getVisibleAlignmentWidth();
766   
767  1 boxWidth = Math.round(
768    (float) (vpranges.getEndRes() - vpranges.getStartRes() + 1)
769    * od.getWidth() / alwidth);
770  1 boxHeight = Math.round(
771    (float) (vpranges.getEndSeq() - vpranges.getStartSeq() + 1)
772    * od.getSequencesHeight() / alheight);
773   
774  1 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
775  1 assertEquals(od.getBoxX(), 0);
776  1 assertEquals(od.getBoxY(), 0);
777  1 assertEquals(od.getBoxWidth(), boxWidth);
778  1 assertEquals(od.getBoxHeight(), boxHeight);
779   
780    // click below hidden rows
781  1 mouseClick(od, 0, 151 + boxHeight / 2);
782  1 assertEquals(od.getBoxX(), 0);
783  1 assertEquals(od.getBoxY(), 151);
784  1 assertEquals(od.getBoxWidth(), boxWidth);
785  1 assertEquals(od.getBoxHeight(), boxHeight);
786    }
787   
788    /**
789    * Test setting of the box position, when there are hidden rows at the middle
790    * of the alignment
791    */
 
792  1 toggle @Test(groups = { "Functional" })
793    public void testFromMouseWithHiddenRowsInMiddle()
794    {
795  1 od.updateViewportFromMouse(0, 0, al.getHiddenSequences(), hiddenCols);
796   
797  1 assertEquals(od.getBoxX(), 0);
798  1 assertEquals(od.getBoxY(), 0);
799  1 assertEquals(od.getBoxWidth(), boxWidth);
800  1 assertEquals(od.getBoxHeight(), boxHeight);
801  1 assertEquals(vpranges.getStartRes(), 0);
802  1 assertEquals(vpranges.getStartSeq(), 0);
803   
804    // hide rows in middle and check updated box position is correct
805    // no changes
806  1 int firstHiddenRow = 50;
807  1 int lastHiddenRow = 54;
808  1 hideSequences(firstHiddenRow, lastHiddenRow);
809   
810    // calculate with visible values
811  1 alheight = vpranges.getVisibleAlignmentHeight();
812  1 alwidth = vpranges.getVisibleAlignmentWidth();
813   
814  1 boxWidth = Math.round(
815    (float) (vpranges.getEndRes() - vpranges.getStartRes() + 1)
816    * od.getWidth() / alwidth);
817  1 boxHeight = Math.round(
818    (float) (vpranges.getEndSeq() - vpranges.getStartSeq() + 1)
819    * od.getSequencesHeight() / alheight);
820   
821  1 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
822   
823  1 assertEquals(od.getBoxX(), 0);
824  1 assertEquals(od.getBoxY(), 0);
825  1 assertEquals(od.getBoxWidth(), boxWidth);
826  1 assertEquals(od.getBoxHeight(), boxHeight);
827   
828    // click above hidden rows, so that box overlaps
829  1 int ypos = 35 + viewHeight / 2; // row value in residues
830  1 mouseClick(od, 0,
831    Math.round((float) ypos * od.getSequencesHeight() / alheight));
832  1 assertEquals(od.getBoxX(), 0);
833  1 assertEquals(od.getBoxY(),
834    Math.round((float) 35 * od.getSequencesHeight() / alheight));
835  1 assertEquals(od.getBoxWidth(), boxWidth);
836  1 assertEquals(od.getBoxHeight(), boxHeight);
837   
838    // click so that box straddles hidden rows
839  1 ypos = 45 + viewHeight / 2; // row value in residues
840  1 mouseClick(od, 0,
841    Math.round((float) ypos * od.getSequencesHeight() / alheight));
842  1 assertEquals(od.getBoxX(), 0);
843  1 assertEquals(od.getBoxY(),
844    Math.round((float) 45 * od.getSequencesHeight() / alheight));
845  1 assertEquals(od.getBoxWidth(), boxWidth);
846  1 assertEquals(od.getBoxHeight(), boxHeight);
847    }
848   
849    /**
850    * Test setting of the box position, when there are hidden rows at the end of
851    * the alignment
852    */
 
853  1 toggle @Test(groups = { "Functional" })
854    public void testFromMouseWithHiddenRowsAtEnd()
855    {
856  1 od.updateViewportFromMouse(0, 0, al.getHiddenSequences(), hiddenCols);
857  1 assertEquals(od.getBoxX(), 0);
858  1 assertEquals(od.getBoxY(), 0);
859  1 assertEquals(od.getBoxWidth(), boxWidth);
860  1 assertEquals(od.getBoxHeight(), boxHeight);
861  1 assertEquals(vpranges.getStartRes(), 0);
862  1 assertEquals(vpranges.getStartSeq(), 0);
863   
864    // hide rows at end and check updated box position is correct
865    // no changes
866  1 int firstHidden = 500;
867  1 int lastHidden = 524;
868  1 hideSequences(firstHidden, lastHidden);
869   
870    // calculate with visible values
871  1 alheight = vpranges.getVisibleAlignmentHeight();
872  1 alwidth = vpranges.getVisibleAlignmentWidth();
873   
874  1 boxWidth = Math.round(
875    (float) (vpranges.getEndRes() - vpranges.getStartRes() + 1)
876    * od.getWidth() / alwidth);
877  1 boxHeight = Math.round(
878    (float) (vpranges.getEndSeq() - vpranges.getStartSeq() + 1)
879    * od.getSequencesHeight() / alheight);
880   
881  1 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
882  1 assertEquals(od.getBoxX(), 0);
883  1 assertEquals(od.getBoxY(), 0);
884  1 assertEquals(od.getBoxWidth(), boxWidth);
885  1 assertEquals(od.getBoxHeight(), boxHeight);
886   
887    // click above hidden rows
888  1 int ypos = 41 + viewHeight / 2; // row 41
889  1 mouseClick(od, 0,
890    Math.round((float) ypos * od.getSequencesHeight() / alheight));
891  1 assertEquals(od.getBoxX(), 0);
892  1 assertEquals(od.getBoxY(),
893    Math.round((float) 41 * od.getSequencesHeight() / alheight));
894  1 assertEquals(od.getBoxWidth(), boxWidth);
895  1 assertEquals(od.getBoxHeight(), boxHeight);
896   
897    // click above hidden rows so box overlaps
898    // boxY, boxHeight remains same
899  1 ypos = 497 + viewHeight / 2; // row 497
900  1 mouseClick(od, 0,
901    Math.round((float) ypos * od.getSequencesHeight() / alheight));
902  1 assertEquals(od.getBoxX(), 0);
903  1 assertEquals(od.getBoxY(), Math
904    .round((float) firstHidden * od.getSequencesHeight() / alheight)
905    - boxHeight);
906  1 assertEquals(od.getBoxWidth(), boxWidth);
907  1 assertEquals(od.getBoxHeight(), boxHeight);
908    }
909   
910    /**
911    * Test the function to determine if a point is in the overview's box or not
912    */
 
913  1 toggle @Test(groups = { "Functional" })
914    public void testPositionInBox()
915    {
916  1 od.updateViewportFromMouse(0, 0, al.getHiddenSequences(), hiddenCols);
917   
918  1 assertFalse(od.isPositionInBox(0, 0));
919  1 assertTrue(od.isPositionInBox(10, 9));
920  1 assertFalse(od.isPositionInBox(0, 9));
921  1 assertFalse(od.isPositionInBox(9, 0));
922  1 assertFalse(od.isPositionInBox(75, 20));
923   
924    // hide columns in the box area
925    // makes absolutely no difference
926  1 hiddenCols.hideColumns(1, 4);
927  1 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
928  1 assertFalse(od.isPositionInBox(0, 0));
929  1 assertTrue(od.isPositionInBox(10, 9));
930  1 assertFalse(od.isPositionInBox(0, 9));
931  1 assertFalse(od.isPositionInBox(9, 0));
932  1 assertFalse(od.isPositionInBox(75, 20));
933   
934    // hide sequences in box area
935    // makes absolutely no difference
936  1 hideSequences(1, 3);
937  1 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
938  1 assertFalse(od.isPositionInBox(0, 0));
939  1 assertTrue(od.isPositionInBox(10, 9));
940  1 assertFalse(od.isPositionInBox(0, 9));
941  1 assertFalse(od.isPositionInBox(9, 0));
942  1 assertFalse(od.isPositionInBox(75, 20));
943    }
944   
945    /**
946    * Test the dragging functionality
947    */
 
948  1 toggle @Test(groups = { "Functional" })
949    public void testDragging()
950    {
951  1 od.updateViewportFromMouse(0, 0, al.getHiddenSequences(), hiddenCols);
952  1 od.setDragPoint(4, 16, al.getHiddenSequences(), hiddenCols);
953  1 od.adjustViewportFromMouse(20, 22, al.getHiddenSequences(), hiddenCols);
954   
955    // updates require an OverviewPanel to exist which it doesn't here
956    // so call setBoxPosition() as it would be called by the AlignmentPanel
957    // normally
958  1 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
959   
960    // corner moves 16 (20-4) right and 6 (22-16) up
961  1 assertEquals(od.getBoxX(), 16);
962  1 assertEquals(od.getBoxY(), 6);
963   
964    // hide columns - makes no difference
965  1 hiddenCols.hideColumns(1, 4);
966  1 od.updateViewportFromMouse(0, 0, al.getHiddenSequences(), hiddenCols);
967  1 od.setDragPoint(4, 16, al.getHiddenSequences(), hiddenCols);
968  1 od.adjustViewportFromMouse(20, 22, al.getHiddenSequences(), hiddenCols);
969  1 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
970   
971    // corner moves 16 (20-4) right and 6 (22-16) up
972  1 assertEquals(od.getBoxX(), 16);
973  1 assertEquals(od.getBoxY(), 6);
974   
975    // hide sequences in box area
976    // makes absolutely no difference
977  1 hideSequences(1, 3);
978  1 od.updateViewportFromMouse(0, 0, al.getHiddenSequences(), hiddenCols);
979  1 od.setDragPoint(4, 16, al.getHiddenSequences(), hiddenCols);
980  1 od.adjustViewportFromMouse(20, 22, al.getHiddenSequences(), hiddenCols);
981  1 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
982   
983    // corner moves 16 (20-4) right and 6 (22-16) up
984  1 assertEquals(od.getBoxX(), 16);
985  1 assertEquals(od.getBoxY(), 6);
986    }
987   
988    /*
989    * Move viewport horizontally: startRes + previous width gives new horizontal extent. Vertical extent stays the same.
990    */
 
991  2 toggle private void moveViewportH(int startRes)
992    {
993  2 vpranges.setViewportStartAndWidth(startRes, viewWidth);
994  2 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
995    }
996   
997    /*
998    * Move viewport vertically: startSeq and endSeq give new vertical extent. Horizontal extent stays the same.
999    */
 
1000  1 toggle private void moveViewportV(int startSeq)
1001    {
1002  1 vpranges.setViewportStartAndHeight(startSeq, viewHeight);
1003  1 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
1004    }
1005   
1006    /*
1007    * Move viewport horizontally and vertically.
1008    */
 
1009  33 toggle private void moveViewport(int startRes, int startSeq)
1010    {
1011  33 vpranges.setViewportStartAndWidth(startRes, viewWidth);
1012  33 vpranges.setViewportStartAndHeight(startSeq, viewHeight);
1013  33 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
1014    }
1015   
1016    /*
1017    * Mouse click as position x,y in overview window
1018    */
 
1019  45 toggle private void mouseClick(OverviewDimensions od, int x, int y)
1020    {
1021  45 od.updateViewportFromMouse(x, y, al.getHiddenSequences(), hiddenCols);
1022   
1023    // updates require an OverviewPanel to exist which it doesn't here
1024    // so call setBoxPosition() as it would be called by the AlignmentPanel
1025    // normally
1026  45 od.setBoxPosition(al.getHiddenSequences(), hiddenCols);
1027    }
1028   
1029    /*
1030    * Test that the box is positioned with the top left corner at xpos, ypos
1031    * and with the original width and height
1032    */
 
1033  8 toggle private void testBoxIsAtClickPoint(int xpos, int ypos)
1034    {
1035  8 mouseClick(od, xpos, ypos);
1036  8 assertEquals(od.getBoxX() + od.getBoxWidth() / 2, xpos);
1037  8 assertEquals(od.getBoxY() + od.getBoxHeight() / 2, ypos);
1038  8 assertEquals(od.getBoxWidth(), boxWidth);
1039  8 assertEquals(od.getBoxHeight(), boxHeight);
1040   
1041    }
1042   
1043    /*
1044    * Hide sequences between start and end
1045    */
 
1046  8 toggle private void hideSequences(int start, int end)
1047    {
1048  8 SequenceI[] allseqs = al.getSequencesArray();
1049  8 SequenceGroup theseSeqs = new SequenceGroup();
1050   
1051  132 for (int i = start; i <= end; i++)
1052    {
1053  124 theseSeqs.addSequence(allseqs[i], false);
1054  124 al.getHiddenSequences().hideSequence(allseqs[i]);
1055    }
1056   
1057  8 hiddenRepSequences.put(allseqs[start], theseSeqs);
1058    }
1059    }