diva.js 6.0.1 → 7.2.3

package/source/js/page-layouts/book-layout.js

@@ -1,161 +0,0 @@
-import getPageDimensions from './page-dimensions';
-
-export default function getBookLayoutGroups (viewerConfig)
-{
-    const groupings = getGroupings(viewerConfig);
-
-    return groupings.map(grouping => getGroupLayoutsFromPageGrouping(viewerConfig, grouping));
-}
-
-function getGroupings(viewerConfig)
-{
-    const manifest = viewerConfig.manifest;
-
-    const pagesByGroup = [];
-    let leftPage = null;
-    let nonPagedPages = []; // Pages to display below the current group
-
-    const _addNonPagedPages = () =>
-    {
-        for (let i = 0, nlen = nonPagedPages.length; i < nlen; i++)
-        {
-            pagesByGroup.push([ nonPagedPages[i] ]);
-        }
-        nonPagedPages = [];
-    };
-
-    manifest.pages.forEach( (page, index) =>
-    {
-        const pageRecord = {
-            index: index,
-            dimensions: getPageDimensions(index, manifest),
-            paged: (!manifest.paged || page.paged)
-        };
-
-        // Only display non-paged pages if specified in the settings
-        if (!viewerConfig.showNonPagedPages && !pageRecord.paged)
-            return;
-
-        if (!pageRecord.paged)
-        {
-            nonPagedPages.push(pageRecord);
-        }
-        else if (index === 0 || page.facingPages)
-        {
-            // The first page is placed on its own
-            pagesByGroup.push([pageRecord]);
-            _addNonPagedPages();
-        }
-        else if (leftPage === null)
-        {
-            leftPage = pageRecord;
-        }
-        else
-        {
-            pagesByGroup.push([leftPage, pageRecord]);
-            leftPage = null;
-            _addNonPagedPages();
-        }
-    });
-
-    // Flush a final left page
-    if (leftPage !== null)
-    {
-        pagesByGroup.push([leftPage]);
-        _addNonPagedPages();
-    }
-
-    return pagesByGroup;
-}
-
-function getGroupLayoutsFromPageGrouping(viewerConfig, grouping)
-{
-    const verticallyOriented = viewerConfig.verticallyOriented;
-
-    if (grouping.length === 2)
-        return getFacingPageGroup(grouping[0], grouping[1], verticallyOriented);
-
-    const page = grouping[0];
-    const pageDims = page.dimensions;
-
-    // The first page is placed on its own to the right in vertical orientation.
-    // NB that this needs to be the page with index 0; if the first page is excluded
-    // from the layout then this special case shouldn't apply.
-    // If the page is tagged as 'non-paged', center it horizontally
-    let leftOffset;
-    if (page.paged)
-        leftOffset = (page.index === 0 && verticallyOriented) ? pageDims.width : 0;
-    else
-        leftOffset = (verticallyOriented) ? pageDims.width / 2 : 0;
-
-    const shouldBeHorizontallyAdjusted =
-        verticallyOriented && !viewerConfig.manifest.pages[page.index].facingPages;
-
-    // We need to left-align the page in vertical orientation, so we double
-    // the group width
-    return {
-        dimensions: {
-            height: pageDims.height,
-            width: shouldBeHorizontallyAdjusted ? pageDims.width * 2 : pageDims.width
-        },
-        pages: [{
-            index: page.index,
-            groupOffset: {
-                top: 0,
-                left: leftOffset
-            },
-            dimensions: pageDims
-        }]
-    };
-}
-
-function getFacingPageGroup(leftPage, rightPage, verticallyOriented)
-{
-    const leftDims = leftPage.dimensions;
-    const rightDims = rightPage.dimensions;
-
-    const height = Math.max(leftDims.height, rightDims.height);
-
-    let width, firstLeftOffset, secondLeftOffset;
-
-    if (verticallyOriented)
-    {
-        const midWidth = Math.max(leftDims.width, rightDims.width);
-
-        width = midWidth * 2;
-
-        firstLeftOffset = midWidth - leftDims.width;
-        secondLeftOffset = midWidth;
-    }
-    else
-    {
-        width = leftDims.width + rightDims.width;
-        firstLeftOffset = 0;
-        secondLeftOffset = leftDims.width;
-    }
-
-    return {
-        dimensions: {
-            height: height,
-            width: width
-        },
-        pages: [
-            {
-                index: leftPage.index,
-                dimensions: leftDims,
-                groupOffset: {
-                    top: 0,
-                    left: firstLeftOffset
-                }
-            },
-            {
-                index: rightPage.index,
-                dimensions: rightDims,
-                groupOffset: {
-                    top: 0,
-                    left: secondLeftOffset
-                }
-            }
-        ]
-    };
-}

