diva.js 6.0.1 → 7.2.3

package/source/js/document-handler.js

@@ -1,180 +0,0 @@
-import maxBy from 'lodash.maxby';
-import PageToolsOverlay from './page-tools-overlay';
-
-
-export default class DocumentHandler
-{
-    constructor (viewerCore)
-    {
-        this._viewerCore = viewerCore;
-        this._viewerState = viewerCore.getInternalState();
-        this._overlays = [];
-
-        if (this._viewerCore.getPageTools().length)
-        {
-            const numPages = viewerCore.getSettings().numPages;
-
-            for (let i = 0; i < numPages; i++)
-            {
-                const overlay = new PageToolsOverlay(i, viewerCore);
-                this._overlays.push(overlay);
-                this._viewerCore.addPageOverlay(overlay);
-
-                // create dummy label for width calculation
-                // this is necessary because the _pageToolsElem is only created on mount
-                // so there's no other way to get its width before the pages are loaded
-                // (which we need to avoid their width temporarily being 0 while loading)
-                let dummyLabel = document.createElement('span');
-                dummyLabel.innerHTML = viewerCore.settings.manifest.pages[i].l;
-                dummyLabel.classList.add('diva-page-labels');
-                dummyLabel.setAttribute('style', 'display: inline-block;');
-                document.body.appendChild(dummyLabel);
-                let labelWidth = dummyLabel.clientWidth;
-                document.body.removeChild(dummyLabel);
-
-                overlay.labelWidth = labelWidth;
-            }
-        }
-    }
-
-    // USER EVENTS
-    onDoubleClick (event, coords)
-    {
-        const settings = this._viewerCore.getSettings();
-        const newZoomLevel = event.ctrlKey ? settings.zoomLevel - 1 : settings.zoomLevel + 1;
-
-        const position = this._viewerCore.getPagePositionAtViewportOffset(coords);
-        this._viewerCore.zoom(newZoomLevel, position);
-    }
-
-    onPinch (event, coords, startDistance, endDistance)
-    {
-        // FIXME: Do this check in a way which is less spaghetti code-y
-        const viewerState = this._viewerCore.getInternalState();
-        const settings = this._viewerCore.getSettings();
-
-        let newZoomLevel = Math.log(Math.pow(2, settings.zoomLevel) * endDistance / (startDistance * Math.log(2))) / Math.log(2);
-        newZoomLevel = Math.max(settings.minZoomLevel, newZoomLevel);
-        newZoomLevel = Math.min(settings.maxZoomLevel, newZoomLevel);
-
-        if (newZoomLevel === settings.zoomLevel)
-        {
-            return;
-        }
-
-        const position = this._viewerCore.getPagePositionAtViewportOffset(coords);
-
-        const layout = this._viewerCore.getCurrentLayout();
-        const centerOffset = layout.getPageToViewportCenterOffset(position.anchorPage, viewerState.viewport);
-        const scaleRatio = 1 / Math.pow(2, settings.zoomLevel - newZoomLevel);
-
-        this._viewerCore.reload({
-            zoomLevel: newZoomLevel,
-            goDirectlyTo: position.anchorPage,
-            horizontalOffset: (centerOffset.x - position.offset.left) + position.offset.left * scaleRatio,
-            verticalOffset: (centerOffset.y - position.offset.top) + position.offset.top * scaleRatio
-        });
-    }
-
-    // VIEW EVENTS
-    onViewWillLoad ()
-    {
-        this._viewerCore.publish('DocumentWillLoad', this._viewerCore.getSettings());
-    }
-
-    onViewDidLoad ()
-    {
-        // TODO: Should only be necessary to handle changes on view update, not
-        // initial load
-        this._handleZoomLevelChange();
-
-        const currentPageIndex = this._viewerCore.getSettings().activePageIndex;
-        const fileName = this._viewerCore.getPageName(currentPageIndex);
-        this._viewerCore.publish("DocumentDidLoad", currentPageIndex, fileName);
-    }
-
-    onViewDidUpdate (renderedPages, targetPage)
-    {
-        const currentPage = (targetPage !== null) ?
-            targetPage :
-            getCentermostPage(renderedPages, this._viewerCore.getCurrentLayout(), this._viewerCore.getViewport());
-
-        // calculate the visible pages from the rendered pages
-        let temp = this._viewerState.viewport.intersectionTolerance;
-        // without setting to 0, isPageVisible returns true for pages out of viewport by intersectionTolerance
-        this._viewerState.viewport.intersectionTolerance = 0;
-        let visiblePages = renderedPages.filter(index => this._viewerState.renderer.isPageVisible(index));
-        // reset back to original value after getting true visible pages
-        this._viewerState.viewport.intersectionTolerance = temp;
-
-        // Don't change the current page if there is no page in the viewport
-        // FIXME: Would be better to fall back to the page closest to the viewport
-        if (currentPage !== null)
-        {
-            this._viewerCore.setCurrentPages(currentPage, visiblePages);
-        }
-
-        if (targetPage !== null)
-        {
-            this._viewerCore.publish("ViewerDidJump", targetPage);
-        }
-
-        this._handleZoomLevelChange();
-    }
-
-    _handleZoomLevelChange ()
-    {
-        const viewerState = this._viewerState;
-        const zoomLevel = viewerState.options.zoomLevel;
-
-        // If this is not the initial load, trigger the zoom events
-        if (viewerState.oldZoomLevel !== zoomLevel && viewerState.oldZoomLevel >= 0)
-        {
-            if (viewerState.oldZoomLevel < zoomLevel)
-            {
-                this._viewerCore.publish("ViewerDidZoomIn", zoomLevel);
-            }
-            else
-            {
-                this._viewerCore.publish("ViewerDidZoomOut", zoomLevel);
-            }
-
-            this._viewerCore.publish("ViewerDidZoom", zoomLevel);
-        }
-
-        viewerState.oldZoomLevel = zoomLevel;
-    }
-
-    destroy ()
-    {
-        this._overlays.forEach((overlay) =>
-        {
-            this._viewerCore.removePageOverlay(overlay);
-        }, this);
-    }
-}
-
-function getCentermostPage (renderedPages, layout, viewport)
-{
-    const centerY = viewport.top + (viewport.height / 2);
-    const centerX = viewport.left + (viewport.width / 2);
-
-    // Find the minimum distance from the viewport center to a page.
-    // Compute minus the squared distance from viewport center to the page's border.
-    // http://gamedev.stackexchange.com/questions/44483/how-do-i-calculate-distance-between-a-point-and-an-axis-aligned-rectangle
-    const centerPage = maxBy(renderedPages, pageIndex =>
-    {
-        const dims = layout.getPageDimensions(pageIndex);
-        const imageOffset = layout.getPageOffset(pageIndex, {includePadding: false});
-
-        const midX = imageOffset.left + (dims.height / 2);
-        const midY = imageOffset.top + (dims.width / 2);
-
-        const dx = Math.max(Math.abs(centerX - midX) - (dims.width / 2), 0);
-        const dy = Math.max(Math.abs(centerY - midY) - (dims.height / 2), 0);
-
-        return -(dx * dx + dy * dy);
-    });
-
-    return centerPage != null ? centerPage : null;
-}

