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.
723 lines
25 KiB
723 lines
25 KiB
/* Copyright 2017 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. |
|
*/ |
|
'use strict'; |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.PDFViewer = exports.PresentationModeState = undefined; |
|
|
|
var _pdfjs = require('./pdfjs'); |
|
|
|
var _ui_utils = require('./ui_utils'); |
|
|
|
var _pdf_rendering_queue = require('./pdf_rendering_queue'); |
|
|
|
var _annotation_layer_builder = require('./annotation_layer_builder'); |
|
|
|
var _dom_events = require('./dom_events'); |
|
|
|
var _pdf_page_view = require('./pdf_page_view'); |
|
|
|
var _pdf_link_service = require('./pdf_link_service'); |
|
|
|
var _text_layer_builder = require('./text_layer_builder'); |
|
|
|
var PresentationModeState = { |
|
UNKNOWN: 0, |
|
NORMAL: 1, |
|
CHANGING: 2, |
|
FULLSCREEN: 3 |
|
}; |
|
var DEFAULT_CACHE_SIZE = 10; |
|
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(); |
|
} |
|
}; |
|
} |
|
function isSameScale(oldScale, newScale) { |
|
if (newScale === oldScale) { |
|
return true; |
|
} |
|
if (Math.abs(newScale - oldScale) < 1e-15) { |
|
return true; |
|
} |
|
return false; |
|
} |
|
function isPortraitOrientation(size) { |
|
return size.width <= size.height; |
|
} |
|
function PDFViewer(options) { |
|
this.container = options.container; |
|
this.viewer = options.viewer || options.container.firstElementChild; |
|
this.eventBus = options.eventBus || (0, _dom_events.getGlobalEventBus)(); |
|
this.linkService = options.linkService || new _pdf_link_service.SimpleLinkService(); |
|
this.downloadManager = options.downloadManager || null; |
|
this.removePageBorders = options.removePageBorders || false; |
|
this.enhanceTextSelection = options.enhanceTextSelection || false; |
|
this.renderInteractiveForms = options.renderInteractiveForms || false; |
|
this.enablePrintAutoRotate = options.enablePrintAutoRotate || false; |
|
this.renderer = options.renderer || _ui_utils.RendererType.CANVAS; |
|
this.defaultRenderingQueue = !options.renderingQueue; |
|
if (this.defaultRenderingQueue) { |
|
this.renderingQueue = new _pdf_rendering_queue.PDFRenderingQueue(); |
|
this.renderingQueue.setViewer(this); |
|
} else { |
|
this.renderingQueue = options.renderingQueue; |
|
} |
|
this.scroll = (0, _ui_utils.watchScroll)(this.container, this._scrollUpdate.bind(this)); |
|
this.presentationModeState = PresentationModeState.UNKNOWN; |
|
this._resetView(); |
|
if (this.removePageBorders) { |
|
this.viewer.classList.add('removePageBorders'); |
|
} |
|
} |
|
PDFViewer.prototype = { |
|
get pagesCount() { |
|
return this._pages.length; |
|
}, |
|
getPageView: function getPageView(index) { |
|
return this._pages[index]; |
|
}, |
|
|
|
get pageViewsReady() { |
|
return this._pageViewsReady; |
|
}, |
|
get currentPageNumber() { |
|
return this._currentPageNumber; |
|
}, |
|
set currentPageNumber(val) { |
|
if ((val | 0) !== val) { |
|
throw new Error('Invalid page number.'); |
|
} |
|
if (!this.pdfDocument) { |
|
this._currentPageNumber = val; |
|
return; |
|
} |
|
this._setCurrentPageNumber(val, true); |
|
}, |
|
_setCurrentPageNumber: function PDFViewer_setCurrentPageNumber(val, resetCurrentPageView) { |
|
if (this._currentPageNumber === val) { |
|
if (resetCurrentPageView) { |
|
this._resetCurrentPageView(); |
|
} |
|
return; |
|
} |
|
if (!(0 < val && val <= this.pagesCount)) { |
|
console.error('PDFViewer_setCurrentPageNumber: "' + val + '" is out of bounds.'); |
|
return; |
|
} |
|
var arg = { |
|
source: this, |
|
pageNumber: val, |
|
pageLabel: this._pageLabels && this._pageLabels[val - 1] |
|
}; |
|
this._currentPageNumber = val; |
|
this.eventBus.dispatch('pagechanging', arg); |
|
this.eventBus.dispatch('pagechange', arg); |
|
if (resetCurrentPageView) { |
|
this._resetCurrentPageView(); |
|
} |
|
}, |
|
get currentPageLabel() { |
|
return this._pageLabels && this._pageLabels[this._currentPageNumber - 1]; |
|
}, |
|
set currentPageLabel(val) { |
|
var pageNumber = val | 0; |
|
if (this._pageLabels) { |
|
var i = this._pageLabels.indexOf(val); |
|
if (i >= 0) { |
|
pageNumber = i + 1; |
|
} |
|
} |
|
this.currentPageNumber = pageNumber; |
|
}, |
|
get currentScale() { |
|
return this._currentScale !== _ui_utils.UNKNOWN_SCALE ? this._currentScale : _ui_utils.DEFAULT_SCALE; |
|
}, |
|
set currentScale(val) { |
|
if (isNaN(val)) { |
|
throw new Error('Invalid numeric scale'); |
|
} |
|
if (!this.pdfDocument) { |
|
this._currentScale = val; |
|
this._currentScaleValue = val !== _ui_utils.UNKNOWN_SCALE ? val.toString() : null; |
|
return; |
|
} |
|
this._setScale(val, false); |
|
}, |
|
get currentScaleValue() { |
|
return this._currentScaleValue; |
|
}, |
|
set currentScaleValue(val) { |
|
if (!this.pdfDocument) { |
|
this._currentScale = isNaN(val) ? _ui_utils.UNKNOWN_SCALE : val; |
|
this._currentScaleValue = val.toString(); |
|
return; |
|
} |
|
this._setScale(val, false); |
|
}, |
|
get pagesRotation() { |
|
return this._pagesRotation; |
|
}, |
|
set pagesRotation(rotation) { |
|
if (!(typeof rotation === 'number' && rotation % 90 === 0)) { |
|
throw new Error('Invalid pages rotation angle.'); |
|
} |
|
this._pagesRotation = rotation; |
|
if (!this.pdfDocument) { |
|
return; |
|
} |
|
for (var i = 0, l = this._pages.length; i < l; i++) { |
|
var pageView = this._pages[i]; |
|
pageView.update(pageView.scale, rotation); |
|
} |
|
this._setScale(this._currentScaleValue, true); |
|
if (this.defaultRenderingQueue) { |
|
this.update(); |
|
} |
|
}, |
|
setDocument: function setDocument(pdfDocument) { |
|
var _this = this; |
|
|
|
if (this.pdfDocument) { |
|
this._cancelRendering(); |
|
this._resetView(); |
|
} |
|
this.pdfDocument = pdfDocument; |
|
if (!pdfDocument) { |
|
return; |
|
} |
|
var pagesCount = pdfDocument.numPages; |
|
var pagesCapability = (0, _pdfjs.createPromiseCapability)(); |
|
this.pagesPromise = pagesCapability.promise; |
|
pagesCapability.promise.then(function () { |
|
_this._pageViewsReady = true; |
|
_this.eventBus.dispatch('pagesloaded', { |
|
source: _this, |
|
pagesCount: pagesCount |
|
}); |
|
}); |
|
var isOnePageRenderedResolved = false; |
|
var onePageRenderedCapability = (0, _pdfjs.createPromiseCapability)(); |
|
this.onePageRendered = onePageRenderedCapability.promise; |
|
var bindOnAfterAndBeforeDraw = function bindOnAfterAndBeforeDraw(pageView) { |
|
pageView.onBeforeDraw = function () { |
|
_this._buffer.push(pageView); |
|
}; |
|
pageView.onAfterDraw = function () { |
|
if (!isOnePageRenderedResolved) { |
|
isOnePageRenderedResolved = true; |
|
onePageRenderedCapability.resolve(); |
|
} |
|
}; |
|
}; |
|
var firstPagePromise = pdfDocument.getPage(1); |
|
this.firstPagePromise = firstPagePromise; |
|
return firstPagePromise.then(function (pdfPage) { |
|
var scale = _this.currentScale; |
|
var viewport = pdfPage.getViewport(scale * _ui_utils.CSS_UNITS); |
|
for (var pageNum = 1; pageNum <= pagesCount; ++pageNum) { |
|
var textLayerFactory = null; |
|
if (!_pdfjs.PDFJS.disableTextLayer) { |
|
textLayerFactory = _this; |
|
} |
|
var pageView = new _pdf_page_view.PDFPageView({ |
|
container: _this.viewer, |
|
eventBus: _this.eventBus, |
|
id: pageNum, |
|
scale: scale, |
|
defaultViewport: viewport.clone(), |
|
renderingQueue: _this.renderingQueue, |
|
textLayerFactory: textLayerFactory, |
|
annotationLayerFactory: _this, |
|
enhanceTextSelection: _this.enhanceTextSelection, |
|
renderInteractiveForms: _this.renderInteractiveForms, |
|
renderer: _this.renderer |
|
}); |
|
bindOnAfterAndBeforeDraw(pageView); |
|
_this._pages.push(pageView); |
|
} |
|
onePageRenderedCapability.promise.then(function () { |
|
if (_pdfjs.PDFJS.disableAutoFetch) { |
|
pagesCapability.resolve(); |
|
return; |
|
} |
|
var getPagesLeft = pagesCount; |
|
|
|
var _loop = function _loop(_pageNum) { |
|
pdfDocument.getPage(_pageNum).then(function (pdfPage) { |
|
var pageView = _this._pages[_pageNum - 1]; |
|
if (!pageView.pdfPage) { |
|
pageView.setPdfPage(pdfPage); |
|
} |
|
_this.linkService.cachePageRef(_pageNum, pdfPage.ref); |
|
if (--getPagesLeft === 0) { |
|
pagesCapability.resolve(); |
|
} |
|
}); |
|
}; |
|
|
|
for (var _pageNum = 1; _pageNum <= pagesCount; ++_pageNum) { |
|
_loop(_pageNum); |
|
} |
|
}); |
|
_this.eventBus.dispatch('pagesinit', { source: _this }); |
|
if (_this.defaultRenderingQueue) { |
|
_this.update(); |
|
} |
|
if (_this.findController) { |
|
_this.findController.resolveFirstPage(); |
|
} |
|
}); |
|
}, |
|
|
|
setPageLabels: function PDFViewer_setPageLabels(labels) { |
|
if (!this.pdfDocument) { |
|
return; |
|
} |
|
if (!labels) { |
|
this._pageLabels = null; |
|
} else if (!(labels instanceof Array && this.pdfDocument.numPages === labels.length)) { |
|
this._pageLabels = null; |
|
console.error('PDFViewer_setPageLabels: Invalid page labels.'); |
|
} else { |
|
this._pageLabels = labels; |
|
} |
|
for (var i = 0, ii = this._pages.length; i < ii; i++) { |
|
var pageView = this._pages[i]; |
|
var label = this._pageLabels && this._pageLabels[i]; |
|
pageView.setPageLabel(label); |
|
} |
|
}, |
|
_resetView: function _resetView() { |
|
this._pages = []; |
|
this._currentPageNumber = 1; |
|
this._currentScale = _ui_utils.UNKNOWN_SCALE; |
|
this._currentScaleValue = null; |
|
this._pageLabels = null; |
|
this._buffer = new PDFPageViewBuffer(DEFAULT_CACHE_SIZE); |
|
this._location = null; |
|
this._pagesRotation = 0; |
|
this._pagesRequests = []; |
|
this._pageViewsReady = false; |
|
this.viewer.textContent = ''; |
|
}, |
|
|
|
_scrollUpdate: function PDFViewer_scrollUpdate() { |
|
if (this.pagesCount === 0) { |
|
return; |
|
} |
|
this.update(); |
|
for (var i = 0, ii = this._pages.length; i < ii; i++) { |
|
this._pages[i].updatePosition(); |
|
} |
|
}, |
|
_setScaleDispatchEvent: function pdfViewer_setScaleDispatchEvent(newScale, newValue, preset) { |
|
var arg = { |
|
source: this, |
|
scale: newScale, |
|
presetValue: preset ? newValue : undefined |
|
}; |
|
this.eventBus.dispatch('scalechanging', arg); |
|
this.eventBus.dispatch('scalechange', arg); |
|
}, |
|
_setScaleUpdatePages: function pdfViewer_setScaleUpdatePages(newScale, newValue, noScroll, preset) { |
|
this._currentScaleValue = newValue.toString(); |
|
if (isSameScale(this._currentScale, newScale)) { |
|
if (preset) { |
|
this._setScaleDispatchEvent(newScale, newValue, true); |
|
} |
|
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; |
|
if (this._location && !_pdfjs.PDFJS.ignoreCurrentPositionOnZoom && !(this.isInPresentationMode || this.isChangingPresentationMode)) { |
|
page = this._location.pageNumber; |
|
dest = [null, { name: 'XYZ' }, this._location.left, this._location.top, null]; |
|
} |
|
this.scrollPageIntoView({ |
|
pageNumber: page, |
|
destArray: dest, |
|
allowNegativeOffset: true |
|
}); |
|
} |
|
this._setScaleDispatchEvent(newScale, newValue, preset); |
|
if (this.defaultRenderingQueue) { |
|
this.update(); |
|
} |
|
}, |
|
_setScale: function PDFViewer_setScale(value, noScroll) { |
|
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 hPadding = this.isInPresentationMode || this.removePageBorders ? 0 : _ui_utils.SCROLLBAR_PADDING; |
|
var vPadding = this.isInPresentationMode || this.removePageBorders ? 0 : _ui_utils.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; |
|
var horizontalScale = isLandscape ? Math.min(pageHeightScale, pageWidthScale) : pageWidthScale; |
|
scale = Math.min(_ui_utils.MAX_AUTO_SCALE, horizontalScale); |
|
break; |
|
default: |
|
console.error('PDFViewer_setScale: "' + value + '" is an unknown zoom value.'); |
|
return; |
|
} |
|
this._setScaleUpdatePages(scale, value, noScroll, true); |
|
} |
|
}, |
|
_resetCurrentPageView: function _resetCurrentPageView() { |
|
if (this.isInPresentationMode) { |
|
this._setScale(this._currentScaleValue, true); |
|
} |
|
var pageView = this._pages[this._currentPageNumber - 1]; |
|
(0, _ui_utils.scrollIntoView)(pageView.div); |
|
}, |
|
|
|
scrollPageIntoView: function PDFViewer_scrollPageIntoView(params) { |
|
if (!this.pdfDocument) { |
|
return; |
|
} |
|
if (arguments.length > 1 || typeof params === 'number') { |
|
console.warn('Call of scrollPageIntoView() with obsolete signature.'); |
|
var paramObj = {}; |
|
if (typeof params === 'number') { |
|
paramObj.pageNumber = params; |
|
} |
|
if (arguments[1] instanceof Array) { |
|
paramObj.destArray = arguments[1]; |
|
} |
|
params = paramObj; |
|
} |
|
var pageNumber = params.pageNumber || 0; |
|
var dest = params.destArray || null; |
|
var allowNegativeOffset = params.allowNegativeOffset || false; |
|
if (this.isInPresentationMode || !dest) { |
|
this._setCurrentPageNumber(pageNumber, true); |
|
return; |
|
} |
|
var pageView = this._pages[pageNumber - 1]; |
|
if (!pageView) { |
|
console.error('PDFViewer_scrollPageIntoView: ' + 'Invalid "pageNumber" parameter.'); |
|
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 / _ui_utils.CSS_UNITS; |
|
var pageHeight = (changeOrientation ? pageView.width : pageView.height) / pageView.scale / _ui_utils.CSS_UNITS; |
|
var scale = 0; |
|
switch (dest[1].name) { |
|
case 'XYZ': |
|
x = dest[2]; |
|
y = dest[3]; |
|
scale = dest[4]; |
|
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'; |
|
if (y === null && this._location) { |
|
x = this._location.left; |
|
y = this._location.top; |
|
} |
|
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 hPadding = this.removePageBorders ? 0 : _ui_utils.SCROLLBAR_PADDING; |
|
var vPadding = this.removePageBorders ? 0 : _ui_utils.VERTICAL_PADDING; |
|
widthScale = (this.container.clientWidth - hPadding) / width / _ui_utils.CSS_UNITS; |
|
heightScale = (this.container.clientHeight - vPadding) / height / _ui_utils.CSS_UNITS; |
|
scale = Math.min(Math.abs(widthScale), Math.abs(heightScale)); |
|
break; |
|
default: |
|
console.error('PDFViewer_scrollPageIntoView: \'' + dest[1].name + '\' is not a valid destination type.'); |
|
return; |
|
} |
|
if (scale && scale !== this._currentScale) { |
|
this.currentScaleValue = scale; |
|
} else if (this._currentScale === _ui_utils.UNKNOWN_SCALE) { |
|
this.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE; |
|
} |
|
if (scale === 'page-fit' && !dest[4]) { |
|
(0, _ui_utils.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]); |
|
if (!allowNegativeOffset) { |
|
left = Math.max(left, 0); |
|
top = Math.max(top, 0); |
|
} |
|
(0, _ui_utils.scrollIntoView)(pageView.div, { |
|
left: left, |
|
top: top |
|
}); |
|
}, |
|
_updateLocation: function _updateLocation(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 PDFViewer_update() { |
|
var visible = this._getVisiblePages(); |
|
var visiblePages = visible.views; |
|
if (visiblePages.length === 0) { |
|
return; |
|
} |
|
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.isInPresentationMode) { |
|
this._setCurrentPageNumber(currentId); |
|
} |
|
this._updateLocation(firstPage); |
|
this.eventBus.dispatch('updateviewarea', { |
|
source: this, |
|
location: this._location |
|
}); |
|
}, |
|
containsElement: function containsElement(element) { |
|
return this.container.contains(element); |
|
}, |
|
focus: function focus() { |
|
this.container.focus(); |
|
}, |
|
|
|
get isInPresentationMode() { |
|
return this.presentationModeState === PresentationModeState.FULLSCREEN; |
|
}, |
|
get isChangingPresentationMode() { |
|
return this.presentationModeState === PresentationModeState.CHANGING; |
|
}, |
|
get isHorizontalScrollbarEnabled() { |
|
return this.isInPresentationMode ? false : this.container.scrollWidth > this.container.clientWidth; |
|
}, |
|
_getVisiblePages: function _getVisiblePages() { |
|
if (!this.isInPresentationMode) { |
|
return (0, _ui_utils.getVisibleElements)(this.container, this._pages, true); |
|
} |
|
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 cleanup() { |
|
for (var i = 0, ii = this._pages.length; i < ii; i++) { |
|
if (this._pages[i] && this._pages[i].renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) { |
|
this._pages[i].reset(); |
|
} |
|
} |
|
}, |
|
|
|
_cancelRendering: function PDFViewer_cancelRendering() { |
|
for (var i = 0, ii = this._pages.length; i < ii; i++) { |
|
if (this._pages[i]) { |
|
this._pages[i].cancelRendering(); |
|
} |
|
} |
|
}, |
|
_ensurePdfPageLoaded: function _ensurePdfPageLoaded(pageView) { |
|
var _this2 = this; |
|
|
|
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) { |
|
if (!pageView.pdfPage) { |
|
pageView.setPdfPage(pdfPage); |
|
} |
|
_this2._pagesRequests[pageNumber] = null; |
|
return pdfPage; |
|
}); |
|
this._pagesRequests[pageNumber] = promise; |
|
return promise; |
|
}, |
|
forceRendering: function forceRendering(currentlyVisiblePages) { |
|
var _this3 = this; |
|
|
|
var visiblePages = currentlyVisiblePages || this._getVisiblePages(); |
|
var pageView = this.renderingQueue.getHighestPriority(visiblePages, this._pages, this.scroll.down); |
|
if (pageView) { |
|
this._ensurePdfPageLoaded(pageView).then(function () { |
|
_this3.renderingQueue.renderView(pageView); |
|
}); |
|
return true; |
|
} |
|
return false; |
|
}, |
|
getPageTextContent: function getPageTextContent(pageIndex) { |
|
return this.pdfDocument.getPage(pageIndex + 1).then(function (page) { |
|
return page.getTextContent({ normalizeWhitespace: true }); |
|
}); |
|
}, |
|
createTextLayerBuilder: function createTextLayerBuilder(textLayerDiv, pageIndex, viewport) { |
|
var enhanceTextSelection = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; |
|
|
|
return new _text_layer_builder.TextLayerBuilder({ |
|
textLayerDiv: textLayerDiv, |
|
eventBus: this.eventBus, |
|
pageIndex: pageIndex, |
|
viewport: viewport, |
|
findController: this.isInPresentationMode ? null : this.findController, |
|
enhanceTextSelection: this.isInPresentationMode ? false : enhanceTextSelection |
|
}); |
|
}, |
|
createAnnotationLayerBuilder: function createAnnotationLayerBuilder(pageDiv, pdfPage) { |
|
var renderInteractiveForms = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; |
|
|
|
return new _annotation_layer_builder.AnnotationLayerBuilder({ |
|
pageDiv: pageDiv, |
|
pdfPage: pdfPage, |
|
renderInteractiveForms: renderInteractiveForms, |
|
linkService: this.linkService, |
|
downloadManager: this.downloadManager |
|
}); |
|
}, |
|
setFindController: function setFindController(findController) { |
|
this.findController = findController; |
|
}, |
|
getPagesOverview: function getPagesOverview() { |
|
var pagesOverview = this._pages.map(function (pageView) { |
|
var viewport = pageView.pdfPage.getViewport(1); |
|
return { |
|
width: viewport.width, |
|
height: viewport.height, |
|
rotation: viewport.rotation |
|
}; |
|
}); |
|
if (!this.enablePrintAutoRotate) { |
|
return pagesOverview; |
|
} |
|
var isFirstPagePortrait = isPortraitOrientation(pagesOverview[0]); |
|
return pagesOverview.map(function (size) { |
|
if (isFirstPagePortrait === isPortraitOrientation(size)) { |
|
return size; |
|
} |
|
return { |
|
width: size.height, |
|
height: size.width, |
|
rotation: (size.rotation + 90) % 360 |
|
}; |
|
}); |
|
} |
|
}; |
|
return PDFViewer; |
|
}(); |
|
exports.PresentationModeState = PresentationModeState; |
|
exports.PDFViewer = PDFViewer; |