@pdftools/four-heights-pdf-web-viewer 4.3.6

package/es6/modules/popup/PopupLayer.js

@@ -0,0 +1,509 @@
+import { CanvasLayer } from '../CanvasLayer';
+import { createPopupView } from './Popup';
+import { getPopups, getOpenPopups } from '../../pdf-viewer-canvas/state/annotations';
+import { PdfItemType, } from '../../pdf-viewer-api';
+import { renderPopupMarker } from '../../pdf-viewer-canvas/view-layers/canvasShapes';
+import { ViewerMode, CursorStyle } from '../../pdf-viewer-canvas/state/viewer';
+import { Color } from '../../common/Color';
+import { getColorPalette } from '../../common/Tools';
+import { addHistoryEntry } from '../../custom/history';
+export class PopupLayer extends CanvasLayer {
+    constructor() {
+        super(...arguments);
+        this.popupView = null;
+        this.context = null;
+        this.maxPopupWidth = window.screen.availWidth < 570 ? 280 : 480;
+        this.maxPopupHeight = 320;
+        this.minPopupWidth = 260;
+        this.minPopupHeight = 200;
+        this.zoom = 0;
+        this.screenToPdfScale = 0;
+    }
+    onCreate() {
+        this.drawPopupRelation = this.drawPopupRelation.bind(this);
+        this.popupMoved = this.popupMoved.bind(this);
+        this.selectPopup = this.selectPopup.bind(this);
+        this.deselectPopup = this.deselectPopup.bind(this);
+        this.openPopup = this.openPopup.bind(this);
+        this.closePopup = this.closePopup.bind(this);
+        this.deletePopup = this.deletePopup.bind(this);
+        this.toggleAnnotationLock = this.toggleAnnotationLock.bind(this);
+        this.updateSelectedPopupContent = this.updateSelectedPopupContent.bind(this);
+        this.updatePopupPosition = this.updatePopupPosition.bind(this);
+        this.updatePopupSize = this.updatePopupSize.bind(this);
+        this.updatePopupColor = this.updatePopupColor.bind(this);
+        this.context = this.createCanvas();
+        this.createPopupView();
+        window.addEventListener('pdfwebviewer.PopupMoved', this.popupMoved, false);
+    }
+    onRemove() { }
+    onSave() {
+        const promise = new Promise((resolve, reject) => {
+            if (this.popupView) {
+                const state = this.popupView.getState();
+                if (state.stateChanged) {
+                    this.updateSelectedPopupContent(true).then(() => {
+                        resolve();
+                    });
+                }
+                else {
+                    resolve();
+                }
+            }
+        });
+        return promise;
+    }
+    render(timestamp, state) {
+        if (this.pdfApi && this.popupView && this.popupViewElement) {
+            if (state.document.zoomChanged && state.document.zoom !== this.zoom) {
+                this.zoom = state.document.zoom;
+                this.screenToPdfScale = this.pdfApi.transformPdfLengthToScreenLength(100) / 100 / this.zoom;
+            }
+            /* tslint:disable-next-line:max-line-length */
+            if (state.annotations.openPopupChanged ||
+                state.document.firstVisiblePageChanged ||
+                state.document.lastVisiblePageChanged ||
+                state.viewer.modeChanged) {
+                this.updateOpenPopupList(state);
+            }
+            if (state.viewer.popupFocus) {
+                this.popupView.setFocus(state.viewer.popupFocus);
+            }
+            if (this.popupView.getState().clearFocus) {
+                this.store.viewer.clearPopupFocus();
+            }
+            if (state.viewer.selectedPopupChanged) {
+                const selectedPopup = this.popupView.getState().selectedPopup;
+                if (state.viewer.selectedPopupId) {
+                    if (selectedPopup !== state.viewer.selectedPopupId) {
+                        this.popupView.selectPopup(state.viewer.selectedPopupId);
+                    }
+                }
+            }
+            const viewerMode = state.viewer.mode;
+            if (viewerMode === ViewerMode.POPUP_SELECTED) {
+                this.store.viewer.setCursorStyle(CursorStyle.DEFAULT);
+            }
+            const { openPopups, selectedPopup } = this.popupView.getState();
+            const popupsVisible = viewerMode === ViewerMode.DEFAULT || viewerMode === ViewerMode.POPUP_SELECTED;
+            if (state.viewer.modeChanged) {
+                if (popupsVisible) {
+                    this.popupViewElement.style.display = 'block';
+                }
+                else {
+                    this.popupViewElement.style.display = 'none';
+                    const ctx = this.context;
+                    ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+                    if (selectedPopup && state.pointer.action !== 'click') {
+                        this.updateSelectedPopupContent(true);
+                    }
+                }
+            }
+            if (viewerMode === ViewerMode.POPUP_SELECTED && state.pointer.action === 'click') {
+                this.deselectPopup();
+            }
+            const updatePopupPosition = state.canvas.canvasInvalidated || openPopups.find((p) => !p.positionCalculated);
+            if (openPopups.length > 0 && updatePopupPosition) {
+                const popupElements = this.popupViewElement.querySelectorAll('.pwv-popup');
+                const canvasWidth = state.canvas.width.cssPixels;
+                const canvasHeight = state.canvas.height.cssPixels;
+                const zoom = state.document.zoom;
+                for (let i = 0; i < popupElements.length; i++) {
+                    const popupElement = popupElements[i];
+                    if (!popupElement.classList.contains('pwv-popup-moving')) {
+                        const id = popupElement.dataset.id;
+                        const popup = openPopups.find((p) => p.id.toString() === id);
+                        if (popup) {
+                            const screenRect = this.pdfApi.transformPdfPageRectToScreenRect(popup.pdfRect);
+                            let x = screenRect.x / devicePixelRatio;
+                            let y = screenRect.y / devicePixelRatio;
+                            const w = parseInt(popupElement.style.width, undefined);
+                            const h = parseInt(popupElement.style.height, undefined);
+                            const padding = 8;
+                            if (x < padding) {
+                                x = padding;
+                            }
+                            else if (x + w + padding * 2 > canvasWidth) {
+                                x = canvasWidth - (w + padding * 2);
+                            }
+                            if (y < padding) {
+                                y = padding;
+                            }
+                            else if (y + h + padding * 2 > canvasHeight) {
+                                y = canvasHeight - (h + padding * 2);
+                            }
+                            popupElement.style.top = `${y}px`;
+                            popupElement.style.left = `${x}px`;
+                            if (!popup.positionCalculated) {
+                                this.popupView.setPositionCalculated(popup.id);
+                            }
+                        }
+                    }
+                }
+            }
+            if ((state.viewer.mode === ViewerMode.POPUP_SELECTED ||
+                state.viewer.mode === ViewerMode.DEFAULT) &&
+                (state.viewer.selectedPopupChanged ||
+                    state.canvas.canvasInvalidated ||
+                    state.pointer.positionChanged ||
+                    state.annotations.openPopupChanged)) {
+                const ctx = this.context;
+                ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+                const scale = state.canvas.pixelRatio * state.document.zoom;
+                if (viewerMode !== ViewerMode.POPUP_SELECTED) {
+                    const popups = getPopups(state.annotations, state.document.firstVisiblePage, state.document.lastVisiblePage);
+                    if (popups === null) {
+                        return;
+                    }
+                    for (let i = 0; i < popups.length; i++) {
+                        const popup = popups[i];
+                        if (popup.itemType !== PdfItemType.TEXT) {
+                            let pos;
+                            pos = this.pdfApi.transformPdfPageRectToScreenRect(popup.pdfRect);
+                            ctx.lineWidth = 1;
+                            ctx.beginPath();
+                            const r = 12 * scale;
+                            const posX = pos.x + r / 2;
+                            const posY = pos.y - r;
+                            ctx.arc(posX, posY, r, 0, 2 * Math.PI);
+                            if (ctx.isPointInPath(state.pointer.x.devicePixels, state.pointer.y.devicePixels)) {
+                                this.store.viewer.setCursorStyle(CursorStyle.POINTER);
+                                ctx.globalAlpha = 0.15;
+                                ctx.fillStyle = this.options.viewer.general.textSelectionColor;
+                                ctx.fill();
+                                ctx.globalAlpha = 1;
+                                if (state.pointer.action === 'click') {
+                                    this.openPopup(popup.id);
+                                }
+                            }
+                            renderPopupMarker(ctx, scale, popup.color || this.options.annotation.colors.defaultHighlightColor, { x: posX, y: posY });
+                        }
+                    }
+                }
+                if (openPopups.length > 0) {
+                    const popupElements = this.popupViewElement.querySelectorAll('.pwv-popup:hover, .pwv-popup.pwv-popup-selected');
+                    for (let i = 0; i < popupElements.length; i++) {
+                        const popupElement = popupElements[i];
+                        const id = popupElement.dataset.id ? parseInt(popupElement.dataset.id, undefined) : -1;
+                        this.drawPopupRelation(ctx, id, {
+                            x: popupElement.offsetLeft,
+                            y: popupElement.offsetTop,
+                            w: popupElement.offsetWidth,
+                            h: popupElement.offsetHeight,
+                        }, popupElement.style.backgroundColor, id === state.viewer.selectedPopupId);
+                    }
+                }
+            }
+        }
+    }
+    updateOpenPopupList(state) {
+        if (this.popupView) {
+            const openPopups = getOpenPopups(state.annotations, state.document.firstVisiblePage, state.document.lastVisiblePage);
+            const zoom = state.document.zoom;
+            const popups = openPopups.map((an) => {
+                const width = this.pdfApi.transformPdfLengthToScreenLength(an.popup.pdfRect.pdfW) / zoom;
+                const height = this.pdfApi.transformPdfLengthToScreenLength(an.popup.pdfRect.pdfH) / zoom;
+                // Take last modified date, author and color
+                // from parent annotation
+                return {
+                    id: an.id,
+                    colorPalette: getColorPalette(an.itemType, this.options),
+                    content: an.content,
+                    subject: an.subject ? an.subject : null,
+                    modificationDate: an.modificationDate,
+                    author: an.author,
+                    color: an.color,
+                    itemType: an.itemType,
+                    isLocked: an.isLocked(),
+                    selected: false,
+                    positionCalculated: false,
+                    pdfRect: an.popup.pdfRect,
+                    cssWidth: width < this.maxPopupWidth ? width : this.maxPopupWidth,
+                    cssHeight: height < this.maxPopupHeight ? height : this.maxPopupHeight,
+                    behaviors: an.behaviors,
+                    isReadOnly: an.isReadOnly,
+                };
+            });
+            this.popupView.updateOpenPopups(popups);
+        }
+    }
+    drawPopupRelation(ctx, annotationId, popupRect, color, selected) {
+        const annotation = this.pdfApi.getItem(annotationId);
+        if (annotation) {
+            const annotationRect = this.pdfApi.transformPdfPageRectToScreenRect(annotation.pdfRect);
+            const popupX1 = popupRect.x * devicePixelRatio;
+            const popupX2 = popupX1 + popupRect.w * devicePixelRatio;
+            const popupXc = popupX1 + (popupRect.w / 2) * devicePixelRatio;
+            const popupY1 = popupRect.y * devicePixelRatio;
+            const popupY2 = popupY1 + popupRect.h * devicePixelRatio;
+            const popupYc = popupY1 + (popupRect.h / 2) * devicePixelRatio;
+            const annotationX1 = annotationRect.x;
+            const annotationX2 = annotationX1 + annotationRect.w;
+            const annotationY1 = annotationRect.y;
+            const annotationY2 = annotationY1 + annotationRect.h;
+            let popupRelX = popupX1;
+            let popupRelY = popupY1;
+            let annotationRelX = annotationX1;
+            let annotationRelY = annotationY1;
+            if (popupX2 <= annotationX1) {
+                popupRelX = popupX2;
+                annotationRelX = annotationX1;
+            }
+            if (popupX1 >= annotationX2) {
+                popupRelX = popupX1;
+                annotationRelX = annotationX2;
+            }
+            if (popupY2 <= annotationY1) {
+                popupRelY = popupY2;
+                annotationRelY = annotationY1;
+            }
+            if (popupY1 >= annotationY2) {
+                popupRelY = popupY1;
+                annotationRelY = annotationY2;
+            }
+            if (popupX2 >= annotationX1 && popupX1 <= annotationX2) {
+                const x = popupXc < annotationX1 ? annotationX1 : popupXc > annotationX2 ? annotationX2 : popupXc;
+                popupRelX = x;
+                annotationRelX = x;
+            }
+            if (popupY2 >= annotationY1 && popupY1 <= annotationY2) {
+                const y = popupYc < annotationY1 ? annotationY1 : popupYc > annotationY2 ? annotationY2 : popupYc;
+                popupRelY = y;
+                annotationRelY = y;
+            }
+            ctx.save();
+            if (!(popupRelX === 0 && popupRelY === 0)) {
+                if (color) {
+                    const rgbColor = new Color(color);
+                    rgbColor.darken(20);
+                    if (!selected) {
+                        rgbColor.setOpacity(0.8);
+                    }
+                    ctx.strokeStyle = rgbColor.toRgba();
+                    ctx.fillStyle = rgbColor.toRgba();
+                }
+                ctx.lineWidth = 2 * window.devicePixelRatio;
+                if (!selected) {
+                    ctx.setLineDash([ctx.lineWidth]);
+                }
+                ctx.beginPath();
+                ctx.moveTo(annotationRelX, annotationRelY);
+                ctx.lineTo(popupRelX, popupRelY);
+                ctx.stroke();
+                ctx.strokeRect(annotationX1, annotationY1, annotationRect.w, annotationRect.h);
+                ctx.restore();
+            }
+        }
+        ctx.restore();
+    }
+    popupMoved(event) {
+        if (this.context !== null && event.detail) {
+            this.context.clearRect(0, 0, this.context.canvas.width, this.context.canvas.height);
+            this.drawPopupRelation(this.context, event.detail.annotationId, event.detail.popupRect, event.detail.color, true);
+        }
+    }
+    createPopupView() {
+        if (this.containerElement) {
+            this.popupViewElement = this.createHtmlLayer();
+            this.popupView = createPopupView({
+                maxPopupWidth: this.maxPopupWidth,
+                maxPopupHeight: this.maxPopupHeight,
+                minPopupWidth: this.minPopupWidth,
+                minPopupHeight: this.minPopupHeight,
+                currentUser: this.options.viewer.general.user ? this.options.viewer.general.user : '',
+                hideSubject: this.options.annotation.hideAnnotationSubject || false,
+                allowLockAnnotations: this.options.viewer.permissions.allowLockAnnotations,
+                allowEditLockedAnnotations: this.options.viewer.permissions.allowEditLockedAnnotations,
+                onSelect: this.selectPopup,
+                onClose: this.closePopup,
+                onDelete: this.deletePopup,
+                onUpdatePosition: this.updatePopupPosition,
+                onUpdateSize: this.updatePopupSize,
+                onUpdateColor: this.updatePopupColor,
+                onLock: this.toggleAnnotationLock,
+            }, this.popupViewElement);
+        }
+    }
+    selectPopup(id) {
+        if (this.popupView) {
+            if (this.popupView.getState().selectedPopup !== null) {
+                this.updateSelectedPopupContent(true);
+            }
+            this.popupView.selectPopup(id);
+            this.store.viewer.selectPopup({ id, focus: false });
+        }
+    }
+    deselectPopup() {
+        if (this.popupView) {
+            this.updateSelectedPopupContent(true);
+            this.popupView.deselectPopup();
+            this.store.viewer.selectPopup({ id: null, focus: false });
+        }
+    }
+    openPopup(id) {
+        if (this.pdfApi) {
+            const annotation = this.pdfApi.getItem(id);
+            if (annotation) {
+                annotation.popup.isOpen = true;
+                this.store.annotations.updateAnnotation(annotation);
+                if (this.pdfViewerCanvas.licenseFeatures.annotate) {
+                    this.pdfApi.updateItem(annotation).then(() => {
+                        this.selectPopup(annotation.id);
+                    });
+                }
+                else {
+                    this.selectPopup(annotation.id);
+                }
+            }
+        }
+    }
+    closePopup() {
+        this.updateSelectedPopupContent(false).then((annot) => {
+            this.store.viewer.deselectPopup();
+            if (this.pdfApi) {
+                if (annot) {
+                    annot.popup.isOpen = false;
+                    this.store.annotations.updateAnnotation(annot);
+                    if (this.pdfViewerCanvas.licenseFeatures.annotate) {
+                        this.pdfApi.updateItem(annot);
+                    }
+                }
+            }
+        });
+    }
+    deletePopup(id) {
+        if (this.pdfApi) {
+            if (this.popupView) {
+                this.popupView.deselectPopup();
+            }
+            this.store.viewer.selectPopup({ id: null, focus: false });
+            const annotation = this.pdfApi.getItem(id);
+            if (annotation) {
+                annotation.content = '';
+                annotation.subject = '';
+                annotation.popup.isOpen = false;
+                this.store.annotations.updateAnnotation(annotation);
+                if (this.pdfViewerCanvas.licenseFeatures.annotate) {
+                    this.pdfApi.updateItem(annotation);
+                }
+            }
+        }
+    }
+    toggleAnnotationLock(id) {
+        if (this.pdfApi) {
+            this.updateSelectedPopupContent(false).then((annotation) => {
+                if (annotation) {
+                    if (this.options.annotation.trackHistory) {
+                        addHistoryEntry(annotation, 'lock', this.options.viewer.general.user);
+                    }
+                    annotation.setLock(!annotation.isLocked());
+                    this.store.annotations.updateAnnotation(annotation);
+                    if (this.pdfViewerCanvas.licenseFeatures.annotate) {
+                        this.pdfApi.updateItem(annotation);
+                    }
+                }
+            });
+        }
+    }
+    updateSelectedPopupContent(syncronize, annotation) {
+        const promise = new Promise((resolve, reject) => {
+            var _a;
+            if (this.pdfApi) {
+                if (this.popupView) {
+                    const state = this.popupView.getState();
+                    const id = state.selectedPopup;
+                    if (id) {
+                        if (!annotation) {
+                            annotation = this.pdfApi.getItem(id);
+                        }
+                        const content = state.activeContent;
+                        const subject = state.activeSubject;
+                        if (this.options.annotation.trackHistory) {
+                            addHistoryEntry(annotation, 'edit', this.options.viewer.general.user, content, subject);
+                        }
+                        annotation.content = content !== null ? content : annotation.content;
+                        annotation.subject = subject !== null ? subject : annotation.subject;
+                        if (((_a = this.pdfViewerCanvas) === null || _a === void 0 ? void 0 : _a.licenseFeatures.annotate) && syncronize) {
+                            this.pdfApi
+                                .updateItem(annotation)
+                                .then(() => {
+                                if (this.popupView) {
+                                    this.popupView.stateChanged(false);
+                                }
+                                resolve();
+                            })
+                                .catch(() => {
+                                reject();
+                            });
+                        }
+                        else {
+                            resolve(annotation);
+                        }
+                    }
+                }
+            }
+            resolve(null);
+        });
+        return promise;
+    }
+    updatePopupPosition(id, x, y) {
+        if (this.pdfApi) {
+            const annotation = this.pdfApi.getItem(id);
+            if (annotation) {
+                const newPdfPos = this.pdfApi.transformScreenPointToPdfPoint({
+                    x: x * window.devicePixelRatio,
+                    y: y * window.devicePixelRatio,
+                }, annotation.pdfRect.page).pdfPoint;
+                if (annotation.popup.pdfRect.pdfX !== newPdfPos.pdfX ||
+                    annotation.popup.pdfRect.pdfY !== newPdfPos.pdfY) {
+                    annotation.popup.pdfRect.pdfX = newPdfPos.pdfX;
+                    annotation.popup.pdfRect.pdfY = newPdfPos.pdfY - annotation.popup.pdfRect.pdfH;
+                    this.store.annotations.updateAnnotation(annotation);
+                    this.updateSelectedPopupContent(true, annotation);
+                }
+            }
+        }
+    }
+    updatePopupSize(id, w, h) {
+        if (this.pdfApi) {
+            const annotation = this.pdfApi.getItem(id);
+            if (annotation) {
+                const newWidth = w / this.screenToPdfScale;
+                const newHeight = h / this.screenToPdfScale;
+                if (annotation.popup.pdfRect.pdfW !== newWidth ||
+                    annotation.popup.pdfRect.pdfH !== newHeight) {
+                    annotation.popup.pdfRect.pdfW = newWidth;
+                    annotation.popup.pdfRect.pdfH = newHeight;
+                    this.store.annotations.updateAnnotation(annotation);
+                    this.updateSelectedPopupContent(true, annotation);
+                }
+            }
+        }
+    }
+    updatePopupColor(id, color) {
+        if (this.pdfApi) {
+            const annotation = this.pdfApi.getItem(id);
+            if (annotation) {
+                if (annotation.itemType === PdfItemType.TEXT ||
+                    annotation.itemType === PdfItemType.HIGHLIGHT ||
+                    annotation.itemType === PdfItemType.SQUIGGLY ||
+                    annotation.itemType === PdfItemType.UNDERLINE ||
+                    annotation.itemType === PdfItemType.STRIKE_OUT) {
+                    ;
+                    annotation.color = color;
+                }
+                else if (annotation.itemType === PdfItemType.INK ||
+                    annotation.itemType === PdfItemType.SQUARE ||
+                    annotation.itemType === PdfItemType.CIRCLE) {
+                    const newColor = new Color(color);
+                    const currentColor = new Color(annotation.color);
+                    newColor.setOpacity(currentColor.a);
+                    annotation.color = newColor.toRgba();
+                }
+                annotation.popup.color = color;
+                this.store.annotations.updateAnnotation(annotation);
+                this.updateSelectedPopupContent(true, annotation);
+            }
+        }
+    }
+}