package/source/js/document-layout.js

@@ -1,286 +0,0 @@
-/**
- * Translate page layouts, as generated by page-layouts, into an
- * object which computes layout information for the document as
- * a whole.
- */
-export default class DocumentLayout
-{
-    constructor (config, zoomLevel)
-    {
-        const computedLayout = getComputedLayout(config, zoomLevel);
-
-        this.dimensions = computedLayout.dimensions;
-        this.pageGroups = computedLayout.pageGroups;
-        this._pageLookup = getPageLookup(computedLayout.pageGroups);
-    }
-
-    /**
-     * @typedef {Object} PageInfo
-     * @property {number} index
-     * @property {{index, dimensions, pages, region, padding}} group
-     * @property {{height: number, width: number}} dimensions
-     * @property {{top: number, left: number}} groupOffset
-     */
-
-    /**
-     * @param pageIndex
-     * @returns {PageInfo|null}
-     */
-    getPageInfo (pageIndex)
-    {
-        return this._pageLookup[pageIndex] || null;
-    }
-
-    /**
-     * Get the dimensions of a page
-     *
-     * @param pageIndex
-     * @returns {{height: number, width: number}}
-     */
-    getPageDimensions (pageIndex)
-    {
-        if (!this._pageLookup || !this._pageLookup[pageIndex])
-            return null;
-
-        const region = getPageRegionFromPageInfo(this._pageLookup[pageIndex]);
-
-        return {
-            height: region.bottom - region.top,
-            width: region.right - region.left
-        };
-    }
-
-    // TODO(wabain): Get rid of this; it's a subset of the page region, so
-    // give that instead
-    /**
-     * Get the top-left coordinates of a page, including*** padding
-     *
-     * @param pageIndex
-     * @param options
-     * @returns {{top: number, left: number} | null}
-     */
-    getPageOffset (pageIndex, options)
-    {
-        const region = this.getPageRegion(pageIndex, options);
-
-        if (!region)
-            return null;
-
-        return {
-            top: region.top,
-            left: region.left
-        };
-    }
-
-    getPageRegion (pageIndex, options)
-    {
-        const pageInfo = this._pageLookup[pageIndex];
-
-        if (!pageInfo)
-            return null;
-
-        const region = getPageRegionFromPageInfo(pageInfo);
-        const padding = pageInfo.group.padding;
-
-        if (options && options.includePadding)
-        {
-            return {
-                top: region.top + padding.top,
-                left: region.left + padding.left,
-                bottom: region.bottom,
-                right: region.right
-            };
-        }
-
-        return {
-            top: region.top,
-            left: region.left,
-            // need to account for plugin icons below the page, see 
-            // https://github.com/DDMAL/diva.js/issues/436
-            bottom: region.bottom + padding.top, 
-            right: region.right
-        };
-    }
-
-    /**
-     * Get the distance from the top-right of the page to the center of the
-     * specified viewport region
-     *
-     * @param pageIndex
-     * @param viewport {{top: number, left: number, bottom: number, right: number}}
-     * @returns {{x: number, y: number}}
-     */
-    getPageToViewportCenterOffset (pageIndex, viewport)
-    {
-        const scrollLeft = viewport.left;
-        const elementWidth = viewport.right - viewport.left;
-
-        const offset = this.getPageOffset(pageIndex);
-
-        const x = scrollLeft - offset.left + parseInt(elementWidth / 2, 10);
-
-        const scrollTop = viewport.top;
-        const elementHeight = viewport.bottom - viewport.top;
-
-        const y = scrollTop - offset.top + parseInt(elementHeight / 2, 10);
-
-        return {
-            x: x,
-            y: y
-        };
-    }
-}
-
-function getPageRegionFromPageInfo (page)
-{
-    const top    = page.groupOffset.top  + page.group.region.top;
-    const bottom = top + page.dimensions.height;
-    const left   = page.groupOffset.left + page.group.region.left;
-    const right  = left + page.dimensions.width;
-
-    return {
-        top: top,
-        bottom: bottom,
-        left: left,
-        right: right
-    };
-}
-
-function getPageLookup (pageGroups)
-{
-    const pageLookup = {};
-
-    pageGroups.forEach(group => {
-        group.pages.forEach(page => {
-            pageLookup[page.index] = {
-                index: page.index,
-                group: group,
-                dimensions: page.dimensions,
-                groupOffset: page.groupOffset
-            };
-        });
-    });
-
-    return pageLookup;
-}
-
-function getComputedLayout (config, zoomLevel)
-{
-    const scaledLayouts = zoomLevel === null ? config.pageLayouts : getScaledPageLayouts(config, zoomLevel);
-
-    const documentSecondaryExtent = getExtentAlongSecondaryAxis(config, scaledLayouts);
-
-    // The current position in the document along the primary axis
-    let primaryDocPosition = config.verticallyOriented ?
-        config.padding.document.top :
-        config.padding.document.left;
-
-    const pageGroups = [];
-
-    // TODO: Use bottom, right as well
-    const pagePadding = {
-        top: config.padding.page.top,
-        left: config.padding.page.left
-    };
-
-    scaledLayouts.forEach((layout, index) => {
-        let top, left;
-
-        if (config.verticallyOriented)
-        {
-            top = primaryDocPosition;
-            left = (documentSecondaryExtent - layout.dimensions.width) / 2;
-        }
-        else
-        {
-            top = (documentSecondaryExtent - layout.dimensions.height) / 2;
-            left = primaryDocPosition;
-        }
-
-        const region = {
-            top: top,
-            bottom: top + pagePadding.top + layout.dimensions.height,
-            left: left,
-            right: left + pagePadding.left + layout.dimensions.width
-        };
-
-        pageGroups.push({
-            index: index,
-            dimensions: layout.dimensions,
-            pages: layout.pages,
-            region: region,
-            padding: pagePadding
-        });
-
-        primaryDocPosition = config.verticallyOriented ? region.bottom : region.right;
-    });
-
-    let height, width;
-
-    if (config.verticallyOriented)
-    {
-        height = primaryDocPosition + pagePadding.top;
-        width = documentSecondaryExtent;
-    }
-    else
-    {
-        height = documentSecondaryExtent;
-        width = primaryDocPosition + pagePadding.left;
-    }
-
-    return {
-        dimensions: {
-            height: height,
-            width: width
-        },
-        pageGroups: pageGroups
-    };
-}
-
-function getScaledPageLayouts (config, zoomLevel)
-{
-    const scaleRatio = Math.pow(2, zoomLevel - config.maxZoomLevel);
-
-    return config.pageLayouts.map(group => ({
-        dimensions: scaleDimensions(group.dimensions, scaleRatio),
-
-        pages: group.pages.map(page => ({
-            index: page.index,
-
-            groupOffset: {
-                top: Math.floor(page.groupOffset.top * scaleRatio),
-                left: Math.floor(page.groupOffset.left * scaleRatio)
-            },
-
-            dimensions: scaleDimensions(page.dimensions, scaleRatio)
-        }))
-    }));
-}
-
-function scaleDimensions (dimensions, scaleRatio)
-{
-    return {
-        height: Math.floor(dimensions.height * scaleRatio),
-        width: Math.floor(dimensions.width * scaleRatio)
-    };
-}
-
-function getExtentAlongSecondaryAxis (config, scaledLayouts)
-{
-    // Get the extent of the document along the secondary axis
-    let secondaryDim, secondaryPadding;
-    const docPadding = config.padding.document;
-
-    if (config.verticallyOriented)
-    {
-        secondaryDim = 'width';
-        secondaryPadding = docPadding.left + docPadding.right;
-    }
-    else
-    {
-        secondaryDim = 'height';
-        secondaryPadding = docPadding.top + docPadding.bottom;
-    }
-
-    return secondaryPadding + scaledLayouts.reduce((maxDim, layout) => Math.max(layout.dimensions[secondaryDim], maxDim), 0);
-}