package/source/js/page-layouts/grid-layout.js

@@ -1,97 +0,0 @@
-
-export default function getGridLayoutGroups (viewerConfig)
-{
-    const viewportWidth = viewerConfig.viewport.width;
-    const manifest = viewerConfig.manifest;
-    const pagesPerRow = viewerConfig.pagesPerRow;
-    const fixedHeightGrid = viewerConfig.fixedHeightGrid;
-    const fixedPadding = viewerConfig.fixedPadding;
-    const showNonPagedPages = viewerConfig.showNonPagedPages;
-
-    const horizontalPadding = fixedPadding * (pagesPerRow + 1);
-    const pageWidth = (viewportWidth - horizontalPadding) / pagesPerRow;
-    const gridPageWidth = pageWidth;
-
-    // Calculate the row height depending on whether we want to fix the width or the height
-    const rowHeight = (fixedHeightGrid) ? fixedPadding + manifest.minRatio * pageWidth : fixedPadding + manifest.maxRatio * pageWidth;
-
-    const groups = [];
-    let currentPages = [];
-
-    const getGridPageDimensions = pageData =>
-    {
-        // Calculate the width, height and horizontal placement of this page
-        // Get dimensions at max zoom level, although any level should be fine
-        const pageDimenData = pageData.d[pageData.d.length - 1];
-        const heightToWidthRatio = pageDimenData.h / pageDimenData.w;
-
-        let pageWidth, pageHeight;
-
-        if (fixedHeightGrid)
-        {
-            pageWidth = (rowHeight - fixedPadding) / heightToWidthRatio;
-            pageHeight = rowHeight - fixedPadding;
-        }
-        else
-        {
-            pageWidth = gridPageWidth;
-            pageHeight = pageWidth * heightToWidthRatio;
-        }
-
-        return {
-            width: Math.round(pageWidth),
-            height: Math.round(pageHeight)
-        };
-    };
-
-    const rowDimensions = {
-        height: rowHeight,
-        width: viewportWidth
-    };
-
-    manifest.pages.forEach( (page, pageIndex) =>
-    {
-        if (!showNonPagedPages && manifest.paged && !page.paged)
-            return;
-
-        // Calculate the width, height and horizontal placement of this page
-        const pageDimens = getGridPageDimensions(page);
-        let leftOffset = Math.floor(currentPages.length * (fixedPadding + gridPageWidth) + fixedPadding);
-
-        // Center the page if the height is fixed (otherwise, there is no horizontal padding)
-        if (fixedHeightGrid)
-        {
-            leftOffset += (gridPageWidth - pageDimens.width) / 2;
-        }
-
-        // TODO: Precompute page dimensions everywhere
-        currentPages.push({
-            index: pageIndex,
-            dimensions: pageDimens,
-            groupOffset: {
-                top: 0,
-                left: leftOffset
-            }
-        });
-
-        if (currentPages.length === pagesPerRow)
-        {
-            groups.push({
-                dimensions: rowDimensions,
-                pages: currentPages
-            });
-
-            currentPages = [];
-        }
-    });
-
-    if (currentPages.length > 0)
-    {
-        groups.push({
-            dimensions: rowDimensions,
-            pages: currentPages
-        });
-    }
-
-    return groups;
-}

package/source/js/page-layouts/index.js

