src/jalview/viewmodel/ViewportRanges.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.viewmodel;
  22
  23 import jalview.datamodel.AlignmentI;
  24 import jalview.datamodel.HiddenColumns;
  25
  26 /**
  27  * Slightly less embryonic class which: Supplies and updates viewport properties
  28  * relating to position such as: start and end residues and sequences; ideally
  29  * will serve hidden columns/rows too. Intention also to support calculations
  30  * for positioning, scrolling etc. such as finding the middle of the viewport,
  31  * checking for scrolls off screen
  32  */
  33 public class ViewportRanges extends ViewportProperties
  34 {
  35   public static final String STARTRES = "startres";
  36
  37   public static final String ENDRES = "endres";
  38
  39   public static final String STARTSEQ = "startseq";
  40
  41   public static final String ENDSEQ = "endseq";
  42
  43   private boolean wrappedMode = false;
  44
  45   // start residue of viewport
  46   private int startRes;
  47
  48   // end residue of viewport
  49   private int endRes;
  50
  51   // start sequence of viewport
  52   private int startSeq;
  53
  54   // end sequence of viewport
  55   private int endSeq;
  56
  57   // alignment
  58   private AlignmentI al;
  59
  60   /**
  61    * Constructor
  62    *
  63    * @param alignment
  64    *          the viewport's alignment
  65    */
  66   public ViewportRanges(AlignmentI alignment)
  67   {
  68     // initial values of viewport settings
  69     this.startRes = 0;
  70     this.endRes = alignment.getWidth() - 1;
  71     this.startSeq = 0;
  72     this.endSeq = alignment.getHeight() - 1;
  73     this.al = alignment;
  74   }
  75
  76   /**
  77    * Get alignment width in cols, including hidden cols
  78    */
  79   public int getAbsoluteAlignmentWidth()
  80   {
  81     return al.getWidth();
  82   }
  83
  84   /**
  85    * Get alignment height in rows, including hidden rows
  86    */
  87   public int getAbsoluteAlignmentHeight()
  88   {
  89     return al.getHeight() + al.getHiddenSequences().getSize();
  90   }
  91
  92   /**
  93    * Get alignment width in cols, excluding hidden cols
  94    */
  95   public int getVisibleAlignmentWidth()
  96   {
  97     return al.getWidth() - al.getHiddenColumns().getSize();
  98   }
  99
 100   /**
 101    * Get alignment height in rows, excluding hidden rows
 102    */
 103   public int getVisibleAlignmentHeight()
 104   {
 105     return al.getHeight();
 106   }
 107
 108   /**
 109    * Set first residue visible in the viewport, and retain the current width.
 110    * Fires a property change event.
 111    *
 112    * @param res
 113    *          residue position
 114    */
 115   public void setStartRes(int res)
 116   {
 117     int width = getViewportWidth();
 118     setStartEndRes(res, res + width - 1);
 119   }
 120
 121   /**
 122    * Set start and end residues at the same time. This method only fires one
 123    * event for the two changes, and should be used in preference to separate
 124    * calls to setStartRes and setEndRes.
 125    *
 126    * @param start
 127    *          the start residue
 128    * @param end
 129    *          the end residue
 130    */
 131   public void setStartEndRes(int start, int end)
 132   {
 133     int oldstartres = this.startRes;
 134
 135     /*
 136      * if not wrapped, don't leave white space at the right margin
 137      */
 138     if (!wrappedMode && (start > getVisibleAlignmentWidth() - 1))
 139     {
 140       startRes = Math.max(getVisibleAlignmentWidth() - 1, 0);
 141     }
 142     else if (start < 0)
 143     {
 144       startRes = 0;
 145     }
 146     else
 147     {
 148       startRes = start;
 149     }
 150
 151     int oldendres = this.endRes;
 152     if (end < 0)
 153     {
 154       endRes = 0;
 155     }
 156     else if (!wrappedMode && (end > getVisibleAlignmentWidth() - 1))
 157     {
 158       endRes = Math.max(getVisibleAlignmentWidth() - 1, 0);
 159     }
 160     else
 161     {
 162       endRes = end;
 163     }
 164
 165     changeSupport.firePropertyChange(STARTRES, oldstartres, startRes);
 166     if (oldstartres == startRes)
 167     {
 168       // event won't be fired if start positions are same
 169       // fire an event for the end positions in case they changed
 170       changeSupport.firePropertyChange(ENDRES, oldendres, endRes);
 171     }
 172   }
 173
 174   /**
 175    * Set last residue visible in the viewport. Fires a property change event.
 176    *
 177    * @param res
 178    *          residue position
 179    */
 180   public void setEndRes(int res)
 181   {
 182     int startres = res;
 183     int width = getViewportWidth();
 184
 185     /*
 186      * if not wrapped, don't leave white space at the right margin
 187      */
 188     if (!wrappedMode)
 189     {
 190       if (startres + width - 1 > getVisibleAlignmentWidth() - 1)
 191       {
 192         startres = getVisibleAlignmentWidth() - width;
 193       }
 194     }
 195     setStartEndRes(startres - width + 1, startres);
 196   }
 197
 198   /**
 199    * Set the first sequence visible in the viewport, maintaining the height. If
 200    * the viewport would extend past the last sequence, sets the viewport so it
 201    * sits at the bottom of the alignment. Fires a property change event.
 202    *
 203    * @param seq
 204    *          sequence position
 205    */
 206   public void setStartSeq(int seq)
 207   {
 208     int startseq = seq;
 209     int height = getViewportHeight();
 210     if (startseq + height - 1 > getVisibleAlignmentHeight() - 1)
 211     {
 212       startseq = getVisibleAlignmentHeight() - height;
 213     }
 214     setStartEndSeq(startseq, startseq + height - 1);
 215   }
 216
 217   /**
 218    * Set start and end sequences at the same time. The viewport height may
 219    * change. This method only fires one event for the two changes, and should be
 220    * used in preference to separate calls to setStartSeq and setEndSeq.
 221    *
 222    * @param start
 223    *          the start sequence
 224    * @param end
 225    *          the end sequence
 226    */
 227   public void setStartEndSeq(int start, int end)
 228   {
 229     int oldstartseq = this.startSeq;
 230     int visibleHeight = getVisibleAlignmentHeight();
 231     if (start > visibleHeight - 1)
 232     {
 233       startSeq = Math.max(visibleHeight - 1, 0);
 234     }
 235     else if (start < 0)
 236     {
 237       startSeq = 0;
 238     }
 239     else
 240     {
 241       startSeq = start;
 242     }
 243
 244     int oldendseq = this.endSeq;
 245     if (end >= visibleHeight)
 246     {
 247       endSeq = Math.max(visibleHeight - 1, 0);
 248     }
 249     else if (end < 0)
 250     {
 251       endSeq = 0;
 252     }
 253     else
 254     {
 255       endSeq = end;
 256     }
 257
 258     changeSupport.firePropertyChange(STARTSEQ, oldstartseq, startSeq);
 259     if (oldstartseq == startSeq)
 260     {
 261       // event won't be fired if start positions are the same
 262       // fire in case the end positions changed
 263       changeSupport.firePropertyChange(ENDSEQ, oldendseq, endSeq);
 264     }
 265   }
 266
 267   /**
 268    * Set the last sequence visible in the viewport. Fires a property change
 269    * event.
 270    *
 271    * @param seq
 272    *          sequence position
 273    */
 274   public void setEndSeq(int seq)
 275   {
 276     int height = getViewportHeight();
 277     setStartEndSeq(seq - height + 1, seq);
 278   }
 279
 280   /**
 281    * Get start residue of viewport
 282    */
 283   public int getStartRes()
 284   {
 285     return startRes;
 286   }
 287
 288   /**
 289    * Get end residue of viewport
 290    */
 291   public int getEndRes()
 292   {
 293     return endRes;
 294   }
 295
 296   /**
 297    * Get start sequence of viewport
 298    */
 299   public int getStartSeq()
 300   {
 301     return startSeq;
 302   }
 303
 304   /**
 305    * Get end sequence of viewport
 306    */
 307   public int getEndSeq()
 308   {
 309     return endSeq;
 310   }
 311
 312   /**
 313    * Set viewport width in residues, without changing startRes. Use in
 314    * preference to calculating endRes from the width, to avoid out by one
 315    * errors! Fires a property change event.
 316    *
 317    * @param w
 318    *          width in residues
 319    */
 320   public void setViewportWidth(int w)
 321   {
 322     setStartEndRes(startRes, startRes + w - 1);
 323   }
 324
 325   /**
 326    * Set viewport height in residues, without changing startSeq. Use in
 327    * preference to calculating endSeq from the height, to avoid out by one
 328    * errors! Fires a property change event.
 329    *
 330    * @param h
 331    *          height in sequences
 332    */
 333   public void setViewportHeight(int h)
 334   {
 335     setStartEndSeq(startSeq, startSeq + h - 1);
 336   }
 337
 338   /**
 339    * Set viewport horizontal start position and width. Use in preference to
 340    * calculating endRes from the width, to avoid out by one errors! Fires a
 341    * property change event.
 342    *
 343    * @param start
 344    *          start residue
 345    * @param w
 346    *          width in residues
 347    */
 348   public void setViewportStartAndWidth(int start, int w)
 349   {
 350     int vpstart = start;
 351     if (vpstart < 0)
 352     {
 353       vpstart = 0;
 354     }
 355
 356     /*
 357      * if not wrapped, don't leave white space at the right margin
 358      */
 359     if (!wrappedMode)
 360     {
 361       if ((w <= getVisibleAlignmentWidth())
 362               && (vpstart + w - 1 > getVisibleAlignmentWidth() - 1))
 363       {
 364         vpstart = getVisibleAlignmentWidth() - w;
 365       }
 366
 367     }
 368     setStartEndRes(vpstart, vpstart + w - 1);
 369   }
 370
 371   /**
 372    * Set viewport vertical start position and height. Use in preference to
 373    * calculating endSeq from the height, to avoid out by one errors! Fires a
 374    * property change event.
 375    *
 376    * @param start
 377    *          start sequence
 378    * @param h
 379    *          height in sequences
 380    */
 381   public void setViewportStartAndHeight(int start, int h)
 382   {
 383     int vpstart = start;
 384     if (vpstart < 0)
 385     {
 386       vpstart = 0;
 387     }
 388     else if ((h <= getVisibleAlignmentHeight())
 389             && (vpstart + h - 1 > getVisibleAlignmentHeight() - 1))
 390     // viewport height is less than the full alignment and we are running off
 391     // the bottom
 392     {
 393       vpstart = getVisibleAlignmentHeight() - h;
 394     }
 395     setStartEndSeq(vpstart, vpstart + h - 1);
 396   }
 397
 398   /**
 399    * Get width of viewport in residues
 400    *
 401    * @return width of viewport
 402    */
 403   public int getViewportWidth()
 404   {
 405     return (endRes - startRes + 1);
 406   }
 407
 408   /**
 409    * Get height of viewport in residues
 410    *
 411    * @return height of viewport
 412    */
 413   public int getViewportHeight()
 414   {
 415     return (endSeq - startSeq + 1);
 416   }
 417
 418   /**
 419    * Scroll the viewport range vertically. Fires a property change event.
 420    *
 421    * @param up
 422    *          true if scrolling up, false if down
 423    *
 424    * @return true if the scroll is valid
 425    */
 426   public boolean scrollUp(boolean up)
 427   {
 428     if (up)
 429     {
 430       if (startSeq < 1)
 431       {
 432         return false;
 433       }
 434
 435       setStartSeq(startSeq - 1);
 436     }
 437     else
 438     {
 439       if (endSeq >= getVisibleAlignmentHeight() - 1)
 440       {
 441         return false;
 442       }
 443
 444       setStartSeq(startSeq + 1);
 445     }
 446     return true;
 447   }
 448
 449   /**
 450    * Scroll the viewport range horizontally. Fires a property change event.
 451    *
 452    * @param right
 453    *          true if scrolling right, false if left
 454    *
 455    * @return true if the scroll is valid
 456    */
 457   public boolean scrollRight(boolean right)
 458   {
 459     if (!right)
 460     {
 461       if (startRes < 1)
 462       {
 463         return false;
 464       }
 465
 466       setStartRes(startRes - 1);
 467     }
 468     else
 469     {
 470       if (endRes >= getVisibleAlignmentWidth() - 1)
 471       {
 472         return false;
 473       }
 474
 475       setStartRes(startRes + 1);
 476     }
 477
 478     return true;
 479   }
 480
 481   /**
 482    * Scroll a wrapped alignment so that the specified residue is visible. Fires
 483    * a property change event.
 484    *
 485    * @param res
 486    *          residue position to scroll to
 487    */
 488   public void scrollToWrappedVisible(int res)
 489   {
 490     // get the start residue of the wrapped row which res is in
 491     // and set that as our start residue
 492     int width = getViewportWidth();
 493     setStartRes((res / width) * width);
 494   }
 495
 496   /**
 497    * Scroll so that (x,y) is visible. Fires a property change event.
 498    *
 499    * @param x
 500    *          x position in alignment
 501    * @param y
 502    *          y position in alignment
 503    */
 504   public void scrollToVisible(int x, int y)
 505   {
 506     while (y < startSeq)
 507     {
 508       scrollUp(true);
 509     }
 510     while (y > endSeq)
 511     {
 512       scrollUp(false);
 513     }
 514
 515     HiddenColumns hidden = al.getHiddenColumns();
 516     while (x < hidden.adjustForHiddenColumns(startRes))
 517     {
 518       if (!scrollRight(false))
 519       {
 520         break;
 521       }
 522     }
 523     while (x > hidden.adjustForHiddenColumns(endRes))
 524     {
 525       if (!scrollRight(true))
 526       {
 527         break;
 528       }
 529     }
 530   }
 531
 532   /**
 533    * Adjust sequence position for page up. Fires a property change event.
 534    */
 535   public void pageUp()
 536   {
 537     if (wrappedMode)
 538     {
 539       setStartRes(Math.max(0, getStartRes() - getViewportWidth()));
 540     }
 541     else
 542     {
 543       setViewportStartAndHeight(startSeq - (endSeq - startSeq),
 544               getViewportHeight());
 545     }
 546   }
 547
 548   /**
 549    * Adjust sequence position for page down. Fires a property change event.
 550    */
 551   public void pageDown()
 552   {
 553     if (wrappedMode)
 554     {
 555       /*
 556        * if height is more than width (i.e. not all sequences fit on screen),
 557        * increase page down to height
 558        */
 559       int newStart = getStartRes()
 560               + Math.max(getViewportHeight(), getViewportWidth());
 561
 562       /*
 563        * don't page down beyond end of alignment, or if not all
 564        * sequences fit in the visible height
 565        */
 566       if (newStart < getVisibleAlignmentWidth())
 567       {
 568         setStartRes(newStart);
 569       }
 570     }
 571     else
 572     {
 573       setViewportStartAndHeight(endSeq, getViewportHeight());
 574     }
 575   }
 576
 577   public void setWrappedMode(boolean wrapped)
 578   {
 579     wrappedMode = wrapped;
 580   }
 581
 582   /**
 583    * Answers the vertical scroll position (0..) to set, given the visible column
 584    * that is at top left. Note that if called with the total visible width of
 585    * the alignment, this gives the maximum cursor scroll value.
 586    *
 587    * <pre>
 588    * Example:
 589    *    viewport width 40 columns (0-39, 40-79, 80-119...)
 590    *    column 0 returns scroll position 0
 591    *    columns 0-40 return scroll position 1
 592    *    columns 41-80 return scroll position 2
 593    *    etc
 594    * </pre>
 595    *
 596    * @param topLeftColumn
 597    *          (0..)
 598    * @return
 599    */
 600   public int getWrappedScrollPosition(final int topLeftColumn)
 601   {
 602     int w = getViewportWidth();
 603
 604     /*
 605      * visible whole widths
 606      */
 607     int scroll = topLeftColumn / w;
 608     scroll += topLeftColumn % w > 0 ? 1 : 0;
 609
 610     return scroll;
 611   }
 612 }