You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2354 lines
73 KiB
2354 lines
73 KiB
/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ |
|
/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */ |
|
/* 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. |
|
*/ |
|
/*jshint globalstrict: false */ |
|
/* globals PDFJS, PDFViewer, PDFPageView, TextLayerBuilder, |
|
DefaultTextLayerFactory, AnnotationsLayerBuilder, |
|
DefaultAnnotationsLayerFactory */ |
|
|
|
// Initializing PDFJS global object (if still undefined) |
|
if (typeof PDFJS === 'undefined') { |
|
(typeof window !== 'undefined' ? window : this).PDFJS = {}; |
|
} |
|
|
|
(function pdfViewerWrapper() { |
|
'use strict'; |
|
|
|
|
|
var CSS_UNITS = 96.0 / 72.0; |
|
var DEFAULT_SCALE = 'auto'; |
|
var UNKNOWN_SCALE = 0; |
|
var MAX_AUTO_SCALE = 1.25; |
|
var SCROLLBAR_PADDING = 40; |
|
var VERTICAL_PADDING = 5; |
|
|
|
// optimised CSS custom property getter/setter |
|
var CustomStyle = (function CustomStyleClosure() { |
|
|
|
// As noted on: http://www.zachstronaut.com/posts/2009/02/17/ |
|
// animate-css-transforms-firefox-webkit.html |
|
// in some versions of IE9 it is critical that ms appear in this list |
|
// before Moz |
|
var prefixes = ['ms', 'Moz', 'Webkit', 'O']; |
|
var _cache = {}; |
|
|
|
function CustomStyle() {} |
|
|
|
CustomStyle.getProp = function get(propName, element) { |
|
// check cache only when no element is given |
|
if (arguments.length === 1 && typeof _cache[propName] === 'string') { |
|
return _cache[propName]; |
|
} |
|
|
|
element = element || document.documentElement; |
|
var style = element.style, prefixed, uPropName; |
|
|
|
// test standard property first |
|
if (typeof style[propName] === 'string') { |
|
return (_cache[propName] = propName); |
|
} |
|
|
|
// capitalize |
|
uPropName = propName.charAt(0).toUpperCase() + propName.slice(1); |
|
|
|
// test vendor specific properties |
|
for (var i = 0, l = prefixes.length; i < l; i++) { |
|
prefixed = prefixes[i] + uPropName; |
|
if (typeof style[prefixed] === 'string') { |
|
return (_cache[propName] = prefixed); |
|
} |
|
} |
|
|
|
//if all fails then set to undefined |
|
return (_cache[propName] = 'undefined'); |
|
}; |
|
|
|
CustomStyle.setProp = function set(propName, element, str) { |
|
var prop = this.getProp(propName); |
|
if (prop !== 'undefined') { |
|
element.style[prop] = str; |
|
} |
|
}; |
|
|
|
return CustomStyle; |
|
})(); |
|
|
|
function getFileName(url) { |
|
var anchor = url.indexOf('#'); |
|
var query = url.indexOf('?'); |
|
var end = Math.min( |
|
anchor > 0 ? anchor : url.length, |
|
query > 0 ? query : url.length); |
|
return url.substring(url.lastIndexOf('/', end) + 1, end); |
|
} |
|
|
|
/** |
|
* Returns scale factor for the canvas. It makes sense for the HiDPI displays. |
|
* @return {Object} The object with horizontal (sx) and vertical (sy) |
|
scales. The scaled property is set to false if scaling is |
|
not required, true otherwise. |
|
*/ |
|
function getOutputScale(ctx) { |
|
var devicePixelRatio = window.devicePixelRatio || 1; |
|
var backingStoreRatio = ctx.webkitBackingStorePixelRatio || |
|
ctx.mozBackingStorePixelRatio || |
|
ctx.msBackingStorePixelRatio || |
|
ctx.oBackingStorePixelRatio || |
|
ctx.backingStorePixelRatio || 1; |
|
var pixelRatio = devicePixelRatio / backingStoreRatio; |
|
return { |
|
sx: pixelRatio, |
|
sy: pixelRatio, |
|
scaled: pixelRatio !== 1 |
|
}; |
|
} |
|
|
|
/** |
|
* Scrolls specified element into view of its parent. |
|
* element {Object} The element to be visible. |
|
* spot {Object} An object with optional top and left properties, |
|
* specifying the offset from the top left edge. |
|
*/ |
|
function scrollIntoView(element, spot) { |
|
// Assuming offsetParent is available (it's not available when viewer is in |
|
// hidden iframe or object). We have to scroll: if the offsetParent is not set |
|
// producing the error. See also animationStartedClosure. |
|
var parent = element.offsetParent; |
|
var offsetY = element.offsetTop + element.clientTop; |
|
var offsetX = element.offsetLeft + element.clientLeft; |
|
if (!parent) { |
|
console.error('offsetParent is not set -- cannot scroll'); |
|
return; |
|
} |
|
while (parent.clientHeight === parent.scrollHeight) { |
|
if (parent.dataset._scaleY) { |
|
offsetY /= parent.dataset._scaleY; |
|
offsetX /= parent.dataset._scaleX; |
|
} |
|
offsetY += parent.offsetTop; |
|
offsetX += parent.offsetLeft; |
|
parent = parent.offsetParent; |
|
if (!parent) { |
|
return; // no need to scroll |
|
} |
|
} |
|
if (spot) { |
|
if (spot.top !== undefined) { |
|
offsetY += spot.top; |
|
} |
|
if (spot.left !== undefined) { |
|
offsetX += spot.left; |
|
parent.scrollLeft = offsetX; |
|
} |
|
} |
|
parent.scrollTop = offsetY; |
|
} |
|
|
|
/** |
|
* Helper function to start monitoring the scroll event and converting them into |
|
* PDF.js friendly one: with scroll debounce and scroll direction. |
|
*/ |
|
function watchScroll(viewAreaElement, callback) { |
|
var debounceScroll = function debounceScroll(evt) { |
|
if (rAF) { |
|
return; |
|
} |
|
// schedule an invocation of scroll for next animation frame. |
|
rAF = window.requestAnimationFrame(function viewAreaElementScrolled() { |
|
rAF = null; |
|
|
|
var currentY = viewAreaElement.scrollTop; |
|
var lastY = state.lastY; |
|
if (currentY > lastY) { |
|
state.down = true; |
|
} else if (currentY < lastY) { |
|
state.down = false; |
|
} |
|
state.lastY = currentY; |
|
// else do nothing and use previous value |
|
callback(state); |
|
}); |
|
}; |
|
|
|
var state = { |
|
down: true, |
|
lastY: viewAreaElement.scrollTop, |
|
_eventHandler: debounceScroll |
|
}; |
|
|
|
var rAF = null; |
|
viewAreaElement.addEventListener('scroll', debounceScroll, true); |
|
return state; |
|
} |
|
|
|
/** |
|
* Generic helper to find out what elements are visible within a scroll pane. |
|
*/ |
|
function getVisibleElements(scrollEl, views, sortByVisibility) { |
|
var top = scrollEl.scrollTop, bottom = top + scrollEl.clientHeight; |
|
var left = scrollEl.scrollLeft, right = left + scrollEl.clientWidth; |
|
|
|
var visible = [], view; |
|
var currentHeight, viewHeight, hiddenHeight, percentHeight; |
|
var currentWidth, viewWidth; |
|
for (var i = 0, ii = views.length; i < ii; ++i) { |
|
view = views[i]; |
|
currentHeight = view.el.offsetTop + view.el.clientTop; |
|
viewHeight = view.el.clientHeight; |
|
if ((currentHeight + viewHeight) < top) { |
|
continue; |
|
} |
|
if (currentHeight > bottom) { |
|
break; |
|
} |
|
currentWidth = view.el.offsetLeft + view.el.clientLeft; |
|
viewWidth = view.el.clientWidth; |
|
if ((currentWidth + viewWidth) < left || currentWidth > right) { |
|
continue; |
|
} |
|
hiddenHeight = Math.max(0, top - currentHeight) + |
|
Math.max(0, currentHeight + viewHeight - bottom); |
|
percentHeight = ((viewHeight - hiddenHeight) * 100 / viewHeight) | 0; |
|
|
|
visible.push({ id: view.id, x: currentWidth, y: currentHeight, |
|
view: view, percent: percentHeight }); |
|
} |
|
|
|
var first = visible[0]; |
|
var last = visible[visible.length - 1]; |
|
|
|
if (sortByVisibility) { |
|
visible.sort(function(a, b) { |
|
var pc = a.percent - b.percent; |
|
if (Math.abs(pc) > 0.001) { |
|
return -pc; |
|
} |
|
return a.id - b.id; // ensure stability |
|
}); |
|
} |
|
return {first: first, last: last, views: visible}; |
|
} |
|
|
|
/** |
|
* Event handler to suppress context menu. |
|
*/ |
|
function noContextMenuHandler(e) { |
|
e.preventDefault(); |
|
} |
|
|
|
/** |
|
* Returns the filename or guessed filename from the url (see issue 3455). |
|
* url {String} The original PDF location. |
|
* @return {String} Guessed PDF file name. |
|
*/ |
|
function getPDFFileNameFromURL(url) { |
|
var reURI = /^(?:([^:]+:)?\/\/[^\/]+)?([^?#]*)(\?[^#]*)?(#.*)?$/; |
|
// SCHEME HOST 1.PATH 2.QUERY 3.REF |
|
// Pattern to get last matching NAME.pdf |
|
var reFilename = /[^\/?#=]+\.pdf\b(?!.*\.pdf\b)/i; |
|
var splitURI = reURI.exec(url); |
|
var suggestedFilename = reFilename.exec(splitURI[1]) || |
|
reFilename.exec(splitURI[2]) || |
|
reFilename.exec(splitURI[3]); |
|
if (suggestedFilename) { |
|
suggestedFilename = suggestedFilename[0]; |
|
if (suggestedFilename.indexOf('%') !== -1) { |
|
// URL-encoded %2Fpath%2Fto%2Ffile.pdf should be file.pdf |
|
try { |
|
suggestedFilename = |
|
reFilename.exec(decodeURIComponent(suggestedFilename))[0]; |
|
} catch(e) { // Possible (extremely rare) errors: |
|
// URIError "Malformed URI", e.g. for "%AA.pdf" |
|
// TypeError "null has no properties", e.g. for "%2F.pdf" |
|
} |
|
} |
|
} |
|
return suggestedFilename || 'document.pdf'; |
|
} |
|
|
|
var ProgressBar = (function ProgressBarClosure() { |
|
|
|
function clamp(v, min, max) { |
|
return Math.min(Math.max(v, min), max); |
|
} |
|
|
|
function ProgressBar(id, opts) { |
|
this.visible = true; |
|
|
|
// Fetch the sub-elements for later. |
|
this.div = document.querySelector(id + ' .progress'); |
|
|
|
// Get the loading bar element, so it can be resized to fit the viewer. |
|
this.bar = this.div.parentNode; |
|
|
|
// Get options, with sensible defaults. |
|
this.height = opts.height || 100; |
|
this.width = opts.width || 100; |
|
this.units = opts.units || '%'; |
|
|
|
// Initialize heights. |
|
this.div.style.height = this.height + this.units; |
|
this.percent = 0; |
|
} |
|
|
|
ProgressBar.prototype = { |
|
|
|
updateBar: function ProgressBar_updateBar() { |
|
if (this._indeterminate) { |
|
this.div.classList.add('indeterminate'); |
|
this.div.style.width = this.width + this.units; |
|
return; |
|
} |
|
|
|
this.div.classList.remove('indeterminate'); |
|
var progressSize = this.width * this._percent / 100; |
|
this.div.style.width = progressSize + this.units; |
|
}, |
|
|
|
get percent() { |
|
return this._percent; |
|
}, |
|
|
|
set percent(val) { |
|
this._indeterminate = isNaN(val); |
|
this._percent = clamp(val, 0, 100); |
|
this.updateBar(); |
|
}, |
|
|
|
setWidth: function ProgressBar_setWidth(viewer) { |
|
if (viewer) { |
|
var container = viewer.parentNode; |
|
var scrollbarWidth = container.offsetWidth - viewer.offsetWidth; |
|
if (scrollbarWidth > 0) { |
|
this.bar.setAttribute('style', 'width: calc(100% - ' + |
|
scrollbarWidth + 'px);'); |
|
} |
|
} |
|
}, |
|
|
|
hide: function ProgressBar_hide() { |
|
if (!this.visible) { |
|
return; |
|
} |
|
this.visible = false; |
|
this.bar.classList.add('hidden'); |
|
document.body.classList.remove('loadingInProgress'); |
|
}, |
|
|
|
show: function ProgressBar_show() { |
|
if (this.visible) { |
|
return; |
|
} |
|
this.visible = true; |
|
document.body.classList.add('loadingInProgress'); |
|
this.bar.classList.remove('hidden'); |
|
} |
|
}; |
|
|
|
return ProgressBar; |
|
})(); |
|
|
|
|
|
var PresentationModeState = { |
|
UNKNOWN: 0, |
|
NORMAL: 1, |
|
CHANGING: 2, |
|
FULLSCREEN: 3, |
|
}; |
|
|
|
var IGNORE_CURRENT_POSITION_ON_ZOOM = false; |
|
var DEFAULT_CACHE_SIZE = 10; |
|
|
|
|
|
var CLEANUP_TIMEOUT = 30000; |
|
|
|
var RenderingStates = { |
|
INITIAL: 0, |
|
RUNNING: 1, |
|
PAUSED: 2, |
|
FINISHED: 3 |
|
}; |
|
|
|
/** |
|
* Controls rendering of the views for pages and thumbnails. |
|
* @class |
|
*/ |
|
var PDFRenderingQueue = (function PDFRenderingQueueClosure() { |
|
/** |
|
* @constructs |
|
*/ |
|
function PDFRenderingQueue() { |
|
this.pdfViewer = null; |
|
this.pdfThumbnailViewer = null; |
|
this.onIdle = null; |
|
|
|
this.highestPriorityPage = null; |
|
this.idleTimeout = null; |
|
this.printing = false; |
|
this.isThumbnailViewEnabled = false; |
|
} |
|
|
|
PDFRenderingQueue.prototype = /** @lends PDFRenderingQueue.prototype */ { |
|
/** |
|
* @param {PDFViewer} pdfViewer |
|
*/ |
|
setViewer: function PDFRenderingQueue_setViewer(pdfViewer) { |
|
this.pdfViewer = pdfViewer; |
|
}, |
|
|
|
/** |
|
* @param {PDFThumbnailViewer} pdfThumbnailViewer |
|
*/ |
|
setThumbnailViewer: |
|
function PDFRenderingQueue_setThumbnailViewer(pdfThumbnailViewer) { |
|
this.pdfThumbnailViewer = pdfThumbnailViewer; |
|
}, |
|
|
|
/** |
|
* @param {IRenderableView} view |
|
* @returns {boolean} |
|
*/ |
|
isHighestPriority: function PDFRenderingQueue_isHighestPriority(view) { |
|
return this.highestPriorityPage === view.renderingId; |
|
}, |
|
|
|
renderHighestPriority: function |
|
PDFRenderingQueue_renderHighestPriority(currentlyVisiblePages) { |
|
if (this.idleTimeout) { |
|
clearTimeout(this.idleTimeout); |
|
this.idleTimeout = null; |
|
} |
|
|
|
// Pages have a higher priority than thumbnails, so check them first. |
|
if (this.pdfViewer.forceRendering(currentlyVisiblePages)) { |
|
return; |
|
} |
|
// No pages needed rendering so check thumbnails. |
|
if (this.pdfThumbnailViewer && this.isThumbnailViewEnabled) { |
|
if (this.pdfThumbnailViewer.forceRendering()) { |
|
return; |
|
} |
|
} |
|
|
|
if (this.printing) { |
|
// If printing is currently ongoing do not reschedule cleanup. |
|
return; |
|
} |
|
|
|
if (this.onIdle) { |
|
this.idleTimeout = setTimeout(this.onIdle.bind(this), CLEANUP_TIMEOUT); |
|
} |
|
}, |
|
|
|
getHighestPriority: function |
|
PDFRenderingQueue_getHighestPriority(visible, views, scrolledDown) { |
|
// The state has changed figure out which page has the highest priority to |
|
// render next (if any). |
|
// Priority: |
|
// 1 visible pages |
|
// 2 if last scrolled down page after the visible pages |
|
// 2 if last scrolled up page before the visible pages |
|
var visibleViews = visible.views; |
|
|
|
var numVisible = visibleViews.length; |
|
if (numVisible === 0) { |
|
return false; |
|
} |
|
for (var i = 0; i < numVisible; ++i) { |
|
var view = visibleViews[i].view; |
|
if (!this.isViewFinished(view)) { |
|
return view; |
|
} |
|
} |
|
|
|
// All the visible views have rendered, try to render next/previous pages. |
|
if (scrolledDown) { |
|
var nextPageIndex = visible.last.id; |
|
// ID's start at 1 so no need to add 1. |
|
if (views[nextPageIndex] && |
|
!this.isViewFinished(views[nextPageIndex])) { |
|
return views[nextPageIndex]; |
|
} |
|
} else { |
|
var previousPageIndex = visible.first.id - 2; |
|
if (views[previousPageIndex] && |
|
!this.isViewFinished(views[previousPageIndex])) { |
|
return views[previousPageIndex]; |
|
} |
|
} |
|
// Everything that needs to be rendered has been. |
|
return null; |
|
}, |
|
|
|
/** |
|
* @param {IRenderableView} view |
|
* @returns {boolean} |
|
*/ |
|
isViewFinished: function PDFRenderingQueue_isViewFinished(view) { |
|
return view.renderingState === RenderingStates.FINISHED; |
|
}, |
|
|
|
/** |
|
* Render a page or thumbnail view. This calls the appropriate function |
|
* based on the views state. If the view is already rendered it will return |
|
* false. |
|
* @param {IRenderableView} view |
|
*/ |
|
renderView: function PDFRenderingQueue_renderView(view) { |
|
var state = view.renderingState; |
|
switch (state) { |
|
case RenderingStates.FINISHED: |
|
return false; |
|
case RenderingStates.PAUSED: |
|
this.highestPriorityPage = view.renderingId; |
|
view.resume(); |
|
break; |
|
case RenderingStates.RUNNING: |
|
this.highestPriorityPage = view.renderingId; |
|
break; |
|
case RenderingStates.INITIAL: |
|
this.highestPriorityPage = view.renderingId; |
|
var continueRendering = function () { |
|
this.renderHighestPriority(); |
|
}.bind(this); |
|
view.draw().then(continueRendering, continueRendering); |
|
break; |
|
} |
|
return true; |
|
}, |
|
}; |
|
|
|
return PDFRenderingQueue; |
|
})(); |
|
|
|
|
|
var TEXT_LAYER_RENDER_DELAY = 200; // ms |
|
|
|
/** |
|
* @typedef {Object} PDFPageViewOptions |
|
* @property {HTMLDivElement} container - The viewer element. |
|
* @property {number} id - The page unique ID (normally its number). |
|
* @property {number} scale - The page scale display. |
|
* @property {PageViewport} defaultViewport - The page viewport. |
|
* @property {PDFRenderingQueue} renderingQueue - The rendering queue object. |
|
* @property {IPDFTextLayerFactory} textLayerFactory |
|
* @property {IPDFAnnotationsLayerFactory} annotationsLayerFactory |
|
*/ |
|
|
|
/** |
|
* @class |
|
* @implements {IRenderableView} |
|
*/ |
|
var PDFPageView = (function PDFPageViewClosure() { |
|
/** |
|
* @constructs PDFPageView |
|
* @param {PDFPageViewOptions} options |
|
*/ |
|
function PDFPageView(options) { |
|
var container = options.container; |
|
var id = options.id; |
|
var scale = options.scale; |
|
var defaultViewport = options.defaultViewport; |
|
var renderingQueue = options.renderingQueue; |
|
var textLayerFactory = options.textLayerFactory; |
|
var annotationsLayerFactory = options.annotationsLayerFactory; |
|
|
|
this.id = id; |
|
this.renderingId = 'page' + id; |
|
|
|
this.rotation = 0; |
|
this.scale = scale || 1.0; |
|
this.viewport = defaultViewport; |
|
this.pdfPageRotate = defaultViewport.rotation; |
|
this.hasRestrictedScaling = false; |
|
|
|
this.renderingQueue = renderingQueue; |
|
this.textLayerFactory = textLayerFactory; |
|
this.annotationsLayerFactory = annotationsLayerFactory; |
|
|
|
this.renderingState = RenderingStates.INITIAL; |
|
this.resume = null; |
|
|
|
this.onBeforeDraw = null; |
|
this.onAfterDraw = null; |
|
|
|
this.textLayer = null; |
|
|
|
this.zoomLayer = null; |
|
|
|
this.annotationLayer = null; |
|
|
|
var anchor = document.createElement('a'); |
|
anchor.name = '' + this.id; |
|
|
|
var div = document.createElement('div'); |
|
div.id = 'pageContainer' + this.id; |
|
div.className = 'page'; |
|
div.style.width = Math.floor(this.viewport.width) + 'px'; |
|
div.style.height = Math.floor(this.viewport.height) + 'px'; |
|
this.el = div; // TODO replace 'el' property usage |
|
this.div = div; |
|
|
|
container.appendChild(anchor); |
|
container.appendChild(div); |
|
} |
|
|
|
PDFPageView.prototype = { |
|
setPdfPage: function PDFPageView_setPdfPage(pdfPage) { |
|
this.pdfPage = pdfPage; |
|
this.pdfPageRotate = pdfPage.rotate; |
|
var totalRotation = (this.rotation + this.pdfPageRotate) % 360; |
|
this.viewport = pdfPage.getViewport(this.scale * CSS_UNITS, |
|
totalRotation); |
|
this.stats = pdfPage.stats; |
|
this.reset(); |
|
}, |
|
|
|
destroy: function PDFPageView_destroy() { |
|
this.zoomLayer = null; |
|
this.reset(); |
|
if (this.pdfPage) { |
|
this.pdfPage.destroy(); |
|
} |
|
}, |
|
|
|
reset: function PDFPageView_reset(keepAnnotations) { |
|
if (this.renderTask) { |
|
this.renderTask.cancel(); |
|
} |
|
this.resume = null; |
|
this.renderingState = RenderingStates.INITIAL; |
|
|
|
var div = this.div; |
|
div.style.width = Math.floor(this.viewport.width) + 'px'; |
|
div.style.height = Math.floor(this.viewport.height) + 'px'; |
|
|
|
var childNodes = div.childNodes; |
|
var currentZoomLayer = this.zoomLayer || null; |
|
var currentAnnotationNode = (keepAnnotations && this.annotationLayer && |
|
this.annotationLayer.div) || null; |
|
for (var i = div.childNodes.length - 1; i >= 0; i--) { |
|
var node = childNodes[i]; |
|
if (currentZoomLayer === node || currentAnnotationNode === node) { |
|
continue; |
|
} |
|
div.removeChild(node); |
|
} |
|
div.removeAttribute('data-loaded'); |
|
|
|
if (keepAnnotations) { |
|
if (this.annotationLayer) { |
|
// Hide annotationLayer until all elements are resized |
|
// so they are not displayed on the already-resized page |
|
this.annotationLayer.hide(); |
|
} |
|
} else { |
|
this.annotationLayer = null; |
|
} |
|
|
|
if (this.canvas) { |
|
// Zeroing the width and height causes Firefox to release graphics |
|
// resources immediately, which can greatly reduce memory consumption. |
|
this.canvas.width = 0; |
|
this.canvas.height = 0; |
|
delete this.canvas; |
|
} |
|
|
|
this.loadingIconDiv = document.createElement('div'); |
|
this.loadingIconDiv.className = 'loadingIcon'; |
|
div.appendChild(this.loadingIconDiv); |
|
}, |
|
|
|
update: function PDFPageView_update(scale, rotation) { |
|
this.scale = scale || this.scale; |
|
|
|
if (typeof rotation !== 'undefined') { |
|
this.rotation = rotation; |
|
} |
|
|
|
var totalRotation = (this.rotation + this.pdfPageRotate) % 360; |
|
this.viewport = this.viewport.clone({ |
|
scale: this.scale * CSS_UNITS, |
|
rotation: totalRotation |
|
}); |
|
|
|
var isScalingRestricted = false; |
|
if (this.canvas && PDFJS.maxCanvasPixels > 0) { |
|
var ctx = this.canvas.getContext('2d'); |
|
var outputScale = getOutputScale(ctx); |
|
var pixelsInViewport = this.viewport.width * this.viewport.height; |
|
var maxScale = Math.sqrt(PDFJS.maxCanvasPixels / pixelsInViewport); |
|
if (((Math.floor(this.viewport.width) * outputScale.sx) | 0) * |
|
((Math.floor(this.viewport.height) * outputScale.sy) | 0) > |
|
PDFJS.maxCanvasPixels) { |
|
isScalingRestricted = true; |
|
} |
|
} |
|
|
|
if (this.canvas && |
|
(PDFJS.useOnlyCssZoom || |
|
(this.hasRestrictedScaling && isScalingRestricted))) { |
|
this.cssTransform(this.canvas, true); |
|
return; |
|
} else if (this.canvas && !this.zoomLayer) { |
|
this.zoomLayer = this.canvas.parentNode; |
|
this.zoomLayer.style.position = 'absolute'; |
|
} |
|
if (this.zoomLayer) { |
|
this.cssTransform(this.zoomLayer.firstChild); |
|
} |
|
this.reset(true); |
|
}, |
|
|
|
/** |
|
* Called when moved in the parent's container. |
|
*/ |
|
updatePosition: function PDFPageView_updatePosition() { |
|
if (this.textLayer) { |
|
this.textLayer.render(TEXT_LAYER_RENDER_DELAY); |
|
} |
|
}, |
|
|
|
cssTransform: function PDFPageView_transform(canvas, redrawAnnotations) { |
|
// Scale canvas, canvas wrapper, and page container. |
|
var width = this.viewport.width; |
|
var height = this.viewport.height; |
|
var div = this.div; |
|
canvas.style.width = canvas.parentNode.style.width = div.style.width = |
|
Math.floor(width) + 'px'; |
|
canvas.style.height = canvas.parentNode.style.height = div.style.height = |
|
Math.floor(height) + 'px'; |
|
// The canvas may have been originally rotated, rotate relative to that. |
|
var relativeRotation = this.viewport.rotation - canvas._viewport.rotation; |
|
var absRotation = Math.abs(relativeRotation); |
|
var scaleX = 1, scaleY = 1; |
|
if (absRotation === 90 || absRotation === 270) { |
|
// Scale x and y because of the rotation. |
|
scaleX = height / width; |
|
scaleY = width / height; |
|
} |
|
var cssTransform = 'rotate(' + relativeRotation + 'deg) ' + |
|
'scale(' + scaleX + ',' + scaleY + ')'; |
|
CustomStyle.setProp('transform', canvas, cssTransform); |
|
|
|
if (this.textLayer) { |
|
// Rotating the text layer is more complicated since the divs inside the |
|
// the text layer are rotated. |
|
// TODO: This could probably be simplified by drawing the text layer in |
|
// one orientation then rotating overall. |
|
var textLayerViewport = this.textLayer.viewport; |
|
var textRelativeRotation = this.viewport.rotation - |
|
textLayerViewport.rotation; |
|
var textAbsRotation = Math.abs(textRelativeRotation); |
|
var scale = width / textLayerViewport.width; |
|
if (textAbsRotation === 90 || textAbsRotation === 270) { |
|
scale = width / textLayerViewport.height; |
|
} |
|
var textLayerDiv = this.textLayer.textLayerDiv; |
|
var transX, transY; |
|
switch (textAbsRotation) { |
|
case 0: |
|
transX = transY = 0; |
|
break; |
|
case 90: |
|
transX = 0; |
|
transY = '-' + textLayerDiv.style.height; |
|
break; |
|
case 180: |
|
transX = '-' + textLayerDiv.style.width; |
|
transY = '-' + textLayerDiv.style.height; |
|
break; |
|
case 270: |
|
transX = '-' + textLayerDiv.style.width; |
|
transY = 0; |
|
break; |
|
default: |
|
console.error('Bad rotation value.'); |
|
break; |
|
} |
|
CustomStyle.setProp('transform', textLayerDiv, |
|
'rotate(' + textAbsRotation + 'deg) ' + |
|
'scale(' + scale + ', ' + scale + ') ' + |
|
'translate(' + transX + ', ' + transY + ')'); |
|
CustomStyle.setProp('transformOrigin', textLayerDiv, '0% 0%'); |
|
} |
|
|
|
if (redrawAnnotations && this.annotationLayer) { |
|
this.annotationLayer.setupAnnotations(this.viewport); |
|
} |
|
}, |
|
|
|
get width() { |
|
return this.viewport.width; |
|
}, |
|
|
|
get height() { |
|
return this.viewport.height; |
|
}, |
|
|
|
getPagePoint: function PDFPageView_getPagePoint(x, y) { |
|
return this.viewport.convertToPdfPoint(x, y); |
|
}, |
|
|
|
draw: function PDFPageView_draw() { |
|
if (this.renderingState !== RenderingStates.INITIAL) { |
|
console.error('Must be in new state before drawing'); |
|
} |
|
|
|
this.renderingState = RenderingStates.RUNNING; |
|
|
|
var pdfPage = this.pdfPage; |
|
var viewport = this.viewport; |
|
var div = this.div; |
|
// Wrap the canvas so if it has a css transform for highdpi the overflow |
|
// will be hidden in FF. |
|
var canvasWrapper = document.createElement('div'); |
|
canvasWrapper.style.width = div.style.width; |
|
canvasWrapper.style.height = div.style.height; |
|
canvasWrapper.classList.add('canvasWrapper'); |
|
|
|
var canvas = document.createElement('canvas'); |
|
canvas.id = 'page' + this.id; |
|
canvasWrapper.appendChild(canvas); |
|
if (this.annotationLayer) { |
|
// annotationLayer needs to stay on top |
|
div.insertBefore(canvasWrapper, this.annotationLayer.div); |
|
} else { |
|
div.appendChild(canvasWrapper); |
|
} |
|
this.canvas = canvas; |
|
|
|
var ctx = canvas.getContext('2d'); |
|
var outputScale = getOutputScale(ctx); |
|
|
|
if (PDFJS.useOnlyCssZoom) { |
|
var actualSizeViewport = viewport.clone({ scale: CSS_UNITS }); |
|
// Use a scale that will make the canvas be the original intended size |
|
// of the page. |
|
outputScale.sx *= actualSizeViewport.width / viewport.width; |
|
outputScale.sy *= actualSizeViewport.height / viewport.height; |
|
outputScale.scaled = true; |
|
} |
|
|
|
if (PDFJS.maxCanvasPixels > 0) { |
|
var pixelsInViewport = viewport.width * viewport.height; |
|
var maxScale = Math.sqrt(PDFJS.maxCanvasPixels / pixelsInViewport); |
|
if (outputScale.sx > maxScale || outputScale.sy > maxScale) { |
|
outputScale.sx = maxScale; |
|
outputScale.sy = maxScale; |
|
outputScale.scaled = true; |
|
this.hasRestrictedScaling = true; |
|
} else { |
|
this.hasRestrictedScaling = false; |
|
} |
|
} |
|
|
|
canvas.width = (Math.floor(viewport.width) * outputScale.sx) | 0; |
|
canvas.height = (Math.floor(viewport.height) * outputScale.sy) | 0; |
|
canvas.style.width = Math.floor(viewport.width) + 'px'; |
|
canvas.style.height = Math.floor(viewport.height) + 'px'; |
|
// Add the viewport so it's known what it was originally drawn with. |
|
canvas._viewport = viewport; |
|
|
|
var textLayerDiv = null; |
|
var textLayer = null; |
|
if (this.textLayerFactory) { |
|
textLayerDiv = document.createElement('div'); |
|
textLayerDiv.className = 'textLayer'; |
|
textLayerDiv.style.width = canvas.style.width; |
|
textLayerDiv.style.height = canvas.style.height; |
|
if (this.annotationLayer) { |
|
// annotationLayer needs to stay on top |
|
div.insertBefore(textLayerDiv, this.annotationLayer.div); |
|
} else { |
|
div.appendChild(textLayerDiv); |
|
} |
|
|
|
textLayer = this.textLayerFactory.createTextLayerBuilder(textLayerDiv, |
|
this.id - 1, |
|
this.viewport); |
|
} |
|
this.textLayer = textLayer; |
|
|
|
// TODO(mack): use data attributes to store these |
|
ctx._scaleX = outputScale.sx; |
|
ctx._scaleY = outputScale.sy; |
|
if (outputScale.scaled) { |
|
ctx.scale(outputScale.sx, outputScale.sy); |
|
} |
|
|
|
var resolveRenderPromise, rejectRenderPromise; |
|
var promise = new Promise(function (resolve, reject) { |
|
resolveRenderPromise = resolve; |
|
rejectRenderPromise = reject; |
|
}); |
|
|
|
// Rendering area |
|
|
|
var self = this; |
|
function pageViewDrawCallback(error) { |
|
// The renderTask may have been replaced by a new one, so only remove |
|
// the reference to the renderTask if it matches the one that is |
|
// triggering this callback. |
|
if (renderTask === self.renderTask) { |
|
self.renderTask = null; |
|
} |
|
|
|
if (error === 'cancelled') { |
|
rejectRenderPromise(error); |
|
return; |
|
} |
|
|
|
self.renderingState = RenderingStates.FINISHED; |
|
|
|
if (self.loadingIconDiv) { |
|
div.removeChild(self.loadingIconDiv); |
|
delete self.loadingIconDiv; |
|
} |
|
|
|
if (self.zoomLayer) { |
|
div.removeChild(self.zoomLayer); |
|
self.zoomLayer = null; |
|
} |
|
|
|
self.error = error; |
|
self.stats = pdfPage.stats; |
|
if (self.onAfterDraw) { |
|
self.onAfterDraw(); |
|
} |
|
var event = document.createEvent('CustomEvent'); |
|
event.initCustomEvent('pagerendered', true, true, { |
|
pageNumber: self.id |
|
}); |
|
div.dispatchEvent(event); |
|
|
|
if (!error) { |
|
resolveRenderPromise(undefined); |
|
} else { |
|
rejectRenderPromise(error); |
|
} |
|
} |
|
|
|
var renderContinueCallback = null; |
|
if (this.renderingQueue) { |
|
renderContinueCallback = function renderContinueCallback(cont) { |
|
if (!self.renderingQueue.isHighestPriority(self)) { |
|
self.renderingState = RenderingStates.PAUSED; |
|
self.resume = function resumeCallback() { |
|
self.renderingState = RenderingStates.RUNNING; |
|
cont(); |
|
}; |
|
return; |
|
} |
|
cont(); |
|
}; |
|
} |
|
|
|
var renderContext = { |
|
canvasContext: ctx, |
|
viewport: this.viewport, |
|
// intent: 'default', // === 'display' |
|
continueCallback: renderContinueCallback |
|
}; |
|
var renderTask = this.renderTask = this.pdfPage.render(renderContext); |
|
|
|
this.renderTask.promise.then( |
|
function pdfPageRenderCallback() { |
|
pageViewDrawCallback(null); |
|
if (textLayer) { |
|
self.pdfPage.getTextContent().then( |
|
function textContentResolved(textContent) { |
|
textLayer.setTextContent(textContent); |
|
textLayer.render(TEXT_LAYER_RENDER_DELAY); |
|
} |
|
); |
|
} |
|
}, |
|
function pdfPageRenderError(error) { |
|
pageViewDrawCallback(error); |
|
} |
|
); |
|
|
|
if (this.annotationsLayerFactory) { |
|
if (!this.annotationLayer) { |
|
this.annotationLayer = this.annotationsLayerFactory. |
|
createAnnotationsLayerBuilder(div, this.pdfPage); |
|
} |
|
this.annotationLayer.setupAnnotations(this.viewport); |
|
} |
|
div.setAttribute('data-loaded', true); |
|
|
|
if (self.onBeforeDraw) { |
|
self.onBeforeDraw(); |
|
} |
|
return promise; |
|
}, |
|
|
|
beforePrint: function PDFPageView_beforePrint() { |
|
var pdfPage = this.pdfPage; |
|
|
|
var viewport = pdfPage.getViewport(1); |
|
// Use the same hack we use for high dpi displays for printing to get |
|
// better output until bug 811002 is fixed in FF. |
|
var PRINT_OUTPUT_SCALE = 2; |
|
var canvas = document.createElement('canvas'); |
|
canvas.width = Math.floor(viewport.width) * PRINT_OUTPUT_SCALE; |
|
canvas.height = Math.floor(viewport.height) * PRINT_OUTPUT_SCALE; |
|
canvas.style.width = (PRINT_OUTPUT_SCALE * viewport.width) + 'pt'; |
|
canvas.style.height = (PRINT_OUTPUT_SCALE * viewport.height) + 'pt'; |
|
var cssScale = 'scale(' + (1 / PRINT_OUTPUT_SCALE) + ', ' + |
|
(1 / PRINT_OUTPUT_SCALE) + ')'; |
|
CustomStyle.setProp('transform' , canvas, cssScale); |
|
CustomStyle.setProp('transformOrigin' , canvas, '0% 0%'); |
|
|
|
var printContainer = document.getElementById('printContainer'); |
|
var canvasWrapper = document.createElement('div'); |
|
canvasWrapper.style.width = viewport.width + 'pt'; |
|
canvasWrapper.style.height = viewport.height + 'pt'; |
|
canvasWrapper.appendChild(canvas); |
|
printContainer.appendChild(canvasWrapper); |
|
|
|
canvas.mozPrintCallback = function(obj) { |
|
var ctx = obj.context; |
|
|
|
ctx.save(); |
|
ctx.fillStyle = 'rgb(255, 255, 255)'; |
|
ctx.fillRect(0, 0, canvas.width, canvas.height); |
|
ctx.restore(); |
|
ctx.scale(PRINT_OUTPUT_SCALE, PRINT_OUTPUT_SCALE); |
|
|
|
var renderContext = { |
|
canvasContext: ctx, |
|
viewport: viewport, |
|
intent: 'print' |
|
}; |
|
|
|
pdfPage.render(renderContext).promise.then(function() { |
|
// Tell the printEngine that rendering this canvas/page has finished. |
|
obj.done(); |
|
}, function(error) { |
|
console.error(error); |
|
// Tell the printEngine that rendering this canvas/page has failed. |
|
// This will make the print proces stop. |
|
if ('abort' in obj) { |
|
obj.abort(); |
|
} else { |
|
obj.done(); |
|
} |
|
}); |
|
}; |
|
}, |
|
}; |
|
|
|
return PDFPageView; |
|
})(); |
|
|
|
|
|
var MAX_TEXT_DIVS_TO_RENDER = 100000; |
|
|
|
var NonWhitespaceRegexp = /\S/; |
|
|
|
function isAllWhitespace(str) { |
|
return !NonWhitespaceRegexp.test(str); |
|
} |
|
|
|
/** |
|
* @typedef {Object} TextLayerBuilderOptions |
|
* @property {HTMLDivElement} textLayerDiv - The text layer container. |
|
* @property {number} pageIndex - The page index. |
|
* @property {PageViewport} viewport - The viewport of the text layer. |
|
* @property {PDFFindController} findController |
|
*/ |
|
|
|
/** |
|
* TextLayerBuilder provides text-selection functionality for the PDF. |
|
* It does this by creating overlay divs over the PDF text. These divs |
|
* contain text that matches the PDF text they are overlaying. This object |
|
* also provides a way to highlight text that is being searched for. |
|
* @class |
|
*/ |
|
var TextLayerBuilder = (function TextLayerBuilderClosure() { |
|
function TextLayerBuilder(options) { |
|
this.textLayerDiv = options.textLayerDiv; |
|
this.renderingDone = false; |
|
this.divContentDone = false; |
|
this.pageIdx = options.pageIndex; |
|
this.pageNumber = this.pageIdx + 1; |
|
this.matches = []; |
|
this.viewport = options.viewport; |
|
this.textDivs = []; |
|
this.findController = options.findController || null; |
|
} |
|
|
|
TextLayerBuilder.prototype = { |
|
_finishRendering: function TextLayerBuilder_finishRendering() { |
|
this.renderingDone = true; |
|
|
|
var event = document.createEvent('CustomEvent'); |
|
event.initCustomEvent('textlayerrendered', true, true, { |
|
pageNumber: this.pageNumber |
|
}); |
|
this.textLayerDiv.dispatchEvent(event); |
|
}, |
|
|
|
renderLayer: function TextLayerBuilder_renderLayer() { |
|
var textLayerFrag = document.createDocumentFragment(); |
|
var textDivs = this.textDivs; |
|
var textDivsLength = textDivs.length; |
|
var canvas = document.createElement('canvas'); |
|
var ctx = canvas.getContext('2d'); |
|
|
|
// No point in rendering many divs as it would make the browser |
|
// unusable even after the divs are rendered. |
|
if (textDivsLength > MAX_TEXT_DIVS_TO_RENDER) { |
|
this._finishRendering(); |
|
return; |
|
} |
|
|
|
var lastFontSize; |
|
var lastFontFamily; |
|
for (var i = 0; i < textDivsLength; i++) { |
|
var textDiv = textDivs[i]; |
|
if (textDiv.dataset.isWhitespace !== undefined) { |
|
continue; |
|
} |
|
|
|
var fontSize = textDiv.style.fontSize; |
|
var fontFamily = textDiv.style.fontFamily; |
|
|
|
// Only build font string and set to context if different from last. |
|
if (fontSize !== lastFontSize || fontFamily !== lastFontFamily) { |
|
ctx.font = fontSize + ' ' + fontFamily; |
|
lastFontSize = fontSize; |
|
lastFontFamily = fontFamily; |
|
} |
|
|
|
var width = ctx.measureText(textDiv.textContent).width; |
|
if (width > 0) { |
|
textLayerFrag.appendChild(textDiv); |
|
var transform; |
|
if (textDiv.dataset.canvasWidth !== undefined) { |
|
// Dataset values come of type string. |
|
var textScale = textDiv.dataset.canvasWidth / width; |
|
transform = 'scaleX(' + textScale + ')'; |
|
} else { |
|
transform = ''; |
|
} |
|
var rotation = textDiv.dataset.angle; |
|
if (rotation) { |
|
transform = 'rotate(' + rotation + 'deg) ' + transform; |
|
} |
|
if (transform) { |
|
CustomStyle.setProp('transform' , textDiv, transform); |
|
} |
|
} |
|
} |
|
|
|
this.textLayerDiv.appendChild(textLayerFrag); |
|
this._finishRendering(); |
|
this.updateMatches(); |
|
}, |
|
|
|
/** |
|
* Renders the text layer. |
|
* @param {number} timeout (optional) if specified, the rendering waits |
|
* for specified amount of ms. |
|
*/ |
|
render: function TextLayerBuilder_render(timeout) { |
|
if (!this.divContentDone || this.renderingDone) { |
|
return; |
|
} |
|
|
|
if (this.renderTimer) { |
|
clearTimeout(this.renderTimer); |
|
this.renderTimer = null; |
|
} |
|
|
|
if (!timeout) { // Render right away |
|
this.renderLayer(); |
|
} else { // Schedule |
|
var self = this; |
|
this.renderTimer = setTimeout(function() { |
|
self.renderLayer(); |
|
self.renderTimer = null; |
|
}, timeout); |
|
} |
|
}, |
|
|
|
appendText: function TextLayerBuilder_appendText(geom, styles) { |
|
var style = styles[geom.fontName]; |
|
var textDiv = document.createElement('div'); |
|
this.textDivs.push(textDiv); |
|
if (isAllWhitespace(geom.str)) { |
|
textDiv.dataset.isWhitespace = true; |
|
return; |
|
} |
|
var tx = PDFJS.Util.transform(this.viewport.transform, geom.transform); |
|
var angle = Math.atan2(tx[1], tx[0]); |
|
if (style.vertical) { |
|
angle += Math.PI / 2; |
|
} |
|
var fontHeight = Math.sqrt((tx[2] * tx[2]) + (tx[3] * tx[3])); |
|
var fontAscent = fontHeight; |
|
if (style.ascent) { |
|
fontAscent = style.ascent * fontAscent; |
|
} else if (style.descent) { |
|
fontAscent = (1 + style.descent) * fontAscent; |
|
} |
|
|
|
var left; |
|
var top; |
|
if (angle === 0) { |
|
left = tx[4]; |
|
top = tx[5] - fontAscent; |
|
} else { |
|
left = tx[4] + (fontAscent * Math.sin(angle)); |
|
top = tx[5] - (fontAscent * Math.cos(angle)); |
|
} |
|
textDiv.style.left = left + 'px'; |
|
textDiv.style.top = top + 'px'; |
|
textDiv.style.fontSize = fontHeight + 'px'; |
|
textDiv.style.fontFamily = style.fontFamily; |
|
|
|
textDiv.textContent = geom.str; |
|
// |fontName| is only used by the Font Inspector. This test will succeed |
|
// when e.g. the Font Inspector is off but the Stepper is on, but it's |
|
// not worth the effort to do a more accurate test. |
|
if (PDFJS.pdfBug) { |
|
textDiv.dataset.fontName = geom.fontName; |
|
} |
|
// Storing into dataset will convert number into string. |
|
if (angle !== 0) { |
|
textDiv.dataset.angle = angle * (180 / Math.PI); |
|
} |
|
// We don't bother scaling single-char text divs, because it has very |
|
// little effect on text highlighting. This makes scrolling on docs with |
|
// lots of such divs a lot faster. |
|
if (textDiv.textContent.length > 1) { |
|
if (style.vertical) { |
|
textDiv.dataset.canvasWidth = geom.height * this.viewport.scale; |
|
} else { |
|
textDiv.dataset.canvasWidth = geom.width * this.viewport.scale; |
|
} |
|
} |
|
}, |
|
|
|
setTextContent: function TextLayerBuilder_setTextContent(textContent) { |
|
this.textContent = textContent; |
|
|
|
var textItems = textContent.items; |
|
for (var i = 0, len = textItems.length; i < len; i++) { |
|
this.appendText(textItems[i], textContent.styles); |
|
} |
|
this.divContentDone = true; |
|
}, |
|
|
|
convertMatches: function TextLayerBuilder_convertMatches(matches) { |
|
var i = 0; |
|
var iIndex = 0; |
|
var bidiTexts = this.textContent.items; |
|
var end = bidiTexts.length - 1; |
|
var queryLen = (this.findController === null ? |
|
0 : this.findController.state.query.length); |
|
var ret = []; |
|
|
|
for (var m = 0, len = matches.length; m < len; m++) { |
|
// Calculate the start position. |
|
var matchIdx = matches[m]; |
|
|
|
// Loop over the divIdxs. |
|
while (i !== end && matchIdx >= (iIndex + bidiTexts[i].str.length)) { |
|
iIndex += bidiTexts[i].str.length; |
|
i++; |
|
} |
|
|
|
if (i === bidiTexts.length) { |
|
console.error('Could not find a matching mapping'); |
|
} |
|
|
|
var match = { |
|
begin: { |
|
divIdx: i, |
|
offset: matchIdx - iIndex |
|
} |
|
}; |
|
|
|
// Calculate the end position. |
|
matchIdx += queryLen; |
|
|
|
// Somewhat the same array as above, but use > instead of >= to get |
|
// the end position right. |
|
while (i !== end && matchIdx > (iIndex + bidiTexts[i].str.length)) { |
|
iIndex += bidiTexts[i].str.length; |
|
i++; |
|
} |
|
|
|
match.end = { |
|
divIdx: i, |
|
offset: matchIdx - iIndex |
|
}; |
|
ret.push(match); |
|
} |
|
|
|
return ret; |
|
}, |
|
|
|
renderMatches: function TextLayerBuilder_renderMatches(matches) { |
|
// Early exit if there is nothing to render. |
|
if (matches.length === 0) { |
|
return; |
|
} |
|
|
|
var bidiTexts = this.textContent.items; |
|
var textDivs = this.textDivs; |
|
var prevEnd = null; |
|
var pageIdx = this.pageIdx; |
|
var isSelectedPage = (this.findController === null ? |
|
false : (pageIdx === this.findController.selected.pageIdx)); |
|
var selectedMatchIdx = (this.findController === null ? |
|
-1 : this.findController.selected.matchIdx); |
|
var highlightAll = (this.findController === null ? |
|
false : this.findController.state.highlightAll); |
|
var infinity = { |
|
divIdx: -1, |
|
offset: undefined |
|
}; |
|
|
|
function beginText(begin, className) { |
|
var divIdx = begin.divIdx; |
|
textDivs[divIdx].textContent = ''; |
|
appendTextToDiv(divIdx, 0, begin.offset, className); |
|
} |
|
|
|
function appendTextToDiv(divIdx, fromOffset, toOffset, className) { |
|
var div = textDivs[divIdx]; |
|
var content = bidiTexts[divIdx].str.substring(fromOffset, toOffset); |
|
var node = document.createTextNode(content); |
|
if (className) { |
|
var span = document.createElement('span'); |
|
span.className = className; |
|
span.appendChild(node); |
|
div.appendChild(span); |
|
return; |
|
} |
|
div.appendChild(node); |
|
} |
|
|
|
var i0 = selectedMatchIdx, i1 = i0 + 1; |
|
if (highlightAll) { |
|
i0 = 0; |
|
i1 = matches.length; |
|
} else if (!isSelectedPage) { |
|
// Not highlighting all and this isn't the selected page, so do nothing. |
|
return; |
|
} |
|
|
|
for (var i = i0; i < i1; i++) { |
|
var match = matches[i]; |
|
var begin = match.begin; |
|
var end = match.end; |
|
var isSelected = (isSelectedPage && i === selectedMatchIdx); |
|
var highlightSuffix = (isSelected ? ' selected' : ''); |
|
|
|
if (this.findController) { |
|
this.findController.updateMatchPosition(pageIdx, i, textDivs, |
|
begin.divIdx, end.divIdx); |
|
} |
|
|
|
// Match inside new div. |
|
if (!prevEnd || begin.divIdx !== prevEnd.divIdx) { |
|
// If there was a previous div, then add the text at the end. |
|
if (prevEnd !== null) { |
|
appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset); |
|
} |
|
// Clear the divs and set the content until the starting point. |
|
beginText(begin); |
|
} else { |
|
appendTextToDiv(prevEnd.divIdx, prevEnd.offset, begin.offset); |
|
} |
|
|
|
if (begin.divIdx === end.divIdx) { |
|
appendTextToDiv(begin.divIdx, begin.offset, end.offset, |
|
'highlight' + highlightSuffix); |
|
} else { |
|
appendTextToDiv(begin.divIdx, begin.offset, infinity.offset, |
|
'highlight begin' + highlightSuffix); |
|
for (var n0 = begin.divIdx + 1, n1 = end.divIdx; n0 < n1; n0++) { |
|
textDivs[n0].className = 'highlight middle' + highlightSuffix; |
|
} |
|
beginText(end, 'highlight end' + highlightSuffix); |
|
} |
|
prevEnd = end; |
|
} |
|
|
|
if (prevEnd) { |
|
appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset); |
|
} |
|
}, |
|
|
|
updateMatches: function TextLayerBuilder_updateMatches() { |
|
// Only show matches when all rendering is done. |
|
if (!this.renderingDone) { |
|
return; |
|
} |
|
|
|
// Clear all matches. |
|
var matches = this.matches; |
|
var textDivs = this.textDivs; |
|
var bidiTexts = this.textContent.items; |
|
var clearedUntilDivIdx = -1; |
|
|
|
// Clear all current matches. |
|
for (var i = 0, len = matches.length; i < len; i++) { |
|
var match = matches[i]; |
|
var begin = Math.max(clearedUntilDivIdx, match.begin.divIdx); |
|
for (var n = begin, end = match.end.divIdx; n <= end; n++) { |
|
var div = textDivs[n]; |
|
div.textContent = bidiTexts[n].str; |
|
div.className = ''; |
|
} |
|
clearedUntilDivIdx = match.end.divIdx + 1; |
|
} |
|
|
|
if (this.findController === null || !this.findController.active) { |
|
return; |
|
} |
|
|
|
// Convert the matches on the page controller into the match format |
|
// used for the textLayer. |
|
this.matches = this.convertMatches(this.findController === null ? |
|
[] : (this.findController.pageMatches[this.pageIdx] || [])); |
|
this.renderMatches(this.matches); |
|
} |
|
}; |
|
return TextLayerBuilder; |
|
})(); |
|
|
|
/** |
|
* @constructor |
|
* @implements IPDFTextLayerFactory |
|
*/ |
|
function DefaultTextLayerFactory() {} |
|
DefaultTextLayerFactory.prototype = { |
|
/** |
|
* @param {HTMLDivElement} textLayerDiv |
|
* @param {number} pageIndex |
|
* @param {PageViewport} viewport |
|
* @returns {TextLayerBuilder} |
|
*/ |
|
createTextLayerBuilder: function (textLayerDiv, pageIndex, viewport) { |
|
return new TextLayerBuilder({ |
|
textLayerDiv: textLayerDiv, |
|
pageIndex: pageIndex, |
|
viewport: viewport |
|
}); |
|
} |
|
}; |
|
|
|
|
|
/** |
|
* @typedef {Object} AnnotationsLayerBuilderOptions |
|
* @property {HTMLDivElement} pageDiv |
|
* @property {PDFPage} pdfPage |
|
* @property {IPDFLinkService} linkService |
|
*/ |
|
|
|
/** |
|
* @class |
|
*/ |
|
var AnnotationsLayerBuilder = (function AnnotationsLayerBuilderClosure() { |
|
/** |
|
* @param {AnnotationsLayerBuilderOptions} options |
|
* @constructs AnnotationsLayerBuilder |
|
*/ |
|
function AnnotationsLayerBuilder(options) { |
|
this.pageDiv = options.pageDiv; |
|
this.pdfPage = options.pdfPage; |
|
this.linkService = options.linkService; |
|
|
|
this.div = null; |
|
} |
|
AnnotationsLayerBuilder.prototype = |
|
/** @lends AnnotationsLayerBuilder.prototype */ { |
|
|
|
/** |
|
* @param {PageViewport} viewport |
|
*/ |
|
setupAnnotations: |
|
function AnnotationsLayerBuilder_setupAnnotations(viewport) { |
|
function bindLink(link, dest) { |
|
link.href = linkService.getDestinationHash(dest); |
|
link.onclick = function annotationsLayerBuilderLinksOnclick() { |
|
if (dest) { |
|
linkService.navigateTo(dest); |
|
} |
|
return false; |
|
}; |
|
if (dest) { |
|
link.className = 'internalLink'; |
|
} |
|
} |
|
|
|
function bindNamedAction(link, action) { |
|
link.href = linkService.getAnchorUrl(''); |
|
link.onclick = function annotationsLayerBuilderNamedActionOnClick() { |
|
linkService.executeNamedAction(action); |
|
return false; |
|
}; |
|
link.className = 'internalLink'; |
|
} |
|
|
|
var linkService = this.linkService; |
|
var pdfPage = this.pdfPage; |
|
var self = this; |
|
|
|
pdfPage.getAnnotations().then(function (annotationsData) { |
|
viewport = viewport.clone({ dontFlip: true }); |
|
var transform = viewport.transform; |
|
var transformStr = 'matrix(' + transform.join(',') + ')'; |
|
var data, element, i, ii; |
|
|
|
if (self.div) { |
|
// If an annotationLayer already exists, refresh its children's |
|
// transformation matrices |
|
for (i = 0, ii = annotationsData.length; i < ii; i++) { |
|
data = annotationsData[i]; |
|
element = self.div.querySelector( |
|
'[data-annotation-id="' + data.id + '"]'); |
|
if (element) { |
|
CustomStyle.setProp('transform', element, transformStr); |
|
} |
|
} |
|
// See PDFPageView.reset() |
|
self.div.removeAttribute('hidden'); |
|
} else { |
|
for (i = 0, ii = annotationsData.length; i < ii; i++) { |
|
data = annotationsData[i]; |
|
if (!data || !data.hasHtml) { |
|
continue; |
|
} |
|
|
|
element = PDFJS.AnnotationUtils.getHtmlElement(data, |
|
pdfPage.commonObjs); |
|
element.setAttribute('data-annotation-id', data.id); |
|
if (typeof mozL10n !== 'undefined') { |
|
mozL10n.translate(element); |
|
} |
|
|
|
var rect = data.rect; |
|
var view = pdfPage.view; |
|
rect = PDFJS.Util.normalizeRect([ |
|
rect[0], |
|
view[3] - rect[1] + view[1], |
|
rect[2], |
|
view[3] - rect[3] + view[1] |
|
]); |
|
element.style.left = rect[0] + 'px'; |
|
element.style.top = rect[1] + 'px'; |
|
element.style.position = 'absolute'; |
|
|
|
CustomStyle.setProp('transform', element, transformStr); |
|
var transformOriginStr = -rect[0] + 'px ' + -rect[1] + 'px'; |
|
CustomStyle.setProp('transformOrigin', element, transformOriginStr); |
|
|
|
if (data.subtype === 'Link' && !data.url) { |
|
var link = element.getElementsByTagName('a')[0]; |
|
if (link) { |
|
if (data.action) { |
|
bindNamedAction(link, data.action); |
|
} else { |
|
bindLink(link, ('dest' in data) ? data.dest : null); |
|
} |
|
} |
|
} |
|
|
|
if (!self.div) { |
|
var annotationLayerDiv = document.createElement('div'); |
|
annotationLayerDiv.className = 'annotationLayer'; |
|
self.pageDiv.appendChild(annotationLayerDiv); |
|
self.div = annotationLayerDiv; |
|
} |
|
|
|
self.div.appendChild(element); |
|
} |
|
} |
|
}); |
|
}, |
|
|
|
hide: function () { |
|
if (!this.div) { |
|
return; |
|
} |
|
this.div.setAttribute('hidden', 'true'); |
|
} |
|
}; |
|
return AnnotationsLayerBuilder; |
|
})(); |
|
|
|
/** |
|
* @constructor |
|
* @implements IPDFAnnotationsLayerFactory |
|
*/ |
|
function DefaultAnnotationsLayerFactory() {} |
|
DefaultAnnotationsLayerFactory.prototype = { |
|
/** |
|
* @param {HTMLDivElement} pageDiv |
|
* @param {PDFPage} pdfPage |
|
* @returns {AnnotationsLayerBuilder} |
|
*/ |
|
createAnnotationsLayerBuilder: function (pageDiv, pdfPage) { |
|
return new AnnotationsLayerBuilder({ |
|
pageDiv: pageDiv, |
|
pdfPage: pdfPage |
|
}); |
|
} |
|
}; |
|
|
|
|
|
/** |
|
* @typedef {Object} PDFViewerOptions |
|
* @property {HTMLDivElement} container - The container for the viewer element. |
|
* @property {HTMLDivElement} viewer - (optional) The viewer element. |
|
* @property {IPDFLinkService} linkService - The navigation/linking service. |
|
* @property {PDFRenderingQueue} renderingQueue - (optional) The rendering |
|
* queue object. |
|
*/ |
|
|
|
/** |
|
* Simple viewer control to display PDF content/pages. |
|
* @class |
|
* @implements {IRenderableView} |
|
*/ |
|
var PDFViewer = (function pdfViewer() { |
|
function PDFPageViewBuffer(size) { |
|
var data = []; |
|
this.push = function cachePush(view) { |
|
var i = data.indexOf(view); |
|
if (i >= 0) { |
|
data.splice(i, 1); |
|
} |
|
data.push(view); |
|
if (data.length > size) { |
|
data.shift().destroy(); |
|
} |
|
}; |
|
this.resize = function (newSize) { |
|
size = newSize; |
|
while (data.length > size) { |
|
data.shift().destroy(); |
|
} |
|
}; |
|
} |
|
|
|
/** |
|
* @constructs PDFViewer |
|
* @param {PDFViewerOptions} options |
|
*/ |
|
function PDFViewer(options) { |
|
this.container = options.container; |
|
this.viewer = options.viewer || options.container.firstElementChild; |
|
this.linkService = options.linkService || new SimpleLinkService(this); |
|
|
|
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.updateInProgress = false; |
|
this.presentationModeState = PresentationModeState.UNKNOWN; |
|
this._resetView(); |
|
} |
|
|
|
PDFViewer.prototype = /** @lends PDFViewer.prototype */{ |
|
get pagesCount() { |
|
return this.pages.length; |
|
}, |
|
|
|
getPageView: function (index) { |
|
return this.pages[index]; |
|
}, |
|
|
|
get currentPageNumber() { |
|
return this._currentPageNumber; |
|
}, |
|
|
|
set currentPageNumber(val) { |
|
if (!this.pdfDocument) { |
|
this._currentPageNumber = val; |
|
return; |
|
} |
|
|
|
var event = document.createEvent('UIEvents'); |
|
event.initUIEvent('pagechange', true, true, window, 0); |
|
event.updateInProgress = this.updateInProgress; |
|
|
|
if (!(0 < val && val <= this.pagesCount)) { |
|
event.pageNumber = this._currentPageNumber; |
|
event.previousPageNumber = val; |
|
this.container.dispatchEvent(event); |
|
return; |
|
} |
|
|
|
event.previousPageNumber = this._currentPageNumber; |
|
this._currentPageNumber = val; |
|
event.pageNumber = val; |
|
this.container.dispatchEvent(event); |
|
}, |
|
|
|
/** |
|
* @returns {number} |
|
*/ |
|
get currentScale() { |
|
return this._currentScale; |
|
}, |
|
|
|
/** |
|
* @param {number} val - Scale of the pages in percents. |
|
*/ |
|
set currentScale(val) { |
|
if (isNaN(val)) { |
|
throw new Error('Invalid numeric scale'); |
|
} |
|
if (!this.pdfDocument) { |
|
this._currentScale = val; |
|
this._currentScaleValue = val.toString(); |
|
return; |
|
} |
|
this._setScale(val, false); |
|
}, |
|
|
|
/** |
|
* @returns {string} |
|
*/ |
|
get currentScaleValue() { |
|
return this._currentScaleValue; |
|
}, |
|
|
|
/** |
|
* @param val - The scale of the pages (in percent or predefined value). |
|
*/ |
|
set currentScaleValue(val) { |
|
if (!this.pdfDocument) { |
|
this._currentScale = isNaN(val) ? UNKNOWN_SCALE : val; |
|
this._currentScaleValue = val; |
|
return; |
|
} |
|
this._setScale(val, false); |
|
}, |
|
|
|
/** |
|
* @returns {number} |
|
*/ |
|
get pagesRotation() { |
|
return this._pagesRotation; |
|
}, |
|
|
|
/** |
|
* @param {number} rotation - The rotation of the pages (0, 90, 180, 270). |
|
*/ |
|
set pagesRotation(rotation) { |
|
this._pagesRotation = rotation; |
|
|
|
for (var i = 0, l = this.pages.length; i < l; i++) { |
|
var page = this.pages[i]; |
|
page.update(page.scale, rotation); |
|
} |
|
|
|
this._setScale(this._currentScaleValue, true); |
|
}, |
|
|
|
/** |
|
* @param pdfDocument {PDFDocument} |
|
*/ |
|
setDocument: function (pdfDocument) { |
|
if (this.pdfDocument) { |
|
this._resetView(); |
|
} |
|
|
|
this.pdfDocument = pdfDocument; |
|
if (!pdfDocument) { |
|
return; |
|
} |
|
|
|
var pagesCount = pdfDocument.numPages; |
|
var pagesRefMap = this.pagesRefMap = {}; |
|
var self = this; |
|
|
|
var resolvePagesPromise; |
|
var pagesPromise = new Promise(function (resolve) { |
|
resolvePagesPromise = resolve; |
|
}); |
|
this.pagesPromise = pagesPromise; |
|
pagesPromise.then(function () { |
|
var event = document.createEvent('CustomEvent'); |
|
event.initCustomEvent('pagesloaded', true, true, { |
|
pagesCount: pagesCount |
|
}); |
|
self.container.dispatchEvent(event); |
|
}); |
|
|
|
var isOnePageRenderedResolved = false; |
|
var resolveOnePageRendered = null; |
|
var onePageRendered = new Promise(function (resolve) { |
|
resolveOnePageRendered = resolve; |
|
}); |
|
this.onePageRendered = onePageRendered; |
|
|
|
var bindOnAfterAndBeforeDraw = function (pageView) { |
|
pageView.onBeforeDraw = function pdfViewLoadOnBeforeDraw() { |
|
// 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. |
|
self._buffer.push(this); |
|
}; |
|
// when page is painted, using the image as thumbnail base |
|
pageView.onAfterDraw = function pdfViewLoadOnAfterDraw() { |
|
if (!isOnePageRenderedResolved) { |
|
isOnePageRenderedResolved = true; |
|
resolveOnePageRendered(); |
|
} |
|
}; |
|
}; |
|
|
|
var firstPagePromise = pdfDocument.getPage(1); |
|
this.firstPagePromise = firstPagePromise; |
|
|
|
// Fetch a single page so we can get a viewport that will be the default |
|
// viewport for all pages |
|
return firstPagePromise.then(function(pdfPage) { |
|
var scale = this._currentScale || 1.0; |
|
var viewport = pdfPage.getViewport(scale * CSS_UNITS); |
|
for (var pageNum = 1; pageNum <= pagesCount; ++pageNum) { |
|
var textLayerFactory = null; |
|
if (!PDFJS.disableTextLayer) { |
|
textLayerFactory = this; |
|
} |
|
var pageView = new PDFPageView({ |
|
container: this.viewer, |
|
id: pageNum, |
|
scale: scale, |
|
defaultViewport: viewport.clone(), |
|
renderingQueue: this.renderingQueue, |
|
textLayerFactory: textLayerFactory, |
|
annotationsLayerFactory: this |
|
}); |
|
bindOnAfterAndBeforeDraw(pageView); |
|
this.pages.push(pageView); |
|
} |
|
|
|
// 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. |
|
onePageRendered.then(function () { |
|
if (!PDFJS.disableAutoFetch) { |
|
var getPagesLeft = pagesCount; |
|
for (var pageNum = 1; pageNum <= pagesCount; ++pageNum) { |
|
pdfDocument.getPage(pageNum).then(function (pageNum, pdfPage) { |
|
var pageView = self.pages[pageNum - 1]; |
|
if (!pageView.pdfPage) { |
|
pageView.setPdfPage(pdfPage); |
|
} |
|
var refStr = pdfPage.ref.num + ' ' + pdfPage.ref.gen + ' R'; |
|
pagesRefMap[refStr] = pageNum; |
|
getPagesLeft--; |
|
if (!getPagesLeft) { |
|
resolvePagesPromise(); |
|
} |
|
}.bind(null, pageNum)); |
|
} |
|
} else { |
|
// XXX: Printing is semi-broken with auto fetch disabled. |
|
resolvePagesPromise(); |
|
} |
|
}); |
|
|
|
var event = document.createEvent('CustomEvent'); |
|
event.initCustomEvent('pagesinit', true, true, null); |
|
self.container.dispatchEvent(event); |
|
|
|
if (this.defaultRenderingQueue) { |
|
this.update(); |
|
} |
|
}.bind(this)); |
|
}, |
|
|
|
_resetView: function () { |
|
this.pages = []; |
|
this._currentPageNumber = 1; |
|
this._currentScale = UNKNOWN_SCALE; |
|
this._currentScaleValue = null; |
|
this._buffer = new PDFPageViewBuffer(DEFAULT_CACHE_SIZE); |
|
this.location = null; |
|
this._pagesRotation = 0; |
|
this._pagesRequests = []; |
|
|
|
var container = this.viewer; |
|
while (container.hasChildNodes()) { |
|
container.removeChild(container.lastChild); |
|
} |
|
}, |
|
|
|
_scrollUpdate: function () { |
|
if (this.pagesCount === 0) { |
|
return; |
|
} |
|
this.update(); |
|
for (var i = 0, ii = this.pages.length; i < ii; i++) { |
|
this.pages[i].updatePosition(); |
|
} |
|
}, |
|
|
|
_setScaleUpdatePages: function pdfViewer_setScaleUpdatePages( |
|
newScale, newValue, noScroll, preset) { |
|
this._currentScaleValue = newValue; |
|
if (newScale === this._currentScale) { |
|
return; |
|
} |
|
for (var i = 0, ii = this.pages.length; i < ii; i++) { |
|
this.pages[i].update(newScale); |
|
} |
|
this._currentScale = newScale; |
|
|
|
if (!noScroll) { |
|
var page = this._currentPageNumber, dest; |
|
var inPresentationMode = |
|
this.presentationModeState === PresentationModeState.CHANGING || |
|
this.presentationModeState === PresentationModeState.FULLSCREEN; |
|
if (this.location && !inPresentationMode && |
|
!IGNORE_CURRENT_POSITION_ON_ZOOM) { |
|
page = this.location.pageNumber; |
|
dest = [null, { name: 'XYZ' }, this.location.left, |
|
this.location.top, null]; |
|
} |
|
this.scrollPageIntoView(page, dest); |
|
} |
|
|
|
var event = document.createEvent('UIEvents'); |
|
event.initUIEvent('scalechange', true, true, window, 0); |
|
event.scale = newScale; |
|
if (preset) { |
|
event.presetValue = newValue; |
|
} |
|
this.container.dispatchEvent(event); |
|
}, |
|
|
|
_setScale: function pdfViewer_setScale(value, noScroll) { |
|
if (value === 'custom') { |
|
return; |
|
} |
|
var scale = parseFloat(value); |
|
|
|
if (scale > 0) { |
|
this._setScaleUpdatePages(scale, value, noScroll, false); |
|
} else { |
|
var currentPage = this.pages[this._currentPageNumber - 1]; |
|
if (!currentPage) { |
|
return; |
|
} |
|
var inPresentationMode = |
|
this.presentationModeState === PresentationModeState.FULLSCREEN; |
|
var hPadding = inPresentationMode ? 0 : SCROLLBAR_PADDING; |
|
var vPadding = inPresentationMode ? 0 : VERTICAL_PADDING; |
|
var pageWidthScale = (this.container.clientWidth - hPadding) / |
|
currentPage.width * currentPage.scale; |
|
var 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': |
|
var isLandscape = (currentPage.width > currentPage.height); |
|
// For pages in landscape mode, fit the page height to the viewer |
|
// *unless* the page would thus become too wide to fit horizontally. |
|
var horizontalScale = isLandscape ? |
|
Math.min(pageHeightScale, pageWidthScale) : pageWidthScale; |
|
scale = Math.min(MAX_AUTO_SCALE, horizontalScale); |
|
break; |
|
default: |
|
console.error('pdfViewSetScale: \'' + value + |
|
'\' is an unknown zoom value.'); |
|
return; |
|
} |
|
this._setScaleUpdatePages(scale, value, noScroll, true); |
|
} |
|
}, |
|
|
|
/** |
|
* Scrolls page into view. |
|
* @param {number} pageNumber |
|
* @param {Array} dest - (optional) original PDF destination array: |
|
* <page-ref> </XYZ|FitXXX> <args..> |
|
*/ |
|
scrollPageIntoView: function PDFViewer_scrollPageIntoView(pageNumber, |
|
dest) { |
|
var pageView = this.pages[pageNumber - 1]; |
|
|
|
if (this.presentationModeState === |
|
PresentationModeState.FULLSCREEN) { |
|
if (this.linkService.page !== pageView.id) { |
|
// Avoid breaking getVisiblePages in presentation mode. |
|
this.linkService.page = pageView.id; |
|
return; |
|
} |
|
dest = null; |
|
// Fixes the case when PDF has different page sizes. |
|
this._setScale(this.currentScaleValue, true); |
|
} |
|
if (!dest) { |
|
scrollIntoView(pageView.div); |
|
return; |
|
} |
|
|
|
var x = 0, y = 0; |
|
var width = 0, height = 0, widthScale, heightScale; |
|
var changeOrientation = (pageView.rotation % 180 === 0 ? false : true); |
|
var pageWidth = (changeOrientation ? pageView.height : pageView.width) / |
|
pageView.scale / CSS_UNITS; |
|
var pageHeight = (changeOrientation ? pageView.width : pageView.height) / |
|
pageView.scale / CSS_UNITS; |
|
var scale = 0; |
|
switch (dest[1].name) { |
|
case 'XYZ': |
|
x = dest[2]; |
|
y = dest[3]; |
|
scale = dest[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 = dest[2]; |
|
scale = 'page-width'; |
|
break; |
|
case 'FitV': |
|
case 'FitBV': |
|
x = dest[2]; |
|
width = pageWidth; |
|
height = pageHeight; |
|
scale = 'page-height'; |
|
break; |
|
case 'FitR': |
|
x = dest[2]; |
|
y = dest[3]; |
|
width = dest[4] - x; |
|
height = dest[5] - y; |
|
var viewerContainer = this.container; |
|
widthScale = (viewerContainer.clientWidth - SCROLLBAR_PADDING) / |
|
width / CSS_UNITS; |
|
heightScale = (viewerContainer.clientHeight - SCROLLBAR_PADDING) / |
|
height / CSS_UNITS; |
|
scale = Math.min(Math.abs(widthScale), Math.abs(heightScale)); |
|
break; |
|
default: |
|
return; |
|
} |
|
|
|
if (scale && scale !== this.currentScale) { |
|
this.currentScaleValue = scale; |
|
} else if (this.currentScale === UNKNOWN_SCALE) { |
|
this.currentScaleValue = DEFAULT_SCALE; |
|
} |
|
|
|
if (scale === 'page-fit' && !dest[4]) { |
|
scrollIntoView(pageView.div); |
|
return; |
|
} |
|
|
|
var boundingRect = [ |
|
pageView.viewport.convertToViewportPoint(x, y), |
|
pageView.viewport.convertToViewportPoint(x + width, y + height) |
|
]; |
|
var left = Math.min(boundingRect[0][0], boundingRect[1][0]); |
|
var top = Math.min(boundingRect[0][1], boundingRect[1][1]); |
|
|
|
scrollIntoView(pageView.div, { left: left, top: top }); |
|
}, |
|
|
|
_updateLocation: function (firstPage) { |
|
var currentScale = this._currentScale; |
|
var currentScaleValue = this._currentScaleValue; |
|
var normalizedScaleValue = |
|
parseFloat(currentScaleValue) === currentScale ? |
|
Math.round(currentScale * 10000) / 100 : currentScaleValue; |
|
|
|
var pageNumber = firstPage.id; |
|
var pdfOpenParams = '#page=' + pageNumber; |
|
pdfOpenParams += '&zoom=' + normalizedScaleValue; |
|
var currentPageView = this.pages[pageNumber - 1]; |
|
var container = this.container; |
|
var topLeft = currentPageView.getPagePoint( |
|
(container.scrollLeft - firstPage.x), |
|
(container.scrollTop - firstPage.y)); |
|
var intLeft = Math.round(topLeft[0]); |
|
var intTop = Math.round(topLeft[1]); |
|
pdfOpenParams += ',' + intLeft + ',' + intTop; |
|
|
|
this.location = { |
|
pageNumber: pageNumber, |
|
scale: normalizedScaleValue, |
|
top: intTop, |
|
left: intLeft, |
|
pdfOpenParams: pdfOpenParams |
|
}; |
|
}, |
|
|
|
update: function () { |
|
var visible = this._getVisiblePages(); |
|
var visiblePages = visible.views; |
|
if (visiblePages.length === 0) { |
|
return; |
|
} |
|
|
|
this.updateInProgress = true; |
|
|
|
var suggestedCacheSize = Math.max(DEFAULT_CACHE_SIZE, |
|
2 * visiblePages.length + 1); |
|
this._buffer.resize(suggestedCacheSize); |
|
|
|
this.renderingQueue.renderHighestPriority(visible); |
|
|
|
var currentId = this.currentPageNumber; |
|
var firstPage = visible.first; |
|
|
|
for (var i = 0, ii = visiblePages.length, stillFullyVisible = false; |
|
i < ii; ++i) { |
|
var page = visiblePages[i]; |
|
|
|
if (page.percent < 100) { |
|
break; |
|
} |
|
if (page.id === currentId) { |
|
stillFullyVisible = true; |
|
break; |
|
} |
|
} |
|
|
|
if (!stillFullyVisible) { |
|
currentId = visiblePages[0].id; |
|
} |
|
|
|
if (this.presentationModeState !== PresentationModeState.FULLSCREEN) { |
|
this.currentPageNumber = currentId; |
|
} |
|
|
|
this._updateLocation(firstPage); |
|
|
|
this.updateInProgress = false; |
|
|
|
var event = document.createEvent('UIEvents'); |
|
event.initUIEvent('updateviewarea', true, true, window, 0); |
|
this.container.dispatchEvent(event); |
|
}, |
|
|
|
containsElement: function (element) { |
|
return this.container.contains(element); |
|
}, |
|
|
|
focus: function () { |
|
this.container.focus(); |
|
}, |
|
|
|
blur: function () { |
|
this.container.blur(); |
|
}, |
|
|
|
get isHorizontalScrollbarEnabled() { |
|
return (this.presentationModeState === PresentationModeState.FULLSCREEN ? |
|
false : (this.container.scrollWidth > this.container.clientWidth)); |
|
}, |
|
|
|
_getVisiblePages: function () { |
|
if (this.presentationModeState !== PresentationModeState.FULLSCREEN) { |
|
return getVisibleElements(this.container, this.pages, true); |
|
} else { |
|
// The algorithm in getVisibleElements doesn't work in all browsers and |
|
// configurations when presentation mode is active. |
|
var visible = []; |
|
var currentPage = this.pages[this._currentPageNumber - 1]; |
|
visible.push({ id: currentPage.id, view: currentPage }); |
|
return { first: currentPage, last: currentPage, views: visible }; |
|
} |
|
}, |
|
|
|
cleanup: function () { |
|
for (var i = 0, ii = this.pages.length; i < ii; i++) { |
|
if (this.pages[i] && |
|
this.pages[i].renderingState !== RenderingStates.FINISHED) { |
|
this.pages[i].reset(); |
|
} |
|
} |
|
}, |
|
|
|
/** |
|
* @param {PDFPageView} pageView |
|
* @returns {PDFPage} |
|
* @private |
|
*/ |
|
_ensurePdfPageLoaded: function (pageView) { |
|
if (pageView.pdfPage) { |
|
return Promise.resolve(pageView.pdfPage); |
|
} |
|
var pageNumber = pageView.id; |
|
if (this._pagesRequests[pageNumber]) { |
|
return this._pagesRequests[pageNumber]; |
|
} |
|
var promise = this.pdfDocument.getPage(pageNumber).then( |
|
function (pdfPage) { |
|
pageView.setPdfPage(pdfPage); |
|
this._pagesRequests[pageNumber] = null; |
|
return pdfPage; |
|
}.bind(this)); |
|
this._pagesRequests[pageNumber] = promise; |
|
return promise; |
|
}, |
|
|
|
forceRendering: function (currentlyVisiblePages) { |
|
var visiblePages = currentlyVisiblePages || this._getVisiblePages(); |
|
var pageView = this.renderingQueue.getHighestPriority(visiblePages, |
|
this.pages, |
|
this.scroll.down); |
|
if (pageView) { |
|
this._ensurePdfPageLoaded(pageView).then(function () { |
|
this.renderingQueue.renderView(pageView); |
|
}.bind(this)); |
|
return true; |
|
} |
|
return false; |
|
}, |
|
|
|
getPageTextContent: function (pageIndex) { |
|
return this.pdfDocument.getPage(pageIndex + 1).then(function (page) { |
|
return page.getTextContent(); |
|
}); |
|
}, |
|
|
|
/** |
|
* @param {HTMLDivElement} textLayerDiv |
|
* @param {number} pageIndex |
|
* @param {PageViewport} viewport |
|
* @returns {TextLayerBuilder} |
|
*/ |
|
createTextLayerBuilder: function (textLayerDiv, pageIndex, viewport) { |
|
var isViewerInPresentationMode = |
|
this.presentationModeState === PresentationModeState.FULLSCREEN; |
|
return new TextLayerBuilder({ |
|
textLayerDiv: textLayerDiv, |
|
pageIndex: pageIndex, |
|
viewport: viewport, |
|
findController: isViewerInPresentationMode ? null : this.findController |
|
}); |
|
}, |
|
|
|
/** |
|
* @param {HTMLDivElement} pageDiv |
|
* @param {PDFPage} pdfPage |
|
* @returns {AnnotationsLayerBuilder} |
|
*/ |
|
createAnnotationsLayerBuilder: function (pageDiv, pdfPage) { |
|
return new AnnotationsLayerBuilder({ |
|
pageDiv: pageDiv, |
|
pdfPage: pdfPage, |
|
linkService: this.linkService |
|
}); |
|
}, |
|
|
|
setFindController: function (findController) { |
|
this.findController = findController; |
|
}, |
|
}; |
|
|
|
return PDFViewer; |
|
})(); |
|
|
|
var SimpleLinkService = (function SimpleLinkServiceClosure() { |
|
function SimpleLinkService(pdfViewer) { |
|
this.pdfViewer = pdfViewer; |
|
} |
|
SimpleLinkService.prototype = { |
|
/** |
|
* @returns {number} |
|
*/ |
|
get page() { |
|
return this.pdfViewer.currentPageNumber; |
|
}, |
|
/** |
|
* @param {number} value |
|
*/ |
|
set page(value) { |
|
this.pdfViewer.currentPageNumber = value; |
|
}, |
|
/** |
|
* @param dest - The PDF destination object. |
|
*/ |
|
navigateTo: function (dest) {}, |
|
/** |
|
* @param dest - The PDF destination object. |
|
* @returns {string} The hyperlink to the PDF object. |
|
*/ |
|
getDestinationHash: function (dest) { |
|
return '#'; |
|
}, |
|
/** |
|
* @param hash - The PDF parameters/hash. |
|
* @returns {string} The hyperlink to the PDF object. |
|
*/ |
|
getAnchorUrl: function (hash) { |
|
return '#'; |
|
}, |
|
/** |
|
* @param {string} hash |
|
*/ |
|
setHash: function (hash) {}, |
|
/** |
|
* @param {string} action |
|
*/ |
|
executeNamedAction: function (action) {}, |
|
}; |
|
return SimpleLinkService; |
|
})(); |
|
|
|
|
|
PDFJS.PDFViewer = PDFViewer; |
|
PDFJS.PDFPageView = PDFPageView; |
|
PDFJS.TextLayerBuilder = TextLayerBuilder; |
|
PDFJS.DefaultTextLayerFactory = DefaultTextLayerFactory; |
|
PDFJS.AnnotationsLayerBuilder = AnnotationsLayerBuilder; |
|
PDFJS.DefaultAnnotationsLayerFactory = DefaultAnnotationsLayerFactory; |
|
}).call((typeof window === 'undefined') ? this : window); |
|
|
|
|