Clover icon

Coverage Report

  1. Project Clover database Tue Mar 10 2026 14:58:44 GMT
  2. Package jalview.viewmodel

File ViewportRanges.java

 

Coverage histogram

../../img/srcFileCovDistChart0.png
0% of files have more coverage

Code metrics

86
180
36
1
804
424
85
0.47
5
36
2.36

Classes

Class Line # Actions
ViewportRanges 32 180 85
0.00%
 

Contributing tests

No tests hitting this source file were found.

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 jalview.datamodel.AlignmentI;
24    import jalview.datamodel.HiddenColumns;
25   
26    /**
27    * Supplies and updates viewport properties relating to position such as: start
28    * and end residues and sequences; ideally will serve hidden columns/rows too.
29    * Intention also to support calculations for positioning, scrolling etc. such
30    * as finding the middle of the viewport, checking for scrolls off screen
31    */
 
32    public class ViewportRanges extends ViewportProperties
33    {
34    public static final String STARTRES = "startres";
35   
36    public static final String ENDRES = "endres";
37   
38    public static final String STARTSEQ = "startseq";
39   
40    public static final String ENDSEQ = "endseq";
41   
42    public static final String STARTRESANDSEQ = "startresandseq";
43   
44    public static final String MOVE_VIEWPORT = "move_viewport";
45   
46    private boolean wrappedMode = false;
47   
48    // start residue of viewport
49    private int startRes;
50   
51    // end residue of viewport
52    private int endRes;
53   
54    // start sequence of viewport
55    private int startSeq;
56   
57    // end sequence of viewport
58    private int endSeq;
59   
60    // alignment
61    private AlignmentI al;
62   
63    /**
64    * Constructor
65    *
66    * @param alignment
67    * the viewport's alignment
68    */
 
69  0 toggle public ViewportRanges(AlignmentI alignment)
70    {
71    // initial values of viewport settings
72  0 this.startRes = 0;
73  0 this.endRes = alignment.getWidth() - 1;
74  0 this.startSeq = 0;
75  0 this.endSeq = alignment.getHeight() - 1;
76  0 this.al = alignment;
77    }
78   
79    /**
80    * Get alignment width in cols, including hidden cols
81    */
 
82  0 toggle public int getAbsoluteAlignmentWidth()
83    {
84  0 return al.getWidth();
85    }
86   
87    /**
88    * Get alignment height in rows, including hidden rows
89    */
 
90  0 toggle public int getAbsoluteAlignmentHeight()
91    {
92  0 return al.getHeight() + al.getHiddenSequences().getSize();
93    }
94   
95    /**
96    * Get alignment width in cols, excluding hidden cols
97    */
 
98  0 toggle public int getVisibleAlignmentWidth()
99    {
100  0 return al.getVisibleWidth();
101    }
102   
103    /**
104    * Get alignment height in rows, excluding hidden rows
105    */
 
106  0 toggle public int getVisibleAlignmentHeight()
107    {
108  0 return al.getHeight();
109    }
110   
111    /**
112    * Set first residue visible in the viewport, and retain the current width.
113    * Fires a property change event.
114    *
115    * @param res
116    * residue position
117    */
 
118  0 toggle public void setStartRes(int res)
119    {
120  0 int width = getViewportWidth();
121  0 setStartEndRes(res, res + width - 1);
122    }
123   
124    /**
125    * Set start and end residues at the same time. This method only fires one
126    * event for the two changes, and should be used in preference to separate
127    * calls to setStartRes and setEndRes.
128    *
129    * @param start
130    * the start residue
131    * @param end
132    * the end residue
133    */
 
134  0 toggle public void setStartEndRes(int start, int end)
135    {
136  0 int[] oldvalues = updateStartEndRes(start, end);
137  0 int oldstartres = oldvalues[0];
138  0 int oldendres = oldvalues[1];
139   
140  0 if (oldstartres == startRes && oldendres == endRes)
141    {
142  0 return; // BH 2019.07.27 standard check for no changes
143    }
144   
145    // "STARTRES" is a misnomer here -- really "STARTORENDRES"
146    // note that this could be "no change" if the range is just being expanded
147  0 changeSupport.firePropertyChange(STARTRES, oldstartres, startRes);
148  0 if (oldstartres == startRes)
149    {
150    // only caught in ViewportRangesTest
151    // No listener cares about this
152    // "ENDRES" is a misnomer here -- really "ENDONLYRES"
153    // BH 2019.07.27 adds end change check
154    // fire only if only the end is changed
155    // event won't be fired if start positions are same
156    // fire an event for the end positions in case they changed
157  0 changeSupport.firePropertyChange(ENDRES, oldendres, endRes);
158    }
159    }
160   
161    /**
162    * Update start and end residue values, adjusting for width constraints if
163    * necessary
164    *
165    * @param start
166    * start residue
167    * @param end
168    * end residue
169    * @return array containing old start and end residue values
170    */
 
171  0 toggle private int[] updateStartEndRes(int start, int end)
172    {
173  0 int oldstartres = this.startRes;
174   
175    /*
176    * if not wrapped, don't leave white space at the right margin
177    */
178  0 int lastColumn = getVisibleAlignmentWidth() - 1;
179  0 if (!wrappedMode && (start > lastColumn))
180    {
181  0 startRes = Math.max(lastColumn, 0);
182    }
183  0 else if (start < 0)
184    {
185  0 startRes = 0;
186    }
187    else
188    {
189  0 startRes = start;
190    }
191   
192  0 int oldendres = this.endRes;
193  0 if (end < 0)
194    {
195  0 endRes = 0;
196    }
197  0 else if (!wrappedMode && (end > lastColumn))
198    {
199  0 endRes = Math.max(lastColumn, 0);
200    }
201    else
202    {
203  0 endRes = end;
204    }
205  0 return new int[] { oldstartres, oldendres };
206    }
207   
208    /**
209    * Set the first sequence visible in the viewport, maintaining the height. If
210    * the viewport would extend past the last sequence, sets the viewport so it
211    * sits at the bottom of the alignment. Fires a property change event.
212    *
213    * @param seq
214    * sequence position
215    */
 
216  0 toggle public void setStartSeq(int seq)
217    {
218  0 int startseq = seq;
219  0 int height = getViewportHeight();
220  0 if (startseq + height - 1 > getVisibleAlignmentHeight() - 1)
221    {
222  0 startseq = getVisibleAlignmentHeight() - height;
223    }
224  0 setStartEndSeq(startseq, startseq + height - 1);
225    }
226   
227    /**
228    * Set start and end sequences at the same time. The viewport height may
229    * change. This method only fires one event for the two changes, and should be
230    * used in preference to separate calls to setStartSeq and setEndSeq.
231    *
232    * @param start
233    * the start sequence
234    * @param end
235    * the end sequence
236    */
 
237  0 toggle public void setStartEndSeq(int start, int end)
238    {
239  0 int[] oldvalues = updateStartEndSeq(start, end);
240  0 int oldstartseq = oldvalues[0];
241  0 int oldendseq = oldvalues[1];
242   
243  0 changeSupport.firePropertyChange(STARTSEQ, oldstartseq, startSeq);
244  0 if (oldstartseq == startSeq)
245    {
246    // event won't be fired if start positions are the same
247    // fire in case the end positions changed
248  0 changeSupport.firePropertyChange(ENDSEQ, oldendseq, endSeq);
249    }
250    }
251   
252    /**
253    * Update start and end sequence values, adjusting for height constraints if
254    * necessary
255    *
256    * @param start
257    * start sequence
258    * @param end
259    * end sequence
260    * @return array containing old start and end sequence values
261    */
 
262  0 toggle private int[] updateStartEndSeq(int start, int end)
263    {
264  0 int oldstartseq = this.startSeq;
265  0 int visibleHeight = getVisibleAlignmentHeight();
266  0 if (start > visibleHeight - 1)
267    {
268  0 startSeq = Math.max(visibleHeight - 1, 0);
269    }
270  0 else if (start < 0)
271    {
272  0 startSeq = 0;
273    }
274    else
275    {
276  0 startSeq = start;
277    }
278   
279  0 int oldendseq = this.endSeq;
280  0 if (end >= visibleHeight)
281    {
282  0 endSeq = Math.max(visibleHeight - 1, 0);
283    }
284  0 else if (end < 0)
285    {
286  0 endSeq = 0;
287    }
288    else
289    {
290  0 endSeq = end;
291    }
292  0 return new int[] { oldstartseq, oldendseq };
293    }
294   
295    /**
296    * Set the last sequence visible in the viewport. Fires a property change
297    * event.
298    *
299    * @param seq
300    * sequence position in the range [0, height)
301    */
 
302  0 toggle public void setEndSeq(int seq)
303    {
304    // BH 2018.04.18 added safety for seq < 0; comment about not being >= height
305  0 setStartEndSeq(Math.max(0, seq + 1 - getViewportHeight()), seq);
306    }
307   
308    /**
309    * Set start residue and start sequence together (fires single event). The
310    * event supplies a pair of old values and a pair of new values: [old start
311    * residue, old start sequence] and [new start residue, new start sequence]
312    *
313    * @param res
314    * the start residue
315    * @param seq
316    * the start sequence
317    */
 
318  0 toggle public void setStartResAndSeq(int res, int seq)
319    {
320  0 int width = getViewportWidth();
321  0 int[] oldresvalues = updateStartEndRes(res, res + width - 1);
322   
323  0 int startseq = seq;
324  0 int height = getViewportHeight();
325  0 if (startseq + height - 1 > getVisibleAlignmentHeight() - 1)
326    {
327  0 startseq = getVisibleAlignmentHeight() - height;
328    }
329  0 int[] oldseqvalues = updateStartEndSeq(startseq, startseq + height - 1);
330   
331  0 int[] old = new int[] { oldresvalues[0], oldseqvalues[0] };
332  0 int[] newresseq = new int[] { startRes, startSeq };
333  0 changeSupport.firePropertyChange(STARTRESANDSEQ, old, newresseq);
334    }
335   
336    /**
337    * Get start residue of viewport
338    */
 
339  0 toggle public int getStartRes()
340    {
341  0 return startRes;
342    }
343   
344    /**
345    * Get end residue of viewport
346    */
 
347  0 toggle public int getEndRes()
348    {
349  0 return endRes;
350    }
351   
352    /**
353    * Get start sequence of viewport
354    */
 
355  0 toggle public int getStartSeq()
356    {
357  0 return startSeq;
358    }
359   
360    /**
361    * Get end sequence of viewport
362    */
 
363  0 toggle public int getEndSeq()
364    {
365  0 return endSeq;
366    }
367   
368    /**
369    * Set viewport width in residues, without changing startRes. Use in
370    * preference to calculating endRes from the width, to avoid out by one
371    * errors! Fires a property change event.
372    *
373    * @param w
374    * width in residues
375    */
 
376  0 toggle public void setViewportWidth(int w)
377    {
378  0 setStartEndRes(startRes, startRes + w - 1);
379    }
380   
381    /**
382    * Set viewport height in residues, without changing startSeq. Use in
383    * preference to calculating endSeq from the height, to avoid out by one
384    * errors! Fires a property change event.
385    *
386    * @param h
387    * height in sequences
388    */
 
389  0 toggle public void setViewportHeight(int h)
390    {
391  0 setStartEndSeq(startSeq, startSeq + h - 1);
392    }
393   
394    /**
395    * Set viewport horizontal start position and width. Use in preference to
396    * calculating endRes from the width, to avoid out by one errors! Fires a
397    * property change event.
398    *
399    * @param start
400    * start residue
401    * @param w
402    * width in residues
403    */
 
404  0 toggle public void setViewportStartAndWidth(int start, int w)
405    {
406  0 int vpstart = Math.max(0, start);
407   
408  0 if (!wrappedMode)
409    {
410    // if not wrapped, don't leave white space at the right margin
411  0 int maxStart = getVisibleAlignmentWidth() - w;
412  0 if (maxStart >= 0)
413    {
414  0 vpstart = Math.min(vpstart, maxStart);
415    }
416   
417    }
418  0 setStartEndRes(vpstart, vpstart + w - 1);
419    }
420   
421    /**
422    * Set viewport vertical start position and height. Use in preference to
423    * calculating endSeq from the height, to avoid out by one errors! Fires a
424    * property change event.
425    *
426    * @param start
427    * start sequence
428    * @param h
429    * height in sequences
430    */
 
431  0 toggle public void setViewportStartAndHeight(int start, int h)
432    {
433  0 int vpstart = Math.max(0, start);
434  0 int maxStart = getVisibleAlignmentHeight() - h;
435  0 if (maxStart > 0)
436    {
437    // can't start higher than vertical extent will allow
438    // (viewport height is less than the full alignment
439    // and we are running off the bottom)
440  0 vpstart = Math.min(vpstart, maxStart);
441    }
442  0 setStartEndSeq(vpstart, vpstart + h - 1);
443    }
444   
445    /**
446    * Get width of viewport in residues
447    *
448    * @return width of viewport
449    */
 
450  0 toggle public int getViewportWidth()
451    {
452  0 return (endRes - startRes + 1);
453    }
454   
455    /**
456    * Get height of viewport in residues
457    *
458    * @return height of viewport
459    */
 
460  0 toggle public int getViewportHeight()
461    {
462  0 return (endSeq - startSeq + 1);
463    }
464   
465    /**
466    * Scroll the viewport range vertically. Fires a property change event.
467    *
468    * @param up
469    * true if scrolling up, false if down
470    *
471    * @return true if the scroll is valid
472    */
 
473  0 toggle public boolean scrollUp(boolean up)
474    {
475    /*
476    * if in unwrapped mode, scroll up or down one sequence row;
477    * if in wrapped mode, scroll by one visible width of columns
478    */
479  0 if (up)
480    {
481  0 if (wrappedMode)
482    {
483  0 pageUp();
484    }
485    else
486    {
487  0 if (startSeq < 1)
488    {
489  0 return false;
490    }
491  0 setStartSeq(startSeq - 1);
492    }
493    }
494    else
495    {
496  0 if (wrappedMode)
497    {
498  0 pageDown();
499    }
500    else
501    {
502  0 if (endSeq >= getVisibleAlignmentHeight() - 1)
503    {
504  0 return false;
505    }
506  0 setStartSeq(startSeq + 1);
507    }
508    }
509  0 return true;
510    }
511   
512    /**
513    * Scroll the viewport range horizontally. Fires a property change event.
514    *
515    * @param right
516    * true if scrolling right, false if left
517    *
518    * @return true if the scroll is valid
519    */
 
520  0 toggle public boolean scrollRight(boolean right)
521    {
522  0 if (!right)
523    {
524  0 if (startRes < 1)
525    {
526  0 return false;
527    }
528   
529  0 setStartRes(startRes - 1);
530    }
531    else
532    {
533  0 if (endRes >= getVisibleAlignmentWidth() - 1)
534    {
535  0 return false;
536    }
537   
538  0 setStartRes(startRes + 1);
539    }
540   
541  0 return true;
542    }
543   
544    /**
545    * Scroll a wrapped alignment so that the specified residue is in the first
546    * repeat of the wrapped view. Fires a property change event. Answers true if
547    * the startRes changed, else false.
548    *
549    * @param res
550    * residue position to scroll to NB visible position not absolute
551    * alignment position
552    * @return
553    */
 
554  0 toggle public boolean scrollToWrappedVisible(int res)
555    {
556  0 int newStartRes = calcWrappedStartResidue(res);
557  0 if (newStartRes == startRes)
558    {
559  0 return false;
560    }
561  0 setStartRes(newStartRes);
562   
563  0 return true;
564    }
565   
566    /**
567    * Calculate wrapped start residue from visible start residue
568    *
569    * @param res
570    * visible start residue
571    * @return left column of panel res will be located in
572    */
 
573  0 toggle private int calcWrappedStartResidue(int res)
574    {
575  0 int oldStartRes = startRes;
576  0 int width = getViewportWidth();
577   
578  0 boolean up = res < oldStartRes;
579  0 int widthsToScroll = Math.abs((res - oldStartRes) / width);
580  0 if (up)
581    {
582  0 widthsToScroll++;
583    }
584   
585  0 int residuesToScroll = width * widthsToScroll;
586  0 int newStartRes = up ? oldStartRes - residuesToScroll
587    : oldStartRes + residuesToScroll;
588  0 if (newStartRes < 0)
589    {
590  0 newStartRes = 0;
591    }
592  0 return newStartRes;
593    }
594   
595    /**
596    * Scroll so that (x,y) is visible. Fires a property change event.
597    *
598    * @param x
599    * x position in alignment (absolute position)
600    * @param y
601    * y position in alignment (absolute position)
602    */
 
603  0 toggle public void scrollToVisible(int x, int y)
604    {
605  0 while (y < startSeq)
606    {
607  0 scrollUp(true);
608    }
609  0 while (y > endSeq)
610    {
611  0 scrollUp(false);
612    }
613   
614  0 HiddenColumns hidden = al.getHiddenColumns();
615  0 while (x < hidden.visibleToAbsoluteColumn(startRes))
616    {
617  0 if (!scrollRight(false))
618    {
619  0 break;
620    }
621    }
622  0 while (x > hidden.visibleToAbsoluteColumn(endRes))
623    {
624  0 if (!scrollRight(true))
625    {
626  0 break;
627    }
628    }
629    }
630   
631    /**
632    * Set the viewport location so that a position is visible
633    *
634    * @param x
635    * column to be visible: absolute position in alignment
636    * @param y
637    * row to be visible: absolute position in alignment
638    */
 
639  0 toggle public boolean setViewportLocation(int x, int y)
640    {
641  0 boolean changedLocation = false;
642   
643    // convert the x,y location to visible coordinates
644  0 int visX = al.getHiddenColumns().absoluteToVisibleColumn(x);
645  0 int visY = al.getHiddenSequences().findIndexWithoutHiddenSeqs(y);
646   
647    // if (vis_x,vis_y) is already visible don't do anything
648  0 if (startRes > visX || visX > endRes
649    || startSeq > visY && visY > endSeq)
650    {
651  0 int[] old = new int[] { startRes, startSeq };
652  0 int[] newresseq;
653  0 if (wrappedMode)
654    {
655  0 int newstartres = calcWrappedStartResidue(visX);
656  0 setStartRes(newstartres);
657  0 newresseq = new int[] { startRes, startSeq };
658    }
659    else
660    {
661    // set the viewport x location to contain vis_x
662  0 int newstartres = visX;
663  0 int width = getViewportWidth();
664  0 if (newstartres + width - 1 > getVisibleAlignmentWidth() - 1)
665    {
666  0 newstartres = getVisibleAlignmentWidth() - width;
667    }
668  0 updateStartEndRes(newstartres, newstartres + width - 1);
669   
670    // set the viewport y location to contain vis_y
671  0 int newstartseq = visY;
672  0 int height = getViewportHeight();
673  0 if (newstartseq + height - 1 > getVisibleAlignmentHeight() - 1)
674    {
675  0 newstartseq = getVisibleAlignmentHeight() - height;
676    }
677  0 updateStartEndSeq(newstartseq, newstartseq + height - 1);
678   
679  0 newresseq = new int[] { startRes, startSeq };
680    }
681  0 changedLocation = true;
682  0 changeSupport.firePropertyChange(MOVE_VIEWPORT, old, newresseq);
683    }
684  0 return changedLocation;
685    }
686   
687    /**
688    * Adjust sequence position for page up. Fires a property change event.
689    */
 
690  0 toggle public void pageUp()
691    {
692  0 if (wrappedMode)
693    {
694  0 setStartRes(Math.max(0, getStartRes() - getViewportWidth()));
695    }
696    else
697    {
698  0 setViewportStartAndHeight(startSeq - (endSeq - startSeq),
699    getViewportHeight());
700    }
701    }
702   
703    /**
704    * Adjust sequence position for page down. Fires a property change event.
705    */
 
706  0 toggle public void pageDown()
707    {
708  0 if (wrappedMode)
709    {
710    /*
711    * if height is more than width (i.e. not all sequences fit on screen),
712    * increase page down to height
713    */
714  0 int newStart = getStartRes()
715    + Math.max(getViewportHeight(), getViewportWidth());
716   
717    /*
718    * don't page down beyond end of alignment, or if not all
719    * sequences fit in the visible height
720    */
721  0 if (newStart < getVisibleAlignmentWidth())
722    {
723  0 setStartRes(newStart);
724    }
725    }
726    else
727    {
728  0 setViewportStartAndHeight(endSeq, getViewportHeight());
729    }
730    }
731   
 
732  0 toggle public void setWrappedMode(boolean wrapped)
733    {
734  0 wrappedMode = wrapped;
735    }
736   
 
737  0 toggle public boolean isWrappedMode()
738    {
739  0 return wrappedMode;
740    }
741   
742    /**
743    * Answers the vertical scroll position (0..) to set, given the visible column
744    * that is at top left.
745    *
746    * <pre>
747    * Example:
748    * viewport width 40 columns (0-39, 40-79, 80-119...)
749    * column 0 returns scroll position 0
750    * columns 1-40 return scroll position 1
751    * columns 41-80 return scroll position 2
752    * etc
753    * </pre>
754    *
755    * @param topLeftColumn
756    * (0..)
757    * @return
758    */
 
759  0 toggle public int getWrappedScrollPosition(final int topLeftColumn)
760    {
761  0 int w = getViewportWidth();
762   
763    /*
764    * visible whole widths
765    */
766  0 int scroll = topLeftColumn / w;
767   
768    /*
769    * add 1 for a part width if there is one
770    */
771  0 scroll += topLeftColumn % w > 0 ? 1 : 0;
772   
773  0 return scroll;
774    }
775   
776    /**
777    * Answers the maximum wrapped vertical scroll value, given the column
778    * position (0..) to show at top left of the visible region.
779    *
780    * @param topLeftColumn
781    * @return
782    */
 
783  0 toggle public int getWrappedMaxScroll(int topLeftColumn)
784    {
785  0 int scrollPosition = getWrappedScrollPosition(topLeftColumn);
786   
787    /*
788    * how many more widths could be drawn after this one?
789    */
790  0 int columnsRemaining = getVisibleAlignmentWidth() - topLeftColumn;
791  0 int width = getViewportWidth();
792  0 int widthsRemaining = columnsRemaining / width
793  0 + (columnsRemaining % width > 0 ? 1 : 0) - 1;
794  0 int maxScroll = scrollPosition + widthsRemaining;
795   
796  0 return maxScroll;
797    }
798   
799   
 
800  0 toggle @Override
801    public String toString() {
802  0 return "[ViewportRange " + startSeq + "-" + endSeq + ", "+ startRes + "-" + endRes + "]";
803    }
804    }
  • Report generated by OpenClover v 4.4.1 on Tue Mar 10 2026 14:59:17 GMT using coverage data from Thu Jan 1 1970 01:00:00 GMT.
  • OpenClover is free and open-source software.