|
@@ -1,919 +0,0 @@
|
|
|
-/* Copyright 2012 Mozilla Foundation
|
|
|
- *
|
|
|
- * Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
- * you may not use this file except in compliance with the License.
|
|
|
- * You may obtain a copy of the License at
|
|
|
- *
|
|
|
- * http://www.apache.org/licenses/LICENSE-2.0
|
|
|
- *
|
|
|
- * Unless required by applicable law or agreed to in writing, software
|
|
|
- * distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
- * See the License for the specific language governing permissions and
|
|
|
- * limitations under the License.
|
|
|
- */
|
|
|
-
|
|
|
-const CSS_UNITS = 96.0 / 72.0;
|
|
|
-const DEFAULT_SCALE_VALUE = 'auto';
|
|
|
-const DEFAULT_SCALE = 1.0;
|
|
|
-const MIN_SCALE = 0.10;
|
|
|
-const MAX_SCALE = 10.0;
|
|
|
-const UNKNOWN_SCALE = 0;
|
|
|
-const MAX_AUTO_SCALE = 1.25;
|
|
|
-const SCROLLBAR_PADDING = 40;
|
|
|
-const VERTICAL_PADDING = 5;
|
|
|
-
|
|
|
-const PresentationModeState = {
|
|
|
- UNKNOWN: 0,
|
|
|
- NORMAL: 1,
|
|
|
- CHANGING: 2,
|
|
|
- FULLSCREEN: 3,
|
|
|
-};
|
|
|
-
|
|
|
-const RendererType = {
|
|
|
- CANVAS: 'canvas',
|
|
|
- SVG: 'svg',
|
|
|
-};
|
|
|
-
|
|
|
-const TextLayerMode = {
|
|
|
- DISABLE: 0,
|
|
|
- ENABLE: 1,
|
|
|
- ENABLE_ENHANCE: 2,
|
|
|
-};
|
|
|
-
|
|
|
-const ScrollMode = {
|
|
|
- UNKNOWN: -1,
|
|
|
- VERTICAL: 0, // Default value.
|
|
|
- HORIZONTAL: 1,
|
|
|
- WRAPPED: 2,
|
|
|
-};
|
|
|
-
|
|
|
-const SpreadMode = {
|
|
|
- UNKNOWN: -1,
|
|
|
- NONE: 0, // Default value.
|
|
|
- ODD: 1,
|
|
|
- EVEN: 2,
|
|
|
-};
|
|
|
-
|
|
|
-// Replaces {{arguments}} with their values.
|
|
|
-function formatL10nValue(text, args) {
|
|
|
- if (!args) {
|
|
|
- return text;
|
|
|
- }
|
|
|
- return text.replace(/\{\{\s*(\w+)\s*\}\}/g, (all, name) => {
|
|
|
- return (name in args ? args[name] : '{{' + name + '}}');
|
|
|
- });
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * No-op implementation of the localization service.
|
|
|
- * @implements {IL10n}
|
|
|
- */
|
|
|
-let NullL10n = {
|
|
|
- async getLanguage() {
|
|
|
- return 'en-us';
|
|
|
- },
|
|
|
-
|
|
|
- async getDirection() {
|
|
|
- return 'ltr';
|
|
|
- },
|
|
|
-
|
|
|
- async get(property, args, fallback) {
|
|
|
- return formatL10nValue(fallback, args);
|
|
|
- },
|
|
|
-
|
|
|
- async translate(element) { },
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * Returns scale factor for the canvas. It makes sense for the HiDPI displays.
|
|
|
- * @return {Object} The object with horizontal (sx) and vertical (sy)
|
|
|
- scales. The scaled property is set to false if scaling is
|
|
|
- not required, true otherwise.
|
|
|
- */
|
|
|
-function getOutputScale(ctx) {
|
|
|
- let devicePixelRatio = window.devicePixelRatio || 1;
|
|
|
- let backingStoreRatio = ctx.webkitBackingStorePixelRatio ||
|
|
|
- ctx.mozBackingStorePixelRatio ||
|
|
|
- ctx.msBackingStorePixelRatio ||
|
|
|
- ctx.oBackingStorePixelRatio ||
|
|
|
- ctx.backingStorePixelRatio || 1;
|
|
|
- let pixelRatio = devicePixelRatio / backingStoreRatio;
|
|
|
- return {
|
|
|
- sx: pixelRatio,
|
|
|
- sy: pixelRatio,
|
|
|
- scaled: pixelRatio !== 1,
|
|
|
- };
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Scrolls specified element into view of its parent.
|
|
|
- * @param {Object} element - The element to be visible.
|
|
|
- * @param {Object} spot - An object with optional top and left properties,
|
|
|
- * specifying the offset from the top left edge.
|
|
|
- * @param {boolean} skipOverflowHiddenElements - Ignore elements that have
|
|
|
- * the CSS rule `overflow: hidden;` set. The default is false.
|
|
|
- */
|
|
|
-function scrollIntoView(element, spot, skipOverflowHiddenElements = false) {
|
|
|
- // Assuming offsetParent is available (it's not available when viewer is in
|
|
|
- // hidden iframe or object). We have to scroll: if the offsetParent is not set
|
|
|
- // producing the error. See also animationStarted.
|
|
|
- let parent = element.offsetParent;
|
|
|
- if (!parent) {
|
|
|
- console.error('offsetParent is not set -- cannot scroll');
|
|
|
- return;
|
|
|
- }
|
|
|
- let offsetY = element.offsetTop + element.clientTop;
|
|
|
- let offsetX = element.offsetLeft + element.clientLeft;
|
|
|
- while ((parent.clientHeight === parent.scrollHeight &&
|
|
|
- parent.clientWidth === parent.scrollWidth) ||
|
|
|
- (skipOverflowHiddenElements &&
|
|
|
- getComputedStyle(parent).overflow === 'hidden')) {
|
|
|
- if (parent.dataset._scaleY) {
|
|
|
- offsetY /= parent.dataset._scaleY;
|
|
|
- offsetX /= parent.dataset._scaleX;
|
|
|
- }
|
|
|
- offsetY += parent.offsetTop;
|
|
|
- offsetX += parent.offsetLeft;
|
|
|
- parent = parent.offsetParent;
|
|
|
- if (!parent) {
|
|
|
- return; // no need to scroll
|
|
|
- }
|
|
|
- }
|
|
|
- if (spot) {
|
|
|
- if (spot.top !== undefined) {
|
|
|
- offsetY += spot.top;
|
|
|
- }
|
|
|
- if (spot.left !== undefined) {
|
|
|
- offsetX += spot.left;
|
|
|
- parent.scrollLeft = offsetX;
|
|
|
- }
|
|
|
- }
|
|
|
- parent.scrollTop = offsetY;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Helper function to start monitoring the scroll event and converting them into
|
|
|
- * PDF.js friendly one: with scroll debounce and scroll direction.
|
|
|
- */
|
|
|
-function watchScroll(viewAreaElement, callback) {
|
|
|
- let debounceScroll = function(evt) {
|
|
|
- if (rAF) {
|
|
|
- return;
|
|
|
- }
|
|
|
- // schedule an invocation of scroll for next animation frame.
|
|
|
- rAF = window.requestAnimationFrame(function viewAreaElementScrolled() {
|
|
|
- rAF = null;
|
|
|
-
|
|
|
- let currentX = viewAreaElement.scrollLeft;
|
|
|
- let lastX = state.lastX;
|
|
|
- if (currentX !== lastX) {
|
|
|
- state.right = currentX > lastX;
|
|
|
- }
|
|
|
- state.lastX = currentX;
|
|
|
- let currentY = viewAreaElement.scrollTop;
|
|
|
- let lastY = state.lastY;
|
|
|
- if (currentY !== lastY) {
|
|
|
- state.down = currentY > lastY;
|
|
|
- }
|
|
|
- state.lastY = currentY;
|
|
|
- callback(state);
|
|
|
- });
|
|
|
- };
|
|
|
-
|
|
|
- let state = {
|
|
|
- right: true,
|
|
|
- down: true,
|
|
|
- lastX: viewAreaElement.scrollLeft,
|
|
|
- lastY: viewAreaElement.scrollTop,
|
|
|
- _eventHandler: debounceScroll,
|
|
|
- };
|
|
|
-
|
|
|
- let rAF = null;
|
|
|
- viewAreaElement.addEventListener('scroll', debounceScroll, true);
|
|
|
- return state;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Helper function to parse query string (e.g. ?param1=value&parm2=...).
|
|
|
- */
|
|
|
-function parseQueryString(query) {
|
|
|
- let parts = query.split('&');
|
|
|
- let params = Object.create(null);
|
|
|
- for (let i = 0, ii = parts.length; i < ii; ++i) {
|
|
|
- let param = parts[i].split('=');
|
|
|
- let key = param[0].toLowerCase();
|
|
|
- let value = param.length > 1 ? param[1] : null;
|
|
|
- params[decodeURIComponent(key)] = decodeURIComponent(value);
|
|
|
- }
|
|
|
- return params;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Use binary search to find the index of the first item in a given array which
|
|
|
- * passes a given condition. The items are expected to be sorted in the sense
|
|
|
- * that if the condition is true for one item in the array, then it is also true
|
|
|
- * for all following items.
|
|
|
- *
|
|
|
- * @returns {Number} Index of the first array element to pass the test,
|
|
|
- * or |items.length| if no such element exists.
|
|
|
- */
|
|
|
-function binarySearchFirstItem(items, condition) {
|
|
|
- let minIndex = 0;
|
|
|
- let maxIndex = items.length - 1;
|
|
|
-
|
|
|
- if (items.length === 0 || !condition(items[maxIndex])) {
|
|
|
- return items.length;
|
|
|
- }
|
|
|
- if (condition(items[minIndex])) {
|
|
|
- return minIndex;
|
|
|
- }
|
|
|
-
|
|
|
- while (minIndex < maxIndex) {
|
|
|
- let currentIndex = (minIndex + maxIndex) >> 1;
|
|
|
- let currentItem = items[currentIndex];
|
|
|
- if (condition(currentItem)) {
|
|
|
- maxIndex = currentIndex;
|
|
|
- } else {
|
|
|
- minIndex = currentIndex + 1;
|
|
|
- }
|
|
|
- }
|
|
|
- return minIndex; /* === maxIndex */
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Approximates float number as a fraction using Farey sequence (max order
|
|
|
- * of 8).
|
|
|
- * @param {number} x - Positive float number.
|
|
|
- * @returns {Array} Estimated fraction: the first array item is a numerator,
|
|
|
- * the second one is a denominator.
|
|
|
- */
|
|
|
-function approximateFraction(x) {
|
|
|
- // Fast paths for int numbers or their inversions.
|
|
|
- if (Math.floor(x) === x) {
|
|
|
- return [x, 1];
|
|
|
- }
|
|
|
- let xinv = 1 / x;
|
|
|
- let limit = 8;
|
|
|
- if (xinv > limit) {
|
|
|
- return [1, limit];
|
|
|
- } else if (Math.floor(xinv) === xinv) {
|
|
|
- return [1, xinv];
|
|
|
- }
|
|
|
-
|
|
|
- let x_ = x > 1 ? xinv : x;
|
|
|
- // a/b and c/d are neighbours in Farey sequence.
|
|
|
- let a = 0, b = 1, c = 1, d = 1;
|
|
|
- // Limiting search to order 8.
|
|
|
- while (true) {
|
|
|
- // Generating next term in sequence (order of q).
|
|
|
- let p = a + c, q = b + d;
|
|
|
- if (q > limit) {
|
|
|
- break;
|
|
|
- }
|
|
|
- if (x_ <= p / q) {
|
|
|
- c = p; d = q;
|
|
|
- } else {
|
|
|
- a = p; b = q;
|
|
|
- }
|
|
|
- }
|
|
|
- let result;
|
|
|
- // Select closest of the neighbours to x.
|
|
|
- if (x_ - a / b < c / d - x_) {
|
|
|
- result = x_ === x ? [a, b] : [b, a];
|
|
|
- } else {
|
|
|
- result = x_ === x ? [c, d] : [d, c];
|
|
|
- }
|
|
|
- return result;
|
|
|
-}
|
|
|
-
|
|
|
-function roundToDivide(x, div) {
|
|
|
- let r = x % div;
|
|
|
- return r === 0 ? x : Math.round(x - r + div);
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Gets the size of the specified page, converted from PDF units to inches.
|
|
|
- * @param {Object} An Object containing the properties: {Array} `view`,
|
|
|
- * {number} `userUnit`, and {number} `rotate`.
|
|
|
- * @return {Object} An Object containing the properties: {number} `width`
|
|
|
- * and {number} `height`, given in inches.
|
|
|
- */
|
|
|
-function getPageSizeInches({ view, userUnit, rotate, }) {
|
|
|
- const [x1, y1, x2, y2] = view;
|
|
|
- // We need to take the page rotation into account as well.
|
|
|
- const changeOrientation = rotate % 180 !== 0;
|
|
|
-
|
|
|
- const width = (x2 - x1) / 72 * userUnit;
|
|
|
- const height = (y2 - y1) / 72 * userUnit;
|
|
|
-
|
|
|
- return {
|
|
|
- width: (changeOrientation ? height : width),
|
|
|
- height: (changeOrientation ? width : height),
|
|
|
- };
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Helper function for getVisibleElements.
|
|
|
- *
|
|
|
- * @param {number} index - initial guess at the first visible element
|
|
|
- * @param {Array} views - array of pages, into which `index` is an index
|
|
|
- * @param {number} top - the top of the scroll pane
|
|
|
- * @returns {number} less than or equal to `index` that is definitely at or
|
|
|
- * before the first visible element in `views`, but not by too much. (Usually,
|
|
|
- * this will be the first element in the first partially visible row in
|
|
|
- * `views`, although sometimes it goes back one row further.)
|
|
|
- */
|
|
|
-function backtrackBeforeAllVisibleElements(index, views, top) {
|
|
|
- // binarySearchFirstItem's assumption is that the input is ordered, with only
|
|
|
- // one index where the conditions flips from false to true: [false ...,
|
|
|
- // true...]. With vertical scrolling and spreads, it is possible to have
|
|
|
- // [false ..., true, false, true ...]. With wrapped scrolling we can have a
|
|
|
- // similar sequence, with many more mixed true and false in the middle.
|
|
|
- //
|
|
|
- // So there is no guarantee that the binary search yields the index of the
|
|
|
- // first visible element. It could have been any of the other visible elements
|
|
|
- // that were preceded by a hidden element.
|
|
|
-
|
|
|
- // Of course, if either this element or the previous (hidden) element is also
|
|
|
- // the first element, there's nothing to worry about.
|
|
|
- if (index < 2) {
|
|
|
- return index;
|
|
|
- }
|
|
|
-
|
|
|
- // That aside, the possible cases are represented below.
|
|
|
- //
|
|
|
- // **** = fully hidden
|
|
|
- // A*B* = mix of partially visible and/or hidden pages
|
|
|
- // CDEF = fully visible
|
|
|
- //
|
|
|
- // (1) Binary search could have returned A, in which case we can stop.
|
|
|
- // (2) Binary search could also have returned B, in which case we need to
|
|
|
- // check the whole row.
|
|
|
- // (3) Binary search could also have returned C, in which case we need to
|
|
|
- // check the whole previous row.
|
|
|
- //
|
|
|
- // There's one other possibility:
|
|
|
- //
|
|
|
- // **** = fully hidden
|
|
|
- // ABCD = mix of fully and/or partially visible pages
|
|
|
- //
|
|
|
- // (4) Binary search could only have returned A.
|
|
|
-
|
|
|
- // Initially assume that we need to find the beginning of the current row
|
|
|
- // (case 1, 2, or 4), which means finding a page that is above the current
|
|
|
- // page's top. If the found page is partially visible, we're definitely not in
|
|
|
- // case 3, and this assumption is correct.
|
|
|
- let elt = views[index].div;
|
|
|
- let pageTop = elt.offsetTop + elt.clientTop;
|
|
|
-
|
|
|
- if (pageTop >= top) {
|
|
|
- // The found page is fully visible, so we're actually either in case 3 or 4,
|
|
|
- // and unfortunately we can't tell the difference between them without
|
|
|
- // scanning the entire previous row, so we just conservatively assume that
|
|
|
- // we do need to backtrack to that row. In both cases, the previous page is
|
|
|
- // in the previous row, so use its top instead.
|
|
|
- elt = views[index - 1].div;
|
|
|
- pageTop = elt.offsetTop + elt.clientTop;
|
|
|
- }
|
|
|
-
|
|
|
- // Now we backtrack to the first page that still has its bottom below
|
|
|
- // `pageTop`, which is the top of a page in the first visible row (unless
|
|
|
- // we're in case 4, in which case it's the row before that).
|
|
|
- // `index` is found by binary search, so the page at `index - 1` is
|
|
|
- // invisible and we can start looking for potentially visible pages from
|
|
|
- // `index - 2`. (However, if this loop terminates on its first iteration,
|
|
|
- // which is the case when pages are stacked vertically, `index` should remain
|
|
|
- // unchanged, so we use a distinct loop variable.)
|
|
|
- for (let i = index - 2; i >= 0; --i) {
|
|
|
- elt = views[i].div;
|
|
|
- if (elt.offsetTop + elt.clientTop + elt.clientHeight <= pageTop) {
|
|
|
- // We have reached the previous row, so stop now.
|
|
|
- // This loop is expected to terminate relatively quickly because the
|
|
|
- // number of pages per row is expected to be small.
|
|
|
- break;
|
|
|
- }
|
|
|
- index = i;
|
|
|
- }
|
|
|
- return index;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Generic helper to find out what elements are visible within a scroll pane.
|
|
|
- *
|
|
|
- * Well, pretty generic. There are some assumptions placed on the elements
|
|
|
- * referenced by `views`:
|
|
|
- * - If `horizontal`, no left of any earlier element is to the right of the
|
|
|
- * left of any later element.
|
|
|
- * - Otherwise, `views` can be split into contiguous rows where, within a row,
|
|
|
- * no top of any element is below the bottom of any other element, and
|
|
|
- * between rows, no bottom of any element in an earlier row is below the
|
|
|
- * top of any element in a later row.
|
|
|
- *
|
|
|
- * (Here, top, left, etc. all refer to the padding edge of the element in
|
|
|
- * question. For pages, that ends up being equivalent to the bounding box of the
|
|
|
- * rendering canvas. Earlier and later refer to index in `views`, not page
|
|
|
- * layout.)
|
|
|
- *
|
|
|
- * @param scrollEl {HTMLElement} - a container that can possibly scroll
|
|
|
- * @param views {Array} - objects with a `div` property that contains an
|
|
|
- * HTMLElement, which should all be descendents of `scrollEl` satisfying the
|
|
|
- * above layout assumptions
|
|
|
- * @param sortByVisibility {boolean} - if true, the returned elements are sorted
|
|
|
- * in descending order of the percent of their padding box that is visible
|
|
|
- * @param horizontal {boolean} - if true, the elements are assumed to be laid
|
|
|
- * out horizontally instead of vertically
|
|
|
- * @returns {Object} `{ first, last, views: [{ id, x, y, view, percent }] }`
|
|
|
- */
|
|
|
-function getVisibleElements(scrollEl, views, sortByVisibility = false,
|
|
|
- horizontal = false) {
|
|
|
- const top = scrollEl.scrollTop, bottom = top + scrollEl.clientHeight;
|
|
|
- const left = scrollEl.scrollLeft, right = left + scrollEl.clientWidth;
|
|
|
-
|
|
|
- // Throughout this "generic" function, comments will assume we're working with
|
|
|
- // PDF document pages, which is the most important and complex case. In this
|
|
|
- // case, the visible elements we're actually interested is the page canvas,
|
|
|
- // which is contained in a wrapper which adds no padding/border/margin, which
|
|
|
- // is itself contained in `view.div` which adds no padding (but does add a
|
|
|
- // border). So, as specified in this function's doc comment, this function
|
|
|
- // does all of its work on the padding edge of the provided views, starting at
|
|
|
- // offsetLeft/Top (which includes margin) and adding clientLeft/Top (which is
|
|
|
- // the border). Adding clientWidth/Height gets us the bottom-right corner of
|
|
|
- // the padding edge.
|
|
|
- function isElementBottomAfterViewTop(view) {
|
|
|
- const element = view.div;
|
|
|
- const elementBottom =
|
|
|
- element.offsetTop + element.clientTop + element.clientHeight;
|
|
|
- return elementBottom > top;
|
|
|
- }
|
|
|
- function isElementRightAfterViewLeft(view) {
|
|
|
- const element = view.div;
|
|
|
- const elementRight =
|
|
|
- element.offsetLeft + element.clientLeft + element.clientWidth;
|
|
|
- return elementRight > left;
|
|
|
- }
|
|
|
-
|
|
|
- const visible = [], numViews = views.length;
|
|
|
- let firstVisibleElementInd = numViews === 0 ? 0 :
|
|
|
- binarySearchFirstItem(views, horizontal ? isElementRightAfterViewLeft :
|
|
|
- isElementBottomAfterViewTop);
|
|
|
-
|
|
|
- // Please note the return value of the `binarySearchFirstItem` function when
|
|
|
- // no valid element is found (hence the `firstVisibleElementInd` check below).
|
|
|
- if (firstVisibleElementInd > 0 && firstVisibleElementInd < numViews &&
|
|
|
- !horizontal) {
|
|
|
- // In wrapped scrolling (or vertical scrolling with spreads), with some page
|
|
|
- // sizes, isElementBottomAfterViewTop doesn't satisfy the binary search
|
|
|
- // condition: there can be pages with bottoms above the view top between
|
|
|
- // pages with bottoms below. This function detects and corrects that error;
|
|
|
- // see it for more comments.
|
|
|
- firstVisibleElementInd =
|
|
|
- backtrackBeforeAllVisibleElements(firstVisibleElementInd, views, top);
|
|
|
- }
|
|
|
-
|
|
|
- // lastEdge acts as a cutoff for us to stop looping, because we know all
|
|
|
- // subsequent pages will be hidden.
|
|
|
- //
|
|
|
- // When using wrapped scrolling or vertical scrolling with spreads, we can't
|
|
|
- // simply stop the first time we reach a page below the bottom of the view;
|
|
|
- // the tops of subsequent pages on the same row could still be visible. In
|
|
|
- // horizontal scrolling, we don't have that issue, so we can stop as soon as
|
|
|
- // we pass `right`, without needing the code below that handles the -1 case.
|
|
|
- let lastEdge = horizontal ? right : -1;
|
|
|
-
|
|
|
- for (let i = firstVisibleElementInd; i < numViews; i++) {
|
|
|
- const view = views[i], element = view.div;
|
|
|
- const currentWidth = element.offsetLeft + element.clientLeft;
|
|
|
- const currentHeight = element.offsetTop + element.clientTop;
|
|
|
- const viewWidth = element.clientWidth, viewHeight = element.clientHeight;
|
|
|
- const viewRight = currentWidth + viewWidth;
|
|
|
- const viewBottom = currentHeight + viewHeight;
|
|
|
-
|
|
|
- if (lastEdge === -1) {
|
|
|
- // As commented above, this is only needed in non-horizontal cases.
|
|
|
- // Setting lastEdge to the bottom of the first page that is partially
|
|
|
- // visible ensures that the next page fully below lastEdge is on the
|
|
|
- // next row, which has to be fully hidden along with all subsequent rows.
|
|
|
- if (viewBottom >= bottom) {
|
|
|
- lastEdge = viewBottom;
|
|
|
- }
|
|
|
- } else if ((horizontal ? currentWidth : currentHeight) > lastEdge) {
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- if (viewBottom <= top || currentHeight >= bottom ||
|
|
|
- viewRight <= left || currentWidth >= right) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- const hiddenHeight = Math.max(0, top - currentHeight) +
|
|
|
- Math.max(0, viewBottom - bottom);
|
|
|
- const hiddenWidth = Math.max(0, left - currentWidth) +
|
|
|
- Math.max(0, viewRight - right);
|
|
|
- const percent = ((viewHeight - hiddenHeight) * (viewWidth - hiddenWidth) *
|
|
|
- 100 / viewHeight / viewWidth) | 0;
|
|
|
- visible.push({
|
|
|
- id: view.id,
|
|
|
- x: currentWidth,
|
|
|
- y: currentHeight,
|
|
|
- view,
|
|
|
- percent,
|
|
|
- });
|
|
|
- }
|
|
|
-
|
|
|
- const first = visible[0], last = visible[visible.length - 1];
|
|
|
-
|
|
|
- if (sortByVisibility) {
|
|
|
- visible.sort(function(a, b) {
|
|
|
- let pc = a.percent - b.percent;
|
|
|
- if (Math.abs(pc) > 0.001) {
|
|
|
- return -pc;
|
|
|
- }
|
|
|
- return a.id - b.id; // ensure stability
|
|
|
- });
|
|
|
- }
|
|
|
- return { first, last, views: visible, };
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Event handler to suppress context menu.
|
|
|
- */
|
|
|
-function noContextMenuHandler(evt) {
|
|
|
- evt.preventDefault();
|
|
|
-}
|
|
|
-
|
|
|
-function isDataSchema(url) {
|
|
|
- let i = 0, ii = url.length;
|
|
|
- while (i < ii && url[i].trim() === '') {
|
|
|
- i++;
|
|
|
- }
|
|
|
- return url.substring(i, i + 5).toLowerCase() === 'data:';
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Returns the filename or guessed filename from the url (see issue 3455).
|
|
|
- * @param {string} url - The original PDF location.
|
|
|
- * @param {string} defaultFilename - The value returned if the filename is
|
|
|
- * unknown, or the protocol is unsupported.
|
|
|
- * @returns {string} Guessed PDF filename.
|
|
|
- */
|
|
|
-function getPDFFileNameFromURL(url, defaultFilename = 'document.pdf') {
|
|
|
- if (typeof url !== 'string') {
|
|
|
- return defaultFilename;
|
|
|
- }
|
|
|
- if (isDataSchema(url)) {
|
|
|
- console.warn('getPDFFileNameFromURL: ' +
|
|
|
- 'ignoring "data:" URL for performance reasons.');
|
|
|
- return defaultFilename;
|
|
|
- }
|
|
|
- const reURI = /^(?:(?:[^:]+:)?\/\/[^\/]+)?([^?#]*)(\?[^#]*)?(#.*)?$/;
|
|
|
- // SCHEME HOST 1.PATH 2.QUERY 3.REF
|
|
|
- // Pattern to get last matching NAME.pdf
|
|
|
- const reFilename = /[^\/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
|
|
|
- let splitURI = reURI.exec(url);
|
|
|
- let suggestedFilename = reFilename.exec(splitURI[1]) ||
|
|
|
- reFilename.exec(splitURI[2]) ||
|
|
|
- reFilename.exec(splitURI[3]);
|
|
|
- if (suggestedFilename) {
|
|
|
- suggestedFilename = suggestedFilename[0];
|
|
|
- if (suggestedFilename.includes('%')) {
|
|
|
- // URL-encoded %2Fpath%2Fto%2Ffile.pdf should be file.pdf
|
|
|
- try {
|
|
|
- suggestedFilename =
|
|
|
- reFilename.exec(decodeURIComponent(suggestedFilename))[0];
|
|
|
- } catch (ex) { // Possible (extremely rare) errors:
|
|
|
- // URIError "Malformed URI", e.g. for "%AA.pdf"
|
|
|
- // TypeError "null has no properties", e.g. for "%2F.pdf"
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return suggestedFilename || defaultFilename;
|
|
|
-}
|
|
|
-
|
|
|
-function normalizeWheelEventDelta(evt) {
|
|
|
- let delta = Math.sqrt(evt.deltaX * evt.deltaX + evt.deltaY * evt.deltaY);
|
|
|
- let angle = Math.atan2(evt.deltaY, evt.deltaX);
|
|
|
- if (-0.25 * Math.PI < angle && angle < 0.75 * Math.PI) {
|
|
|
- // All that is left-up oriented has to change the sign.
|
|
|
- delta = -delta;
|
|
|
- }
|
|
|
-
|
|
|
- const MOUSE_DOM_DELTA_PIXEL_MODE = 0;
|
|
|
- const MOUSE_DOM_DELTA_LINE_MODE = 1;
|
|
|
- const MOUSE_PIXELS_PER_LINE = 30;
|
|
|
- const MOUSE_LINES_PER_PAGE = 30;
|
|
|
-
|
|
|
- // Converts delta to per-page units
|
|
|
- if (evt.deltaMode === MOUSE_DOM_DELTA_PIXEL_MODE) {
|
|
|
- delta /= MOUSE_PIXELS_PER_LINE * MOUSE_LINES_PER_PAGE;
|
|
|
- } else if (evt.deltaMode === MOUSE_DOM_DELTA_LINE_MODE) {
|
|
|
- delta /= MOUSE_LINES_PER_PAGE;
|
|
|
- }
|
|
|
- return delta;
|
|
|
-}
|
|
|
-
|
|
|
-function isValidRotation(angle) {
|
|
|
- return Number.isInteger(angle) && angle % 90 === 0;
|
|
|
-}
|
|
|
-
|
|
|
-function isValidScrollMode(mode) {
|
|
|
- return (Number.isInteger(mode) && Object.values(ScrollMode).includes(mode) &&
|
|
|
- mode !== ScrollMode.UNKNOWN);
|
|
|
-}
|
|
|
-
|
|
|
-function isValidSpreadMode(mode) {
|
|
|
- return (Number.isInteger(mode) && Object.values(SpreadMode).includes(mode) &&
|
|
|
- mode !== SpreadMode.UNKNOWN);
|
|
|
-}
|
|
|
-
|
|
|
-function isPortraitOrientation(size) {
|
|
|
- return size.width <= size.height;
|
|
|
-}
|
|
|
-
|
|
|
-const WaitOnType = {
|
|
|
- EVENT: 'event',
|
|
|
- TIMEOUT: 'timeout',
|
|
|
-};
|
|
|
-
|
|
|
-/**
|
|
|
- * @typedef {Object} WaitOnEventOrTimeoutParameters
|
|
|
- * @property {Object} target - The event target, can for example be:
|
|
|
- * `window`, `document`, a DOM element, or an {EventBus} instance.
|
|
|
- * @property {string} name - The name of the event.
|
|
|
- * @property {number} delay - The delay, in milliseconds, after which the
|
|
|
- * timeout occurs (if the event wasn't already dispatched).
|
|
|
- */
|
|
|
-
|
|
|
-/**
|
|
|
- * Allows waiting for an event or a timeout, whichever occurs first.
|
|
|
- * Can be used to ensure that an action always occurs, even when an event
|
|
|
- * arrives late or not at all.
|
|
|
- *
|
|
|
- * @param {WaitOnEventOrTimeoutParameters}
|
|
|
- * @returns {Promise} A promise that is resolved with a {WaitOnType} value.
|
|
|
- */
|
|
|
-function waitOnEventOrTimeout({ target, name, delay = 0, }) {
|
|
|
- return new Promise(function(resolve, reject) {
|
|
|
- if (typeof target !== 'object' || !(name && typeof name === 'string') ||
|
|
|
- !(Number.isInteger(delay) && delay >= 0)) {
|
|
|
- throw new Error('waitOnEventOrTimeout - invalid parameters.');
|
|
|
- }
|
|
|
-
|
|
|
- function handler(type) {
|
|
|
- if (target instanceof EventBus) {
|
|
|
- target.off(name, eventHandler);
|
|
|
- } else {
|
|
|
- target.removeEventListener(name, eventHandler);
|
|
|
- }
|
|
|
-
|
|
|
- if (timeout) {
|
|
|
- clearTimeout(timeout);
|
|
|
- }
|
|
|
- resolve(type);
|
|
|
- }
|
|
|
-
|
|
|
- const eventHandler = handler.bind(null, WaitOnType.EVENT);
|
|
|
- if (target instanceof EventBus) {
|
|
|
- target.on(name, eventHandler);
|
|
|
- } else {
|
|
|
- target.addEventListener(name, eventHandler);
|
|
|
- }
|
|
|
-
|
|
|
- const timeoutHandler = handler.bind(null, WaitOnType.TIMEOUT);
|
|
|
- let timeout = setTimeout(timeoutHandler, delay);
|
|
|
- });
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Promise that is resolved when DOM window becomes visible.
|
|
|
- */
|
|
|
-let animationStarted = new Promise(function (resolve) {
|
|
|
- if ((typeof PDFJSDev !== 'undefined' && PDFJSDev.test('LIB')) &&
|
|
|
- typeof window === 'undefined') {
|
|
|
- // Prevent "ReferenceError: window is not defined" errors when running the
|
|
|
- // unit-tests in Node.js/Travis.
|
|
|
- setTimeout(resolve, 20);
|
|
|
- return;
|
|
|
- }
|
|
|
- window.requestAnimationFrame(resolve);
|
|
|
-});
|
|
|
-
|
|
|
-/**
|
|
|
- * Simple event bus for an application. Listeners are attached using the
|
|
|
- * `on` and `off` methods. To raise an event, the `dispatch` method shall be
|
|
|
- * used.
|
|
|
- */
|
|
|
-class EventBus {
|
|
|
- constructor({ dispatchToDOM = false, } = {}) {
|
|
|
- this._listeners = Object.create(null);
|
|
|
- this._dispatchToDOM = dispatchToDOM === true;
|
|
|
- }
|
|
|
-
|
|
|
- on(eventName, listener) {
|
|
|
- let eventListeners = this._listeners[eventName];
|
|
|
- if (!eventListeners) {
|
|
|
- eventListeners = [];
|
|
|
- this._listeners[eventName] = eventListeners;
|
|
|
- }
|
|
|
- eventListeners.push(listener);
|
|
|
- }
|
|
|
-
|
|
|
- off(eventName, listener) {
|
|
|
- let eventListeners = this._listeners[eventName];
|
|
|
- let i;
|
|
|
- if (!eventListeners || ((i = eventListeners.indexOf(listener)) < 0)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- eventListeners.splice(i, 1);
|
|
|
- }
|
|
|
-
|
|
|
- dispatch(eventName) {
|
|
|
- let eventListeners = this._listeners[eventName];
|
|
|
- if (!eventListeners || eventListeners.length === 0) {
|
|
|
- if (this._dispatchToDOM) {
|
|
|
- const args = Array.prototype.slice.call(arguments, 1);
|
|
|
- this._dispatchDOMEvent(eventName, args);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- // Passing all arguments after the eventName to the listeners.
|
|
|
- const args = Array.prototype.slice.call(arguments, 1);
|
|
|
- // Making copy of the listeners array in case if it will be modified
|
|
|
- // during dispatch.
|
|
|
- eventListeners.slice(0).forEach(function (listener) {
|
|
|
- listener.apply(null, args);
|
|
|
- });
|
|
|
- if (this._dispatchToDOM) {
|
|
|
- this._dispatchDOMEvent(eventName, args);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /**
|
|
|
- * @private
|
|
|
- */
|
|
|
- _dispatchDOMEvent(eventName, args = null) {
|
|
|
- const details = Object.create(null);
|
|
|
- if (args && args.length > 0) {
|
|
|
- const obj = args[0];
|
|
|
- for (let key in obj) {
|
|
|
- const value = obj[key];
|
|
|
- if (key === 'source') {
|
|
|
- if (value === window || value === document) {
|
|
|
- return; // No need to re-dispatch (already) global events.
|
|
|
- }
|
|
|
- continue; // Ignore the `source` property.
|
|
|
- }
|
|
|
- details[key] = value;
|
|
|
- }
|
|
|
- }
|
|
|
- const event = document.createEvent('CustomEvent');
|
|
|
- event.initCustomEvent(eventName, true, true, details);
|
|
|
- document.dispatchEvent(event);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-let globalEventBus = null;
|
|
|
-function getGlobalEventBus(dispatchToDOM = false) {
|
|
|
- if (!globalEventBus) {
|
|
|
- globalEventBus = new EventBus({ dispatchToDOM, });
|
|
|
- }
|
|
|
- return globalEventBus;
|
|
|
-}
|
|
|
-
|
|
|
-function clamp(v, min, max) {
|
|
|
- return Math.min(Math.max(v, min), max);
|
|
|
-}
|
|
|
-
|
|
|
-class ProgressBar {
|
|
|
- constructor(id, { height, width, units, } = {}) {
|
|
|
- this.visible = true;
|
|
|
-
|
|
|
- // Fetch the sub-elements for later.
|
|
|
- this.div = document.querySelector(id + ' .progress');
|
|
|
- // Get the loading bar element, so it can be resized to fit the viewer.
|
|
|
- this.bar = this.div.parentNode;
|
|
|
-
|
|
|
- // Get options, with sensible defaults.
|
|
|
- this.height = height || 100;
|
|
|
- this.width = width || 100;
|
|
|
- this.units = units || '%';
|
|
|
-
|
|
|
- // Initialize heights.
|
|
|
- this.div.style.height = this.height + this.units;
|
|
|
- this.percent = 0;
|
|
|
- }
|
|
|
-
|
|
|
- _updateBar() {
|
|
|
- if (this._indeterminate) {
|
|
|
- this.div.classList.add('indeterminate');
|
|
|
- this.div.style.width = this.width + this.units;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- this.div.classList.remove('indeterminate');
|
|
|
- let progressSize = this.width * this._percent / 100;
|
|
|
- this.div.style.width = progressSize + this.units;
|
|
|
- }
|
|
|
-
|
|
|
- get percent() {
|
|
|
- return this._percent;
|
|
|
- }
|
|
|
-
|
|
|
- set percent(val) {
|
|
|
- this._indeterminate = isNaN(val);
|
|
|
- this._percent = clamp(val, 0, 100);
|
|
|
- this._updateBar();
|
|
|
- }
|
|
|
-
|
|
|
- setWidth(viewer) {
|
|
|
- if (!viewer) {
|
|
|
- return;
|
|
|
- }
|
|
|
- let container = viewer.parentNode;
|
|
|
- let scrollbarWidth = container.offsetWidth - viewer.offsetWidth;
|
|
|
- if (scrollbarWidth > 0) {
|
|
|
- this.bar.setAttribute('style', 'width: calc(100% - ' +
|
|
|
- scrollbarWidth + 'px);');
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- hide() {
|
|
|
- if (!this.visible) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.visible = false;
|
|
|
- this.bar.classList.add('hidden');
|
|
|
- document.body.classList.remove('loadingInProgress');
|
|
|
- }
|
|
|
-
|
|
|
- show() {
|
|
|
- if (this.visible) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this.visible = true;
|
|
|
- document.body.classList.add('loadingInProgress');
|
|
|
- this.bar.classList.remove('hidden');
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * Moves all elements of an array that satisfy condition to the end of the
|
|
|
- * array, preserving the order of the rest.
|
|
|
- */
|
|
|
-function moveToEndOfArray(arr, condition) {
|
|
|
- const moved = [], len = arr.length;
|
|
|
- let write = 0;
|
|
|
- for (let read = 0; read < len; ++read) {
|
|
|
- if (condition(arr[read])) {
|
|
|
- moved.push(arr[read]);
|
|
|
- } else {
|
|
|
- arr[write] = arr[read];
|
|
|
- ++write;
|
|
|
- }
|
|
|
- }
|
|
|
- for (let read = 0; write < len; ++read, ++write) {
|
|
|
- arr[write] = moved[read];
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-export {
|
|
|
- CSS_UNITS,
|
|
|
- DEFAULT_SCALE_VALUE,
|
|
|
- DEFAULT_SCALE,
|
|
|
- MIN_SCALE,
|
|
|
- MAX_SCALE,
|
|
|
- UNKNOWN_SCALE,
|
|
|
- MAX_AUTO_SCALE,
|
|
|
- SCROLLBAR_PADDING,
|
|
|
- VERTICAL_PADDING,
|
|
|
- isValidRotation,
|
|
|
- isValidScrollMode,
|
|
|
- isValidSpreadMode,
|
|
|
- isPortraitOrientation,
|
|
|
- PresentationModeState,
|
|
|
- RendererType,
|
|
|
- TextLayerMode,
|
|
|
- ScrollMode,
|
|
|
- SpreadMode,
|
|
|
- NullL10n,
|
|
|
- EventBus,
|
|
|
- getGlobalEventBus,
|
|
|
- ProgressBar,
|
|
|
- getPDFFileNameFromURL,
|
|
|
- noContextMenuHandler,
|
|
|
- parseQueryString,
|
|
|
- backtrackBeforeAllVisibleElements, // only exported for testing
|
|
|
- getVisibleElements,
|
|
|
- roundToDivide,
|
|
|
- getPageSizeInches,
|
|
|
- approximateFraction,
|
|
|
- getOutputScale,
|
|
|
- scrollIntoView,
|
|
|
- watchScroll,
|
|
|
- binarySearchFirstItem,
|
|
|
- normalizeWheelEventDelta,
|
|
|
- animationStarted,
|
|
|
- WaitOnType,
|
|
|
- waitOnEventOrTimeout,
|
|
|
- moveToEndOfArray,
|
|
|
-};
|