de628cec59
- Add support for logical assignment operators, i.e. `&&=`, `||=`, and `??=`, with a Babel-plugin. Given that these required incrementing the ECMAScript version in the ESLint and Acorn configurations, and that platform/browser support is still fairly limited, always transpiling them seems appropriate for now. - Cache the `hasJSActions` promise in the API, similar to the existing `getAnnotations` caching. With this implemented, the lookup should now be cheap enough that it can be called unconditionally in the viewer. - Slightly improve cleanup of resources when destroying the `WorkerTransport`. - Remove the `annotationStorage`-property from the `PDFPageView` constructor, since it's not necessary and also brings it more inline with the `BaseViewer`. - Update the `BaseViewer.createAnnotationLayerBuilder` method to actaually agree with the `IPDFAnnotationLayerFactory` interface.[1] - Slightly tweak a couple of JSDoc comments. --- [1] We probably ought to re-factor both the `IPDFTextLayerFactory` and `IPDFAnnotationLayerFactory` interfaces to take parameter objects instead, since especially the `IPDFAnnotationLayerFactory` one is becoming quite unwieldy. Given that that would likely be a breaking change for any custom viewer-components implementation, this probably requires careful deprecation.
1482 lines
44 KiB
JavaScript
1482 lines
44 KiB
JavaScript
/* Copyright 2014 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.
|
|
*/
|
|
|
|
import { createPromiseCapability, version } from "pdfjs-lib";
|
|
import {
|
|
CSS_UNITS,
|
|
DEFAULT_SCALE,
|
|
DEFAULT_SCALE_VALUE,
|
|
getVisibleElements,
|
|
isPortraitOrientation,
|
|
isValidRotation,
|
|
isValidScrollMode,
|
|
isValidSpreadMode,
|
|
MAX_AUTO_SCALE,
|
|
moveToEndOfArray,
|
|
NullL10n,
|
|
PresentationModeState,
|
|
RendererType,
|
|
SCROLLBAR_PADDING,
|
|
scrollIntoView,
|
|
ScrollMode,
|
|
SpreadMode,
|
|
TextLayerMode,
|
|
UNKNOWN_SCALE,
|
|
VERTICAL_PADDING,
|
|
watchScroll,
|
|
} from "./ui_utils.js";
|
|
import { PDFRenderingQueue, RenderingStates } from "./pdf_rendering_queue.js";
|
|
import { AnnotationLayerBuilder } from "./annotation_layer_builder.js";
|
|
import { PDFPageView } from "./pdf_page_view.js";
|
|
import { SimpleLinkService } from "./pdf_link_service.js";
|
|
import { TextLayerBuilder } from "./text_layer_builder.js";
|
|
|
|
const DEFAULT_CACHE_SIZE = 10;
|
|
|
|
/**
|
|
* @typedef {Object} PDFViewerOptions
|
|
* @property {HTMLDivElement} container - The container for the viewer element.
|
|
* @property {HTMLDivElement} [viewer] - The viewer element.
|
|
* @property {EventBus} eventBus - The application event bus.
|
|
* @property {IPDFLinkService} linkService - The navigation/linking service.
|
|
* @property {DownloadManager} [downloadManager] - The download manager
|
|
* component.
|
|
* @property {PDFFindController} [findController] - The find controller
|
|
* component.
|
|
* @property {PDFRenderingQueue} [renderingQueue] - The rendering queue object.
|
|
* @property {boolean} [removePageBorders] - Removes the border shadow around
|
|
* the pages. The default value is `false`.
|
|
* @property {number} [textLayerMode] - Controls if the text layer used for
|
|
* selection and searching is created, and if the improved text selection
|
|
* behaviour is enabled. The constants from {TextLayerMode} should be used.
|
|
* The default value is `TextLayerMode.ENABLE`.
|
|
* @property {string} [imageResourcesPath] - Path for image resources, mainly
|
|
* mainly for annotation icons. Include trailing slash.
|
|
* @property {boolean} [renderInteractiveForms] - Enables rendering of
|
|
* interactive form elements. The default value is `true`.
|
|
* @property {boolean} [enablePrintAutoRotate] - Enables automatic rotation of
|
|
* landscape pages upon printing. The default is `false`.
|
|
* @property {string} renderer - 'canvas' or 'svg'. The default is 'canvas'.
|
|
* @property {boolean} [enableWebGL] - Enables WebGL accelerated rendering for
|
|
* some operations. The default value is `false`.
|
|
* @property {boolean} [useOnlyCssZoom] - Enables CSS only zooming. The default
|
|
* value is `false`.
|
|
* @property {number} [maxCanvasPixels] - The maximum supported canvas size in
|
|
* total pixels, i.e. width * height. Use -1 for no limit. The default value
|
|
* is 4096 * 4096 (16 mega-pixels).
|
|
* @property {IL10n} l10n - Localization service.
|
|
* @property {boolean} [enableScripting] - Enable embedded script execution.
|
|
* The default value is `false`.
|
|
*/
|
|
|
|
function PDFPageViewBuffer(size) {
|
|
const data = [];
|
|
this.push = function (view) {
|
|
const i = data.indexOf(view);
|
|
if (i >= 0) {
|
|
data.splice(i, 1);
|
|
}
|
|
data.push(view);
|
|
if (data.length > size) {
|
|
data.shift().destroy();
|
|
}
|
|
};
|
|
/**
|
|
* After calling resize, the size of the buffer will be newSize. The optional
|
|
* parameter pagesToKeep is, if present, an array of pages to push to the back
|
|
* of the buffer, delaying their destruction. The size of pagesToKeep has no
|
|
* impact on the final size of the buffer; if pagesToKeep has length larger
|
|
* than newSize, some of those pages will be destroyed anyway.
|
|
*/
|
|
this.resize = function (newSize, pagesToKeep) {
|
|
size = newSize;
|
|
if (pagesToKeep) {
|
|
const pageIdsToKeep = new Set();
|
|
for (let i = 0, iMax = pagesToKeep.length; i < iMax; ++i) {
|
|
pageIdsToKeep.add(pagesToKeep[i].id);
|
|
}
|
|
moveToEndOfArray(data, function (page) {
|
|
return pageIdsToKeep.has(page.id);
|
|
});
|
|
}
|
|
while (data.length > size) {
|
|
data.shift().destroy();
|
|
}
|
|
};
|
|
|
|
this.has = function (view) {
|
|
return data.includes(view);
|
|
};
|
|
}
|
|
|
|
function isSameScale(oldScale, newScale) {
|
|
if (newScale === oldScale) {
|
|
return true;
|
|
}
|
|
if (Math.abs(newScale - oldScale) < 1e-15) {
|
|
// Prevent unnecessary re-rendering of all pages when the scale
|
|
// changes only because of limited numerical precision.
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Simple viewer control to display PDF content/pages.
|
|
* @implements {IRenderableView}
|
|
*/
|
|
class BaseViewer {
|
|
/**
|
|
* @param {PDFViewerOptions} options
|
|
*/
|
|
constructor(options) {
|
|
if (this.constructor === BaseViewer) {
|
|
throw new Error("Cannot initialize BaseViewer.");
|
|
}
|
|
const viewerVersion =
|
|
typeof PDFJSDev !== "undefined" ? PDFJSDev.eval("BUNDLE_VERSION") : null;
|
|
if (version !== viewerVersion) {
|
|
throw new Error(
|
|
`The API version "${version}" does not match the Viewer version "${viewerVersion}".`
|
|
);
|
|
}
|
|
this._name = this.constructor.name;
|
|
|
|
this.container = options.container;
|
|
this.viewer = options.viewer || options.container.firstElementChild;
|
|
|
|
if (
|
|
typeof PDFJSDev === "undefined" ||
|
|
PDFJSDev.test("!PRODUCTION || GENERIC")
|
|
) {
|
|
if (
|
|
!(
|
|
this.container?.tagName.toUpperCase() === "DIV" &&
|
|
this.viewer?.tagName.toUpperCase() === "DIV"
|
|
)
|
|
) {
|
|
throw new Error("Invalid `container` and/or `viewer` option.");
|
|
}
|
|
|
|
if (getComputedStyle(this.container).position !== "absolute") {
|
|
throw new Error("The `container` must be absolutely positioned.");
|
|
}
|
|
}
|
|
this.eventBus = options.eventBus;
|
|
this.linkService = options.linkService || new SimpleLinkService();
|
|
this.downloadManager = options.downloadManager || null;
|
|
this.findController = options.findController || null;
|
|
this.removePageBorders = options.removePageBorders || false;
|
|
this.textLayerMode = Number.isInteger(options.textLayerMode)
|
|
? options.textLayerMode
|
|
: TextLayerMode.ENABLE;
|
|
this.imageResourcesPath = options.imageResourcesPath || "";
|
|
this.renderInteractiveForms =
|
|
typeof options.renderInteractiveForms === "boolean"
|
|
? options.renderInteractiveForms
|
|
: true;
|
|
this.enablePrintAutoRotate = options.enablePrintAutoRotate || false;
|
|
this.renderer = options.renderer || RendererType.CANVAS;
|
|
this.enableWebGL = options.enableWebGL || false;
|
|
this.useOnlyCssZoom = options.useOnlyCssZoom || false;
|
|
this.maxCanvasPixels = options.maxCanvasPixels;
|
|
this.l10n = options.l10n || NullL10n;
|
|
this.enableScripting = options.enableScripting || false;
|
|
|
|
this.defaultRenderingQueue = !options.renderingQueue;
|
|
if (this.defaultRenderingQueue) {
|
|
// Custom rendering queue is not specified, using default one
|
|
this.renderingQueue = new PDFRenderingQueue();
|
|
this.renderingQueue.setViewer(this);
|
|
} else {
|
|
this.renderingQueue = options.renderingQueue;
|
|
}
|
|
|
|
this.scroll = watchScroll(this.container, this._scrollUpdate.bind(this));
|
|
this.presentationModeState = PresentationModeState.UNKNOWN;
|
|
this._onBeforeDraw = this._onAfterDraw = null;
|
|
this._resetView();
|
|
|
|
if (this.removePageBorders) {
|
|
this.viewer.classList.add("removePageBorders");
|
|
}
|
|
// Defer the dispatching of this event, to give other viewer components
|
|
// time to initialize *and* register 'baseviewerinit' event listeners.
|
|
Promise.resolve().then(() => {
|
|
this.eventBus.dispatch("baseviewerinit", { source: this });
|
|
});
|
|
}
|
|
|
|
get pagesCount() {
|
|
return this._pages.length;
|
|
}
|
|
|
|
getPageView(index) {
|
|
return this._pages[index];
|
|
}
|
|
|
|
/**
|
|
* @type {boolean} - True if all {PDFPageView} objects are initialized.
|
|
*/
|
|
get pageViewsReady() {
|
|
if (!this._pagesCapability.settled) {
|
|
return false;
|
|
}
|
|
// Prevent printing errors when 'disableAutoFetch' is set, by ensuring
|
|
// that *all* pages have in fact been completely loaded.
|
|
return this._pages.every(function (pageView) {
|
|
return pageView && pageView.pdfPage;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @type {number}
|
|
*/
|
|
get currentPageNumber() {
|
|
return this._currentPageNumber;
|
|
}
|
|
|
|
/**
|
|
* @param {number} val - The page number.
|
|
*/
|
|
set currentPageNumber(val) {
|
|
if (!Number.isInteger(val)) {
|
|
throw new Error("Invalid page number.");
|
|
}
|
|
if (!this.pdfDocument) {
|
|
return;
|
|
}
|
|
// The intent can be to just reset a scroll position and/or scale.
|
|
if (!this._setCurrentPageNumber(val, /* resetCurrentPageView = */ true)) {
|
|
console.error(
|
|
`${this._name}.currentPageNumber: "${val}" is not a valid page.`
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @returns {boolean} Whether the pageNumber is valid (within bounds).
|
|
* @private
|
|
*/
|
|
_setCurrentPageNumber(val, resetCurrentPageView = false) {
|
|
if (this._currentPageNumber === val) {
|
|
if (resetCurrentPageView) {
|
|
this._resetCurrentPageView();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (!(0 < val && val <= this.pagesCount)) {
|
|
return false;
|
|
}
|
|
this._currentPageNumber = val;
|
|
|
|
this.eventBus.dispatch("pagechanging", {
|
|
source: this,
|
|
pageNumber: val,
|
|
pageLabel: this._pageLabels && this._pageLabels[val - 1],
|
|
});
|
|
|
|
if (resetCurrentPageView) {
|
|
this._resetCurrentPageView();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @type {string|null} Returns the current page label, or `null` if no page
|
|
* labels exist.
|
|
*/
|
|
get currentPageLabel() {
|
|
return this._pageLabels && this._pageLabels[this._currentPageNumber - 1];
|
|
}
|
|
|
|
/**
|
|
* @param {string} val - The page label.
|
|
*/
|
|
set currentPageLabel(val) {
|
|
if (!this.pdfDocument) {
|
|
return;
|
|
}
|
|
let page = val | 0; // Fallback page number.
|
|
if (this._pageLabels) {
|
|
const i = this._pageLabels.indexOf(val);
|
|
if (i >= 0) {
|
|
page = i + 1;
|
|
}
|
|
}
|
|
// The intent can be to just reset a scroll position and/or scale.
|
|
if (!this._setCurrentPageNumber(page, /* resetCurrentPageView = */ true)) {
|
|
console.error(
|
|
`${this._name}.currentPageLabel: "${val}" is not a valid page.`
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @type {number}
|
|
*/
|
|
get currentScale() {
|
|
return this._currentScale !== UNKNOWN_SCALE
|
|
? this._currentScale
|
|
: DEFAULT_SCALE;
|
|
}
|
|
|
|
/**
|
|
* @param {number} val - Scale of the pages in percents.
|
|
*/
|
|
set currentScale(val) {
|
|
if (isNaN(val)) {
|
|
throw new Error("Invalid numeric scale.");
|
|
}
|
|
if (!this.pdfDocument) {
|
|
return;
|
|
}
|
|
this._setScale(val, false);
|
|
}
|
|
|
|
/**
|
|
* @type {string}
|
|
*/
|
|
get currentScaleValue() {
|
|
return this._currentScaleValue;
|
|
}
|
|
|
|
/**
|
|
* @param val - The scale of the pages (in percent or predefined value).
|
|
*/
|
|
set currentScaleValue(val) {
|
|
if (!this.pdfDocument) {
|
|
return;
|
|
}
|
|
this._setScale(val, false);
|
|
}
|
|
|
|
/**
|
|
* @type {number}
|
|
*/
|
|
get pagesRotation() {
|
|
return this._pagesRotation;
|
|
}
|
|
|
|
/**
|
|
* @param {number} rotation - The rotation of the pages (0, 90, 180, 270).
|
|
*/
|
|
set pagesRotation(rotation) {
|
|
if (!isValidRotation(rotation)) {
|
|
throw new Error("Invalid pages rotation angle.");
|
|
}
|
|
if (!this.pdfDocument) {
|
|
return;
|
|
}
|
|
if (this._pagesRotation === rotation) {
|
|
return; // The rotation didn't change.
|
|
}
|
|
this._pagesRotation = rotation;
|
|
|
|
const pageNumber = this._currentPageNumber;
|
|
|
|
for (let i = 0, ii = this._pages.length; i < ii; i++) {
|
|
const pageView = this._pages[i];
|
|
pageView.update(pageView.scale, rotation);
|
|
}
|
|
// Prevent errors in case the rotation changes *before* the scale has been
|
|
// set to a non-default value.
|
|
if (this._currentScaleValue) {
|
|
this._setScale(this._currentScaleValue, true);
|
|
}
|
|
|
|
this.eventBus.dispatch("rotationchanging", {
|
|
source: this,
|
|
pagesRotation: rotation,
|
|
pageNumber,
|
|
});
|
|
|
|
if (this.defaultRenderingQueue) {
|
|
this.update();
|
|
}
|
|
}
|
|
|
|
get firstPagePromise() {
|
|
return this.pdfDocument ? this._firstPageCapability.promise : null;
|
|
}
|
|
|
|
get onePageRendered() {
|
|
return this.pdfDocument ? this._onePageRenderedCapability.promise : null;
|
|
}
|
|
|
|
get pagesPromise() {
|
|
return this.pdfDocument ? this._pagesCapability.promise : null;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
get _viewerElement() {
|
|
// In most viewers, e.g. `PDFViewer`, this should return `this.viewer`.
|
|
throw new Error("Not implemented: _viewerElement");
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
_onePageRenderedOrForceFetch() {
|
|
// Unless the viewer *and* its pages are visible, rendering won't start and
|
|
// `this._onePageRenderedCapability` thus won't be resolved.
|
|
// To ensure that automatic printing, on document load, still works even in
|
|
// those cases we force-allow fetching of all pages when:
|
|
// - The viewer is hidden in the DOM, e.g. in a `display: none` <iframe>
|
|
// element; fixes bug 1618621.
|
|
// - The viewer is visible, but none of the pages are (e.g. if the
|
|
// viewer is very small); fixes bug 1618955.
|
|
if (
|
|
!this.container.offsetParent ||
|
|
this._getVisiblePages().views.length === 0
|
|
) {
|
|
return Promise.resolve();
|
|
}
|
|
return this._onePageRenderedCapability.promise;
|
|
}
|
|
|
|
/**
|
|
* @param pdfDocument {PDFDocument}
|
|
*/
|
|
setDocument(pdfDocument) {
|
|
if (this.pdfDocument) {
|
|
this._cancelRendering();
|
|
this._resetView();
|
|
|
|
if (this.findController) {
|
|
this.findController.setDocument(null);
|
|
}
|
|
}
|
|
|
|
this.pdfDocument = pdfDocument;
|
|
if (!pdfDocument) {
|
|
return;
|
|
}
|
|
const pagesCount = pdfDocument.numPages;
|
|
const firstPagePromise = pdfDocument.getPage(1);
|
|
// Rendering (potentially) depends on this, hence fetching it immediately.
|
|
const optionalContentConfigPromise = pdfDocument.getOptionalContentConfig();
|
|
|
|
this._pagesCapability.promise.then(() => {
|
|
this.eventBus.dispatch("pagesloaded", {
|
|
source: this,
|
|
pagesCount,
|
|
});
|
|
});
|
|
|
|
this._onBeforeDraw = evt => {
|
|
const pageView = this._pages[evt.pageNumber - 1];
|
|
if (!pageView) {
|
|
return;
|
|
}
|
|
// Add the page to the buffer at the start of drawing. That way it can be
|
|
// evicted from the buffer and destroyed even if we pause its rendering.
|
|
this._buffer.push(pageView);
|
|
};
|
|
this.eventBus._on("pagerender", this._onBeforeDraw);
|
|
|
|
this._onAfterDraw = evt => {
|
|
if (evt.cssTransform || this._onePageRenderedCapability.settled) {
|
|
return;
|
|
}
|
|
this._onePageRenderedCapability.resolve();
|
|
|
|
this.eventBus._off("pagerendered", this._onAfterDraw);
|
|
this._onAfterDraw = null;
|
|
};
|
|
this.eventBus._on("pagerendered", this._onAfterDraw);
|
|
|
|
// Fetch a single page so we can get a viewport that will be the default
|
|
// viewport for all pages
|
|
firstPagePromise
|
|
.then(firstPdfPage => {
|
|
this._firstPageCapability.resolve(firstPdfPage);
|
|
this._optionalContentConfigPromise = optionalContentConfigPromise;
|
|
|
|
const scale = this.currentScale;
|
|
const viewport = firstPdfPage.getViewport({ scale: scale * CSS_UNITS });
|
|
const textLayerFactory =
|
|
this.textLayerMode !== TextLayerMode.DISABLE ? this : null;
|
|
|
|
for (let pageNum = 1; pageNum <= pagesCount; ++pageNum) {
|
|
const pageView = new PDFPageView({
|
|
container: this._viewerElement,
|
|
eventBus: this.eventBus,
|
|
id: pageNum,
|
|
scale,
|
|
defaultViewport: viewport.clone(),
|
|
optionalContentConfigPromise,
|
|
renderingQueue: this.renderingQueue,
|
|
textLayerFactory,
|
|
textLayerMode: this.textLayerMode,
|
|
annotationLayerFactory: this,
|
|
imageResourcesPath: this.imageResourcesPath,
|
|
renderInteractiveForms: this.renderInteractiveForms,
|
|
renderer: this.renderer,
|
|
enableWebGL: this.enableWebGL,
|
|
useOnlyCssZoom: this.useOnlyCssZoom,
|
|
maxCanvasPixels: this.maxCanvasPixels,
|
|
l10n: this.l10n,
|
|
enableScripting: this.enableScripting,
|
|
});
|
|
this._pages.push(pageView);
|
|
}
|
|
// Set the first `pdfPage` immediately, since it's already loaded,
|
|
// rather than having to repeat the `PDFDocumentProxy.getPage` call in
|
|
// the `this._ensurePdfPageLoaded` method before rendering can start.
|
|
const firstPageView = this._pages[0];
|
|
if (firstPageView) {
|
|
firstPageView.setPdfPage(firstPdfPage);
|
|
this.linkService.cachePageRef(1, firstPdfPage.ref);
|
|
}
|
|
if (this._spreadMode !== SpreadMode.NONE) {
|
|
this._updateSpreadMode();
|
|
}
|
|
|
|
// Fetch all the pages since the viewport is needed before printing
|
|
// starts to create the correct size canvas. Wait until one page is
|
|
// rendered so we don't tie up too many resources early on.
|
|
this._onePageRenderedOrForceFetch().then(() => {
|
|
if (this.findController) {
|
|
this.findController.setDocument(pdfDocument); // Enable searching.
|
|
}
|
|
|
|
// In addition to 'disableAutoFetch' being set, also attempt to reduce
|
|
// resource usage when loading *very* long/large documents.
|
|
if (pdfDocument.loadingParams.disableAutoFetch || pagesCount > 7500) {
|
|
// XXX: Printing is semi-broken with auto fetch disabled.
|
|
this._pagesCapability.resolve();
|
|
return;
|
|
}
|
|
let getPagesLeft = pagesCount - 1; // The first page was already loaded.
|
|
|
|
if (getPagesLeft <= 0) {
|
|
this._pagesCapability.resolve();
|
|
return;
|
|
}
|
|
for (let pageNum = 2; pageNum <= pagesCount; ++pageNum) {
|
|
pdfDocument.getPage(pageNum).then(
|
|
pdfPage => {
|
|
const pageView = this._pages[pageNum - 1];
|
|
if (!pageView.pdfPage) {
|
|
pageView.setPdfPage(pdfPage);
|
|
}
|
|
this.linkService.cachePageRef(pageNum, pdfPage.ref);
|
|
if (--getPagesLeft === 0) {
|
|
this._pagesCapability.resolve();
|
|
}
|
|
},
|
|
reason => {
|
|
console.error(
|
|
`Unable to get page ${pageNum} to initialize viewer`,
|
|
reason
|
|
);
|
|
if (--getPagesLeft === 0) {
|
|
this._pagesCapability.resolve();
|
|
}
|
|
}
|
|
);
|
|
}
|
|
});
|
|
|
|
this.eventBus.dispatch("pagesinit", { source: this });
|
|
|
|
if (this.defaultRenderingQueue) {
|
|
this.update();
|
|
}
|
|
})
|
|
.catch(reason => {
|
|
console.error("Unable to initialize viewer", reason);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @param {Array|null} labels
|
|
*/
|
|
setPageLabels(labels) {
|
|
if (!this.pdfDocument) {
|
|
return;
|
|
}
|
|
if (!labels) {
|
|
this._pageLabels = null;
|
|
} else if (
|
|
!(Array.isArray(labels) && this.pdfDocument.numPages === labels.length)
|
|
) {
|
|
this._pageLabels = null;
|
|
console.error(`${this._name}.setPageLabels: Invalid page labels.`);
|
|
} else {
|
|
this._pageLabels = labels;
|
|
}
|
|
// Update all the `PDFPageView` instances.
|
|
for (let i = 0, ii = this._pages.length; i < ii; i++) {
|
|
const pageView = this._pages[i];
|
|
const label = this._pageLabels && this._pageLabels[i];
|
|
pageView.setPageLabel(label);
|
|
}
|
|
}
|
|
|
|
_resetView() {
|
|
this._pages = [];
|
|
this._currentPageNumber = 1;
|
|
this._currentScale = UNKNOWN_SCALE;
|
|
this._currentScaleValue = null;
|
|
this._pageLabels = null;
|
|
this._buffer = new PDFPageViewBuffer(DEFAULT_CACHE_SIZE);
|
|
this._location = null;
|
|
this._pagesRotation = 0;
|
|
this._optionalContentConfigPromise = null;
|
|
this._pagesRequests = new WeakMap();
|
|
this._firstPageCapability = createPromiseCapability();
|
|
this._onePageRenderedCapability = createPromiseCapability();
|
|
this._pagesCapability = createPromiseCapability();
|
|
this._scrollMode = ScrollMode.VERTICAL;
|
|
this._spreadMode = SpreadMode.NONE;
|
|
|
|
if (this._onBeforeDraw) {
|
|
this.eventBus._off("pagerender", this._onBeforeDraw);
|
|
this._onBeforeDraw = null;
|
|
}
|
|
if (this._onAfterDraw) {
|
|
this.eventBus._off("pagerendered", this._onAfterDraw);
|
|
this._onAfterDraw = null;
|
|
}
|
|
// Remove the pages from the DOM...
|
|
this.viewer.textContent = "";
|
|
// ... and reset the Scroll mode CSS class(es) afterwards.
|
|
this._updateScrollMode();
|
|
}
|
|
|
|
_scrollUpdate() {
|
|
if (this.pagesCount === 0) {
|
|
return;
|
|
}
|
|
this.update();
|
|
}
|
|
|
|
_scrollIntoView({ pageDiv, pageSpot = null, pageNumber = null }) {
|
|
scrollIntoView(pageDiv, pageSpot);
|
|
}
|
|
|
|
_setScaleUpdatePages(newScale, newValue, noScroll = false, preset = false) {
|
|
this._currentScaleValue = newValue.toString();
|
|
|
|
if (isSameScale(this._currentScale, newScale)) {
|
|
if (preset) {
|
|
this.eventBus.dispatch("scalechanging", {
|
|
source: this,
|
|
scale: newScale,
|
|
presetValue: newValue,
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
|
|
for (let i = 0, ii = this._pages.length; i < ii; i++) {
|
|
this._pages[i].update(newScale);
|
|
}
|
|
this._currentScale = newScale;
|
|
|
|
if (!noScroll) {
|
|
let page = this._currentPageNumber,
|
|
dest;
|
|
if (
|
|
this._location &&
|
|
!(this.isInPresentationMode || this.isChangingPresentationMode)
|
|
) {
|
|
page = this._location.pageNumber;
|
|
dest = [
|
|
null,
|
|
{ name: "XYZ" },
|
|
this._location.left,
|
|
this._location.top,
|
|
null,
|
|
];
|
|
}
|
|
this.scrollPageIntoView({
|
|
pageNumber: page,
|
|
destArray: dest,
|
|
allowNegativeOffset: true,
|
|
});
|
|
}
|
|
|
|
this.eventBus.dispatch("scalechanging", {
|
|
source: this,
|
|
scale: newScale,
|
|
presetValue: preset ? newValue : undefined,
|
|
});
|
|
|
|
if (this.defaultRenderingQueue) {
|
|
this.update();
|
|
}
|
|
}
|
|
|
|
_setScale(value, noScroll = false) {
|
|
let scale = parseFloat(value);
|
|
|
|
if (scale > 0) {
|
|
this._setScaleUpdatePages(scale, value, noScroll, /* preset = */ false);
|
|
} else {
|
|
const currentPage = this._pages[this._currentPageNumber - 1];
|
|
if (!currentPage) {
|
|
return;
|
|
}
|
|
const noPadding = this.isInPresentationMode || this.removePageBorders;
|
|
let hPadding = noPadding ? 0 : SCROLLBAR_PADDING;
|
|
let vPadding = noPadding ? 0 : VERTICAL_PADDING;
|
|
|
|
if (!noPadding && this._isScrollModeHorizontal) {
|
|
[hPadding, vPadding] = [vPadding, hPadding]; // Swap the padding values.
|
|
}
|
|
const pageWidthScale =
|
|
((this.container.clientWidth - hPadding) / currentPage.width) *
|
|
currentPage.scale;
|
|
const pageHeightScale =
|
|
((this.container.clientHeight - vPadding) / currentPage.height) *
|
|
currentPage.scale;
|
|
switch (value) {
|
|
case "page-actual":
|
|
scale = 1;
|
|
break;
|
|
case "page-width":
|
|
scale = pageWidthScale;
|
|
break;
|
|
case "page-height":
|
|
scale = pageHeightScale;
|
|
break;
|
|
case "page-fit":
|
|
scale = Math.min(pageWidthScale, pageHeightScale);
|
|
break;
|
|
case "auto":
|
|
// For pages in landscape mode, fit the page height to the viewer
|
|
// *unless* the page would thus become too wide to fit horizontally.
|
|
const horizontalScale = isPortraitOrientation(currentPage)
|
|
? pageWidthScale
|
|
: Math.min(pageHeightScale, pageWidthScale);
|
|
scale = Math.min(MAX_AUTO_SCALE, horizontalScale);
|
|
break;
|
|
default:
|
|
console.error(
|
|
`${this._name}._setScale: "${value}" is an unknown zoom value.`
|
|
);
|
|
return;
|
|
}
|
|
this._setScaleUpdatePages(scale, value, noScroll, /* preset = */ true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Refreshes page view: scrolls to the current page and updates the scale.
|
|
* @private
|
|
*/
|
|
_resetCurrentPageView() {
|
|
if (this.isInPresentationMode) {
|
|
// Fixes the case when PDF has different page sizes.
|
|
this._setScale(this._currentScaleValue, true);
|
|
}
|
|
|
|
const pageView = this._pages[this._currentPageNumber - 1];
|
|
this._scrollIntoView({ pageDiv: pageView.div });
|
|
}
|
|
|
|
/**
|
|
* @param {string} label - The page label.
|
|
* @returns {number|null} The page number corresponding to the page label,
|
|
* or `null` when no page labels exist and/or the input is invalid.
|
|
*/
|
|
pageLabelToPageNumber(label) {
|
|
if (!this._pageLabels) {
|
|
return null;
|
|
}
|
|
const i = this._pageLabels.indexOf(label);
|
|
if (i < 0) {
|
|
return null;
|
|
}
|
|
return i + 1;
|
|
}
|
|
|
|
/**
|
|
* @typedef ScrollPageIntoViewParameters
|
|
* @property {number} pageNumber - The page number.
|
|
* @property {Array} [destArray] - The original PDF destination array, in the
|
|
* format: <page-ref> </XYZ|/FitXXX> <args..>
|
|
* @property {boolean} [allowNegativeOffset] - Allow negative page offsets.
|
|
* The default value is `false`.
|
|
* @property {boolean} [ignoreDestinationZoom] - Ignore the zoom argument in
|
|
* the destination array. The default value is `false`.
|
|
*/
|
|
|
|
/**
|
|
* Scrolls page into view.
|
|
* @param {ScrollPageIntoViewParameters} params
|
|
*/
|
|
scrollPageIntoView({
|
|
pageNumber,
|
|
destArray = null,
|
|
allowNegativeOffset = false,
|
|
ignoreDestinationZoom = false,
|
|
}) {
|
|
if (!this.pdfDocument) {
|
|
return;
|
|
}
|
|
const pageView =
|
|
Number.isInteger(pageNumber) && this._pages[pageNumber - 1];
|
|
if (!pageView) {
|
|
console.error(
|
|
`${this._name}.scrollPageIntoView: ` +
|
|
`"${pageNumber}" is not a valid pageNumber parameter.`
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (this.isInPresentationMode || !destArray) {
|
|
this._setCurrentPageNumber(pageNumber, /* resetCurrentPageView = */ true);
|
|
return;
|
|
}
|
|
let x = 0,
|
|
y = 0;
|
|
let width = 0,
|
|
height = 0,
|
|
widthScale,
|
|
heightScale;
|
|
const changeOrientation = pageView.rotation % 180 !== 0;
|
|
const pageWidth =
|
|
(changeOrientation ? pageView.height : pageView.width) /
|
|
pageView.scale /
|
|
CSS_UNITS;
|
|
const pageHeight =
|
|
(changeOrientation ? pageView.width : pageView.height) /
|
|
pageView.scale /
|
|
CSS_UNITS;
|
|
let scale = 0;
|
|
switch (destArray[1].name) {
|
|
case "XYZ":
|
|
x = destArray[2];
|
|
y = destArray[3];
|
|
scale = destArray[4];
|
|
// If x and/or y coordinates are not supplied, default to
|
|
// _top_ left of the page (not the obvious bottom left,
|
|
// since aligning the bottom of the intended page with the
|
|
// top of the window is rarely helpful).
|
|
x = x !== null ? x : 0;
|
|
y = y !== null ? y : pageHeight;
|
|
break;
|
|
case "Fit":
|
|
case "FitB":
|
|
scale = "page-fit";
|
|
break;
|
|
case "FitH":
|
|
case "FitBH":
|
|
y = destArray[2];
|
|
scale = "page-width";
|
|
// According to the PDF spec, section 12.3.2.2, a `null` value in the
|
|
// parameter should maintain the position relative to the new page.
|
|
if (y === null && this._location) {
|
|
x = this._location.left;
|
|
y = this._location.top;
|
|
} else if (typeof y !== "number") {
|
|
// The "top" value isn't optional, according to the spec, however some
|
|
// bad PDF generators will pretend that it is (fixes bug 1663390).
|
|
y = pageHeight;
|
|
}
|
|
break;
|
|
case "FitV":
|
|
case "FitBV":
|
|
x = destArray[2];
|
|
width = pageWidth;
|
|
height = pageHeight;
|
|
scale = "page-height";
|
|
break;
|
|
case "FitR":
|
|
x = destArray[2];
|
|
y = destArray[3];
|
|
width = destArray[4] - x;
|
|
height = destArray[5] - y;
|
|
const hPadding = this.removePageBorders ? 0 : SCROLLBAR_PADDING;
|
|
const vPadding = this.removePageBorders ? 0 : VERTICAL_PADDING;
|
|
|
|
widthScale =
|
|
(this.container.clientWidth - hPadding) / width / CSS_UNITS;
|
|
heightScale =
|
|
(this.container.clientHeight - vPadding) / height / CSS_UNITS;
|
|
scale = Math.min(Math.abs(widthScale), Math.abs(heightScale));
|
|
break;
|
|
default:
|
|
console.error(
|
|
`${this._name}.scrollPageIntoView: ` +
|
|
`"${destArray[1].name}" is not a valid destination type.`
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (!ignoreDestinationZoom) {
|
|
if (scale && scale !== this._currentScale) {
|
|
this.currentScaleValue = scale;
|
|
} else if (this._currentScale === UNKNOWN_SCALE) {
|
|
this.currentScaleValue = DEFAULT_SCALE_VALUE;
|
|
}
|
|
}
|
|
|
|
if (scale === "page-fit" && !destArray[4]) {
|
|
this._scrollIntoView({
|
|
pageDiv: pageView.div,
|
|
pageNumber,
|
|
});
|
|
return;
|
|
}
|
|
|
|
const boundingRect = [
|
|
pageView.viewport.convertToViewportPoint(x, y),
|
|
pageView.viewport.convertToViewportPoint(x + width, y + height),
|
|
];
|
|
let left = Math.min(boundingRect[0][0], boundingRect[1][0]);
|
|
let top = Math.min(boundingRect[0][1], boundingRect[1][1]);
|
|
|
|
if (!allowNegativeOffset) {
|
|
// Some bad PDF generators will create destinations with e.g. top values
|
|
// that exceeds the page height. Ensure that offsets are not negative,
|
|
// to prevent a previous page from becoming visible (fixes bug 874482).
|
|
left = Math.max(left, 0);
|
|
top = Math.max(top, 0);
|
|
}
|
|
this._scrollIntoView({
|
|
pageDiv: pageView.div,
|
|
pageSpot: { left, top },
|
|
pageNumber,
|
|
});
|
|
}
|
|
|
|
_updateLocation(firstPage) {
|
|
const currentScale = this._currentScale;
|
|
const currentScaleValue = this._currentScaleValue;
|
|
const normalizedScaleValue =
|
|
parseFloat(currentScaleValue) === currentScale
|
|
? Math.round(currentScale * 10000) / 100
|
|
: currentScaleValue;
|
|
|
|
const pageNumber = firstPage.id;
|
|
let pdfOpenParams = "#page=" + pageNumber;
|
|
pdfOpenParams += "&zoom=" + normalizedScaleValue;
|
|
const currentPageView = this._pages[pageNumber - 1];
|
|
const container = this.container;
|
|
const topLeft = currentPageView.getPagePoint(
|
|
container.scrollLeft - firstPage.x,
|
|
container.scrollTop - firstPage.y
|
|
);
|
|
const intLeft = Math.round(topLeft[0]);
|
|
const intTop = Math.round(topLeft[1]);
|
|
pdfOpenParams += "," + intLeft + "," + intTop;
|
|
|
|
this._location = {
|
|
pageNumber,
|
|
scale: normalizedScaleValue,
|
|
top: intTop,
|
|
left: intLeft,
|
|
rotation: this._pagesRotation,
|
|
pdfOpenParams,
|
|
};
|
|
}
|
|
|
|
_updateHelper(visiblePages) {
|
|
throw new Error("Not implemented: _updateHelper");
|
|
}
|
|
|
|
update() {
|
|
const visible = this._getVisiblePages();
|
|
const visiblePages = visible.views,
|
|
numVisiblePages = visiblePages.length;
|
|
|
|
if (numVisiblePages === 0) {
|
|
return;
|
|
}
|
|
const newCacheSize = Math.max(DEFAULT_CACHE_SIZE, 2 * numVisiblePages + 1);
|
|
this._buffer.resize(newCacheSize, visiblePages);
|
|
|
|
this.renderingQueue.renderHighestPriority(visible);
|
|
|
|
this._updateHelper(visiblePages); // Run any class-specific update code.
|
|
|
|
this._updateLocation(visible.first);
|
|
this.eventBus.dispatch("updateviewarea", {
|
|
source: this,
|
|
location: this._location,
|
|
});
|
|
}
|
|
|
|
containsElement(element) {
|
|
return this.container.contains(element);
|
|
}
|
|
|
|
focus() {
|
|
this.container.focus();
|
|
}
|
|
|
|
get _isScrollModeHorizontal() {
|
|
// Used to ensure that pre-rendering of the next/previous page works
|
|
// correctly, since Scroll/Spread modes are ignored in Presentation Mode.
|
|
return this.isInPresentationMode
|
|
? false
|
|
: this._scrollMode === ScrollMode.HORIZONTAL;
|
|
}
|
|
|
|
get _isContainerRtl() {
|
|
return getComputedStyle(this.container).direction === "rtl";
|
|
}
|
|
|
|
get isInPresentationMode() {
|
|
return this.presentationModeState === PresentationModeState.FULLSCREEN;
|
|
}
|
|
|
|
get isChangingPresentationMode() {
|
|
return this.presentationModeState === PresentationModeState.CHANGING;
|
|
}
|
|
|
|
get isHorizontalScrollbarEnabled() {
|
|
return this.isInPresentationMode
|
|
? false
|
|
: this.container.scrollWidth > this.container.clientWidth;
|
|
}
|
|
|
|
get isVerticalScrollbarEnabled() {
|
|
return this.isInPresentationMode
|
|
? false
|
|
: this.container.scrollHeight > this.container.clientHeight;
|
|
}
|
|
|
|
/**
|
|
* Helper method for `this._getVisiblePages`. Should only ever be used when
|
|
* the viewer can only display a single page at a time, for example in:
|
|
* - `PDFSinglePageViewer`.
|
|
* - `PDFViewer` with Presentation Mode active.
|
|
*/
|
|
_getCurrentVisiblePage() {
|
|
if (!this.pagesCount) {
|
|
return { views: [] };
|
|
}
|
|
const pageView = this._pages[this._currentPageNumber - 1];
|
|
// NOTE: Compute the `x` and `y` properties of the current view,
|
|
// since `this._updateLocation` depends of them being available.
|
|
const element = pageView.div;
|
|
|
|
const view = {
|
|
id: pageView.id,
|
|
x: element.offsetLeft + element.clientLeft,
|
|
y: element.offsetTop + element.clientTop,
|
|
view: pageView,
|
|
};
|
|
return { first: view, last: view, views: [view] };
|
|
}
|
|
|
|
_getVisiblePages() {
|
|
return getVisibleElements({
|
|
scrollEl: this.container,
|
|
views: this._pages,
|
|
sortByVisibility: true,
|
|
horizontal: this._isScrollModeHorizontal,
|
|
rtl: this._isScrollModeHorizontal && this._isContainerRtl,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @param {number} pageNumber
|
|
*/
|
|
isPageVisible(pageNumber) {
|
|
if (!this.pdfDocument) {
|
|
return false;
|
|
}
|
|
if (
|
|
!(
|
|
Number.isInteger(pageNumber) &&
|
|
pageNumber > 0 &&
|
|
pageNumber <= this.pagesCount
|
|
)
|
|
) {
|
|
console.error(
|
|
`${this._name}.isPageVisible: "${pageNumber}" is not a valid page.`
|
|
);
|
|
return false;
|
|
}
|
|
return this._getVisiblePages().views.some(function (view) {
|
|
return view.id === pageNumber;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @param {number} pageNumber
|
|
*/
|
|
isPageCached(pageNumber) {
|
|
if (!this.pdfDocument || !this._buffer) {
|
|
return false;
|
|
}
|
|
if (
|
|
!(
|
|
Number.isInteger(pageNumber) &&
|
|
pageNumber > 0 &&
|
|
pageNumber <= this.pagesCount
|
|
)
|
|
) {
|
|
console.error(
|
|
`${this._name}.isPageCached: "${pageNumber}" is not a valid page.`
|
|
);
|
|
return false;
|
|
}
|
|
const pageView = this._pages[pageNumber - 1];
|
|
if (!pageView) {
|
|
return false;
|
|
}
|
|
return this._buffer.has(pageView);
|
|
}
|
|
|
|
cleanup() {
|
|
for (let i = 0, ii = this._pages.length; i < ii; i++) {
|
|
if (
|
|
this._pages[i] &&
|
|
this._pages[i].renderingState !== RenderingStates.FINISHED
|
|
) {
|
|
this._pages[i].reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
_cancelRendering() {
|
|
for (let i = 0, ii = this._pages.length; i < ii; i++) {
|
|
if (this._pages[i]) {
|
|
this._pages[i].cancelRendering();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {PDFPageView} pageView
|
|
* @returns {Promise} Returns a promise containing a {PDFPageProxy} object.
|
|
* @private
|
|
*/
|
|
_ensurePdfPageLoaded(pageView) {
|
|
if (pageView.pdfPage) {
|
|
return Promise.resolve(pageView.pdfPage);
|
|
}
|
|
if (this._pagesRequests.has(pageView)) {
|
|
return this._pagesRequests.get(pageView);
|
|
}
|
|
const promise = this.pdfDocument
|
|
.getPage(pageView.id)
|
|
.then(pdfPage => {
|
|
if (!pageView.pdfPage) {
|
|
pageView.setPdfPage(pdfPage);
|
|
}
|
|
this._pagesRequests.delete(pageView);
|
|
return pdfPage;
|
|
})
|
|
.catch(reason => {
|
|
console.error("Unable to get page for page view", reason);
|
|
// Page error -- there is nothing that can be done.
|
|
this._pagesRequests.delete(pageView);
|
|
});
|
|
this._pagesRequests.set(pageView, promise);
|
|
return promise;
|
|
}
|
|
|
|
forceRendering(currentlyVisiblePages) {
|
|
const visiblePages = currentlyVisiblePages || this._getVisiblePages();
|
|
const scrollAhead = this._isScrollModeHorizontal
|
|
? this.scroll.right
|
|
: this.scroll.down;
|
|
const pageView = this.renderingQueue.getHighestPriority(
|
|
visiblePages,
|
|
this._pages,
|
|
scrollAhead
|
|
);
|
|
if (pageView) {
|
|
this._ensurePdfPageLoaded(pageView).then(() => {
|
|
this.renderingQueue.renderView(pageView);
|
|
});
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param {HTMLDivElement} textLayerDiv
|
|
* @param {number} pageIndex
|
|
* @param {PageViewport} viewport
|
|
* @param {boolean} enhanceTextSelection
|
|
* @param {EventBus} eventBus
|
|
* @returns {TextLayerBuilder}
|
|
*/
|
|
createTextLayerBuilder(
|
|
textLayerDiv,
|
|
pageIndex,
|
|
viewport,
|
|
enhanceTextSelection = false,
|
|
eventBus
|
|
) {
|
|
return new TextLayerBuilder({
|
|
textLayerDiv,
|
|
eventBus,
|
|
pageIndex,
|
|
viewport,
|
|
findController: this.isInPresentationMode ? null : this.findController,
|
|
enhanceTextSelection: this.isInPresentationMode
|
|
? false
|
|
: enhanceTextSelection,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @param {HTMLDivElement} pageDiv
|
|
* @param {PDFPage} pdfPage
|
|
* @param {AnnotationStorage} [annotationStorage] - Storage for annotation
|
|
* data in forms.
|
|
* @param {string} [imageResourcesPath] - Path for image resources, mainly
|
|
* for annotation icons. Include trailing slash.
|
|
* @param {boolean} renderInteractiveForms
|
|
* @param {IL10n} l10n
|
|
* @param {boolean} [enableScripting]
|
|
* @param {Promise<boolean>} [hasJSActionsPromise]
|
|
* @returns {AnnotationLayerBuilder}
|
|
*/
|
|
createAnnotationLayerBuilder(
|
|
pageDiv,
|
|
pdfPage,
|
|
annotationStorage = null,
|
|
imageResourcesPath = "",
|
|
renderInteractiveForms = false,
|
|
l10n = NullL10n,
|
|
enableScripting = false,
|
|
hasJSActionsPromise = null
|
|
) {
|
|
return new AnnotationLayerBuilder({
|
|
pageDiv,
|
|
pdfPage,
|
|
annotationStorage:
|
|
annotationStorage || this.pdfDocument?.annotationStorage,
|
|
imageResourcesPath,
|
|
renderInteractiveForms,
|
|
linkService: this.linkService,
|
|
downloadManager: this.downloadManager,
|
|
l10n,
|
|
enableScripting,
|
|
hasJSActionsPromise:
|
|
hasJSActionsPromise || this.pdfDocument?.hasJSActions(),
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @type {boolean} Whether all pages of the PDF document have identical
|
|
* widths and heights.
|
|
*/
|
|
get hasEqualPageSizes() {
|
|
const firstPageView = this._pages[0];
|
|
for (let i = 1, ii = this._pages.length; i < ii; ++i) {
|
|
const pageView = this._pages[i];
|
|
if (
|
|
pageView.width !== firstPageView.width ||
|
|
pageView.height !== firstPageView.height
|
|
) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Returns sizes of the pages.
|
|
* @returns {Array} Array of objects with width/height/rotation fields.
|
|
*/
|
|
getPagesOverview() {
|
|
const pagesOverview = this._pages.map(function (pageView) {
|
|
const viewport = pageView.pdfPage.getViewport({ scale: 1 });
|
|
return {
|
|
width: viewport.width,
|
|
height: viewport.height,
|
|
rotation: viewport.rotation,
|
|
};
|
|
});
|
|
if (!this.enablePrintAutoRotate) {
|
|
return pagesOverview;
|
|
}
|
|
return pagesOverview.map(function (size) {
|
|
if (isPortraitOrientation(size)) {
|
|
return size;
|
|
}
|
|
return {
|
|
width: size.height,
|
|
height: size.width,
|
|
rotation: (size.rotation + 90) % 360,
|
|
};
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @type {Promise<OptionalContentConfig | null>}
|
|
*/
|
|
get optionalContentConfigPromise() {
|
|
if (!this.pdfDocument) {
|
|
return Promise.resolve(null);
|
|
}
|
|
if (!this._optionalContentConfigPromise) {
|
|
// Prevent issues if the getter is accessed *before* the `onePageRendered`
|
|
// promise has resolved; won't (normally) happen in the default viewer.
|
|
return this.pdfDocument.getOptionalContentConfig();
|
|
}
|
|
return this._optionalContentConfigPromise;
|
|
}
|
|
|
|
/**
|
|
* @param {Promise<OptionalContentConfig>} promise - A promise that is
|
|
* resolved with an {@link OptionalContentConfig} instance.
|
|
*/
|
|
set optionalContentConfigPromise(promise) {
|
|
if (!(promise instanceof Promise)) {
|
|
throw new Error(`Invalid optionalContentConfigPromise: ${promise}`);
|
|
}
|
|
if (!this.pdfDocument) {
|
|
return;
|
|
}
|
|
if (!this._optionalContentConfigPromise) {
|
|
// Ignore the setter *before* the `onePageRendered` promise has resolved,
|
|
// since it'll be overwritten anyway; won't happen in the default viewer.
|
|
return;
|
|
}
|
|
this._optionalContentConfigPromise = promise;
|
|
|
|
for (const pageView of this._pages) {
|
|
pageView.update(pageView.scale, pageView.rotation, promise);
|
|
}
|
|
this.update();
|
|
|
|
this.eventBus.dispatch("optionalcontentconfigchanged", {
|
|
source: this,
|
|
promise,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @type {number} One of the values in {ScrollMode}.
|
|
*/
|
|
get scrollMode() {
|
|
return this._scrollMode;
|
|
}
|
|
|
|
/**
|
|
* @param {number} mode - The direction in which the document pages should be
|
|
* laid out within the scrolling container.
|
|
* The constants from {ScrollMode} should be used.
|
|
*/
|
|
set scrollMode(mode) {
|
|
if (this._scrollMode === mode) {
|
|
return; // The Scroll mode didn't change.
|
|
}
|
|
if (!isValidScrollMode(mode)) {
|
|
throw new Error(`Invalid scroll mode: ${mode}`);
|
|
}
|
|
this._scrollMode = mode;
|
|
this.eventBus.dispatch("scrollmodechanged", { source: this, mode });
|
|
|
|
this._updateScrollMode(/* pageNumber = */ this._currentPageNumber);
|
|
}
|
|
|
|
_updateScrollMode(pageNumber = null) {
|
|
const scrollMode = this._scrollMode,
|
|
viewer = this.viewer;
|
|
|
|
viewer.classList.toggle(
|
|
"scrollHorizontal",
|
|
scrollMode === ScrollMode.HORIZONTAL
|
|
);
|
|
viewer.classList.toggle("scrollWrapped", scrollMode === ScrollMode.WRAPPED);
|
|
|
|
if (!this.pdfDocument || !pageNumber) {
|
|
return;
|
|
}
|
|
// Non-numeric scale values can be sensitive to the scroll orientation.
|
|
// Call this before re-scrolling to the current page, to ensure that any
|
|
// changes in scale don't move the current page.
|
|
if (this._currentScaleValue && isNaN(this._currentScaleValue)) {
|
|
this._setScale(this._currentScaleValue, true);
|
|
}
|
|
this._setCurrentPageNumber(pageNumber, /* resetCurrentPageView = */ true);
|
|
this.update();
|
|
}
|
|
|
|
/**
|
|
* @type {number} One of the values in {SpreadMode}.
|
|
*/
|
|
get spreadMode() {
|
|
return this._spreadMode;
|
|
}
|
|
|
|
/**
|
|
* @param {number} mode - Group the pages in spreads, starting with odd- or
|
|
* even-number pages (unless `SpreadMode.NONE` is used).
|
|
* The constants from {SpreadMode} should be used.
|
|
*/
|
|
set spreadMode(mode) {
|
|
if (this._spreadMode === mode) {
|
|
return; // The Spread mode didn't change.
|
|
}
|
|
if (!isValidSpreadMode(mode)) {
|
|
throw new Error(`Invalid spread mode: ${mode}`);
|
|
}
|
|
this._spreadMode = mode;
|
|
this.eventBus.dispatch("spreadmodechanged", { source: this, mode });
|
|
|
|
this._updateSpreadMode(/* pageNumber = */ this._currentPageNumber);
|
|
}
|
|
|
|
_updateSpreadMode(pageNumber = null) {
|
|
if (!this.pdfDocument) {
|
|
return;
|
|
}
|
|
const viewer = this.viewer,
|
|
pages = this._pages;
|
|
// Temporarily remove all the pages from the DOM.
|
|
viewer.textContent = "";
|
|
|
|
if (this._spreadMode === SpreadMode.NONE) {
|
|
for (let i = 0, iMax = pages.length; i < iMax; ++i) {
|
|
viewer.appendChild(pages[i].div);
|
|
}
|
|
} else {
|
|
const parity = this._spreadMode - 1;
|
|
let spread = null;
|
|
for (let i = 0, iMax = pages.length; i < iMax; ++i) {
|
|
if (spread === null) {
|
|
spread = document.createElement("div");
|
|
spread.className = "spread";
|
|
viewer.appendChild(spread);
|
|
} else if (i % 2 === parity) {
|
|
spread = spread.cloneNode(false);
|
|
viewer.appendChild(spread);
|
|
}
|
|
spread.appendChild(pages[i].div);
|
|
}
|
|
}
|
|
|
|
if (!pageNumber) {
|
|
return;
|
|
}
|
|
this._setCurrentPageNumber(pageNumber, /* resetCurrentPageView = */ true);
|
|
this.update();
|
|
}
|
|
}
|
|
|
|
export { BaseViewer };
|