- * Preference is obviously given to reusing cells whenever possible, to keep
- * performance costs down.
- */
- public abstract I createCell();
-
- /**
- * This enables skin subclasses to provide a custom VirtualFlow implementation,
- * rather than have VirtualContainerBase instantiate the default instance.
- */
- protected VirtualPageFlow createVirtualFlow() {
- return new VirtualPageFlow<>();
- }
-
- /**
- * Returns the total number of items in this container, including those
- * that are currently hidden because they are out of view.
- */
- public abstract int getPageCount();
-
- protected abstract void updatePageCount();
-
- double getMaxCellWidth(int rowsToCount) {
- return snappedLeftInset() + flow.getMaxCellWidth(rowsToCount) + snappedRightInset();
- }
-
- double getVirtualFlowPreferredHeight(int rows) {
- double height = 1.0;
-
- for (int i = 0; i < rows && i < getPageCount(); i++) {
- height += flow.getCellLength(i);
- }
-
- return height + snappedTopInset() + snappedBottomInset();
- }
-
- @Override
- protected void layoutChildren(double x, double y, double w, double h) {
- checkState();
- }
-
- protected void checkState() {
- if (pageCountDirty) {
- updatePageCount();
- pageCountDirty = false;
- }
- }
-}
diff --git a/viewer/viewer-fx/src/main/java/com/icepdf/fx/scene/control/skin/VirtualPageFlow.java b/viewer/viewer-fx/src/main/java/com/icepdf/fx/scene/control/skin/VirtualPageFlow.java
deleted file mode 100644
index b2a144a55..000000000
--- a/viewer/viewer-fx/src/main/java/com/icepdf/fx/scene/control/skin/VirtualPageFlow.java
+++ /dev/null
@@ -1,2852 +0,0 @@
-package com.icepdf.fx.scene.control.skin;
-
-
-import com.icepdf.fx.scene.control.PageView;
-import com.sun.javafx.scene.control.Logging;
-import com.sun.javafx.scene.control.skin.Utils;
-import com.sun.javafx.scene.traversal.Algorithm;
-import com.sun.javafx.scene.traversal.Direction;
-import com.sun.javafx.scene.traversal.ParentTraversalEngine;
-import com.sun.javafx.scene.traversal.TraversalContext;
-import javafx.animation.KeyFrame;
-import javafx.animation.Timeline;
-import javafx.application.ConditionalFeature;
-import javafx.application.Platform;
-import javafx.beans.InvalidationListener;
-import javafx.beans.Observable;
-import javafx.beans.property.BooleanProperty;
-import javafx.beans.property.BooleanPropertyBase;
-import javafx.beans.value.ChangeListener;
-import javafx.collections.ObservableList;
-import javafx.event.EventDispatcher;
-import javafx.event.EventHandler;
-import javafx.geometry.Orientation;
-import javafx.scene.*;
-import javafx.scene.control.ScrollBar;
-import javafx.scene.input.MouseEvent;
-import javafx.scene.input.ScrollEvent;
-import javafx.scene.layout.Region;
-import javafx.scene.layout.StackPane;
-import javafx.scene.shape.Rectangle;
-import javafx.util.Callback;
-import javafx.util.Duration;
-import sun.util.logging.PlatformLogger;
-
-import java.util.AbstractList;
-import java.util.ArrayList;
-import java.util.BitSet;
-import java.util.List;
-
-/**
- * Implementation of a virtualized container using a cell based mechanism.
- */
-public class VirtualPageFlow
- * In general, this is the largest preferred size in the non-virtual
- * direction that we have ever encountered. We don't reduce this size
- * unless instructed to do so, so as to reduce the amount of scroll bar
- * jitter. The access on this variable is package ONLY FOR TESTING.
- */
- private double maxPrefBreadth;
-
- protected final void setMaxPrefBreadth(double value) {
- this.maxPrefBreadth = value;
- }
-
- protected final double getMaxPrefBreadth() {
- return maxPrefBreadth;
- }
-
- /**
- * The breadth of the viewport portion of the VirtualFlow as computed during
- * the layout pass. In a vertical flow this would be the same as the clip
- * view width. In a horizontal flow this is the clip view height.
- * The access on this variable is package ONLY FOR TESTING.
- */
- private double viewportBreadth;
-
- protected final void setViewportBreadth(double value) {
- this.viewportBreadth = value;
- }
-
- protected final double getViewportBreadth() {
- return viewportBreadth;
- }
-
- /**
- * The length of the viewport portion of the VirtualFlow as computed
- * during the layout pass. In a vertical flow this would be the same as the
- * clip view height. In a horizontal flow this is the clip view width.
- * The access on this variable is package ONLY FOR TESTING.
- */
- private double viewportLength;
-
- void setViewportLength(double value) {
- this.viewportLength = value;
- }
-
- protected double getViewportLength() {
- return viewportLength;
- }
-
-
- /**
- * The width of the VirtualFlow the last time it was laid out. We
- * use this information for several fast paths during the layout pass.
- */
- double lastWidth = -1;
-
- /**
- * The height of the VirtualFlow the last time it was laid out. We
- * use this information for several fast paths during the layout pass.
- */
- double lastHeight = -1;
-
- /**
- * The number of "virtual" cells in the flow the last time it was laid out.
- * For example, there may have been 1000 virtual cells, but only 20 actual
- * cells created and in use. In that case, lastCellCount would be 1000.
- */
- int lastCellCount = 0;
-
- /**
- * We remember the last value for vertical the last time we laid out the
- * flow. If vertical has changed, we will want to change the max & value
- * for the different scroll bars. Since we do all the scroll bar update
- * work in the layoutChildren function, we need to know what the old value for
- * vertical was.
- */
- boolean lastVertical;
-
- /**
- * The position last time we laid out. If none of the lastXXX vars have
- * changed respective to their values in layoutChildren, then we can just punt
- * out of the method (I hope...)
- */
- double lastPosition;
-
- /**
- * The breadth of the first visible cell last time we laid out.
- */
- double lastCellBreadth = -1;
-
- /**
- * The length of the first visible cell last time we laid out.
- */
- double lastCellLength = -1;
-
- /**
- * The list of cells representing those cells which actually make up the
- * current view. The cells are ordered such that the first cell in this
- * list is the first in the view, and the last cell is the last in the
- * view. When pixel scrolling, the list is simply shifted and items drop
- * off the beginning or the end, depending on the order of scrolling.
- *
- * This is package private ONLY FOR TESTING
- */
- final ArrayLinkedList
- * This is package private ONLY FOR TESTING
- */
- final ArrayLinkedList
- * See RT-23616 for more details.
- */
- private static final String NEW_CELL = "newcell";
-
- /**
- * Get a cell which can be used in the layout. This function will reuse
- * cells from the pile where possible, and will create new cells when
- * necessary.
- */
- protected T getAvailableCell(int prefIndex) {
- T cell = null;
-
- // Fix for RT-12822. We try to retrieve the cell from the pile rather
- // than just grab a random cell from the pile (or create another cell).
- for (int i = 0, max = pile.size(); i < max; i++) {
- T _cell = pile.get(i);
- assert _cell != null;
-
- if (getCellIndex(_cell) == prefIndex) {
- cell = _cell;
- pile.remove(i);
- break;
- }
- cell = null;
- }
-
- if (cell == null) {
- if (pile.size() > 0) {
- // we try to get a cell with an index that is the same even/odd
- // as the prefIndex. This saves us from having to run so much
- // css on the cell as it will not change from even to odd, or
- // vice versa
- final boolean prefIndexIsEven = (prefIndex & 1) == 0;
- for (int i = 0, max = pile.size(); i < max; i++) {
- final T c = pile.get(i);
- final int cellIndex = getCellIndex(c);
-
- if ((cellIndex & 1) == 0 && prefIndexIsEven) {
- cell = c;
- pile.remove(i);
- break;
- } else if ((cellIndex & 1) == 1 && !prefIndexIsEven) {
- cell = c;
- pile.remove(i);
- break;
- }
- }
-
- if (cell == null) {
- cell = pile.removeFirst();
- }
- } else {
- cell = getCreateCell().call(this);
- cell.getProperties().put(NEW_CELL, null);
- }
- }
-
- if (cell.getParent() == null) {
- sheetChildren.add(cell);
- }
-
- return cell;
- }
-
- // protected to allow subclasses to clean up
- protected void addAllToPile() {
- for (int i = 0, max = cells.size(); i < max; i++) {
- addToPile(cells.removeFirst());
- }
- }
-
- /**
- * Puts the given cell onto the pile. This is called whenever a cell has
- * fallen off the flow's start.
- */
- private void addToPile(T cell) {
- assert cell != null;
- pile.addLast(cell);
- }
-
- private void cleanPile() {
- boolean wasFocusOwner = false;
-
- for (int i = 0, max = pile.size(); i < max; i++) {
- T cell = pile.get(i);
- wasFocusOwner = wasFocusOwner || doesCellContainFocus(cell);
- cell.setVisible(false);
- }
-
- // Fix for RT-35876: Rather than have the cells do weird things with
- // focus (in particular, have focus jump between cells), we return focus
- // to the VirtualFlow itself.
- if (wasFocusOwner) {
- requestFocus();
- }
- }
-
- private boolean doesCellContainFocus(PageView c) {
- Scene scene = c.getScene();
- final Node focusOwner = scene == null ? null : scene.getFocusOwner();
-
- if (focusOwner != null) {
- if (c.equals(focusOwner)) {
- return true;
- }
-
- Parent p = focusOwner.getParent();
- while (p != null && !(p instanceof VirtualPageFlow)) {
- if (c.equals(p)) {
- return true;
- }
- p = p.getParent();
- }
- }
-
- return false;
- }
-
- /**
- * Gets a cell for the given index if the cell has been created and laid out.
- * "Visible" is a bit of a misnomer, the cell might not be visible in the
- * viewport (it may be clipped), but does distinguish between cells that
- * have been created and are in use vs. those that are in the pile or
- * not created.
- */
- public T getVisibleCell(int index) {
- if (cells.isEmpty()) return null;
-
- // check the last index
- T lastCell = cells.getLast();
- int lastIndex = getCellIndex(lastCell);
- if (index == lastIndex) return lastCell;
-
- // check the first index
- T firstCell = cells.getFirst();
- int firstIndex = getCellIndex(firstCell);
- if (index == firstIndex) return firstCell;
-
- // if index is > firstIndex and < lastIndex then we can get the index
- if (index > firstIndex && index < lastIndex) {
- T cell = cells.get(index - firstIndex);
- if (getCellIndex(cell) == index) return cell;
- }
-
- // there is no visible cell for the specified index
- return null;
- }
-
- /**
- * Locates and returns the last non-empty IndexedCell that is currently
- * partially or completely visible. This function may return null if there
- * are no cells, or if the viewport length is 0.
- */
- public T getLastVisibleCell() {
- if (cells.isEmpty() || getViewportLength() <= 0) return null;
-
- T cell;
- for (int i = cells.size() - 1; i >= 0; i--) {
- cell = cells.get(i);
-// if (!cell.isEmpty()) {
- return cell;
-// }
- }
-
- return null;
- }
-
- /**
- * Locates and returns the first non-empty IndexedCell that is partially or
- * completely visible. This really only ever returns null if there are no
- * cells or the viewport length is 0.
- */
- public T getFirstVisibleCell() {
- if (cells.isEmpty() || getViewportLength() <= 0) return null;
- T cell = cells.getFirst();
- return cell; //cell.isEmpty() ? null : cell;
- }
-
- // Returns last visible cell whose bounds are entirely within the viewport
- public T getLastVisibleCellWithinViewPort() {
- if (cells.isEmpty() || getViewportLength() <= 0) return null;
-
- T cell;
- final double max = getViewportLength();
- for (int i = cells.size() - 1; i >= 0; i--) {
- cell = cells.get(i);
-// if (cell.isEmpty()) continue;
-
- final double cellStart = getCellPosition(cell);
- final double cellEnd = cellStart + getCellLength(cell);
-
- // we use the magic +2 to allow for a little bit of fuzziness,
- // this is to help in situations such as RT-34407
- if (cellEnd <= (max + 2)) {
- return cell;
- }
- }
-
- return null;
- }
-
- // Returns first visible cell whose bounds are entirely within the viewport
- public T getFirstVisibleCellWithinViewPort() {
- if (cells.isEmpty() || getViewportLength() <= 0) return null;
-
- T cell;
- for (int i = 0; i < cells.size(); i++) {
- cell = cells.get(i);
-// if (cell.isEmpty()) continue;
-
- final double cellStart = getCellPosition(cell);
- if (cellStart >= 0) {
- return cell;
- }
- }
-
- return null;
- }
-
- /**
- * Adjust the position of cells so that the specified cell
- * will be positioned at the start of the viewport. The given cell must
- * already be "live". This is bad public API!
- */
- public void showAsFirst(T firstCell) {
- if (firstCell != null) {
- adjustPixels(getCellPosition(firstCell));
- }
- }
-
- /**
- * Adjust the position of cells so that the specified cell
- * will be positioned at the end of the viewport. The given cell must
- * already be "live". This is bad public API!
- */
- public void showAsLast(T lastCell) {
- if (lastCell != null) {
- adjustPixels(getCellPosition(lastCell) + getCellLength(lastCell) - getViewportLength());
- }
- }
-
- /**
- * Adjusts the cells such that the selected cell will be fully visible in
- * the viewport (but only just).
- */
- public void show(T cell) {
- if (cell != null) {
- final double start = getCellPosition(cell);
- final double length = getCellLength(cell);
- final double end = start + length;
- final double viewportLength = getViewportLength();
-
- if (start < 0) {
- adjustPixels(start);
- } else if (end > viewportLength) {
- adjustPixels(end - viewportLength);
- }
- }
- }
-
- public void show(int index) {
- T cell = getVisibleCell(index);
- if (cell != null) {
- show(cell);
- } else {
- // See if the previous index is a visible cell
- T prev = getVisibleCell(index - 1);
- if (prev != null) {
- // Need to add a new cell and then we can show it
-// layingOut = true;
- cell = getAvailableCell(index);
- setCellIndex(cell, index);
- resizeCellSize(cell); // resize must be after config
- cells.addLast(cell);
- positionCell(cell, getCellPosition(prev) + getCellLength(prev));
- setMaxPrefBreadth(Math.max(getMaxPrefBreadth(), getCellBreadth(cell)));
- cell.setVisible(true);
- show(cell);
-// layingOut = false;
- return;
- }
- // See if the next index is a visible cell
- T next = getVisibleCell(index + 1);
- if (next != null) {
-// layingOut = true;
- cell = getAvailableCell(index);
- setCellIndex(cell, index);
- resizeCellSize(cell); // resize must be after config
- cells.addFirst(cell);
- positionCell(cell, getCellPosition(next) - getCellLength(cell));
- setMaxPrefBreadth(Math.max(getMaxPrefBreadth(), getCellBreadth(cell)));
- cell.setVisible(true);
- show(cell);
-// layingOut = false;
- return;
- }
-
- // In this case, we're asked to show a random cell
-// layingOut = true;
- adjustPositionToIndex(index);
- addAllToPile();
- requestLayout();
-// layingOut = false;
- }
- }
-
- public void scrollTo(int index) {
- boolean posSet = false;
-
- if (index >= cellCount - 1) {
- setPosition(1);
- posSet = true;
- } else if (index < 0) {
- setPosition(0);
- posSet = true;
- }
-
- if (!posSet) {
- adjustPositionToIndex(index);
- double offset = -computeOffsetForCell(index);
- adjustByPixelAmount(offset);
- }
-
- requestLayout();
- }
-
- //TODO We assume all the cell have the same length. We will need to support
- // cells of different lengths.
- public void scrollToOffset(int offset) {
- adjustPixels(offset * getCellLength(0));
- }
-
- /**
- * Given a delta value representing a number of pixels, this method attempts
- * to move the VirtualFlow in the given direction (positive is down/right,
- * negative is up/left) the given number of pixels. It returns the number of
- * pixels actually moved.
- */
- public double adjustPixels(final double delta) {
- // Short cut this method for cases where nothing should be done
- if (delta == 0) return 0;
-
- final boolean isVertical = isVertical();
- if (((isVertical && (tempVisibility ? !needLengthBar : !vbar.isVisible())) ||
- (!isVertical && (tempVisibility ? !needLengthBar : !hbar.isVisible())))) return 0;
-
- double pos = getPosition();
- if (pos == 0.0f && delta < 0) return 0;
- if (pos == 1.0f && delta > 0) return 0;
-
- adjustByPixelAmount(delta);
- if (pos == getPosition()) {
- // The pos hasn't changed, there's nothing to do. This is likely
- // to occur when we hit either extremity
- return 0;
- }
-
- // Now move stuff around. Translating by pixels fundamentally means
- // moving the cells by the delta. However, after having
- // done that, we need to go through the cells and see which cells,
- // after adding in the translation factor, now fall off the viewport.
- // Also, we need to add cells as appropriate to the end (or beginning,
- // depending on the direction of travel).
- //
- // One simplifying assumption (that had better be true!) is that we
- // will only make it this far in the function if the virtual scroll
- // bar is visible. Otherwise, we never will pixel scroll. So as we go,
- // if we find that the maxPrefBreadth exceeds the viewportBreadth,
- // then we will be sure to show the breadthBar and update it
- // accordingly.
- if (cells.size() > 0) {
- double position;
- for (int i = 0; i < cells.size(); i++) {
- T cell = cells.get(i);
- assert cell != null;
- position = getCellPosition(cell) - delta;
- positionCell(cell, position);
- }
-
- // Fix for RT-32908
- T firstCell = cells.getFirst();
- double layoutY = firstCell == null ? 0 : getCellPosition(firstCell);
- for (int i = 0; i < cells.size(); i++) {
- T cell = cells.get(i);
- assert cell != null;
- double actualLayoutY = getCellPosition(cell);
- if (actualLayoutY != layoutY) {
- // we need to shift the cell to layoutY
- positionCell(cell, layoutY);
- }
-
- layoutY += getCellLength(cell);
- }
- // end of fix for RT-32908
- cull();
- firstCell = cells.getFirst();
-
- // Add any necessary leading cells
- if (firstCell != null) {
- int firstIndex = getCellIndex(firstCell);
- double prevIndexSize = getCellLength(firstIndex - 1);
- addLeadingCells(firstIndex - 1, getCellPosition(firstCell) - prevIndexSize);
- } else {
- int currentIndex = computeCurrentIndex();
-
- // The distance from the top of the viewport to the top of the
- // cell for the current index.
- double offset = -computeViewportOffset(getPosition());
-
- // Add all the leading and trailing cells (the call to add leading
- // cells will add the current cell as well -- that is, the one that
- // represents the current position on the mapper).
- addLeadingCells(currentIndex, offset);
- }
-
- // Starting at the tail of the list, loop adding cells until
- // all the space on the table is filled up. We want to make
- // sure that we DO NOT add empty trailing cells (since we are
- // in the full virtual case and so there are no trailing empty
- // cells).
- if (!addTrailingCells(false)) {
- // Reached the end, but not enough cells to fill up to
- // the end. So, remove the trailing empty space, and translate
- // the cells down
- final T lastCell = getLastVisibleCell();
- final double lastCellSize = getCellLength(lastCell);
- final double cellEnd = getCellPosition(lastCell) + lastCellSize;
- final double viewportLength = getViewportLength();
-
- if (cellEnd < viewportLength) {
- // Reposition the nodes
- double emptySize = viewportLength - cellEnd;
- for (int i = 0; i < cells.size(); i++) {
- T cell = cells.get(i);
- positionCell(cell, getCellPosition(cell) + emptySize);
- }
- setPosition(1.0f);
- // fill the leading empty space
- firstCell = cells.getFirst();
- int firstIndex = getCellIndex(firstCell);
- double prevIndexSize = getCellLength(firstIndex - 1);
- addLeadingCells(firstIndex - 1, getCellPosition(firstCell) - prevIndexSize);
- }
- }
- }
-
- // Now throw away any cells that don't fit
- cull();
-
- // Finally, update the scroll bars
- updateScrollBarsAndCells(false);
- lastPosition = getPosition();
-
- // notify
- return delta; // TODO fake
- }
-
- private boolean needsReconfigureCells = false; // when cell contents are the same
- private boolean needsRecreateCells = false; // when cell factory changed
- private boolean needsRebuildCells = false; // when cell contents have changed
- private boolean needsCellsLayout = false;
- private boolean sizeChanged = false;
- private final BitSet dirtyCells = new BitSet();
-
- public void reconfigureCells() {
- needsReconfigureCells = true;
- requestLayout();
- }
-
- public void recreateCells() {
- needsRecreateCells = true;
- requestLayout();
- }
-
- public void rebuildCells() {
- needsRebuildCells = true;
- requestLayout();
- }
-
- public void requestCellLayout() {
- needsCellsLayout = true;
- requestLayout();
- }
-
- public void setCellDirty(int index) {
- dirtyCells.set(index);
- requestLayout();
- }
-
- private static final double GOLDEN_RATIO_MULTIPLIER = 0.618033987;
-
- private double getPrefBreadth(double oppDimension) {
- double max = getMaxCellWidth(10);
-
- // This primarily exists for the case where we do not want the breadth
- // to grow to ensure a golden ratio between width and height (for example,
- // when a ListView is used in a ComboBox - the width should not grow
- // just because items are being added to the ListView)
- if (oppDimension > -1) {
- double prefLength = getPrefLength();
- max = Math.max(max, prefLength * GOLDEN_RATIO_MULTIPLIER);
- }
-
- return max;
- }
-
- private double getPrefLength() {
- double sum = 0.0;
- int rows = Math.min(10, cellCount);
- for (int i = 0; i < rows; i++) {
- sum += getCellLength(i);
- }
- return sum;
- }
-
- @Override
- protected double computePrefWidth(double height) {
- double w = isVertical() ? getPrefBreadth(height) : getPrefLength();
- return w + vbar.prefWidth(-1);
- }
-
- @Override
- protected double computePrefHeight(double width) {
- double h = isVertical() ? getPrefLength() : getPrefBreadth(width);
- return h + hbar.prefHeight(-1);
- }
-
- double getMaxCellWidth(int rowsToCount) {
- double max = 0.0;
-
- // we always measure at least one row
- int rows = Math.max(1, rowsToCount == -1 ? cellCount : rowsToCount);
- for (int i = 0; i < rows; i++) {
- max = Math.max(max, getCellBreadth(i));
- }
- return max;
- }
-
-
- // Old PositionMapper
-
- /**
- * Given a position value between 0 and 1, compute and return the viewport
- * offset from the "current" cell associated with that position value.
- * That is, if the return value of this function where used as a translation
- * factor for a sheet that contained all the items, then the current
- * item would end up positioned correctly.
- */
- private double computeViewportOffset(double position) {
- double p = com.sun.javafx.util.Utils.clamp(0, position, 1);
- double fractionalPosition = p * getCellCount();
- int cellIndex = (int) fractionalPosition;
- double fraction = fractionalPosition - cellIndex;
- double cellSize = getCellLength(cellIndex);
- double pixelOffset = cellSize * fraction;
- double viewportOffset = getViewportLength() * p;
- return pixelOffset - viewportOffset;
- }
-
- private void adjustPositionToIndex(int index) {
- int cellCount = getCellCount();
- if (cellCount <= 0) {
- setPosition(0.0f);
- } else {
- setPosition(((double) index) / cellCount);
- }
- }
-
- /**
- * Adjust the position based on a delta of pixels. If negative, then the
- * position will be adjusted negatively. If positive, then the position will
- * be adjusted positively. If the pixel amount is too great for the range of
- * the position, then it will be clamped such that position is always
- * strictly between 0 and 1
- */
- private void adjustByPixelAmount(double numPixels) {
- if (numPixels == 0) return;
- // Starting from the current cell, we move in the direction indicated
- // by numPixels one cell at a team. For each cell, we discover how many
- // pixels the "position" line would move within that cell, and adjust
- // our count of numPixels accordingly. When we come to the "final" cell,
- // then we can take the remaining number of pixels and multiply it by
- // the "travel rate" of "p" within that cell to get the delta. Add
- // the delta to "p" to get position.
-
- // get some basic info about the list and the current cell
- boolean forward = numPixels > 0;
- int cellCount = getCellCount();
- double fractionalPosition = getPosition() * cellCount;
- int cellIndex = (int) fractionalPosition;
- if (forward && cellIndex == cellCount) return;
- double cellSize = getCellLength(cellIndex);
- double fraction = fractionalPosition - cellIndex;
- double pixelOffset = cellSize * fraction;
-
- // compute the percentage of "position" that represents each cell
- double cellPercent = 1.0 / cellCount;
-
- // To help simplify the algorithm, we pretend as though the current
- // position is at the beginning of the current cell. This reduces some
- // of the corner cases and provides a simpler algorithm without adding
- // any overhead to performance.
- double start = computeOffsetForCell(cellIndex);
- double end = cellSize + computeOffsetForCell(cellIndex + 1);
-
- // We need to discover the distance that the fictional "position line"
- // would travel within this cell, from its current position to the end.
- double remaining = end - start;
-
- // Keep track of the number of pixels left to travel
- double n = forward ?
- numPixels + pixelOffset - (getViewportLength() * getPosition()) - start
- : -numPixels + end - (pixelOffset - (getViewportLength() * getPosition()));
-
- // "p" represents the most recent value for position. This is always
- // based on the edge between two cells, except at the very end of the
- // algorithm where it is added to the computed "p" offset for the final
- // value of Position.
- double p = cellPercent * cellIndex;
-
- // Loop over the cells one at a time until either we reach the end of
- // the cells, or we find that the "n" will fall within the cell we're on
- while (n > remaining && ((forward && cellIndex < cellCount - 1) || (!forward && cellIndex > 0))) {
- if (forward) cellIndex++;
- else cellIndex--;
- n -= remaining;
- cellSize = getCellLength(cellIndex);
- start = computeOffsetForCell(cellIndex);
- end = cellSize + computeOffsetForCell(cellIndex + 1);
- remaining = end - start;
- p = cellPercent * cellIndex;
- }
-
- // if remaining is < n, then we must have hit an end, so as a
- // fast path, we can just set position to 1.0 or 0.0 and return
- // because we know we hit the end
- if (n > remaining) {
- setPosition(forward ? 1.0f : 0.0f);
- } else if (forward) {
- double rate = cellPercent / Math.abs(end - start);
- setPosition(p + (rate * n));
- } else {
- double rate = cellPercent / Math.abs(end - start);
- setPosition((p + cellPercent) - (rate * n));
- }
- }
-
- private int computeCurrentIndex() {
- return (int) (getPosition() * getCellCount());
- }
-
- /**
- * Given an item index, this function will compute and return the viewport
- * offset from the beginning of the specified item. Notice that because each
- * item has the same percentage of the position dedicated to it, and since
- * we are measuring from the start of each item, this is a very simple
- * calculation.
- */
- private double computeOffsetForCell(int itemIndex) {
- double cellCount = getCellCount();
- double p = com.sun.javafx.util.Utils.clamp(0, itemIndex, cellCount) / cellCount;
- return -(getViewportLength() * p);
- }
-
-// /**
-// * Adjust the position based on a chunk of pixels. The position is based
-// * on the start of the scrollbar position.
-// */
-// private void adjustByPixelChunk(double numPixels) {
-// setPosition(0);
-// adjustByPixelAmount(numPixels);
-// }
- // end of old PositionMapper code
-
-
- /**
- * A simple extension to Region that ensures that anything wanting to flow
- * outside of the bounds of the Region is clipped.
- */
- static class ClippedContainer extends Region {
-
- /**
- * The Node which is embedded within this {@code ClipView}.
- */
- private Node node;
-
- public Node getNode() {
- return this.node;
- }
-
- public void setNode(Node n) {
- this.node = n;
-
- getChildren().clear();
- getChildren().add(node);
- }
-
- public void setClipX(double clipX) {
- setLayoutX(-clipX);
- clipRect.setLayoutX(clipX);
- }
-
- public void setClipY(double clipY) {
- setLayoutY(-clipY);
- clipRect.setLayoutY(clipY);
- }
-
- private final Rectangle clipRect;
-
- public ClippedContainer(final VirtualPageFlow flow) {
- if (flow == null) {
- throw new IllegalArgumentException("VirtualFlow can not be null");
- }
-
- getStyleClass().add("clipped-container");
-
- // clipping
- clipRect = new Rectangle();
- clipRect.setSmooth(false);
- setClip(clipRect);
- // --- clipping
-
- super.widthProperty().addListener(valueModel -> {
- clipRect.setWidth(getWidth());
- });
- super.heightProperty().addListener(valueModel -> {
- clipRect.setHeight(getHeight());
- });
- }
- }
-
- /**
- * A List-like implementation that is exceedingly efficient for the purposes
- * of the VirtualFlow. Typically there is not much variance in the number of
- * cells -- it is always some reasonably consistent number. Yet for efficiency
- * in code, we like to use a linked list implementation so as to append to
- * start or append to end. However, at times when we need to iterate, LinkedList
- * is expensive computationally as well as requiring the construction of
- * temporary iterators.
- *
- * This linked list like implementation is done using an array. It begins by
- * putting the first item in the center of the allocated array, and then grows
- * outward (either towards the first or last of the array depending on whether
- * we are inserting at the head or tail). It maintains an index to the start
- * and end of the array, so that it can efficiently expose iteration.
- *
- * This class is package private solely for the sake of testing.
- */
- public static class ArrayLinkedList