package/es6/modules/popup/PopupModule.d.ts

@@ -0,0 +1,16 @@
+import { CanvasModule, CanvasModuleType } from '../CanvasModule';
+export declare class PopupModule extends CanvasModule {
+    static moduleInfo: {
+        name: string;
+        moduleType: CanvasModuleType;
+        requiredFeatures: {
+            annotate: boolean;
+            fillFormFields: boolean;
+        };
+        translationKey: string;
+        icon: string;
+    };
+    constructor();
+    onRegister(): {};
+    activate(): void;
+}

package/es6/modules/popup/PopupModule.js

@@ -0,0 +1,25 @@
+import { CanvasModule, CanvasModuleType } from '../CanvasModule';
+import { PopupLayer } from './PopupLayer';
+export class PopupModule extends CanvasModule {
+    constructor() {
+        super();
+        this.name = PopupModule.moduleInfo.name;
+    }
+    onRegister() {
+        this.createCanvasLayer('popup', PopupLayer);
+        return {};
+    }
+    activate() {
+        return;
+    }
+}
+PopupModule.moduleInfo = {
+    name: 'PopupModule',
+    moduleType: CanvasModuleType.Layer,
+    requiredFeatures: {
+        annotate: false,
+        fillFormFields: false,
+    },
+    translationKey: 'a',
+    icon: 'a',
+};

package/es6/modules/print-service/PrintServiceDialog.d.ts

@@ -0,0 +1,30 @@
+export declare enum PaperFormat {
+    A4 = 0,
+    LETTER = 1
+}
+export interface PrintServiceProps {
+    pageCount: number;
+    currentPage: number;
+    print({ pages, format, includeAnnotations, }: {
+        pages: number[];
+        format?: PaperFormat;
+        includeAnnotations: boolean;
+    }): void;
+    cancel(): void;
+    parseRange(range: string): number[];
+    validateRange(range: string): boolean;
+}
+export interface PrintDialogState {
+    printPending: boolean;
+    pages: number[];
+    radio_selection: 'all' | 'current_page' | 'range';
+    selectedFormat: PaperFormat;
+    includeAnnotations: boolean;
+}
+export interface PrintDialogActions {
+    setPrintPending(printPending: boolean): void;
+    setFormat(format: number): PrintDialogState;
+    setRadioSelection(selection: string): PrintDialogState;
+    toggleIncludeAnnotations(includeAnnotations: string): PrintDialogState;
+}
+export declare const createPrintServiceDialog: (props: PrintServiceProps, element: HTMLElement) => PrintDialogActions;