2852 lines
76 KiB
JavaScript
2852 lines
76 KiB
JavaScript
/**
|
|
* @licstart The following is the entire license notice for the
|
|
* JavaScript code in this page
|
|
*
|
|
* Copyright 2022 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.
|
|
*
|
|
* @licend The above is the entire license notice for the
|
|
* JavaScript code in this page
|
|
*/
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.PDFViewerApplication = exports.PDFPrintServiceFactory = exports.DefaultExternalServices = void 0;
|
|
|
|
var _ui_utils = require("./ui_utils.js");
|
|
|
|
var _pdf = require("../pdf");
|
|
|
|
var _app_options = require("./app_options.js");
|
|
|
|
var _event_utils = require("./event_utils.js");
|
|
|
|
var _pdf_cursor_tools = require("./pdf_cursor_tools.js");
|
|
|
|
var _pdf_link_service = require("./pdf_link_service.js");
|
|
|
|
var _annotation_editor_params = require("./annotation_editor_params.js");
|
|
|
|
var _overlay_manager = require("./overlay_manager.js");
|
|
|
|
var _password_prompt = require("./password_prompt.js");
|
|
|
|
var _pdf_attachment_viewer = require("./pdf_attachment_viewer.js");
|
|
|
|
var _pdf_document_properties = require("./pdf_document_properties.js");
|
|
|
|
var _pdf_find_bar = require("./pdf_find_bar.js");
|
|
|
|
var _pdf_find_controller = require("./pdf_find_controller.js");
|
|
|
|
var _pdf_history = require("./pdf_history.js");
|
|
|
|
var _pdf_layer_viewer = require("./pdf_layer_viewer.js");
|
|
|
|
var _pdf_outline_viewer = require("./pdf_outline_viewer.js");
|
|
|
|
var _pdf_presentation_mode = require("./pdf_presentation_mode.js");
|
|
|
|
var _pdf_rendering_queue = require("./pdf_rendering_queue.js");
|
|
|
|
var _pdf_scripting_manager = require("./pdf_scripting_manager.js");
|
|
|
|
var _pdf_sidebar = require("./pdf_sidebar.js");
|
|
|
|
var _pdf_sidebar_resizer = require("./pdf_sidebar_resizer.js");
|
|
|
|
var _pdf_thumbnail_viewer = require("./pdf_thumbnail_viewer.js");
|
|
|
|
var _pdf_viewer = require("./pdf_viewer.js");
|
|
|
|
var _secondary_toolbar = require("./secondary_toolbar.js");
|
|
|
|
var _toolbar = require("./toolbar.js");
|
|
|
|
var _view_history = require("./view_history.js");
|
|
|
|
const DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT = 5000;
|
|
const FORCE_PAGES_LOADED_TIMEOUT = 10000;
|
|
const WHEEL_ZOOM_DISABLED_TIMEOUT = 1000;
|
|
const ViewOnLoad = {
|
|
UNKNOWN: -1,
|
|
PREVIOUS: 0,
|
|
INITIAL: 1
|
|
};
|
|
const ViewerCssTheme = {
|
|
AUTOMATIC: 0,
|
|
LIGHT: 1,
|
|
DARK: 2
|
|
};
|
|
const KNOWN_VERSIONS = ["1.0", "1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "1.8", "1.9", "2.0", "2.1", "2.2", "2.3"];
|
|
const KNOWN_GENERATORS = ["acrobat distiller", "acrobat pdfwriter", "adobe livecycle", "adobe pdf library", "adobe photoshop", "ghostscript", "tcpdf", "cairo", "dvipdfm", "dvips", "pdftex", "pdfkit", "itext", "prince", "quarkxpress", "mac os x", "microsoft", "openoffice", "oracle", "luradocument", "pdf-xchange", "antenna house", "aspose.cells", "fpdf"];
|
|
|
|
class DefaultExternalServices {
|
|
constructor() {
|
|
throw new Error("Cannot initialize DefaultExternalServices.");
|
|
}
|
|
|
|
static updateFindControlState(data) {}
|
|
|
|
static updateFindMatchesCount(data) {}
|
|
|
|
static initPassiveLoading(callbacks) {}
|
|
|
|
static reportTelemetry(data) {}
|
|
|
|
static createDownloadManager(options) {
|
|
throw new Error("Not implemented: createDownloadManager");
|
|
}
|
|
|
|
static createPreferences() {
|
|
throw new Error("Not implemented: createPreferences");
|
|
}
|
|
|
|
static createL10n(options) {
|
|
throw new Error("Not implemented: createL10n");
|
|
}
|
|
|
|
static createScripting(options) {
|
|
throw new Error("Not implemented: createScripting");
|
|
}
|
|
|
|
static get supportsIntegratedFind() {
|
|
return (0, _pdf.shadow)(this, "supportsIntegratedFind", false);
|
|
}
|
|
|
|
static get supportsDocumentFonts() {
|
|
return (0, _pdf.shadow)(this, "supportsDocumentFonts", true);
|
|
}
|
|
|
|
static get supportedMouseWheelZoomModifierKeys() {
|
|
return (0, _pdf.shadow)(this, "supportedMouseWheelZoomModifierKeys", {
|
|
ctrlKey: true,
|
|
metaKey: true
|
|
});
|
|
}
|
|
|
|
static get isInAutomation() {
|
|
return (0, _pdf.shadow)(this, "isInAutomation", false);
|
|
}
|
|
|
|
static updateEditorStates(data) {
|
|
throw new Error("Not implemented: updateEditorStates");
|
|
}
|
|
|
|
}
|
|
|
|
exports.DefaultExternalServices = DefaultExternalServices;
|
|
const PDFViewerApplication = {
|
|
initialBookmark: document.location.hash.substring(1),
|
|
_initializedCapability: (0, _pdf.createPromiseCapability)(),
|
|
appConfig: null,
|
|
pdfDocument: null,
|
|
pdfLoadingTask: null,
|
|
printService: null,
|
|
pdfViewer: null,
|
|
pdfThumbnailViewer: null,
|
|
pdfRenderingQueue: null,
|
|
pdfPresentationMode: null,
|
|
pdfDocumentProperties: null,
|
|
pdfLinkService: null,
|
|
pdfHistory: null,
|
|
pdfSidebar: null,
|
|
pdfSidebarResizer: null,
|
|
pdfOutlineViewer: null,
|
|
pdfAttachmentViewer: null,
|
|
pdfLayerViewer: null,
|
|
pdfCursorTools: null,
|
|
pdfScriptingManager: null,
|
|
store: null,
|
|
downloadManager: null,
|
|
overlayManager: null,
|
|
preferences: null,
|
|
toolbar: null,
|
|
secondaryToolbar: null,
|
|
eventBus: null,
|
|
l10n: null,
|
|
annotationEditorParams: null,
|
|
isInitialViewSet: false,
|
|
downloadComplete: false,
|
|
isViewerEmbedded: window.parent !== window,
|
|
url: "",
|
|
baseUrl: "",
|
|
_downloadUrl: "",
|
|
externalServices: DefaultExternalServices,
|
|
_boundEvents: Object.create(null),
|
|
documentInfo: null,
|
|
metadata: null,
|
|
_contentDispositionFilename: null,
|
|
_contentLength: null,
|
|
_saveInProgress: false,
|
|
_docStats: null,
|
|
_wheelUnusedTicks: 0,
|
|
_idleCallbacks: new Set(),
|
|
_PDFBug: null,
|
|
_hasAnnotationEditors: false,
|
|
_title: document.title,
|
|
_printAnnotationStoragePromise: null,
|
|
|
|
async initialize(appConfig) {
|
|
this.preferences = this.externalServices.createPreferences();
|
|
this.appConfig = appConfig;
|
|
await this._readPreferences();
|
|
await this._parseHashParameters();
|
|
|
|
this._forceCssTheme();
|
|
|
|
await this._initializeL10n();
|
|
|
|
if (this.isViewerEmbedded && _app_options.AppOptions.get("externalLinkTarget") === _pdf_link_service.LinkTarget.NONE) {
|
|
_app_options.AppOptions.set("externalLinkTarget", _pdf_link_service.LinkTarget.TOP);
|
|
}
|
|
|
|
await this._initializeViewerComponents();
|
|
this.bindEvents();
|
|
this.bindWindowEvents();
|
|
const appContainer = appConfig.appContainer || document.documentElement;
|
|
this.l10n.translate(appContainer).then(() => {
|
|
this.eventBus.dispatch("localized", {
|
|
source: this
|
|
});
|
|
});
|
|
|
|
this._initializedCapability.resolve();
|
|
},
|
|
|
|
async _readPreferences() {
|
|
if (_app_options.AppOptions.get("disablePreferences")) {
|
|
return;
|
|
}
|
|
|
|
if (_app_options.AppOptions._hasUserOptions()) {
|
|
console.warn("_readPreferences: The Preferences may override manually set AppOptions; " + 'please use the "disablePreferences"-option in order to prevent that.');
|
|
}
|
|
|
|
try {
|
|
_app_options.AppOptions.setAll(await this.preferences.getAll());
|
|
} catch (reason) {
|
|
console.error(`_readPreferences: "${reason?.message}".`);
|
|
}
|
|
},
|
|
|
|
async _parseHashParameters() {
|
|
if (!_app_options.AppOptions.get("pdfBugEnabled")) {
|
|
return;
|
|
}
|
|
|
|
const hash = document.location.hash.substring(1);
|
|
|
|
if (!hash) {
|
|
return;
|
|
}
|
|
|
|
const {
|
|
mainContainer,
|
|
viewerContainer
|
|
} = this.appConfig,
|
|
params = (0, _ui_utils.parseQueryString)(hash);
|
|
|
|
if (params.get("disableworker") === "true") {
|
|
try {
|
|
await loadFakeWorker();
|
|
} catch (ex) {
|
|
console.error(`_parseHashParameters: "${ex.message}".`);
|
|
}
|
|
}
|
|
|
|
if (params.has("disablerange")) {
|
|
_app_options.AppOptions.set("disableRange", params.get("disablerange") === "true");
|
|
}
|
|
|
|
if (params.has("disablestream")) {
|
|
_app_options.AppOptions.set("disableStream", params.get("disablestream") === "true");
|
|
}
|
|
|
|
if (params.has("disableautofetch")) {
|
|
_app_options.AppOptions.set("disableAutoFetch", params.get("disableautofetch") === "true");
|
|
}
|
|
|
|
if (params.has("disablefontface")) {
|
|
_app_options.AppOptions.set("disableFontFace", params.get("disablefontface") === "true");
|
|
}
|
|
|
|
if (params.has("disablehistory")) {
|
|
_app_options.AppOptions.set("disableHistory", params.get("disablehistory") === "true");
|
|
}
|
|
|
|
if (params.has("verbosity")) {
|
|
_app_options.AppOptions.set("verbosity", params.get("verbosity") | 0);
|
|
}
|
|
|
|
if (params.has("textlayer")) {
|
|
switch (params.get("textlayer")) {
|
|
case "off":
|
|
_app_options.AppOptions.set("textLayerMode", _ui_utils.TextLayerMode.DISABLE);
|
|
|
|
break;
|
|
|
|
case "visible":
|
|
case "shadow":
|
|
case "hover":
|
|
viewerContainer.classList.add(`textLayer-${params.get("textlayer")}`);
|
|
|
|
try {
|
|
await loadPDFBug(this);
|
|
|
|
this._PDFBug.loadCSS();
|
|
} catch (ex) {
|
|
console.error(`_parseHashParameters: "${ex.message}".`);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (params.has("pdfbug")) {
|
|
_app_options.AppOptions.set("pdfBug", true);
|
|
|
|
_app_options.AppOptions.set("fontExtraProperties", true);
|
|
|
|
const enabled = params.get("pdfbug").split(",");
|
|
|
|
try {
|
|
await loadPDFBug(this);
|
|
|
|
this._PDFBug.init({
|
|
OPS: _pdf.OPS
|
|
}, mainContainer, enabled);
|
|
} catch (ex) {
|
|
console.error(`_parseHashParameters: "${ex.message}".`);
|
|
}
|
|
}
|
|
|
|
if (params.has("locale")) {
|
|
_app_options.AppOptions.set("locale", params.get("locale"));
|
|
}
|
|
},
|
|
|
|
async _initializeL10n() {
|
|
this.l10n = this.externalServices.createL10n({
|
|
locale: _app_options.AppOptions.get("locale")
|
|
});
|
|
const dir = await this.l10n.getDirection();
|
|
document.getElementsByTagName("html")[0].dir = dir;
|
|
},
|
|
|
|
_forceCssTheme() {
|
|
const cssTheme = _app_options.AppOptions.get("viewerCssTheme");
|
|
|
|
if (cssTheme === ViewerCssTheme.AUTOMATIC || !Object.values(ViewerCssTheme).includes(cssTheme)) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const styleSheet = document.styleSheets[0];
|
|
const cssRules = styleSheet?.cssRules || [];
|
|
|
|
for (let i = 0, ii = cssRules.length; i < ii; i++) {
|
|
const rule = cssRules[i];
|
|
|
|
if (rule instanceof CSSMediaRule && rule.media?.[0] === "(prefers-color-scheme: dark)") {
|
|
if (cssTheme === ViewerCssTheme.LIGHT) {
|
|
styleSheet.deleteRule(i);
|
|
return;
|
|
}
|
|
|
|
const darkRules = /^@media \(prefers-color-scheme: dark\) {\n\s*([\w\s-.,:;/\\{}()]+)\n}$/.exec(rule.cssText);
|
|
|
|
if (darkRules?.[1]) {
|
|
styleSheet.deleteRule(i);
|
|
styleSheet.insertRule(darkRules[1], i);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
} catch (reason) {
|
|
console.error(`_forceCssTheme: "${reason?.message}".`);
|
|
}
|
|
},
|
|
|
|
async _initializeViewerComponents() {
|
|
const {
|
|
appConfig,
|
|
externalServices
|
|
} = this;
|
|
const eventBus = externalServices.isInAutomation ? new _event_utils.AutomationEventBus() : new _event_utils.EventBus();
|
|
this.eventBus = eventBus;
|
|
this.overlayManager = new _overlay_manager.OverlayManager();
|
|
const pdfRenderingQueue = new _pdf_rendering_queue.PDFRenderingQueue();
|
|
pdfRenderingQueue.onIdle = this._cleanup.bind(this);
|
|
this.pdfRenderingQueue = pdfRenderingQueue;
|
|
const pdfLinkService = new _pdf_link_service.PDFLinkService({
|
|
eventBus,
|
|
externalLinkTarget: _app_options.AppOptions.get("externalLinkTarget"),
|
|
externalLinkRel: _app_options.AppOptions.get("externalLinkRel"),
|
|
ignoreDestinationZoom: _app_options.AppOptions.get("ignoreDestinationZoom")
|
|
});
|
|
this.pdfLinkService = pdfLinkService;
|
|
const downloadManager = externalServices.createDownloadManager();
|
|
this.downloadManager = downloadManager;
|
|
const findController = new _pdf_find_controller.PDFFindController({
|
|
linkService: pdfLinkService,
|
|
eventBus
|
|
});
|
|
this.findController = findController;
|
|
const pdfScriptingManager = new _pdf_scripting_manager.PDFScriptingManager({
|
|
eventBus,
|
|
sandboxBundleSrc: _app_options.AppOptions.get("sandboxBundleSrc"),
|
|
scriptingFactory: externalServices,
|
|
docPropertiesLookup: this._scriptingDocProperties.bind(this)
|
|
});
|
|
this.pdfScriptingManager = pdfScriptingManager;
|
|
const container = appConfig.mainContainer,
|
|
viewer = appConfig.viewerContainer;
|
|
|
|
const annotationEditorMode = _app_options.AppOptions.get("annotationEditorMode");
|
|
|
|
const pageColors = _app_options.AppOptions.get("forcePageColors") || window.matchMedia("(forced-colors: active)").matches ? {
|
|
background: _app_options.AppOptions.get("pageColorsBackground"),
|
|
foreground: _app_options.AppOptions.get("pageColorsForeground")
|
|
} : null;
|
|
this.pdfViewer = new _pdf_viewer.PDFViewer({
|
|
container,
|
|
viewer,
|
|
eventBus,
|
|
renderingQueue: pdfRenderingQueue,
|
|
linkService: pdfLinkService,
|
|
downloadManager,
|
|
findController,
|
|
scriptingManager: _app_options.AppOptions.get("enableScripting") && pdfScriptingManager,
|
|
renderer: _app_options.AppOptions.get("renderer"),
|
|
l10n: this.l10n,
|
|
textLayerMode: _app_options.AppOptions.get("textLayerMode"),
|
|
annotationMode: _app_options.AppOptions.get("annotationMode"),
|
|
annotationEditorMode,
|
|
imageResourcesPath: _app_options.AppOptions.get("imageResourcesPath"),
|
|
enablePrintAutoRotate: _app_options.AppOptions.get("enablePrintAutoRotate"),
|
|
useOnlyCssZoom: _app_options.AppOptions.get("useOnlyCssZoom"),
|
|
maxCanvasPixels: _app_options.AppOptions.get("maxCanvasPixels"),
|
|
enablePermissions: _app_options.AppOptions.get("enablePermissions"),
|
|
pageColors
|
|
});
|
|
pdfRenderingQueue.setViewer(this.pdfViewer);
|
|
pdfLinkService.setViewer(this.pdfViewer);
|
|
pdfScriptingManager.setViewer(this.pdfViewer);
|
|
this.pdfThumbnailViewer = new _pdf_thumbnail_viewer.PDFThumbnailViewer({
|
|
container: appConfig.sidebar.thumbnailView,
|
|
eventBus,
|
|
renderingQueue: pdfRenderingQueue,
|
|
linkService: pdfLinkService,
|
|
l10n: this.l10n,
|
|
pageColors
|
|
});
|
|
pdfRenderingQueue.setThumbnailViewer(this.pdfThumbnailViewer);
|
|
|
|
if (!this.isViewerEmbedded && !_app_options.AppOptions.get("disableHistory")) {
|
|
this.pdfHistory = new _pdf_history.PDFHistory({
|
|
linkService: pdfLinkService,
|
|
eventBus
|
|
});
|
|
pdfLinkService.setHistory(this.pdfHistory);
|
|
}
|
|
|
|
if (!this.supportsIntegratedFind) {
|
|
this.findBar = new _pdf_find_bar.PDFFindBar(appConfig.findBar, eventBus, this.l10n);
|
|
}
|
|
|
|
if (annotationEditorMode !== _pdf.AnnotationEditorType.DISABLE) {
|
|
this.annotationEditorParams = new _annotation_editor_params.AnnotationEditorParams(appConfig.annotationEditorParams, eventBus);
|
|
|
|
for (const element of [document.getElementById("editorModeButtons"), document.getElementById("editorModeSeparator")]) {
|
|
element.classList.remove("hidden");
|
|
}
|
|
}
|
|
|
|
this.pdfDocumentProperties = new _pdf_document_properties.PDFDocumentProperties(appConfig.documentProperties, this.overlayManager, eventBus, this.l10n, () => {
|
|
return this._docFilename;
|
|
});
|
|
this.pdfCursorTools = new _pdf_cursor_tools.PDFCursorTools({
|
|
container,
|
|
eventBus,
|
|
cursorToolOnLoad: _app_options.AppOptions.get("cursorToolOnLoad")
|
|
});
|
|
this.toolbar = new _toolbar.Toolbar(appConfig.toolbar, eventBus, this.l10n);
|
|
this.secondaryToolbar = new _secondary_toolbar.SecondaryToolbar(appConfig.secondaryToolbar, eventBus);
|
|
|
|
if (this.supportsFullscreen) {
|
|
this.pdfPresentationMode = new _pdf_presentation_mode.PDFPresentationMode({
|
|
container,
|
|
pdfViewer: this.pdfViewer,
|
|
eventBus
|
|
});
|
|
}
|
|
|
|
this.passwordPrompt = new _password_prompt.PasswordPrompt(appConfig.passwordOverlay, this.overlayManager, this.l10n, this.isViewerEmbedded);
|
|
this.pdfOutlineViewer = new _pdf_outline_viewer.PDFOutlineViewer({
|
|
container: appConfig.sidebar.outlineView,
|
|
eventBus,
|
|
linkService: pdfLinkService
|
|
});
|
|
this.pdfAttachmentViewer = new _pdf_attachment_viewer.PDFAttachmentViewer({
|
|
container: appConfig.sidebar.attachmentsView,
|
|
eventBus,
|
|
downloadManager
|
|
});
|
|
this.pdfLayerViewer = new _pdf_layer_viewer.PDFLayerViewer({
|
|
container: appConfig.sidebar.layersView,
|
|
eventBus,
|
|
l10n: this.l10n
|
|
});
|
|
this.pdfSidebar = new _pdf_sidebar.PDFSidebar({
|
|
elements: appConfig.sidebar,
|
|
pdfViewer: this.pdfViewer,
|
|
pdfThumbnailViewer: this.pdfThumbnailViewer,
|
|
eventBus,
|
|
l10n: this.l10n
|
|
});
|
|
this.pdfSidebar.onToggled = this.forceRendering.bind(this);
|
|
this.pdfSidebarResizer = new _pdf_sidebar_resizer.PDFSidebarResizer(appConfig.sidebarResizer, eventBus, this.l10n);
|
|
},
|
|
|
|
run(config) {
|
|
this.initialize(config).then(webViewerInitialized);
|
|
},
|
|
|
|
get initialized() {
|
|
return this._initializedCapability.settled;
|
|
},
|
|
|
|
get initializedPromise() {
|
|
return this._initializedCapability.promise;
|
|
},
|
|
|
|
zoomIn(steps) {
|
|
if (this.pdfViewer.isInPresentationMode) {
|
|
return;
|
|
}
|
|
|
|
this.pdfViewer.increaseScale(steps);
|
|
},
|
|
|
|
zoomOut(steps) {
|
|
if (this.pdfViewer.isInPresentationMode) {
|
|
return;
|
|
}
|
|
|
|
this.pdfViewer.decreaseScale(steps);
|
|
},
|
|
|
|
zoomReset() {
|
|
if (this.pdfViewer.isInPresentationMode) {
|
|
return;
|
|
}
|
|
|
|
this.pdfViewer.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
|
|
},
|
|
|
|
get pagesCount() {
|
|
return this.pdfDocument ? this.pdfDocument.numPages : 0;
|
|
},
|
|
|
|
get page() {
|
|
return this.pdfViewer.currentPageNumber;
|
|
},
|
|
|
|
set page(val) {
|
|
this.pdfViewer.currentPageNumber = val;
|
|
},
|
|
|
|
get supportsPrinting() {
|
|
return PDFPrintServiceFactory.instance.supportsPrinting;
|
|
},
|
|
|
|
get supportsFullscreen() {
|
|
return (0, _pdf.shadow)(this, "supportsFullscreen", document.fullscreenEnabled);
|
|
},
|
|
|
|
get supportsIntegratedFind() {
|
|
return this.externalServices.supportsIntegratedFind;
|
|
},
|
|
|
|
get supportsDocumentFonts() {
|
|
return this.externalServices.supportsDocumentFonts;
|
|
},
|
|
|
|
get loadingBar() {
|
|
const bar = new _ui_utils.ProgressBar("loadingBar");
|
|
return (0, _pdf.shadow)(this, "loadingBar", bar);
|
|
},
|
|
|
|
get supportedMouseWheelZoomModifierKeys() {
|
|
return this.externalServices.supportedMouseWheelZoomModifierKeys;
|
|
},
|
|
|
|
initPassiveLoading() {
|
|
throw new Error("Not implemented: initPassiveLoading");
|
|
},
|
|
|
|
setTitleUsingUrl(url = "", downloadUrl = null) {
|
|
this.url = url;
|
|
this.baseUrl = url.split("#")[0];
|
|
|
|
if (downloadUrl) {
|
|
this._downloadUrl = downloadUrl === url ? this.baseUrl : downloadUrl.split("#")[0];
|
|
}
|
|
|
|
let title = (0, _pdf.getPdfFilenameFromUrl)(url, "");
|
|
|
|
if (!title) {
|
|
try {
|
|
title = decodeURIComponent((0, _pdf.getFilenameFromUrl)(url)) || url;
|
|
} catch (ex) {
|
|
title = url;
|
|
}
|
|
}
|
|
|
|
this.setTitle(title);
|
|
},
|
|
|
|
setTitle(title = this._title) {
|
|
this._title = title;
|
|
|
|
if (this.isViewerEmbedded) {
|
|
return;
|
|
}
|
|
|
|
document.title = `${this._hasAnnotationEditors ? "* " : ""}${title}`;
|
|
},
|
|
|
|
get _docFilename() {
|
|
return this._contentDispositionFilename || (0, _pdf.getPdfFilenameFromUrl)(this.url);
|
|
},
|
|
|
|
_hideViewBookmark() {
|
|
const {
|
|
toolbar,
|
|
secondaryToolbar
|
|
} = this.appConfig;
|
|
toolbar.viewBookmark.hidden = true;
|
|
secondaryToolbar.viewBookmarkButton.hidden = true;
|
|
},
|
|
|
|
_cancelIdleCallbacks() {
|
|
if (!this._idleCallbacks.size) {
|
|
return;
|
|
}
|
|
|
|
for (const callback of this._idleCallbacks) {
|
|
window.cancelIdleCallback(callback);
|
|
}
|
|
|
|
this._idleCallbacks.clear();
|
|
},
|
|
|
|
async close() {
|
|
this._unblockDocumentLoadEvent();
|
|
|
|
this._hideViewBookmark();
|
|
|
|
const {
|
|
container
|
|
} = this.appConfig.errorWrapper;
|
|
container.hidden = true;
|
|
|
|
if (!this.pdfLoadingTask) {
|
|
return;
|
|
}
|
|
|
|
if (this.pdfDocument?.annotationStorage.size > 0 && this._annotationStorageModified) {
|
|
try {
|
|
await this.save();
|
|
} catch (reason) {}
|
|
}
|
|
|
|
const promises = [];
|
|
promises.push(this.pdfLoadingTask.destroy());
|
|
this.pdfLoadingTask = null;
|
|
|
|
if (this.pdfDocument) {
|
|
this.pdfDocument = null;
|
|
this.pdfThumbnailViewer.setDocument(null);
|
|
this.pdfViewer.setDocument(null);
|
|
this.pdfLinkService.setDocument(null);
|
|
this.pdfDocumentProperties.setDocument(null);
|
|
}
|
|
|
|
this.pdfLinkService.externalLinkEnabled = true;
|
|
this.store = null;
|
|
this.isInitialViewSet = false;
|
|
this.downloadComplete = false;
|
|
this.url = "";
|
|
this.baseUrl = "";
|
|
this._downloadUrl = "";
|
|
this.documentInfo = null;
|
|
this.metadata = null;
|
|
this._contentDispositionFilename = null;
|
|
this._contentLength = null;
|
|
this._saveInProgress = false;
|
|
this._docStats = null;
|
|
this._hasAnnotationEditors = false;
|
|
|
|
this._cancelIdleCallbacks();
|
|
|
|
promises.push(this.pdfScriptingManager.destroyPromise);
|
|
this.setTitle();
|
|
this.pdfSidebar.reset();
|
|
this.pdfOutlineViewer.reset();
|
|
this.pdfAttachmentViewer.reset();
|
|
this.pdfLayerViewer.reset();
|
|
this.pdfHistory?.reset();
|
|
this.findBar?.reset();
|
|
this.toolbar.reset();
|
|
this.secondaryToolbar.reset();
|
|
this._PDFBug?.cleanup();
|
|
await Promise.all(promises);
|
|
},
|
|
|
|
async open(file, args) {
|
|
if (this.pdfLoadingTask) {
|
|
await this.close();
|
|
}
|
|
|
|
const workerParameters = _app_options.AppOptions.getAll(_app_options.OptionKind.WORKER);
|
|
|
|
for (const key in workerParameters) {
|
|
_pdf.GlobalWorkerOptions[key] = workerParameters[key];
|
|
}
|
|
|
|
const parameters = Object.create(null);
|
|
|
|
if (typeof file === "string") {
|
|
this.setTitleUsingUrl(file, file);
|
|
parameters.url = file;
|
|
} else if (file && "byteLength" in file) {
|
|
parameters.data = file;
|
|
} else if (file.url && file.originalUrl) {
|
|
this.setTitleUsingUrl(file.originalUrl, file.url);
|
|
parameters.url = file.url;
|
|
}
|
|
|
|
const apiParameters = _app_options.AppOptions.getAll(_app_options.OptionKind.API);
|
|
|
|
for (const key in apiParameters) {
|
|
let value = apiParameters[key];
|
|
|
|
if (key === "docBaseUrl" && !value) {}
|
|
|
|
parameters[key] = value;
|
|
}
|
|
|
|
if (args) {
|
|
for (const key in args) {
|
|
parameters[key] = args[key];
|
|
}
|
|
}
|
|
|
|
const loadingTask = (0, _pdf.getDocument)(parameters);
|
|
this.pdfLoadingTask = loadingTask;
|
|
|
|
loadingTask.onPassword = (updateCallback, reason) => {
|
|
this.pdfLinkService.externalLinkEnabled = false;
|
|
this.passwordPrompt.setUpdateCallback(updateCallback, reason);
|
|
this.passwordPrompt.open();
|
|
};
|
|
|
|
loadingTask.onProgress = ({
|
|
loaded,
|
|
total
|
|
}) => {
|
|
this.progress(loaded / total);
|
|
};
|
|
|
|
loadingTask.onUnsupportedFeature = this.fallback.bind(this);
|
|
return loadingTask.promise.then(pdfDocument => {
|
|
this.load(pdfDocument);
|
|
}, reason => {
|
|
if (loadingTask !== this.pdfLoadingTask) {
|
|
return undefined;
|
|
}
|
|
|
|
let key = "loading_error";
|
|
|
|
if (reason instanceof _pdf.InvalidPDFException) {
|
|
key = "invalid_file_error";
|
|
} else if (reason instanceof _pdf.MissingPDFException) {
|
|
key = "missing_file_error";
|
|
} else if (reason instanceof _pdf.UnexpectedResponseException) {
|
|
key = "unexpected_response_error";
|
|
}
|
|
|
|
return this.l10n.get(key).then(msg => {
|
|
this._documentError(msg, {
|
|
message: reason?.message
|
|
});
|
|
|
|
throw reason;
|
|
});
|
|
});
|
|
},
|
|
|
|
_ensureDownloadComplete() {
|
|
if (this.pdfDocument && this.downloadComplete) {
|
|
return;
|
|
}
|
|
|
|
throw new Error("PDF document not downloaded.");
|
|
},
|
|
|
|
async download() {
|
|
const url = this._downloadUrl,
|
|
filename = this._docFilename;
|
|
|
|
try {
|
|
this._ensureDownloadComplete();
|
|
|
|
const data = await this.pdfDocument.getData();
|
|
const blob = new Blob([data], {
|
|
type: "application/pdf"
|
|
});
|
|
await this.downloadManager.download(blob, url, filename);
|
|
} catch (reason) {
|
|
await this.downloadManager.downloadUrl(url, filename);
|
|
}
|
|
},
|
|
|
|
async save() {
|
|
if (this._saveInProgress) {
|
|
return;
|
|
}
|
|
|
|
this._saveInProgress = true;
|
|
await this.pdfScriptingManager.dispatchWillSave();
|
|
const url = this._downloadUrl,
|
|
filename = this._docFilename;
|
|
|
|
try {
|
|
this._ensureDownloadComplete();
|
|
|
|
const data = await this.pdfDocument.saveDocument();
|
|
const blob = new Blob([data], {
|
|
type: "application/pdf"
|
|
});
|
|
await this.downloadManager.download(blob, url, filename);
|
|
} catch (reason) {
|
|
console.error(`Error when saving the document: ${reason.message}`);
|
|
await this.download();
|
|
} finally {
|
|
await this.pdfScriptingManager.dispatchDidSave();
|
|
this._saveInProgress = false;
|
|
}
|
|
|
|
if (this._hasAnnotationEditors) {
|
|
this.externalServices.reportTelemetry({
|
|
type: "editing",
|
|
data: {
|
|
type: "save"
|
|
}
|
|
});
|
|
}
|
|
},
|
|
|
|
downloadOrSave() {
|
|
if (this.pdfDocument?.annotationStorage.size > 0) {
|
|
this.save();
|
|
} else {
|
|
this.download();
|
|
}
|
|
},
|
|
|
|
fallback(featureId) {
|
|
this.externalServices.reportTelemetry({
|
|
type: "unsupportedFeature",
|
|
featureId
|
|
});
|
|
},
|
|
|
|
_documentError(message, moreInfo = null) {
|
|
this._unblockDocumentLoadEvent();
|
|
|
|
this._otherError(message, moreInfo);
|
|
|
|
this.eventBus.dispatch("documenterror", {
|
|
source: this,
|
|
message,
|
|
reason: moreInfo?.message ?? null
|
|
});
|
|
},
|
|
|
|
_otherError(message, moreInfo = null) {
|
|
const moreInfoText = [this.l10n.get("error_version_info", {
|
|
version: _pdf.version || "?",
|
|
build: _pdf.build || "?"
|
|
})];
|
|
|
|
if (moreInfo) {
|
|
moreInfoText.push(this.l10n.get("error_message", {
|
|
message: moreInfo.message
|
|
}));
|
|
|
|
if (moreInfo.stack) {
|
|
moreInfoText.push(this.l10n.get("error_stack", {
|
|
stack: moreInfo.stack
|
|
}));
|
|
} else {
|
|
if (moreInfo.filename) {
|
|
moreInfoText.push(this.l10n.get("error_file", {
|
|
file: moreInfo.filename
|
|
}));
|
|
}
|
|
|
|
if (moreInfo.lineNumber) {
|
|
moreInfoText.push(this.l10n.get("error_line", {
|
|
line: moreInfo.lineNumber
|
|
}));
|
|
}
|
|
}
|
|
}
|
|
|
|
const errorWrapperConfig = this.appConfig.errorWrapper;
|
|
const errorWrapper = errorWrapperConfig.container;
|
|
errorWrapper.hidden = false;
|
|
const errorMessage = errorWrapperConfig.errorMessage;
|
|
errorMessage.textContent = message;
|
|
const closeButton = errorWrapperConfig.closeButton;
|
|
|
|
closeButton.onclick = function () {
|
|
errorWrapper.hidden = true;
|
|
};
|
|
|
|
const errorMoreInfo = errorWrapperConfig.errorMoreInfo;
|
|
const moreInfoButton = errorWrapperConfig.moreInfoButton;
|
|
const lessInfoButton = errorWrapperConfig.lessInfoButton;
|
|
|
|
moreInfoButton.onclick = function () {
|
|
errorMoreInfo.hidden = false;
|
|
moreInfoButton.hidden = true;
|
|
lessInfoButton.hidden = false;
|
|
errorMoreInfo.style.height = errorMoreInfo.scrollHeight + "px";
|
|
};
|
|
|
|
lessInfoButton.onclick = function () {
|
|
errorMoreInfo.hidden = true;
|
|
moreInfoButton.hidden = false;
|
|
lessInfoButton.hidden = true;
|
|
};
|
|
|
|
moreInfoButton.oncontextmenu = _ui_utils.noContextMenuHandler;
|
|
lessInfoButton.oncontextmenu = _ui_utils.noContextMenuHandler;
|
|
closeButton.oncontextmenu = _ui_utils.noContextMenuHandler;
|
|
moreInfoButton.hidden = false;
|
|
lessInfoButton.hidden = true;
|
|
Promise.all(moreInfoText).then(parts => {
|
|
errorMoreInfo.value = parts.join("\n");
|
|
});
|
|
},
|
|
|
|
progress(level) {
|
|
if (this.downloadComplete) {
|
|
return;
|
|
}
|
|
|
|
const percent = Math.round(level * 100);
|
|
|
|
if (percent <= this.loadingBar.percent) {
|
|
return;
|
|
}
|
|
|
|
this.loadingBar.percent = percent;
|
|
|
|
const disableAutoFetch = this.pdfDocument?.loadingParams.disableAutoFetch ?? _app_options.AppOptions.get("disableAutoFetch");
|
|
|
|
if (!disableAutoFetch || isNaN(percent)) {
|
|
return;
|
|
}
|
|
|
|
if (this.disableAutoFetchLoadingBarTimeout) {
|
|
clearTimeout(this.disableAutoFetchLoadingBarTimeout);
|
|
this.disableAutoFetchLoadingBarTimeout = null;
|
|
}
|
|
|
|
this.loadingBar.show();
|
|
this.disableAutoFetchLoadingBarTimeout = setTimeout(() => {
|
|
this.loadingBar.hide();
|
|
this.disableAutoFetchLoadingBarTimeout = null;
|
|
}, DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT);
|
|
},
|
|
|
|
load(pdfDocument) {
|
|
this.pdfDocument = pdfDocument;
|
|
pdfDocument.getDownloadInfo().then(({
|
|
length
|
|
}) => {
|
|
this._contentLength = length;
|
|
this.downloadComplete = true;
|
|
this.loadingBar.hide();
|
|
firstPagePromise.then(() => {
|
|
this.eventBus.dispatch("documentloaded", {
|
|
source: this
|
|
});
|
|
});
|
|
});
|
|
const pageLayoutPromise = pdfDocument.getPageLayout().catch(function () {});
|
|
const pageModePromise = pdfDocument.getPageMode().catch(function () {});
|
|
const openActionPromise = pdfDocument.getOpenAction().catch(function () {});
|
|
this.toolbar.setPagesCount(pdfDocument.numPages, false);
|
|
this.secondaryToolbar.setPagesCount(pdfDocument.numPages);
|
|
let baseDocumentUrl;
|
|
baseDocumentUrl = null;
|
|
this.pdfLinkService.setDocument(pdfDocument, baseDocumentUrl);
|
|
this.pdfDocumentProperties.setDocument(pdfDocument);
|
|
const pdfViewer = this.pdfViewer;
|
|
pdfViewer.setDocument(pdfDocument);
|
|
const {
|
|
firstPagePromise,
|
|
onePageRendered,
|
|
pagesPromise
|
|
} = pdfViewer;
|
|
const pdfThumbnailViewer = this.pdfThumbnailViewer;
|
|
pdfThumbnailViewer.setDocument(pdfDocument);
|
|
const storedPromise = (this.store = new _view_history.ViewHistory(pdfDocument.fingerprints[0])).getMultiple({
|
|
page: null,
|
|
zoom: _ui_utils.DEFAULT_SCALE_VALUE,
|
|
scrollLeft: "0",
|
|
scrollTop: "0",
|
|
rotation: null,
|
|
sidebarView: _ui_utils.SidebarView.UNKNOWN,
|
|
scrollMode: _ui_utils.ScrollMode.UNKNOWN,
|
|
spreadMode: _ui_utils.SpreadMode.UNKNOWN
|
|
}).catch(() => {
|
|
return Object.create(null);
|
|
});
|
|
firstPagePromise.then(pdfPage => {
|
|
this.loadingBar.setWidth(this.appConfig.viewerContainer);
|
|
|
|
this._initializeAnnotationStorageCallbacks(pdfDocument);
|
|
|
|
Promise.all([_ui_utils.animationStarted, storedPromise, pageLayoutPromise, pageModePromise, openActionPromise]).then(async ([timeStamp, stored, pageLayout, pageMode, openAction]) => {
|
|
const viewOnLoad = _app_options.AppOptions.get("viewOnLoad");
|
|
|
|
this._initializePdfHistory({
|
|
fingerprint: pdfDocument.fingerprints[0],
|
|
viewOnLoad,
|
|
initialDest: openAction?.dest
|
|
});
|
|
|
|
const initialBookmark = this.initialBookmark;
|
|
|
|
const zoom = _app_options.AppOptions.get("defaultZoomValue");
|
|
|
|
let hash = zoom ? `zoom=${zoom}` : null;
|
|
let rotation = null;
|
|
|
|
let sidebarView = _app_options.AppOptions.get("sidebarViewOnLoad");
|
|
|
|
let scrollMode = _app_options.AppOptions.get("scrollModeOnLoad");
|
|
|
|
let spreadMode = _app_options.AppOptions.get("spreadModeOnLoad");
|
|
|
|
if (stored.page && viewOnLoad !== ViewOnLoad.INITIAL) {
|
|
hash = `page=${stored.page}&zoom=${zoom || stored.zoom},` + `${stored.scrollLeft},${stored.scrollTop}`;
|
|
rotation = parseInt(stored.rotation, 10);
|
|
|
|
if (sidebarView === _ui_utils.SidebarView.UNKNOWN) {
|
|
sidebarView = stored.sidebarView | 0;
|
|
}
|
|
|
|
if (scrollMode === _ui_utils.ScrollMode.UNKNOWN) {
|
|
scrollMode = stored.scrollMode | 0;
|
|
}
|
|
|
|
if (spreadMode === _ui_utils.SpreadMode.UNKNOWN) {
|
|
spreadMode = stored.spreadMode | 0;
|
|
}
|
|
}
|
|
|
|
if (pageMode && sidebarView === _ui_utils.SidebarView.UNKNOWN) {
|
|
sidebarView = (0, _ui_utils.apiPageModeToSidebarView)(pageMode);
|
|
}
|
|
|
|
if (pageLayout && scrollMode === _ui_utils.ScrollMode.UNKNOWN && spreadMode === _ui_utils.SpreadMode.UNKNOWN) {
|
|
const modes = (0, _ui_utils.apiPageLayoutToViewerModes)(pageLayout);
|
|
spreadMode = modes.spreadMode;
|
|
}
|
|
|
|
this.setInitialView(hash, {
|
|
rotation,
|
|
sidebarView,
|
|
scrollMode,
|
|
spreadMode
|
|
});
|
|
this.eventBus.dispatch("documentinit", {
|
|
source: this
|
|
});
|
|
|
|
if (!this.isViewerEmbedded) {
|
|
pdfViewer.focus();
|
|
}
|
|
|
|
await Promise.race([pagesPromise, new Promise(resolve => {
|
|
setTimeout(resolve, FORCE_PAGES_LOADED_TIMEOUT);
|
|
})]);
|
|
|
|
if (!initialBookmark && !hash) {
|
|
return;
|
|
}
|
|
|
|
if (pdfViewer.hasEqualPageSizes) {
|
|
return;
|
|
}
|
|
|
|
this.initialBookmark = initialBookmark;
|
|
pdfViewer.currentScaleValue = pdfViewer.currentScaleValue;
|
|
this.setInitialView(hash);
|
|
}).catch(() => {
|
|
this.setInitialView();
|
|
}).then(function () {
|
|
pdfViewer.update();
|
|
});
|
|
});
|
|
pagesPromise.then(() => {
|
|
this._unblockDocumentLoadEvent();
|
|
|
|
this._initializeAutoPrint(pdfDocument, openActionPromise);
|
|
}, reason => {
|
|
this.l10n.get("loading_error").then(msg => {
|
|
this._documentError(msg, {
|
|
message: reason?.message
|
|
});
|
|
});
|
|
});
|
|
onePageRendered.then(data => {
|
|
this.externalServices.reportTelemetry({
|
|
type: "pageInfo",
|
|
timestamp: data.timestamp
|
|
});
|
|
pdfDocument.getOutline().then(outline => {
|
|
if (pdfDocument !== this.pdfDocument) {
|
|
return;
|
|
}
|
|
|
|
this.pdfOutlineViewer.render({
|
|
outline,
|
|
pdfDocument
|
|
});
|
|
});
|
|
pdfDocument.getAttachments().then(attachments => {
|
|
if (pdfDocument !== this.pdfDocument) {
|
|
return;
|
|
}
|
|
|
|
this.pdfAttachmentViewer.render({
|
|
attachments
|
|
});
|
|
});
|
|
pdfViewer.optionalContentConfigPromise.then(optionalContentConfig => {
|
|
if (pdfDocument !== this.pdfDocument) {
|
|
return;
|
|
}
|
|
|
|
this.pdfLayerViewer.render({
|
|
optionalContentConfig,
|
|
pdfDocument
|
|
});
|
|
});
|
|
|
|
if ("requestIdleCallback" in window) {
|
|
const callback = window.requestIdleCallback(() => {
|
|
this._collectTelemetry(pdfDocument);
|
|
|
|
this._idleCallbacks.delete(callback);
|
|
}, {
|
|
timeout: 1000
|
|
});
|
|
|
|
this._idleCallbacks.add(callback);
|
|
}
|
|
});
|
|
|
|
this._initializePageLabels(pdfDocument);
|
|
|
|
this._initializeMetadata(pdfDocument);
|
|
},
|
|
|
|
async _scriptingDocProperties(pdfDocument) {
|
|
if (!this.documentInfo) {
|
|
await new Promise(resolve => {
|
|
this.eventBus._on("metadataloaded", resolve, {
|
|
once: true
|
|
});
|
|
});
|
|
|
|
if (pdfDocument !== this.pdfDocument) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (!this._contentLength) {
|
|
await new Promise(resolve => {
|
|
this.eventBus._on("documentloaded", resolve, {
|
|
once: true
|
|
});
|
|
});
|
|
|
|
if (pdfDocument !== this.pdfDocument) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return { ...this.documentInfo,
|
|
baseURL: this.baseUrl,
|
|
filesize: this._contentLength,
|
|
filename: this._docFilename,
|
|
metadata: this.metadata?.getRaw(),
|
|
authors: this.metadata?.get("dc:creator"),
|
|
numPages: this.pagesCount,
|
|
URL: this.url
|
|
};
|
|
},
|
|
|
|
async _collectTelemetry(pdfDocument) {
|
|
const markInfo = await this.pdfDocument.getMarkInfo();
|
|
|
|
if (pdfDocument !== this.pdfDocument) {
|
|
return;
|
|
}
|
|
|
|
const tagged = markInfo?.Marked || false;
|
|
this.externalServices.reportTelemetry({
|
|
type: "tagged",
|
|
tagged
|
|
});
|
|
},
|
|
|
|
async _initializeAutoPrint(pdfDocument, openActionPromise) {
|
|
const [openAction, javaScript] = await Promise.all([openActionPromise, !this.pdfViewer.enableScripting ? pdfDocument.getJavaScript() : null]);
|
|
|
|
if (pdfDocument !== this.pdfDocument) {
|
|
return;
|
|
}
|
|
|
|
let triggerAutoPrint = false;
|
|
|
|
if (openAction?.action === "Print") {
|
|
triggerAutoPrint = true;
|
|
}
|
|
|
|
if (javaScript) {
|
|
javaScript.some(js => {
|
|
if (!js) {
|
|
return false;
|
|
}
|
|
|
|
console.warn("Warning: JavaScript support is not enabled");
|
|
this.fallback(_pdf.UNSUPPORTED_FEATURES.javaScript);
|
|
return true;
|
|
});
|
|
|
|
if (!triggerAutoPrint) {
|
|
for (const js of javaScript) {
|
|
if (js && _ui_utils.AutoPrintRegExp.test(js)) {
|
|
triggerAutoPrint = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (triggerAutoPrint) {
|
|
this.triggerPrinting();
|
|
}
|
|
},
|
|
|
|
async _initializeMetadata(pdfDocument) {
|
|
const {
|
|
info,
|
|
metadata,
|
|
contentDispositionFilename,
|
|
contentLength
|
|
} = await pdfDocument.getMetadata();
|
|
|
|
if (pdfDocument !== this.pdfDocument) {
|
|
return;
|
|
}
|
|
|
|
this.documentInfo = info;
|
|
this.metadata = metadata;
|
|
this._contentDispositionFilename ??= contentDispositionFilename;
|
|
this._contentLength ??= contentLength;
|
|
console.log(`PDF ${pdfDocument.fingerprints[0]} [${info.PDFFormatVersion} ` + `${(info.Producer || "-").trim()} / ${(info.Creator || "-").trim()}] ` + `(PDF.js: ${_pdf.version || "-"})`);
|
|
let pdfTitle = info.Title;
|
|
const metadataTitle = metadata?.get("dc:title");
|
|
|
|
if (metadataTitle) {
|
|
if (metadataTitle !== "Untitled" && !/[\uFFF0-\uFFFF]/g.test(metadataTitle)) {
|
|
pdfTitle = metadataTitle;
|
|
}
|
|
}
|
|
|
|
if (pdfTitle) {
|
|
this.setTitle(`${pdfTitle} - ${this._contentDispositionFilename || this._title}`);
|
|
} else if (this._contentDispositionFilename) {
|
|
this.setTitle(this._contentDispositionFilename);
|
|
}
|
|
|
|
if (info.IsXFAPresent && !info.IsAcroFormPresent && !pdfDocument.isPureXfa) {
|
|
if (pdfDocument.loadingParams.enableXfa) {
|
|
console.warn("Warning: XFA Foreground documents are not supported");
|
|
} else {
|
|
console.warn("Warning: XFA support is not enabled");
|
|
}
|
|
|
|
this.fallback(_pdf.UNSUPPORTED_FEATURES.forms);
|
|
} else if ((info.IsAcroFormPresent || info.IsXFAPresent) && !this.pdfViewer.renderForms) {
|
|
console.warn("Warning: Interactive form support is not enabled");
|
|
this.fallback(_pdf.UNSUPPORTED_FEATURES.forms);
|
|
}
|
|
|
|
if (info.IsSignaturesPresent) {
|
|
console.warn("Warning: Digital signatures validation is not supported");
|
|
this.fallback(_pdf.UNSUPPORTED_FEATURES.signatures);
|
|
}
|
|
|
|
let versionId = "other";
|
|
|
|
if (KNOWN_VERSIONS.includes(info.PDFFormatVersion)) {
|
|
versionId = `v${info.PDFFormatVersion.replace(".", "_")}`;
|
|
}
|
|
|
|
let generatorId = "other";
|
|
|
|
if (info.Producer) {
|
|
const producer = info.Producer.toLowerCase();
|
|
KNOWN_GENERATORS.some(function (generator) {
|
|
if (!producer.includes(generator)) {
|
|
return false;
|
|
}
|
|
|
|
generatorId = generator.replace(/[ .-]/g, "_");
|
|
return true;
|
|
});
|
|
}
|
|
|
|
let formType = null;
|
|
|
|
if (info.IsXFAPresent) {
|
|
formType = "xfa";
|
|
} else if (info.IsAcroFormPresent) {
|
|
formType = "acroform";
|
|
}
|
|
|
|
this.externalServices.reportTelemetry({
|
|
type: "documentInfo",
|
|
version: versionId,
|
|
generator: generatorId,
|
|
formType
|
|
});
|
|
this.eventBus.dispatch("metadataloaded", {
|
|
source: this
|
|
});
|
|
},
|
|
|
|
async _initializePageLabels(pdfDocument) {
|
|
const labels = await pdfDocument.getPageLabels();
|
|
|
|
if (pdfDocument !== this.pdfDocument) {
|
|
return;
|
|
}
|
|
|
|
if (!labels || _app_options.AppOptions.get("disablePageLabels")) {
|
|
return;
|
|
}
|
|
|
|
const numLabels = labels.length;
|
|
let standardLabels = 0,
|
|
emptyLabels = 0;
|
|
|
|
for (let i = 0; i < numLabels; i++) {
|
|
const label = labels[i];
|
|
|
|
if (label === (i + 1).toString()) {
|
|
standardLabels++;
|
|
} else if (label === "") {
|
|
emptyLabels++;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (standardLabels >= numLabels || emptyLabels >= numLabels) {
|
|
return;
|
|
}
|
|
|
|
const {
|
|
pdfViewer,
|
|
pdfThumbnailViewer,
|
|
toolbar
|
|
} = this;
|
|
pdfViewer.setPageLabels(labels);
|
|
pdfThumbnailViewer.setPageLabels(labels);
|
|
toolbar.setPagesCount(numLabels, true);
|
|
toolbar.setPageNumber(pdfViewer.currentPageNumber, pdfViewer.currentPageLabel);
|
|
},
|
|
|
|
_initializePdfHistory({
|
|
fingerprint,
|
|
viewOnLoad,
|
|
initialDest = null
|
|
}) {
|
|
if (!this.pdfHistory) {
|
|
return;
|
|
}
|
|
|
|
this.pdfHistory.initialize({
|
|
fingerprint,
|
|
resetHistory: viewOnLoad === ViewOnLoad.INITIAL,
|
|
updateUrl: _app_options.AppOptions.get("historyUpdateUrl")
|
|
});
|
|
|
|
if (this.pdfHistory.initialBookmark) {
|
|
this.initialBookmark = this.pdfHistory.initialBookmark;
|
|
this.initialRotation = this.pdfHistory.initialRotation;
|
|
}
|
|
|
|
if (initialDest && !this.initialBookmark && viewOnLoad === ViewOnLoad.UNKNOWN) {
|
|
this.initialBookmark = JSON.stringify(initialDest);
|
|
this.pdfHistory.push({
|
|
explicitDest: initialDest,
|
|
pageNumber: null
|
|
});
|
|
}
|
|
},
|
|
|
|
_initializeAnnotationStorageCallbacks(pdfDocument) {
|
|
if (pdfDocument !== this.pdfDocument) {
|
|
return;
|
|
}
|
|
|
|
const {
|
|
annotationStorage
|
|
} = pdfDocument;
|
|
|
|
annotationStorage.onSetModified = () => {
|
|
window.addEventListener("beforeunload", beforeUnload);
|
|
this._annotationStorageModified = true;
|
|
};
|
|
|
|
annotationStorage.onResetModified = () => {
|
|
window.removeEventListener("beforeunload", beforeUnload);
|
|
delete this._annotationStorageModified;
|
|
};
|
|
|
|
annotationStorage.onAnnotationEditor = typeStr => {
|
|
this._hasAnnotationEditors = !!typeStr;
|
|
this.setTitle();
|
|
|
|
if (typeStr) {
|
|
this.externalServices.reportTelemetry({
|
|
type: "editing",
|
|
data: {
|
|
type: typeStr
|
|
}
|
|
});
|
|
}
|
|
};
|
|
},
|
|
|
|
setInitialView(storedHash, {
|
|
rotation,
|
|
sidebarView,
|
|
scrollMode,
|
|
spreadMode
|
|
} = {}) {
|
|
const setRotation = angle => {
|
|
if ((0, _ui_utils.isValidRotation)(angle)) {
|
|
this.pdfViewer.pagesRotation = angle;
|
|
}
|
|
};
|
|
|
|
const setViewerModes = (scroll, spread) => {
|
|
if ((0, _ui_utils.isValidScrollMode)(scroll)) {
|
|
this.pdfViewer.scrollMode = scroll;
|
|
}
|
|
|
|
if ((0, _ui_utils.isValidSpreadMode)(spread)) {
|
|
this.pdfViewer.spreadMode = spread;
|
|
}
|
|
};
|
|
|
|
this.isInitialViewSet = true;
|
|
this.pdfSidebar.setInitialView(sidebarView);
|
|
setViewerModes(scrollMode, spreadMode);
|
|
|
|
if (this.initialBookmark) {
|
|
setRotation(this.initialRotation);
|
|
delete this.initialRotation;
|
|
this.pdfLinkService.setHash(this.initialBookmark);
|
|
this.initialBookmark = null;
|
|
} else if (storedHash) {
|
|
setRotation(rotation);
|
|
this.pdfLinkService.setHash(storedHash);
|
|
}
|
|
|
|
this.toolbar.setPageNumber(this.pdfViewer.currentPageNumber, this.pdfViewer.currentPageLabel);
|
|
this.secondaryToolbar.setPageNumber(this.pdfViewer.currentPageNumber);
|
|
|
|
if (!this.pdfViewer.currentScaleValue) {
|
|
this.pdfViewer.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
|
|
}
|
|
},
|
|
|
|
_cleanup() {
|
|
if (!this.pdfDocument) {
|
|
return;
|
|
}
|
|
|
|
this.pdfViewer.cleanup();
|
|
this.pdfThumbnailViewer.cleanup();
|
|
this.pdfDocument.cleanup(this.pdfViewer.renderer === _ui_utils.RendererType.SVG);
|
|
},
|
|
|
|
forceRendering() {
|
|
this.pdfRenderingQueue.printing = !!this.printService;
|
|
this.pdfRenderingQueue.isThumbnailViewEnabled = this.pdfSidebar.visibleView === _ui_utils.SidebarView.THUMBS;
|
|
this.pdfRenderingQueue.renderHighestPriority();
|
|
},
|
|
|
|
beforePrint() {
|
|
this._printAnnotationStoragePromise = this.pdfScriptingManager.dispatchWillPrint().catch(() => {}).then(() => {
|
|
return this.pdfDocument?.annotationStorage.print;
|
|
});
|
|
|
|
if (this.printService) {
|
|
return;
|
|
}
|
|
|
|
if (!this.supportsPrinting) {
|
|
this.l10n.get("printing_not_supported").then(msg => {
|
|
this._otherError(msg);
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (!this.pdfViewer.pageViewsReady) {
|
|
this.l10n.get("printing_not_ready").then(msg => {
|
|
window.alert(msg);
|
|
});
|
|
return;
|
|
}
|
|
|
|
const pagesOverview = this.pdfViewer.getPagesOverview();
|
|
const printContainer = this.appConfig.printContainer;
|
|
|
|
const printResolution = _app_options.AppOptions.get("printResolution");
|
|
|
|
const optionalContentConfigPromise = this.pdfViewer.optionalContentConfigPromise;
|
|
const printService = PDFPrintServiceFactory.instance.createPrintService(this.pdfDocument, pagesOverview, printContainer, printResolution, optionalContentConfigPromise, this._printAnnotationStoragePromise, this.l10n);
|
|
this.printService = printService;
|
|
this.forceRendering();
|
|
printService.layout();
|
|
this.externalServices.reportTelemetry({
|
|
type: "print"
|
|
});
|
|
|
|
if (this._hasAnnotationEditors) {
|
|
this.externalServices.reportTelemetry({
|
|
type: "editing",
|
|
data: {
|
|
type: "print"
|
|
}
|
|
});
|
|
}
|
|
},
|
|
|
|
afterPrint() {
|
|
if (this._printAnnotationStoragePromise) {
|
|
this._printAnnotationStoragePromise.then(() => {
|
|
this.pdfScriptingManager.dispatchDidPrint();
|
|
});
|
|
|
|
this._printAnnotationStoragePromise = null;
|
|
}
|
|
|
|
if (this.printService) {
|
|
this.printService.destroy();
|
|
this.printService = null;
|
|
this.pdfDocument?.annotationStorage.resetModified();
|
|
}
|
|
|
|
this.forceRendering();
|
|
},
|
|
|
|
rotatePages(delta) {
|
|
this.pdfViewer.pagesRotation += delta;
|
|
},
|
|
|
|
requestPresentationMode() {
|
|
this.pdfPresentationMode?.request();
|
|
},
|
|
|
|
triggerPrinting() {
|
|
if (!this.supportsPrinting) {
|
|
return;
|
|
}
|
|
|
|
window.print();
|
|
},
|
|
|
|
bindEvents() {
|
|
const {
|
|
eventBus,
|
|
_boundEvents
|
|
} = this;
|
|
_boundEvents.beforePrint = this.beforePrint.bind(this);
|
|
_boundEvents.afterPrint = this.afterPrint.bind(this);
|
|
|
|
eventBus._on("resize", webViewerResize);
|
|
|
|
eventBus._on("hashchange", webViewerHashchange);
|
|
|
|
eventBus._on("beforeprint", _boundEvents.beforePrint);
|
|
|
|
eventBus._on("afterprint", _boundEvents.afterPrint);
|
|
|
|
eventBus._on("pagerendered", webViewerPageRendered);
|
|
|
|
eventBus._on("updateviewarea", webViewerUpdateViewarea);
|
|
|
|
eventBus._on("pagechanging", webViewerPageChanging);
|
|
|
|
eventBus._on("scalechanging", webViewerScaleChanging);
|
|
|
|
eventBus._on("rotationchanging", webViewerRotationChanging);
|
|
|
|
eventBus._on("sidebarviewchanged", webViewerSidebarViewChanged);
|
|
|
|
eventBus._on("pagemode", webViewerPageMode);
|
|
|
|
eventBus._on("namedaction", webViewerNamedAction);
|
|
|
|
eventBus._on("presentationmodechanged", webViewerPresentationModeChanged);
|
|
|
|
eventBus._on("presentationmode", webViewerPresentationMode);
|
|
|
|
eventBus._on("switchannotationeditormode", webViewerSwitchAnnotationEditorMode);
|
|
|
|
eventBus._on("switchannotationeditorparams", webViewerSwitchAnnotationEditorParams);
|
|
|
|
eventBus._on("print", webViewerPrint);
|
|
|
|
eventBus._on("download", webViewerDownload);
|
|
|
|
eventBus._on("firstpage", webViewerFirstPage);
|
|
|
|
eventBus._on("lastpage", webViewerLastPage);
|
|
|
|
eventBus._on("nextpage", webViewerNextPage);
|
|
|
|
eventBus._on("previouspage", webViewerPreviousPage);
|
|
|
|
eventBus._on("zoomin", webViewerZoomIn);
|
|
|
|
eventBus._on("zoomout", webViewerZoomOut);
|
|
|
|
eventBus._on("zoomreset", webViewerZoomReset);
|
|
|
|
eventBus._on("pagenumberchanged", webViewerPageNumberChanged);
|
|
|
|
eventBus._on("scalechanged", webViewerScaleChanged);
|
|
|
|
eventBus._on("rotatecw", webViewerRotateCw);
|
|
|
|
eventBus._on("rotateccw", webViewerRotateCcw);
|
|
|
|
eventBus._on("optionalcontentconfig", webViewerOptionalContentConfig);
|
|
|
|
eventBus._on("switchscrollmode", webViewerSwitchScrollMode);
|
|
|
|
eventBus._on("scrollmodechanged", webViewerScrollModeChanged);
|
|
|
|
eventBus._on("switchspreadmode", webViewerSwitchSpreadMode);
|
|
|
|
eventBus._on("spreadmodechanged", webViewerSpreadModeChanged);
|
|
|
|
eventBus._on("documentproperties", webViewerDocumentProperties);
|
|
|
|
eventBus._on("findfromurlhash", webViewerFindFromUrlHash);
|
|
|
|
eventBus._on("updatefindmatchescount", webViewerUpdateFindMatchesCount);
|
|
|
|
eventBus._on("updatefindcontrolstate", webViewerUpdateFindControlState);
|
|
|
|
if (_app_options.AppOptions.get("pdfBug")) {
|
|
_boundEvents.reportPageStatsPDFBug = reportPageStatsPDFBug;
|
|
|
|
eventBus._on("pagerendered", _boundEvents.reportPageStatsPDFBug);
|
|
|
|
eventBus._on("pagechanging", _boundEvents.reportPageStatsPDFBug);
|
|
}
|
|
|
|
eventBus._on("fileinputchange", webViewerFileInputChange);
|
|
|
|
eventBus._on("openfile", webViewerOpenFile);
|
|
},
|
|
|
|
bindWindowEvents() {
|
|
const {
|
|
eventBus,
|
|
_boundEvents
|
|
} = this;
|
|
|
|
function addWindowResolutionChange(evt = null) {
|
|
if (evt) {
|
|
webViewerResolutionChange(evt);
|
|
}
|
|
|
|
const mediaQueryList = window.matchMedia(`(resolution: ${window.devicePixelRatio || 1}dppx)`);
|
|
mediaQueryList.addEventListener("change", addWindowResolutionChange, {
|
|
once: true
|
|
});
|
|
|
|
_boundEvents.removeWindowResolutionChange ||= function () {
|
|
mediaQueryList.removeEventListener("change", addWindowResolutionChange);
|
|
_boundEvents.removeWindowResolutionChange = null;
|
|
};
|
|
}
|
|
|
|
addWindowResolutionChange();
|
|
|
|
_boundEvents.windowResize = () => {
|
|
eventBus.dispatch("resize", {
|
|
source: window
|
|
});
|
|
};
|
|
|
|
_boundEvents.windowHashChange = () => {
|
|
eventBus.dispatch("hashchange", {
|
|
source: window,
|
|
hash: document.location.hash.substring(1)
|
|
});
|
|
};
|
|
|
|
_boundEvents.windowBeforePrint = () => {
|
|
eventBus.dispatch("beforeprint", {
|
|
source: window
|
|
});
|
|
};
|
|
|
|
_boundEvents.windowAfterPrint = () => {
|
|
eventBus.dispatch("afterprint", {
|
|
source: window
|
|
});
|
|
};
|
|
|
|
_boundEvents.windowUpdateFromSandbox = event => {
|
|
eventBus.dispatch("updatefromsandbox", {
|
|
source: window,
|
|
detail: event.detail
|
|
});
|
|
};
|
|
|
|
window.addEventListener("visibilitychange", webViewerVisibilityChange);
|
|
window.addEventListener("wheel", webViewerWheel, {
|
|
passive: false
|
|
});
|
|
window.addEventListener("touchstart", webViewerTouchStart, {
|
|
passive: false
|
|
});
|
|
window.addEventListener("click", webViewerClick);
|
|
window.addEventListener("keydown", webViewerKeyDown);
|
|
window.addEventListener("resize", _boundEvents.windowResize);
|
|
window.addEventListener("hashchange", _boundEvents.windowHashChange);
|
|
window.addEventListener("beforeprint", _boundEvents.windowBeforePrint);
|
|
window.addEventListener("afterprint", _boundEvents.windowAfterPrint);
|
|
window.addEventListener("updatefromsandbox", _boundEvents.windowUpdateFromSandbox);
|
|
},
|
|
|
|
unbindEvents() {
|
|
const {
|
|
eventBus,
|
|
_boundEvents
|
|
} = this;
|
|
|
|
eventBus._off("resize", webViewerResize);
|
|
|
|
eventBus._off("hashchange", webViewerHashchange);
|
|
|
|
eventBus._off("beforeprint", _boundEvents.beforePrint);
|
|
|
|
eventBus._off("afterprint", _boundEvents.afterPrint);
|
|
|
|
eventBus._off("pagerendered", webViewerPageRendered);
|
|
|
|
eventBus._off("updateviewarea", webViewerUpdateViewarea);
|
|
|
|
eventBus._off("pagechanging", webViewerPageChanging);
|
|
|
|
eventBus._off("scalechanging", webViewerScaleChanging);
|
|
|
|
eventBus._off("rotationchanging", webViewerRotationChanging);
|
|
|
|
eventBus._off("sidebarviewchanged", webViewerSidebarViewChanged);
|
|
|
|
eventBus._off("pagemode", webViewerPageMode);
|
|
|
|
eventBus._off("namedaction", webViewerNamedAction);
|
|
|
|
eventBus._off("presentationmodechanged", webViewerPresentationModeChanged);
|
|
|
|
eventBus._off("presentationmode", webViewerPresentationMode);
|
|
|
|
eventBus._off("print", webViewerPrint);
|
|
|
|
eventBus._off("download", webViewerDownload);
|
|
|
|
eventBus._off("firstpage", webViewerFirstPage);
|
|
|
|
eventBus._off("lastpage", webViewerLastPage);
|
|
|
|
eventBus._off("nextpage", webViewerNextPage);
|
|
|
|
eventBus._off("previouspage", webViewerPreviousPage);
|
|
|
|
eventBus._off("zoomin", webViewerZoomIn);
|
|
|
|
eventBus._off("zoomout", webViewerZoomOut);
|
|
|
|
eventBus._off("zoomreset", webViewerZoomReset);
|
|
|
|
eventBus._off("pagenumberchanged", webViewerPageNumberChanged);
|
|
|
|
eventBus._off("scalechanged", webViewerScaleChanged);
|
|
|
|
eventBus._off("rotatecw", webViewerRotateCw);
|
|
|
|
eventBus._off("rotateccw", webViewerRotateCcw);
|
|
|
|
eventBus._off("optionalcontentconfig", webViewerOptionalContentConfig);
|
|
|
|
eventBus._off("switchscrollmode", webViewerSwitchScrollMode);
|
|
|
|
eventBus._off("scrollmodechanged", webViewerScrollModeChanged);
|
|
|
|
eventBus._off("switchspreadmode", webViewerSwitchSpreadMode);
|
|
|
|
eventBus._off("spreadmodechanged", webViewerSpreadModeChanged);
|
|
|
|
eventBus._off("documentproperties", webViewerDocumentProperties);
|
|
|
|
eventBus._off("findfromurlhash", webViewerFindFromUrlHash);
|
|
|
|
eventBus._off("updatefindmatchescount", webViewerUpdateFindMatchesCount);
|
|
|
|
eventBus._off("updatefindcontrolstate", webViewerUpdateFindControlState);
|
|
|
|
if (_boundEvents.reportPageStatsPDFBug) {
|
|
eventBus._off("pagerendered", _boundEvents.reportPageStatsPDFBug);
|
|
|
|
eventBus._off("pagechanging", _boundEvents.reportPageStatsPDFBug);
|
|
|
|
_boundEvents.reportPageStatsPDFBug = null;
|
|
}
|
|
|
|
eventBus._off("fileinputchange", webViewerFileInputChange);
|
|
|
|
eventBus._off("openfile", webViewerOpenFile);
|
|
|
|
_boundEvents.beforePrint = null;
|
|
_boundEvents.afterPrint = null;
|
|
},
|
|
|
|
unbindWindowEvents() {
|
|
const {
|
|
_boundEvents
|
|
} = this;
|
|
window.removeEventListener("visibilitychange", webViewerVisibilityChange);
|
|
window.removeEventListener("wheel", webViewerWheel, {
|
|
passive: false
|
|
});
|
|
window.removeEventListener("touchstart", webViewerTouchStart, {
|
|
passive: false
|
|
});
|
|
window.removeEventListener("click", webViewerClick);
|
|
window.removeEventListener("keydown", webViewerKeyDown);
|
|
window.removeEventListener("resize", _boundEvents.windowResize);
|
|
window.removeEventListener("hashchange", _boundEvents.windowHashChange);
|
|
window.removeEventListener("beforeprint", _boundEvents.windowBeforePrint);
|
|
window.removeEventListener("afterprint", _boundEvents.windowAfterPrint);
|
|
window.removeEventListener("updatefromsandbox", _boundEvents.windowUpdateFromSandbox);
|
|
_boundEvents.removeWindowResolutionChange?.();
|
|
_boundEvents.windowResize = null;
|
|
_boundEvents.windowHashChange = null;
|
|
_boundEvents.windowBeforePrint = null;
|
|
_boundEvents.windowAfterPrint = null;
|
|
_boundEvents.windowUpdateFromSandbox = null;
|
|
},
|
|
|
|
accumulateWheelTicks(ticks) {
|
|
if (this._wheelUnusedTicks > 0 && ticks < 0 || this._wheelUnusedTicks < 0 && ticks > 0) {
|
|
this._wheelUnusedTicks = 0;
|
|
}
|
|
|
|
this._wheelUnusedTicks += ticks;
|
|
const wholeTicks = Math.sign(this._wheelUnusedTicks) * Math.floor(Math.abs(this._wheelUnusedTicks));
|
|
this._wheelUnusedTicks -= wholeTicks;
|
|
return wholeTicks;
|
|
},
|
|
|
|
_unblockDocumentLoadEvent() {
|
|
document.blockUnblockOnload?.(false);
|
|
|
|
this._unblockDocumentLoadEvent = () => {};
|
|
},
|
|
|
|
_reportDocumentStatsTelemetry() {
|
|
const {
|
|
stats
|
|
} = this.pdfDocument;
|
|
|
|
if (stats !== this._docStats) {
|
|
this._docStats = stats;
|
|
this.externalServices.reportTelemetry({
|
|
type: "documentStats",
|
|
stats
|
|
});
|
|
}
|
|
},
|
|
|
|
get scriptingReady() {
|
|
return this.pdfScriptingManager.ready;
|
|
}
|
|
|
|
};
|
|
exports.PDFViewerApplication = PDFViewerApplication;
|
|
let validateFileURL;
|
|
{
|
|
const HOSTED_VIEWER_ORIGINS = ["null", "http://mozilla.github.io", "https://mozilla.github.io"];
|
|
|
|
validateFileURL = function (file) {
|
|
if (!file) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const viewerOrigin = new URL(window.location.href).origin || "null";
|
|
|
|
if (HOSTED_VIEWER_ORIGINS.includes(viewerOrigin)) {
|
|
return;
|
|
}
|
|
|
|
const fileOrigin = new URL(file, window.location.href).origin;
|
|
|
|
if (fileOrigin !== viewerOrigin) {
|
|
throw new Error("file origin does not match viewer's");
|
|
}
|
|
} catch (ex) {
|
|
PDFViewerApplication.l10n.get("loading_error").then(msg => {
|
|
PDFViewerApplication._documentError(msg, {
|
|
message: ex?.message
|
|
});
|
|
});
|
|
throw ex;
|
|
}
|
|
};
|
|
}
|
|
|
|
async function loadFakeWorker() {
|
|
_pdf.GlobalWorkerOptions.workerSrc ||= _app_options.AppOptions.get("workerSrc");
|
|
await (0, _pdf.loadScript)(_pdf.PDFWorker.workerSrc);
|
|
}
|
|
|
|
async function loadPDFBug(self) {
|
|
const {
|
|
debuggerScriptPath
|
|
} = self.appConfig;
|
|
const {
|
|
PDFBug
|
|
} = await import(debuggerScriptPath);
|
|
self._PDFBug = PDFBug;
|
|
}
|
|
|
|
function reportPageStatsPDFBug({
|
|
pageNumber
|
|
}) {
|
|
if (!globalThis.Stats?.enabled) {
|
|
return;
|
|
}
|
|
|
|
const pageView = PDFViewerApplication.pdfViewer.getPageView(pageNumber - 1);
|
|
globalThis.Stats.add(pageNumber, pageView?.pdfPage?.stats);
|
|
}
|
|
|
|
function webViewerInitialized() {
|
|
const {
|
|
appConfig,
|
|
eventBus
|
|
} = PDFViewerApplication;
|
|
let file;
|
|
const queryString = document.location.search.substring(1);
|
|
const params = (0, _ui_utils.parseQueryString)(queryString);
|
|
file = params.get("file") ?? _app_options.AppOptions.get("defaultUrl");
|
|
validateFileURL(file);
|
|
const fileInput = appConfig.openFileInput;
|
|
fileInput.value = null;
|
|
fileInput.addEventListener("change", function (evt) {
|
|
const {
|
|
files
|
|
} = evt.target;
|
|
|
|
if (!files || files.length === 0) {
|
|
return;
|
|
}
|
|
|
|
eventBus.dispatch("fileinputchange", {
|
|
source: this,
|
|
fileInput: evt.target
|
|
});
|
|
});
|
|
appConfig.mainContainer.addEventListener("dragover", function (evt) {
|
|
evt.preventDefault();
|
|
evt.dataTransfer.dropEffect = evt.dataTransfer.effectAllowed === "copy" ? "copy" : "move";
|
|
});
|
|
appConfig.mainContainer.addEventListener("drop", function (evt) {
|
|
evt.preventDefault();
|
|
const {
|
|
files
|
|
} = evt.dataTransfer;
|
|
|
|
if (!files || files.length === 0) {
|
|
return;
|
|
}
|
|
|
|
eventBus.dispatch("fileinputchange", {
|
|
source: this,
|
|
fileInput: evt.dataTransfer
|
|
});
|
|
});
|
|
|
|
if (!PDFViewerApplication.supportsDocumentFonts) {
|
|
_app_options.AppOptions.set("disableFontFace", true);
|
|
|
|
PDFViewerApplication.l10n.get("web_fonts_disabled").then(msg => {
|
|
console.warn(msg);
|
|
});
|
|
}
|
|
|
|
if (!PDFViewerApplication.supportsPrinting) {
|
|
appConfig.toolbar.print.classList.add("hidden");
|
|
appConfig.secondaryToolbar.printButton.classList.add("hidden");
|
|
}
|
|
|
|
if (!PDFViewerApplication.supportsFullscreen) {
|
|
appConfig.toolbar.presentationModeButton.classList.add("hidden");
|
|
appConfig.secondaryToolbar.presentationModeButton.classList.add("hidden");
|
|
}
|
|
|
|
if (PDFViewerApplication.supportsIntegratedFind) {
|
|
appConfig.toolbar.viewFind.classList.add("hidden");
|
|
}
|
|
|
|
appConfig.mainContainer.addEventListener("transitionend", function (evt) {
|
|
if (evt.target === this) {
|
|
eventBus.dispatch("resize", {
|
|
source: this
|
|
});
|
|
}
|
|
}, true);
|
|
|
|
try {
|
|
if (file) {
|
|
PDFViewerApplication.open(file);
|
|
} else {
|
|
PDFViewerApplication._hideViewBookmark();
|
|
}
|
|
} catch (reason) {
|
|
PDFViewerApplication.l10n.get("loading_error").then(msg => {
|
|
PDFViewerApplication._documentError(msg, reason);
|
|
});
|
|
}
|
|
}
|
|
|
|
function webViewerPageRendered({
|
|
pageNumber,
|
|
error
|
|
}) {
|
|
if (pageNumber === PDFViewerApplication.page) {
|
|
PDFViewerApplication.toolbar.updateLoadingIndicatorState(false);
|
|
}
|
|
|
|
if (PDFViewerApplication.pdfSidebar.visibleView === _ui_utils.SidebarView.THUMBS) {
|
|
const pageView = PDFViewerApplication.pdfViewer.getPageView(pageNumber - 1);
|
|
const thumbnailView = PDFViewerApplication.pdfThumbnailViewer.getThumbnail(pageNumber - 1);
|
|
|
|
if (pageView && thumbnailView) {
|
|
thumbnailView.setImage(pageView);
|
|
}
|
|
}
|
|
|
|
if (error) {
|
|
PDFViewerApplication.l10n.get("rendering_error").then(msg => {
|
|
PDFViewerApplication._otherError(msg, error);
|
|
});
|
|
}
|
|
|
|
PDFViewerApplication._reportDocumentStatsTelemetry();
|
|
}
|
|
|
|
function webViewerPageMode({
|
|
mode
|
|
}) {
|
|
let view;
|
|
|
|
switch (mode) {
|
|
case "thumbs":
|
|
view = _ui_utils.SidebarView.THUMBS;
|
|
break;
|
|
|
|
case "bookmarks":
|
|
case "outline":
|
|
view = _ui_utils.SidebarView.OUTLINE;
|
|
break;
|
|
|
|
case "attachments":
|
|
view = _ui_utils.SidebarView.ATTACHMENTS;
|
|
break;
|
|
|
|
case "layers":
|
|
view = _ui_utils.SidebarView.LAYERS;
|
|
break;
|
|
|
|
case "none":
|
|
view = _ui_utils.SidebarView.NONE;
|
|
break;
|
|
|
|
default:
|
|
console.error('Invalid "pagemode" hash parameter: ' + mode);
|
|
return;
|
|
}
|
|
|
|
PDFViewerApplication.pdfSidebar.switchView(view, true);
|
|
}
|
|
|
|
function webViewerNamedAction(evt) {
|
|
switch (evt.action) {
|
|
case "GoToPage":
|
|
PDFViewerApplication.appConfig.toolbar.pageNumber.select();
|
|
break;
|
|
|
|
case "Find":
|
|
if (!PDFViewerApplication.supportsIntegratedFind) {
|
|
PDFViewerApplication.findBar.toggle();
|
|
}
|
|
|
|
break;
|
|
|
|
case "Print":
|
|
PDFViewerApplication.triggerPrinting();
|
|
break;
|
|
|
|
case "SaveAs":
|
|
PDFViewerApplication.downloadOrSave();
|
|
break;
|
|
}
|
|
}
|
|
|
|
function webViewerPresentationModeChanged(evt) {
|
|
PDFViewerApplication.pdfViewer.presentationModeState = evt.state;
|
|
}
|
|
|
|
function webViewerSidebarViewChanged({
|
|
view
|
|
}) {
|
|
PDFViewerApplication.pdfRenderingQueue.isThumbnailViewEnabled = view === _ui_utils.SidebarView.THUMBS;
|
|
|
|
if (PDFViewerApplication.isInitialViewSet) {
|
|
PDFViewerApplication.store?.set("sidebarView", view).catch(() => {});
|
|
}
|
|
}
|
|
|
|
function webViewerUpdateViewarea({
|
|
location
|
|
}) {
|
|
if (PDFViewerApplication.isInitialViewSet) {
|
|
PDFViewerApplication.store?.setMultiple({
|
|
page: location.pageNumber,
|
|
zoom: location.scale,
|
|
scrollLeft: location.left,
|
|
scrollTop: location.top,
|
|
rotation: location.rotation
|
|
}).catch(() => {});
|
|
}
|
|
|
|
const href = PDFViewerApplication.pdfLinkService.getAnchorUrl(location.pdfOpenParams);
|
|
PDFViewerApplication.appConfig.toolbar.viewBookmark.href = href;
|
|
PDFViewerApplication.appConfig.secondaryToolbar.viewBookmarkButton.href = href;
|
|
const currentPage = PDFViewerApplication.pdfViewer.getPageView(PDFViewerApplication.page - 1);
|
|
const loading = currentPage?.renderingState !== _ui_utils.RenderingStates.FINISHED;
|
|
PDFViewerApplication.toolbar.updateLoadingIndicatorState(loading);
|
|
}
|
|
|
|
function webViewerScrollModeChanged(evt) {
|
|
if (PDFViewerApplication.isInitialViewSet) {
|
|
PDFViewerApplication.store?.set("scrollMode", evt.mode).catch(() => {});
|
|
}
|
|
}
|
|
|
|
function webViewerSpreadModeChanged(evt) {
|
|
if (PDFViewerApplication.isInitialViewSet) {
|
|
PDFViewerApplication.store?.set("spreadMode", evt.mode).catch(() => {});
|
|
}
|
|
}
|
|
|
|
function webViewerResize() {
|
|
const {
|
|
pdfDocument,
|
|
pdfViewer,
|
|
pdfRenderingQueue
|
|
} = PDFViewerApplication;
|
|
|
|
if (pdfRenderingQueue.printing && window.matchMedia("print").matches) {
|
|
return;
|
|
}
|
|
|
|
pdfViewer.updateContainerHeightCss();
|
|
|
|
if (!pdfDocument) {
|
|
return;
|
|
}
|
|
|
|
const currentScaleValue = pdfViewer.currentScaleValue;
|
|
|
|
if (currentScaleValue === "auto" || currentScaleValue === "page-fit" || currentScaleValue === "page-width") {
|
|
pdfViewer.currentScaleValue = currentScaleValue;
|
|
}
|
|
|
|
pdfViewer.update();
|
|
}
|
|
|
|
function webViewerHashchange(evt) {
|
|
const hash = evt.hash;
|
|
|
|
if (!hash) {
|
|
return;
|
|
}
|
|
|
|
if (!PDFViewerApplication.isInitialViewSet) {
|
|
PDFViewerApplication.initialBookmark = hash;
|
|
} else if (!PDFViewerApplication.pdfHistory?.popStateInProgress) {
|
|
PDFViewerApplication.pdfLinkService.setHash(hash);
|
|
}
|
|
}
|
|
|
|
{
|
|
var webViewerFileInputChange = function (evt) {
|
|
if (PDFViewerApplication.pdfViewer?.isInPresentationMode) {
|
|
return;
|
|
}
|
|
|
|
const file = evt.fileInput.files[0];
|
|
let url = URL.createObjectURL(file);
|
|
|
|
if (file.name) {
|
|
url = {
|
|
url,
|
|
originalUrl: file.name
|
|
};
|
|
}
|
|
|
|
PDFViewerApplication.open(url);
|
|
};
|
|
|
|
var webViewerOpenFile = function (evt) {
|
|
const fileInput = PDFViewerApplication.appConfig.openFileInput;
|
|
fileInput.click();
|
|
};
|
|
}
|
|
|
|
function webViewerPresentationMode() {
|
|
PDFViewerApplication.requestPresentationMode();
|
|
}
|
|
|
|
function webViewerSwitchAnnotationEditorMode(evt) {
|
|
PDFViewerApplication.pdfViewer.annotationEditorMode = evt.mode;
|
|
}
|
|
|
|
function webViewerSwitchAnnotationEditorParams(evt) {
|
|
PDFViewerApplication.pdfViewer.annotationEditorParams = evt;
|
|
}
|
|
|
|
function webViewerPrint() {
|
|
PDFViewerApplication.triggerPrinting();
|
|
}
|
|
|
|
function webViewerDownload() {
|
|
PDFViewerApplication.downloadOrSave();
|
|
}
|
|
|
|
function webViewerFirstPage() {
|
|
if (PDFViewerApplication.pdfDocument) {
|
|
PDFViewerApplication.page = 1;
|
|
}
|
|
}
|
|
|
|
function webViewerLastPage() {
|
|
if (PDFViewerApplication.pdfDocument) {
|
|
PDFViewerApplication.page = PDFViewerApplication.pagesCount;
|
|
}
|
|
}
|
|
|
|
function webViewerNextPage() {
|
|
PDFViewerApplication.pdfViewer.nextPage();
|
|
}
|
|
|
|
function webViewerPreviousPage() {
|
|
PDFViewerApplication.pdfViewer.previousPage();
|
|
}
|
|
|
|
function webViewerZoomIn() {
|
|
PDFViewerApplication.zoomIn();
|
|
}
|
|
|
|
function webViewerZoomOut() {
|
|
PDFViewerApplication.zoomOut();
|
|
}
|
|
|
|
function webViewerZoomReset() {
|
|
PDFViewerApplication.zoomReset();
|
|
}
|
|
|
|
function webViewerPageNumberChanged(evt) {
|
|
const pdfViewer = PDFViewerApplication.pdfViewer;
|
|
|
|
if (evt.value !== "") {
|
|
PDFViewerApplication.pdfLinkService.goToPage(evt.value);
|
|
}
|
|
|
|
if (evt.value !== pdfViewer.currentPageNumber.toString() && evt.value !== pdfViewer.currentPageLabel) {
|
|
PDFViewerApplication.toolbar.setPageNumber(pdfViewer.currentPageNumber, pdfViewer.currentPageLabel);
|
|
}
|
|
}
|
|
|
|
function webViewerScaleChanged(evt) {
|
|
PDFViewerApplication.pdfViewer.currentScaleValue = evt.value;
|
|
}
|
|
|
|
function webViewerRotateCw() {
|
|
PDFViewerApplication.rotatePages(90);
|
|
}
|
|
|
|
function webViewerRotateCcw() {
|
|
PDFViewerApplication.rotatePages(-90);
|
|
}
|
|
|
|
function webViewerOptionalContentConfig(evt) {
|
|
PDFViewerApplication.pdfViewer.optionalContentConfigPromise = evt.promise;
|
|
}
|
|
|
|
function webViewerSwitchScrollMode(evt) {
|
|
PDFViewerApplication.pdfViewer.scrollMode = evt.mode;
|
|
}
|
|
|
|
function webViewerSwitchSpreadMode(evt) {
|
|
PDFViewerApplication.pdfViewer.spreadMode = evt.mode;
|
|
}
|
|
|
|
function webViewerDocumentProperties() {
|
|
PDFViewerApplication.pdfDocumentProperties.open();
|
|
}
|
|
|
|
function webViewerFindFromUrlHash(evt) {
|
|
PDFViewerApplication.eventBus.dispatch("find", {
|
|
source: evt.source,
|
|
type: "",
|
|
query: evt.query,
|
|
phraseSearch: evt.phraseSearch,
|
|
caseSensitive: false,
|
|
entireWord: false,
|
|
highlightAll: true,
|
|
findPrevious: false,
|
|
matchDiacritics: true
|
|
});
|
|
}
|
|
|
|
function webViewerUpdateFindMatchesCount({
|
|
matchesCount
|
|
}) {
|
|
if (PDFViewerApplication.supportsIntegratedFind) {
|
|
PDFViewerApplication.externalServices.updateFindMatchesCount(matchesCount);
|
|
} else {
|
|
PDFViewerApplication.findBar.updateResultsCount(matchesCount);
|
|
}
|
|
}
|
|
|
|
function webViewerUpdateFindControlState({
|
|
state,
|
|
previous,
|
|
matchesCount,
|
|
rawQuery
|
|
}) {
|
|
if (PDFViewerApplication.supportsIntegratedFind) {
|
|
PDFViewerApplication.externalServices.updateFindControlState({
|
|
result: state,
|
|
findPrevious: previous,
|
|
matchesCount,
|
|
rawQuery
|
|
});
|
|
} else {
|
|
PDFViewerApplication.findBar.updateUIState(state, previous, matchesCount);
|
|
}
|
|
}
|
|
|
|
function webViewerScaleChanging(evt) {
|
|
PDFViewerApplication.toolbar.setPageScale(evt.presetValue, evt.scale);
|
|
PDFViewerApplication.pdfViewer.update();
|
|
}
|
|
|
|
function webViewerRotationChanging(evt) {
|
|
PDFViewerApplication.pdfThumbnailViewer.pagesRotation = evt.pagesRotation;
|
|
PDFViewerApplication.forceRendering();
|
|
PDFViewerApplication.pdfViewer.currentPageNumber = evt.pageNumber;
|
|
}
|
|
|
|
function webViewerPageChanging({
|
|
pageNumber,
|
|
pageLabel
|
|
}) {
|
|
PDFViewerApplication.toolbar.setPageNumber(pageNumber, pageLabel);
|
|
PDFViewerApplication.secondaryToolbar.setPageNumber(pageNumber);
|
|
|
|
if (PDFViewerApplication.pdfSidebar.visibleView === _ui_utils.SidebarView.THUMBS) {
|
|
PDFViewerApplication.pdfThumbnailViewer.scrollThumbnailIntoView(pageNumber);
|
|
}
|
|
}
|
|
|
|
function webViewerResolutionChange(evt) {
|
|
PDFViewerApplication.pdfViewer.refresh();
|
|
}
|
|
|
|
function webViewerVisibilityChange(evt) {
|
|
if (document.visibilityState === "visible") {
|
|
setZoomDisabledTimeout();
|
|
}
|
|
}
|
|
|
|
let zoomDisabledTimeout = null;
|
|
|
|
function setZoomDisabledTimeout() {
|
|
if (zoomDisabledTimeout) {
|
|
clearTimeout(zoomDisabledTimeout);
|
|
}
|
|
|
|
zoomDisabledTimeout = setTimeout(function () {
|
|
zoomDisabledTimeout = null;
|
|
}, WHEEL_ZOOM_DISABLED_TIMEOUT);
|
|
}
|
|
|
|
function webViewerWheel(evt) {
|
|
const {
|
|
pdfViewer,
|
|
supportedMouseWheelZoomModifierKeys
|
|
} = PDFViewerApplication;
|
|
|
|
if (pdfViewer.isInPresentationMode) {
|
|
return;
|
|
}
|
|
|
|
if (evt.ctrlKey && supportedMouseWheelZoomModifierKeys.ctrlKey || evt.metaKey && supportedMouseWheelZoomModifierKeys.metaKey) {
|
|
evt.preventDefault();
|
|
|
|
if (zoomDisabledTimeout || document.visibilityState === "hidden") {
|
|
return;
|
|
}
|
|
|
|
const deltaMode = evt.deltaMode;
|
|
const delta = (0, _ui_utils.normalizeWheelEventDirection)(evt);
|
|
const previousScale = pdfViewer.currentScale;
|
|
let ticks = 0;
|
|
|
|
if (deltaMode === WheelEvent.DOM_DELTA_LINE || deltaMode === WheelEvent.DOM_DELTA_PAGE) {
|
|
if (Math.abs(delta) >= 1) {
|
|
ticks = Math.sign(delta);
|
|
} else {
|
|
ticks = PDFViewerApplication.accumulateWheelTicks(delta);
|
|
}
|
|
} else {
|
|
const PIXELS_PER_LINE_SCALE = 30;
|
|
ticks = PDFViewerApplication.accumulateWheelTicks(delta / PIXELS_PER_LINE_SCALE);
|
|
}
|
|
|
|
if (ticks < 0) {
|
|
PDFViewerApplication.zoomOut(-ticks);
|
|
} else if (ticks > 0) {
|
|
PDFViewerApplication.zoomIn(ticks);
|
|
}
|
|
|
|
const currentScale = pdfViewer.currentScale;
|
|
|
|
if (previousScale !== currentScale) {
|
|
const scaleCorrectionFactor = currentScale / previousScale - 1;
|
|
const rect = pdfViewer.container.getBoundingClientRect();
|
|
const dx = evt.clientX - rect.left;
|
|
const dy = evt.clientY - rect.top;
|
|
pdfViewer.container.scrollLeft += dx * scaleCorrectionFactor;
|
|
pdfViewer.container.scrollTop += dy * scaleCorrectionFactor;
|
|
}
|
|
} else {
|
|
setZoomDisabledTimeout();
|
|
}
|
|
}
|
|
|
|
function webViewerTouchStart(evt) {
|
|
if (evt.touches.length > 1) {
|
|
evt.preventDefault();
|
|
}
|
|
}
|
|
|
|
function webViewerClick(evt) {
|
|
if (!PDFViewerApplication.secondaryToolbar.isOpen) {
|
|
return;
|
|
}
|
|
|
|
const appConfig = PDFViewerApplication.appConfig;
|
|
|
|
if (PDFViewerApplication.pdfViewer.containsElement(evt.target) || appConfig.toolbar.container.contains(evt.target) && evt.target !== appConfig.secondaryToolbar.toggleButton) {
|
|
PDFViewerApplication.secondaryToolbar.close();
|
|
}
|
|
}
|
|
|
|
function webViewerKeyDown(evt) {
|
|
if (PDFViewerApplication.overlayManager.active) {
|
|
return;
|
|
}
|
|
|
|
const {
|
|
eventBus,
|
|
pdfViewer
|
|
} = PDFViewerApplication;
|
|
const isViewerInPresentationMode = pdfViewer.isInPresentationMode;
|
|
let handled = false,
|
|
ensureViewerFocused = false;
|
|
const cmd = (evt.ctrlKey ? 1 : 0) | (evt.altKey ? 2 : 0) | (evt.shiftKey ? 4 : 0) | (evt.metaKey ? 8 : 0);
|
|
|
|
if (cmd === 1 || cmd === 8 || cmd === 5 || cmd === 12) {
|
|
switch (evt.keyCode) {
|
|
case 70:
|
|
if (!PDFViewerApplication.supportsIntegratedFind && !evt.shiftKey) {
|
|
PDFViewerApplication.findBar.open();
|
|
handled = true;
|
|
}
|
|
|
|
break;
|
|
|
|
case 71:
|
|
if (!PDFViewerApplication.supportsIntegratedFind) {
|
|
const {
|
|
state
|
|
} = PDFViewerApplication.findController;
|
|
|
|
if (state) {
|
|
const eventState = Object.assign(Object.create(null), state, {
|
|
source: window,
|
|
type: "again",
|
|
findPrevious: cmd === 5 || cmd === 12
|
|
});
|
|
eventBus.dispatch("find", eventState);
|
|
}
|
|
|
|
handled = true;
|
|
}
|
|
|
|
break;
|
|
|
|
case 61:
|
|
case 107:
|
|
case 187:
|
|
case 171:
|
|
if (!isViewerInPresentationMode) {
|
|
PDFViewerApplication.zoomIn();
|
|
}
|
|
|
|
handled = true;
|
|
break;
|
|
|
|
case 173:
|
|
case 109:
|
|
case 189:
|
|
if (!isViewerInPresentationMode) {
|
|
PDFViewerApplication.zoomOut();
|
|
}
|
|
|
|
handled = true;
|
|
break;
|
|
|
|
case 48:
|
|
case 96:
|
|
if (!isViewerInPresentationMode) {
|
|
setTimeout(function () {
|
|
PDFViewerApplication.zoomReset();
|
|
});
|
|
handled = false;
|
|
}
|
|
|
|
break;
|
|
|
|
case 38:
|
|
if (isViewerInPresentationMode || PDFViewerApplication.page > 1) {
|
|
PDFViewerApplication.page = 1;
|
|
handled = true;
|
|
ensureViewerFocused = true;
|
|
}
|
|
|
|
break;
|
|
|
|
case 40:
|
|
if (isViewerInPresentationMode || PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
|
|
PDFViewerApplication.page = PDFViewerApplication.pagesCount;
|
|
handled = true;
|
|
ensureViewerFocused = true;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (cmd === 1 || cmd === 8) {
|
|
switch (evt.keyCode) {
|
|
case 83:
|
|
eventBus.dispatch("download", {
|
|
source: window
|
|
});
|
|
handled = true;
|
|
break;
|
|
|
|
case 79:
|
|
{
|
|
eventBus.dispatch("openfile", {
|
|
source: window
|
|
});
|
|
handled = true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (cmd === 3 || cmd === 10) {
|
|
switch (evt.keyCode) {
|
|
case 80:
|
|
PDFViewerApplication.requestPresentationMode();
|
|
handled = true;
|
|
break;
|
|
|
|
case 71:
|
|
PDFViewerApplication.appConfig.toolbar.pageNumber.select();
|
|
handled = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (handled) {
|
|
if (ensureViewerFocused && !isViewerInPresentationMode) {
|
|
pdfViewer.focus();
|
|
}
|
|
|
|
evt.preventDefault();
|
|
return;
|
|
}
|
|
|
|
const curElement = (0, _ui_utils.getActiveOrFocusedElement)();
|
|
const curElementTagName = curElement?.tagName.toUpperCase();
|
|
|
|
if (curElementTagName === "INPUT" || curElementTagName === "TEXTAREA" || curElementTagName === "SELECT" || curElement?.isContentEditable) {
|
|
if (evt.keyCode !== 27) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (cmd === 0) {
|
|
let turnPage = 0,
|
|
turnOnlyIfPageFit = false;
|
|
|
|
switch (evt.keyCode) {
|
|
case 38:
|
|
case 33:
|
|
if (pdfViewer.isVerticalScrollbarEnabled) {
|
|
turnOnlyIfPageFit = true;
|
|
}
|
|
|
|
turnPage = -1;
|
|
break;
|
|
|
|
case 8:
|
|
if (!isViewerInPresentationMode) {
|
|
turnOnlyIfPageFit = true;
|
|
}
|
|
|
|
turnPage = -1;
|
|
break;
|
|
|
|
case 37:
|
|
if (pdfViewer.isHorizontalScrollbarEnabled) {
|
|
turnOnlyIfPageFit = true;
|
|
}
|
|
|
|
case 75:
|
|
case 80:
|
|
turnPage = -1;
|
|
break;
|
|
|
|
case 27:
|
|
if (PDFViewerApplication.secondaryToolbar.isOpen) {
|
|
PDFViewerApplication.secondaryToolbar.close();
|
|
handled = true;
|
|
}
|
|
|
|
if (!PDFViewerApplication.supportsIntegratedFind && PDFViewerApplication.findBar.opened) {
|
|
PDFViewerApplication.findBar.close();
|
|
handled = true;
|
|
}
|
|
|
|
break;
|
|
|
|
case 40:
|
|
case 34:
|
|
if (pdfViewer.isVerticalScrollbarEnabled) {
|
|
turnOnlyIfPageFit = true;
|
|
}
|
|
|
|
turnPage = 1;
|
|
break;
|
|
|
|
case 13:
|
|
case 32:
|
|
if (!isViewerInPresentationMode) {
|
|
turnOnlyIfPageFit = true;
|
|
}
|
|
|
|
turnPage = 1;
|
|
break;
|
|
|
|
case 39:
|
|
if (pdfViewer.isHorizontalScrollbarEnabled) {
|
|
turnOnlyIfPageFit = true;
|
|
}
|
|
|
|
case 74:
|
|
case 78:
|
|
turnPage = 1;
|
|
break;
|
|
|
|
case 36:
|
|
if (isViewerInPresentationMode || PDFViewerApplication.page > 1) {
|
|
PDFViewerApplication.page = 1;
|
|
handled = true;
|
|
ensureViewerFocused = true;
|
|
}
|
|
|
|
break;
|
|
|
|
case 35:
|
|
if (isViewerInPresentationMode || PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
|
|
PDFViewerApplication.page = PDFViewerApplication.pagesCount;
|
|
handled = true;
|
|
ensureViewerFocused = true;
|
|
}
|
|
|
|
break;
|
|
|
|
case 83:
|
|
PDFViewerApplication.pdfCursorTools.switchTool(_pdf_cursor_tools.CursorTool.SELECT);
|
|
break;
|
|
|
|
case 72:
|
|
PDFViewerApplication.pdfCursorTools.switchTool(_pdf_cursor_tools.CursorTool.HAND);
|
|
break;
|
|
|
|
case 82:
|
|
PDFViewerApplication.rotatePages(90);
|
|
break;
|
|
|
|
case 115:
|
|
PDFViewerApplication.pdfSidebar.toggle();
|
|
break;
|
|
}
|
|
|
|
if (turnPage !== 0 && (!turnOnlyIfPageFit || pdfViewer.currentScaleValue === "page-fit")) {
|
|
if (turnPage > 0) {
|
|
pdfViewer.nextPage();
|
|
} else {
|
|
pdfViewer.previousPage();
|
|
}
|
|
|
|
handled = true;
|
|
}
|
|
}
|
|
|
|
if (cmd === 4) {
|
|
switch (evt.keyCode) {
|
|
case 13:
|
|
case 32:
|
|
if (!isViewerInPresentationMode && pdfViewer.currentScaleValue !== "page-fit") {
|
|
break;
|
|
}
|
|
|
|
pdfViewer.previousPage();
|
|
handled = true;
|
|
break;
|
|
|
|
case 82:
|
|
PDFViewerApplication.rotatePages(-90);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!handled && !isViewerInPresentationMode) {
|
|
if (evt.keyCode >= 33 && evt.keyCode <= 40 || evt.keyCode === 32 && curElementTagName !== "BUTTON") {
|
|
ensureViewerFocused = true;
|
|
}
|
|
}
|
|
|
|
if (ensureViewerFocused && !pdfViewer.containsElement(curElement)) {
|
|
pdfViewer.focus();
|
|
}
|
|
|
|
if (handled) {
|
|
evt.preventDefault();
|
|
}
|
|
}
|
|
|
|
function beforeUnload(evt) {
|
|
evt.preventDefault();
|
|
evt.returnValue = "";
|
|
return false;
|
|
}
|
|
|
|
function webViewerAnnotationEditorStatesChanged(data) {
|
|
PDFViewerApplication.externalServices.updateEditorStates(data);
|
|
}
|
|
|
|
const PDFPrintServiceFactory = {
|
|
instance: {
|
|
supportsPrinting: false,
|
|
|
|
createPrintService() {
|
|
throw new Error("Not implemented: createPrintService");
|
|
}
|
|
|
|
}
|
|
};
|
|
exports.PDFPrintServiceFactory = PDFPrintServiceFactory; |