@@ -1,38 +0,0 @@
-import getBookLayoutGroups from './book-layout';
-import getSinglesLayoutGroups from './singles-layout';
-import getGridLayoutGroups from './grid-layout';
-
-/** Get the relative positioning of pages for the current view */
-export default function getPageLayouts (settings)
-{
-    if (settings.inGrid)
-    {
-        return getGridLayoutGroups(pluck(settings, [
-            'manifest',
-            'viewport',
-            'pagesPerRow',
-            'fixedHeightGrid',
-            'fixedPadding',
-            'showNonPagedPages'
-        ]));
-    }
-    else
-    {
-        const config = pluck(settings, ['manifest', 'verticallyOriented', 'showNonPagedPages']);
-
-        if (settings.inBookLayout)
-            return getBookLayoutGroups(config);
-        else
-            return getSinglesLayoutGroups(config);
-    }
-}
-
-function pluck (obj, keys)
-{
-    const out = {};
-    keys.forEach(function (key)
-    {
-        out[key] = obj[key];
-    });
-    return out;
-}

package/source/js/page-layouts/page-dimensions.js

@@ -1,9 +0,0 @@
-export default function getPageDimensions (pageIndex, manifest)
-{
-    const dims = manifest.getMaxPageDimensions(pageIndex);
-
-    return {
-        width: Math.floor(dims.width),
-        height: Math.floor(dims.height)
-    };
-}

package/source/js/page-layouts/singles-layout.js

@@ -1,27 +0,0 @@
-import getPageDimensions from './page-dimensions';
-
-export default function getSinglesLayoutGroups (viewerConfig)
-{
-    const manifest = viewerConfig.manifest;
-
-    // Render each page alone in a group
-    const pages = [];
-    manifest.pages.forEach( (page, index) =>
-    {
-        if (!viewerConfig.showNonPagedPages && manifest.paged && !page.paged)
-            return;
-
-        const pageDims = getPageDimensions(index, manifest);
-
-        pages.push({
-            dimensions: pageDims,
-            pages: [{
-                index: index,
-                groupOffset: { top: 0, left: 0 },
-                dimensions: pageDims
-            }]
-        });
-    });
-
-    return pages;
-}

package/source/js/page-overlay-manager.js

@@ -1,102 +0,0 @@
-/**
- * Manages a collection of page overlays, which implement a low-level
- * API for synchronizing HTML pages to the canvas. Each overlay needs
- * to implement the following protocol:
- *
- *   mount(): Called when a page is first rendered
- *   refresh(): Called when a page is moved
- *   unmount(): Called when a previously rendered page has stopped being rendered
- *
- * @class
- */
-
-export default class PageOverlayManager
-{
-    constructor ()
-    {
-        this._pages = {};
-        this._renderedPages = [];
-        this._renderedPageMap = {};
-    }
-
-    addOverlay (overlay)
-    {
-        const overlaysByPage = this._pages[overlay.page] || (this._pages[overlay.page] = []);
-
-        overlaysByPage.push(overlay);
-
-        if (this._renderedPageMap[overlay.page])
-            overlay.mount();
-    }
-
-    removeOverlay (overlay)
-    {
-        const page = overlay.page;
-        const overlaysByPage = this._pages[page];
-
-        if (!overlaysByPage)
-            return;
-
-        const overlayIndex = overlaysByPage.indexOf(overlay);
-
-        if (overlayIndex === -1)
-            return;
-
-        if (this._renderedPageMap[page])
-            overlaysByPage[overlayIndex].unmount();
-
-        overlaysByPage.splice(overlayIndex, 1);
-
-        if (overlaysByPage.length === 0)
-            delete this._pages[page];
-    }
-
-    updateOverlays (renderedPages)
-    {
-        const previouslyRendered = this._renderedPages;
-        const newRenderedMap = {};
-
-        renderedPages.map( (pageIndex) =>
-        {
-            newRenderedMap[pageIndex] = true;
-
-            if (!this._renderedPageMap[pageIndex])
-            {
-                this._renderedPageMap[pageIndex] = true;
-
-                this._invokeOnOverlays(pageIndex, overlay =>
-                {
-                    overlay.mount();
-                });
-            }
-        });
-
-        previouslyRendered.map( (pageIndex) =>
-        {
-            if (newRenderedMap[pageIndex])
-            {
-                this._invokeOnOverlays(pageIndex, (overlay) =>
-                {
-                    overlay.refresh();
-                });
-            }
-            else
-            {
-                delete this._renderedPageMap[pageIndex];
-                this._invokeOnOverlays(pageIndex, overlay =>
-                {
-                    overlay.unmount();
-                });
-            }
-        });
-
-        this._renderedPages = renderedPages;
-    }
-
-    _invokeOnOverlays (pageIndex, func)
-    {
-        const overlays = this._pages[pageIndex];
-        if (overlays)
-            overlays.map( (o) => func(o) );
-    }
-}

