X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fjalview%2Fviewmodel%2FViewportRanges.java;h=6f817bb0cdd8c8a82a93a7b5c43da29686cfcc62;hb=afffa24481a7d3cb65ae41e0948c16a5f490f302;hp=fc163e0a1f43291a46fc0cd4c4f4f679f873a17e;hpb=14985603cea28569e295ddabb219da8034f1c7b2;p=jalview.git diff --git a/src/jalview/viewmodel/ViewportRanges.java b/src/jalview/viewmodel/ViewportRanges.java index fc163e0..6f817bb 100644 --- a/src/jalview/viewmodel/ViewportRanges.java +++ b/src/jalview/viewmodel/ViewportRanges.java @@ -21,16 +21,30 @@ package jalview.viewmodel; import jalview.datamodel.AlignmentI; +import jalview.datamodel.HiddenColumns; /** - * Embryonic class which: Supplies and updates viewport properties relating to - * position such as: start and end residues and sequences; ideally will serve - * hidden columns/rows too. Intention also to support calculations for - * positioning, scrolling etc. such as finding the middle of the viewport, - * checking for scrolls off screen + * Supplies and updates viewport properties relating to position such as: start + * and end residues and sequences; ideally will serve hidden columns/rows too. + * Intention also to support calculations for positioning, scrolling etc. such + * as finding the middle of the viewport, checking for scrolls off screen */ public class ViewportRanges extends ViewportProperties { + public static final String STARTRES = "startres"; + + public static final String ENDRES = "endres"; + + public static final String STARTSEQ = "startseq"; + + public static final String ENDSEQ = "endseq"; + + public static final String STARTRESANDSEQ = "startresandseq"; + + public static final String MOVE_VIEWPORT = "move_viewport"; + + private boolean wrappedMode = false; + // start residue of viewport private int startRes; @@ -83,7 +97,7 @@ public class ViewportRanges extends ViewportProperties */ public int getVisibleAlignmentWidth() { - return al.getWidth() - al.getHiddenColumns().getSize(); + return al.getVisibleWidth(); } /** @@ -95,79 +109,216 @@ public class ViewportRanges extends ViewportProperties } /** - * Set first residue visible in the viewport + * Set first residue visible in the viewport, and retain the current width. + * Fires a property change event. * * @param res * residue position */ public void setStartRes(int res) { - if (res > al.getWidth() - 1) - { - res = al.getWidth() - 1; - } - else if (res < 0) + int width = getViewportWidth(); + setStartEndRes(res, res + width - 1); + } + + /** + * Set start and end residues at the same time. This method only fires one + * event for the two changes, and should be used in preference to separate + * calls to setStartRes and setEndRes. + * + * @param start + * the start residue + * @param end + * the end residue + */ + public void setStartEndRes(int start, int end) + { + int[] oldvalues = updateStartEndRes(start, end); + int oldstartres = oldvalues[0]; + int oldendres = oldvalues[1]; + + changeSupport.firePropertyChange(STARTRES, oldstartres, startRes); + if (oldstartres == startRes) { - res = 0; + // event won't be fired if start positions are same + // fire an event for the end positions in case they changed + changeSupport.firePropertyChange(ENDRES, oldendres, endRes); } - this.startRes = res; } /** - * Set last residue visible in the viewport + * Update start and end residue values, adjusting for width constraints if + * necessary * - * @param res - * residue position + * @param start + * start residue + * @param end + * end residue + * @return array containing old start and end residue values */ - public void setEndRes(int res) + private int[] updateStartEndRes(int start, int end) { - if (res >= al.getWidth()) + int oldstartres = this.startRes; + + /* + * if not wrapped, don't leave white space at the right margin + */ + int lastColumn = getVisibleAlignmentWidth() - 1; + if (!wrappedMode && (start > lastColumn)) + { + startRes = Math.max(lastColumn, 0); + } + else if (start < 0) + { + startRes = 0; + } + else + { + startRes = start; + } + + int oldendres = this.endRes; + if (end < 0) { - res = al.getWidth() - 1; + endRes = 0; } - else if (res < 0) + else if (!wrappedMode && (end > lastColumn)) { - res = 0; + endRes = Math.max(lastColumn, 0); } - this.endRes = res; + else + { + endRes = end; + } + return new int[] { oldstartres, oldendres }; } /** - * Set the first sequence visible in the viewport + * Set the first sequence visible in the viewport, maintaining the height. If + * the viewport would extend past the last sequence, sets the viewport so it + * sits at the bottom of the alignment. Fires a property change event. * * @param seq * sequence position */ public void setStartSeq(int seq) { - if (seq > al.getHeight() - 1) + int startseq = seq; + int height = getViewportHeight(); + if (startseq + height - 1 > getVisibleAlignmentHeight() - 1) + { + startseq = getVisibleAlignmentHeight() - height; + } + setStartEndSeq(startseq, startseq + height - 1); + } + + /** + * Set start and end sequences at the same time. The viewport height may + * change. This method only fires one event for the two changes, and should be + * used in preference to separate calls to setStartSeq and setEndSeq. + * + * @param start + * the start sequence + * @param end + * the end sequence + */ + public void setStartEndSeq(int start, int end) + { + int[] oldvalues = updateStartEndSeq(start, end); + int oldstartseq = oldvalues[0]; + int oldendseq = oldvalues[1]; + + changeSupport.firePropertyChange(STARTSEQ, oldstartseq, startSeq); + if (oldstartseq == startSeq) { - seq = al.getHeight() - 1; + // event won't be fired if start positions are the same + // fire in case the end positions changed + changeSupport.firePropertyChange(ENDSEQ, oldendseq, endSeq); } - else if (seq < 0) + } + + /** + * Update start and end sequence values, adjusting for height constraints if + * necessary + * + * @param start + * start sequence + * @param end + * end sequence + * @return array containing old start and end sequence values + */ + private int[] updateStartEndSeq(int start, int end) + { + int oldstartseq = this.startSeq; + int visibleHeight = getVisibleAlignmentHeight(); + if (start > visibleHeight - 1) { - seq = 0; + startSeq = Math.max(visibleHeight - 1, 0); } - this.startSeq = seq; + else if (start < 0) + { + startSeq = 0; + } + else + { + startSeq = start; + } + + int oldendseq = this.endSeq; + if (end >= visibleHeight) + { + endSeq = Math.max(visibleHeight - 1, 0); + } + else if (end < 0) + { + endSeq = 0; + } + else + { + endSeq = end; + } + return new int[] { oldstartseq, oldendseq }; } /** - * Set the last sequence visible in the viewport + * Set the last sequence visible in the viewport. Fires a property change + * event. * * @param seq * sequence position */ public void setEndSeq(int seq) { - if (seq >= al.getHeight()) - { - seq = al.getHeight() - 1; - } - else if (seq < 0) + int height = getViewportHeight(); + setStartEndSeq(seq - height + 1, seq); + } + + /** + * Set start residue and start sequence together (fires single event). The + * event supplies a pair of old values and a pair of new values: [old start + * residue, old start sequence] and [new start residue, new start sequence] + * + * @param res + * the start residue + * @param seq + * the start sequence + */ + public void setStartResAndSeq(int res, int seq) + { + int width = getViewportWidth(); + int[] oldresvalues = updateStartEndRes(res, res + width - 1); + + int startseq = seq; + int height = getViewportHeight(); + if (startseq + height - 1 > getVisibleAlignmentHeight() - 1) { - seq = 0; + startseq = getVisibleAlignmentHeight() - height; } - this.endSeq = seq; + int[] oldseqvalues = updateStartEndSeq(startseq, startseq + height - 1); + + int[] old = new int[] { oldresvalues[0], oldseqvalues[0] }; + int[] newresseq = new int[] { startRes, startSeq }; + changeSupport.firePropertyChange(STARTRESANDSEQ, old, newresseq); } /** @@ -201,4 +352,444 @@ public class ViewportRanges extends ViewportProperties { return endSeq; } + + /** + * Set viewport width in residues, without changing startRes. Use in + * preference to calculating endRes from the width, to avoid out by one + * errors! Fires a property change event. + * + * @param w + * width in residues + */ + public void setViewportWidth(int w) + { + setStartEndRes(startRes, startRes + w - 1); + } + + /** + * Set viewport height in residues, without changing startSeq. Use in + * preference to calculating endSeq from the height, to avoid out by one + * errors! Fires a property change event. + * + * @param h + * height in sequences + */ + public void setViewportHeight(int h) + { + setStartEndSeq(startSeq, startSeq + h - 1); + } + + /** + * Set viewport horizontal start position and width. Use in preference to + * calculating endRes from the width, to avoid out by one errors! Fires a + * property change event. + * + * @param start + * start residue + * @param w + * width in residues + */ + public void setViewportStartAndWidth(int start, int w) + { + int vpstart = start; + if (vpstart < 0) + { + vpstart = 0; + } + + /* + * if not wrapped, don't leave white space at the right margin + */ + if (!wrappedMode) + { + if ((w <= getVisibleAlignmentWidth()) + && (vpstart + w - 1 > getVisibleAlignmentWidth() - 1)) + { + vpstart = getVisibleAlignmentWidth() - w; + } + + } + setStartEndRes(vpstart, vpstart + w - 1); + } + + /** + * Set viewport vertical start position and height. Use in preference to + * calculating endSeq from the height, to avoid out by one errors! Fires a + * property change event. + * + * @param start + * start sequence + * @param h + * height in sequences + */ + public void setViewportStartAndHeight(int start, int h) + { + int vpstart = start; + if (vpstart < 0) + { + vpstart = 0; + } + else if ((h <= getVisibleAlignmentHeight()) + && (vpstart + h - 1 > getVisibleAlignmentHeight() - 1)) + // viewport height is less than the full alignment and we are running off + // the bottom + { + vpstart = getVisibleAlignmentHeight() - h; + } + setStartEndSeq(vpstart, vpstart + h - 1); + } + + /** + * Get width of viewport in residues + * + * @return width of viewport + */ + public int getViewportWidth() + { + return (endRes - startRes + 1); + } + + /** + * Get height of viewport in residues + * + * @return height of viewport + */ + public int getViewportHeight() + { + return (endSeq - startSeq + 1); + } + + /** + * Scroll the viewport range vertically. Fires a property change event. + * + * @param up + * true if scrolling up, false if down + * + * @return true if the scroll is valid + */ + public boolean scrollUp(boolean up) + { + /* + * if in unwrapped mode, scroll up or down one sequence row; + * if in wrapped mode, scroll by one visible width of columns + */ + if (up) + { + if (wrappedMode) + { + pageUp(); + } + else + { + if (startSeq < 1) + { + return false; + } + setStartSeq(startSeq - 1); + } + } + else + { + if (wrappedMode) + { + pageDown(); + } + else + { + if (endSeq >= getVisibleAlignmentHeight() - 1) + { + return false; + } + setStartSeq(startSeq + 1); + } + } + return true; + } + + /** + * Scroll the viewport range horizontally. Fires a property change event. + * + * @param right + * true if scrolling right, false if left + * + * @return true if the scroll is valid + */ + public boolean scrollRight(boolean right) + { + if (!right) + { + if (startRes < 1) + { + return false; + } + + setStartRes(startRes - 1); + } + else + { + if (endRes >= getVisibleAlignmentWidth() - 1) + { + return false; + } + + setStartRes(startRes + 1); + } + + return true; + } + + /** + * Scroll a wrapped alignment so that the specified residue is in the first + * repeat of the wrapped view. Fires a property change event. Answers true if + * the startRes changed, else false. + * + * @param res + * residue position to scroll to NB visible position not absolute + * alignment position + * @return + */ + public boolean scrollToWrappedVisible(int res) + { + int newStartRes = calcWrappedStartResidue(res); + if (newStartRes == startRes) + { + return false; + } + setStartRes(newStartRes); + + return true; + } + + /** + * Calculate wrapped start residue from visible start residue + * + * @param res + * visible start residue + * @return left column of panel res will be located in + */ + private int calcWrappedStartResidue(int res) + { + int oldStartRes = startRes; + int width = getViewportWidth(); + + boolean up = res < oldStartRes; + int widthsToScroll = Math.abs((res - oldStartRes) / width); + if (up) + { + widthsToScroll++; + } + + int residuesToScroll = width * widthsToScroll; + int newStartRes = up ? oldStartRes - residuesToScroll : oldStartRes + + residuesToScroll; + if (newStartRes < 0) + { + newStartRes = 0; + } + return newStartRes; + } + + /** + * Scroll so that (x,y) is visible. Fires a property change event. + * + * @param x + * x position in alignment (absolute position) + * @param y + * y position in alignment (absolute position) + */ + public void scrollToVisible(int x, int y) + { + while (y < startSeq) + { + scrollUp(true); + } + while (y > endSeq) + { + scrollUp(false); + } + + HiddenColumns hidden = al.getHiddenColumns(); + while (x < hidden.visibleToAbsoluteColumn(startRes)) + { + if (!scrollRight(false)) + { + break; + } + } + while (x > hidden.visibleToAbsoluteColumn(endRes)) + { + if (!scrollRight(true)) + { + break; + } + } + } + + /** + * Set the viewport location so that a position is visible + * + * @param x + * column to be visible: absolute position in alignment + * @param y + * row to be visible: absolute position in alignment + */ + public boolean setViewportLocation(int x, int y) + { + boolean changedLocation = false; + + // convert the x,y location to visible coordinates + int visX = al.getHiddenColumns().absoluteToVisibleColumn(x); + int visY = al.getHiddenSequences().findIndexWithoutHiddenSeqs(y); + + // if (vis_x,vis_y) is already visible don't do anything + if (startRes > visX || visX > endRes + || startSeq > visY && visY > endSeq) + { + int[] old = new int[] { startRes, startSeq }; + int[] newresseq; + if (wrappedMode) + { + int newstartres = calcWrappedStartResidue(visX); + setStartRes(newstartres); + newresseq = new int[] { startRes, startSeq }; + } + else + { + // set the viewport x location to contain vis_x + int newstartres = visX; + int width = getViewportWidth(); + if (newstartres + width - 1 > getVisibleAlignmentWidth() - 1) + { + newstartres = getVisibleAlignmentWidth() - width; + } + updateStartEndRes(newstartres, newstartres + width - 1); + + // set the viewport y location to contain vis_y + int newstartseq = visY; + int height = getViewportHeight(); + if (newstartseq + height - 1 > getVisibleAlignmentHeight() - 1) + { + newstartseq = getVisibleAlignmentHeight() - height; + } + updateStartEndSeq(newstartseq, newstartseq + height - 1); + + newresseq = new int[] { startRes, startSeq }; + } + changedLocation = true; + changeSupport.firePropertyChange(MOVE_VIEWPORT, old, newresseq); + } + return changedLocation; + } + + /** + * Adjust sequence position for page up. Fires a property change event. + */ + public void pageUp() + { + if (wrappedMode) + { + setStartRes(Math.max(0, getStartRes() - getViewportWidth())); + } + else + { + setViewportStartAndHeight(startSeq - (endSeq - startSeq), + getViewportHeight()); + } + } + + /** + * Adjust sequence position for page down. Fires a property change event. + */ + public void pageDown() + { + if (wrappedMode) + { + /* + * if height is more than width (i.e. not all sequences fit on screen), + * increase page down to height + */ + int newStart = getStartRes() + + Math.max(getViewportHeight(), getViewportWidth()); + + /* + * don't page down beyond end of alignment, or if not all + * sequences fit in the visible height + */ + if (newStart < getVisibleAlignmentWidth()) + { + setStartRes(newStart); + } + } + else + { + setViewportStartAndHeight(endSeq, getViewportHeight()); + } + } + + public void setWrappedMode(boolean wrapped) + { + wrappedMode = wrapped; + } + + public boolean isWrappedMode() + { + return wrappedMode; + } + + /** + * Answers the vertical scroll position (0..) to set, given the visible column + * that is at top left. + * + *
+ * Example: + * viewport width 40 columns (0-39, 40-79, 80-119...) + * column 0 returns scroll position 0 + * columns 1-40 return scroll position 1 + * columns 41-80 return scroll position 2 + * etc + *+ * + * @param topLeftColumn + * (0..) + * @return + */ + public int getWrappedScrollPosition(final int topLeftColumn) + { + int w = getViewportWidth(); + + /* + * visible whole widths + */ + int scroll = topLeftColumn / w; + + /* + * add 1 for a part width if there is one + */ + scroll += topLeftColumn % w > 0 ? 1 : 0; + + return scroll; + } + + /** + * Answers the maximum wrapped vertical scroll value, given the column + * position (0..) to show at top left of the visible region. + * + * @param topLeftColumn + * @return + */ + public int getWrappedMaxScroll(int topLeftColumn) + { + int scrollPosition = getWrappedScrollPosition(topLeftColumn); + + /* + * how many more widths could be drawn after this one? + */ + int columnsRemaining = getVisibleAlignmentWidth() - topLeftColumn; + int width = getViewportWidth(); + int widthsRemaining = columnsRemaining / width + + (columnsRemaining % width > 0 ? 1 : 0) - 1; + int maxScroll = scrollPosition + widthsRemaining; + + return maxScroll; + } }