package/source/js/exceptions.js

@@ -1,26 +0,0 @@
-export function DivaParentElementNotFoundException (message)
-{
-    this.name = "DivaParentElementNotFoundException";
-    this.message = message;
-    this.stack = (new Error()).stack;
-}
-
-DivaParentElementNotFoundException.prototype = new Error();
-
-export function NotAnIIIFManifestException (message)
-{
-    this.name = "NotAnIIIFManifestException";
-    this.message = message;
-    this.stack = (new Error()).stack;
-}
-
-NotAnIIIFManifestException.prototype = new Error();
-
-export function ObjectDataNotSuppliedException (message)
-{
-    this.name = "ObjectDataNotSuppliedException";
-    this.message = message;
-    this.stack = (new Error()).stack;
-}
-
-ObjectDataNotSuppliedException.prototype = new Error();

package/source/js/gesture-events.js

@@ -1,190 +0,0 @@
-export default {
-    onDoubleClick,
-    onPinch,
-    onDoubleTap
-};
-
-const DOUBLE_CLICK_TIMEOUT = 500;
-const DOUBLE_TAP_DISTANCE_THRESHOLD = 50;
-const DOUBLE_TAP_TIMEOUT = 250;
-
-function onDoubleClick(elem, callback)
-{
-    elem.addEventListener('dblclick', function (event)
-    {
-        if (!event.ctrlKey)
-        {
-            callback(event, getRelativeOffset(event.currentTarget, event));
-        }
-    });
-
-    // Handle the control key for macs (in conjunction with double-clicking)
-    // FIXME: Does a click get handled with ctrl pressed on non-Macs?
-    const tracker = createDoubleEventTracker(DOUBLE_CLICK_TIMEOUT);
-
-    elem.addEventListener('contextmenu', function (event)
-    {
-        event.preventDefault();
-
-        if (event.ctrlKey)
-        {
-            if (tracker.isTriggered())
-            {
-                tracker.reset();
-                callback(event, getRelativeOffset(event.currentTarget, event));
-            }
-            else
-            {
-                tracker.trigger();
-            }
-        }
-    });
-}
-
-function onPinch(elem, callback)
-{
-    let startDistance = 0;
-
-    elem.addEventListener('touchstart', function (event)
-    {
-        // Prevent mouse event from firing
-        event.preventDefault();
-
-        if (event.originalEvent.touches.length === 2)
-        {
-            startDistance = distance(
-                event.originalEvent.touches[0].clientX,
-                event.originalEvent.touches[0].clientY,
-                event.originalEvent.touches[1].clientX,
-                event.originalEvent.touches[1].clientY
-            );
-        }
-    });
-
-    elem.addEventListener('touchmove', function(event)
-    {
-        // Prevent mouse event from firing
-        event.preventDefault();
-
-        if (event.originalEvent.touches.length === 2)
-        {
-            const touches = event.originalEvent.touches;
-
-            const moveDistance = distance(
-                touches[0].clientX,
-                touches[0].clientY,
-                touches[1].clientX,
-                touches[1].clientY
-            );
-
-            const zoomDelta = moveDistance - startDistance;
-
-            if (Math.abs(zoomDelta) > 0)
-            {
-                const touchCenter = {
-                    pageX: (touches[0].clientX + touches[1].clientX) / 2,
-                    pageY: (touches[0].clientY + touches[1].clientY) / 2
-                };
-
-                callback(event, getRelativeOffset(event.currentTarget, touchCenter), startDistance, moveDistance);
-            }
-        }
-    });
-}
-
-function onDoubleTap(elem, callback)
-{
-    const tracker = createDoubleEventTracker(DOUBLE_TAP_TIMEOUT);
-    let firstTap = null;
-
-    elem.addEventListener('touchend', (event) =>
-    {
-        // Prevent mouse event from firing
-        event.preventDefault();
-
-        if (tracker.isTriggered())
-        {
-            tracker.reset();
-
-            // Doubletap has occurred
-            const secondTap = {
-                pageX: event.originalEvent.changedTouches[0].clientX,
-                pageY: event.originalEvent.changedTouches[0].clientY
-            };
-
-            // If first tap is close to second tap (prevents interference with scale event)
-            const tapDistance = distance(firstTap.pageX, firstTap.pageY, secondTap.pageX, secondTap.pageY);
-
-            // TODO: Could give something higher-level than secondTap to callback
-            if (tapDistance < DOUBLE_TAP_DISTANCE_THRESHOLD)
-                callback(event, getRelativeOffset(event.currentTarget, secondTap));
-
-            firstTap = null;
-        }
-        else
-        {
-            firstTap = {
-                pageX: event.originalEvent.changedTouches[0].clientX,
-                pageY: event.originalEvent.changedTouches[0].clientY
-            };
-
-            tracker.trigger();
-        }
-    });
-}
-
-// Pythagorean theorem to get the distance between two points (used for
-// calculating finger distance for double-tap and pinch-zoom)
-function distance(x1, y1, x2, y2)
-{
-    return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
-}
-
-// Utility to keep track of whether an event has been triggered twice
-// during a a given duration
-function createDoubleEventTracker(timeoutDuration)
-{
-    let triggered = false;
-    let timeoutId = null;
-
-    return {
-        trigger()
-        {
-            triggered = true;
-            resetTimeout();
-            timeoutId = setTimeout(function ()
-            {
-                triggered = false;
-                timeoutId = null;
-            }, timeoutDuration);
-        },
-        isTriggered()
-        {
-            return triggered;
-        },
-        reset()
-        {
-            triggered = false;
-            resetTimeout();
-        }
-    };
-
-    function resetTimeout()
-    {
-        if (timeoutId !== null)
-        {
-            clearTimeout(timeoutId);
-            timeoutId = null;
-        }
-    }
-}
-
-function getRelativeOffset(elem, pageCoords)
-{
-    const bounds = elem.getBoundingClientRect();
-
-    return {
-        left: pageCoords.pageX - bounds.left,
-        top: pageCoords.pageY - bounds.top
-    };
-}