package/source/js/page-tools-overlay.js

@@ -1,95 +0,0 @@
-import { elt } from './utils/elt';
-/**
-*
-*
-**/
-export default class PageToolsOverlay
-{
-    constructor (pageIndex, viewerCore)
-    {
-        this.page = pageIndex;
-
-        this._viewerCore = viewerCore;
-
-        this._innerElement = this._viewerCore.getSettings().innerElement;
-        this._pageToolsElem = null;
-        this.labelWidth = 0;
-    }
-
-    mount ()
-    {
-        if (this._pageToolsElem === null)
-        {
-            this._buttons = this._initializePageToolButtons();
-
-            this._pageToolsElem = elt('div', { class: 'diva-page-tools-wrapper' },
-                elt('div', { class: 'diva-page-tools' }, this._buttons)
-            );
-
-            this._pageLabelsElem = elt('div', { class: 'diva-page-labels-wrapper'},
-                elt('div', { class: 'diva-page-labels' }, this._viewerCore.settings.manifest.pages[this.page].l)
-            );
-        }
-
-        this.refresh();
-        this._innerElement.appendChild(this._pageToolsElem);
-        this._innerElement.appendChild(this._pageLabelsElem);
-    }
-
-    _initializePageToolButtons ()
-    {
-        // Callback parameters
-        const settings = this._viewerCore.getSettings();
-        const publicInstance = this._viewerCore.getPublicInstance();
-        const pageIndex = this.page;
-
-        return this._viewerCore.getPageTools().map( (plugin) =>
-        {
-            // !!! The node needs to be cloned otherwise it is detached from
-            //  one and reattached to the other.
-            const button = plugin.pageToolsIcon.cloneNode(true);
-
-            // ensure the plugin instance is handed as the first argument to call;
-            // this will set the context (i.e., `this`) of the handleClick call to the plugin instance
-            // itself.
-            button.addEventListener('click', (event) =>
-            {
-                plugin.handleClick.call(plugin, event, settings, publicInstance, pageIndex);
-            }, false);
-
-            button.addEventListener('touchend', (event) =>
-            {
-                // Prevent firing of emulated mouse events
-                event.preventDefault();
-
-                plugin.handleClick.call(plugin, event, settings, publicInstance, pageIndex);
-            }, false);
-
-            return button;
-
-        });
-    }
-
-    unmount ()
-    {
-        this._innerElement.removeChild(this._pageToolsElem);
-        this._innerElement.removeChild(this._pageLabelsElem);
-    }
-
-    refresh ()
-    {
-        const pos = this._viewerCore.getPageRegion(this.page, {
-            includePadding: true,
-            incorporateViewport: true
-        });
-
-        // if window is resized larger, a margin is created - need to subtract this from offsets
-        let marginLeft = window.getComputedStyle(this._innerElement, null).getPropertyValue('margin-left');
-
-        this._pageToolsElem.style.top = `${pos.top}px`;
-        this._pageToolsElem.style.left = `${pos.left - parseInt(marginLeft)}px`;
-
-        this._pageLabelsElem.style.top = `${pos.top}px`;
-        this._pageLabelsElem.style.left = `${pos.right - parseInt(marginLeft) - this.labelWidth - 5}px`;
-    }
-}