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

package/es6/pdf-viewer-canvas/view-layers/ViewLayerBase.d.ts

@@ -0,0 +1,31 @@
+import { PdfViewerApi, Annotation } from '../../pdf-viewer-api';
+import { PdfViewerCanvas, PdfViewerCanvasEventMap } from '../PdfViewerCanvas';
+import { WebViewerOptions } from '../../pdf-web-viewer/WebViewerOptions';
+import { ViewerCanvasState, ViewerCanvasStore } from '../state/store';
+export interface ViewLayer {
+    resize(width: number, height: number, devicePixelRatio: number): void;
+    render(timestamp: number, viewerCanvasState: ViewerCanvasState): void;
+}
+export declare abstract class ViewLayerBase implements ViewLayer {
+    protected viewerCanvas: PdfViewerCanvas | undefined;
+    protected dispatchEvent: any;
+    protected containerElement: HTMLElement | undefined;
+    private canvasContexts;
+    private htmlLayers;
+    private pPdfViewerApi;
+    private pStore;
+    private pOptions;
+    constructor();
+    protected get pdfViewerApi(): PdfViewerApi;
+    protected get store(): ViewerCanvasStore;
+    protected get options(): WebViewerOptions;
+    resize(width: number, height: number, pixelRatio: number): void;
+    register(viewerCanvas: PdfViewerCanvas, dispatchEvent: <K extends keyof PdfViewerCanvasEventMap>(type: K, args: PdfViewerCanvasEventMap[K]) => void): void;
+    abstract create(): void;
+    abstract render(timestamp: number, state: ViewerCanvasState): void | boolean;
+    protected createHtmlLayer(): HTMLDivElement;
+    protected createCanvas(className?: string): CanvasRenderingContext2D;
+    protected removeHtmlElements(): void;
+    protected removeCanvasElements(): void;
+    protected addDeleteHistory(annotation: Annotation): void;
+}

package/es6/pdf-viewer-canvas/view-layers/ViewLayerBase.js

@@ -0,0 +1,106 @@
+import { addHistoryEntry } from '../../custom/history';
+export class ViewLayerBase {
+    constructor() {
+        this.canvasContexts = [];
+        this.htmlLayers = [];
+    }
+    get pdfViewerApi() {
+        if (!this.pPdfViewerApi) {
+            this.pPdfViewerApi = this.viewerCanvas.pdfViewerApi;
+            if (!this.pPdfViewerApi) {
+                throw new Error('pdfViewerApi in undefined');
+            }
+        }
+        return this.pPdfViewerApi;
+    }
+    get store() {
+        if (!this.pStore) {
+            this.pStore = this.viewerCanvas.store;
+            if (!this.pStore) {
+                throw new Error('pStore in undefined');
+            }
+        }
+        return this.pStore;
+    }
+    get options() {
+        if (!this.pOptions) {
+            this.pOptions = this.viewerCanvas.options;
+            if (!this.pOptions) {
+                throw new Error('options in undefined');
+            }
+        }
+        return this.pOptions;
+    }
+    resize(width, height, pixelRatio) {
+        try {
+            const tempCanvas = document.createElement('canvas');
+            tempCanvas.width = width * pixelRatio;
+            tempCanvas.height = height * pixelRatio;
+            const tempContext = tempCanvas.getContext('2d');
+            this.canvasContexts.forEach((ctx) => {
+                tempContext.drawImage(ctx.canvas, 0, 0);
+                ctx.canvas.style.width = width + 'px';
+                ctx.canvas.style.height = height + 'px';
+                ctx.canvas.width = width * pixelRatio;
+                ctx.canvas.height = height * pixelRatio;
+                ctx.drawImage(tempContext.canvas, 0, 0);
+            });
+        }
+        catch (err) {
+            console.warn(err);
+        }
+    }
+    register(viewerCanvas, dispatchEvent) {
+        this.viewerCanvas = viewerCanvas;
+        this.dispatchEvent = dispatchEvent;
+        this.containerElement = this.viewerCanvas.viewLayersElement;
+        this.create();
+    }
+    createHtmlLayer() {
+        const element = document.createElement('div');
+        this.htmlLayers.push(element);
+        if (this.containerElement) {
+            this.containerElement.appendChild(element);
+        }
+        return element;
+    }
+    createCanvas(className) {
+        const element = document.createElement('canvas');
+        element.style.position = 'absolute';
+        element.style.top = '0';
+        element.style.left = '0';
+        element.style.right = '0';
+        element.style.bottom = '0';
+        if (className) {
+            element.classList.add(className);
+        }
+        const context = element.getContext('2d');
+        this.canvasContexts.push(context);
+        if (this.containerElement) {
+            this.containerElement.appendChild(element);
+            const rect = this.containerElement.getBoundingClientRect();
+            context.canvas.width = rect.width * devicePixelRatio;
+            context.canvas.height = rect.height * devicePixelRatio;
+        }
+        return context;
+    }
+    removeHtmlElements() {
+        if (this.containerElement) {
+            for (let i = 0; i < this.htmlLayers.length; i++) {
+                this.containerElement.removeChild(this.htmlLayers[i]);
+            }
+            this.htmlLayers = [];
+        }
+    }
+    removeCanvasElements() {
+        if (this.containerElement) {
+            for (let i = 0; i < this.canvasContexts.length; i++) {
+                this.containerElement.removeChild(this.canvasContexts[i].canvas);
+            }
+            this.canvasContexts = [];
+        }
+    }
+    addDeleteHistory(annotation) {
+        addHistoryEntry(annotation, 'delete', this.options.viewer.general.user);
+    }
+}

package/es6/pdf-viewer-canvas/view-layers/canvasShapes.d.ts

@@ -0,0 +1,11 @@
+import { Rect, Point } from '../../pdf-viewer-api';
+/** internal */
+export declare const renderAnnotationSelection: (ctx: CanvasRenderingContext2D, scale: number, color: string, rect: Rect, resizable: boolean) => void;
+/** internal */
+export declare const renderTextMarker: (ctx: CanvasRenderingContext2D, scale: number, type: 'start' | 'end', color: string, rect: Rect) => void;
+/** internal */
+export declare const renderTextSelection: (ctx: CanvasRenderingContext2D, scale: number, color: string, selection: Point[][]) => void;
+/** internal */
+export declare const renderPopupMarker: (ctx: CanvasRenderingContext2D, scale: number, color: string, pos: Point) => void;
+/** internal */
+export declare const renderStickyNote: (ctx: CanvasRenderingContext2D, scale: number, rect: Rect, fillColor: string, strokeColor: string) => void;

package/es6/pdf-viewer-canvas/view-layers/canvasShapes.js

@@ -0,0 +1,149 @@
+/** internal */
+/* tslint:disable-next-line */
+export const renderAnnotationSelection = (ctx, scale, color, rect, resizable) => {
+    const handle = 10 * scale;
+    const handleOffset = handle / 2;
+    const padding = 4 * scale;
+    const x = rect.x - padding;
+    const y = rect.y - padding;
+    const w = rect.w + 2 * padding;
+    const h = rect.h + 2 * padding;
+    ctx.lineWidth = 2 * scale;
+    ctx.strokeStyle = color;
+    ctx.fillStyle = color;
+    if (resizable) {
+        const x1 = x - handleOffset;
+        const x2 = x1 + w;
+        const y1 = y - handleOffset;
+        const y2 = y1 + h;
+        ctx.fillRect(x1, y1, handle, handle);
+        ctx.fillRect(x1, y2, handle, handle);
+        ctx.fillRect(x2, y1, handle, handle);
+        ctx.fillRect(x2, y2, handle, handle);
+    }
+    ctx.strokeRect(x, y, w, h);
+};
+/** internal */
+export const renderTextMarker = (ctx, scale, type, color, rect) => {
+    ctx.save();
+    const startType = type === 'start';
+    const lineWidth = 2 * scale;
+    const p = 3 * scale;
+    const x = startType ? rect.x - lineWidth / 2 : rect.x + rect.w + lineWidth / 2;
+    const y1 = startType ? rect.y - p : rect.y + rect.h + p;
+    const y2 = startType ? rect.y + rect.h : rect.y;
+    ctx.strokeStyle = color;
+    ctx.fillStyle = color;
+    ctx.lineWidth = lineWidth;
+    ctx.globalAlpha = 0.8;
+    ctx.beginPath();
+    ctx.moveTo(x, y1);
+    ctx.lineTo(x, y2);
+    ctx.closePath();
+    ctx.stroke();
+    ctx.restore();
+};
+/** internal */
+export const renderTextSelection = (ctx, scale, color, selection) => {
+    ctx.save();
+    ctx.globalCompositeOperation = 'multiply';
+    ctx.globalAlpha = 0.3;
+    ctx.fillStyle = color;
+    if (selection.length) {
+        ctx.beginPath();
+        for (let i = 0; i < selection.length; i++) {
+            const path = selection[i];
+            for (let k = 0; k < path.length; k++) {
+                const point = path[k];
+                if (k === 0) {
+                    ctx.moveTo(point.x, point.y);
+                }
+                else {
+                    ctx.lineTo(point.x, point.y);
+                }
+            }
+        }
+        ctx.closePath();
+        ctx.fill();
+    }
+    ctx.restore();
+};
+/** internal */
+export const renderPopupMarker = (ctx, scale, color, pos) => {
+    const posX = pos.x;
+    const posY = pos.y;
+    ctx.beginPath();
+    ctx.moveTo(posX - 5 * scale, posY - 5 * scale);
+    ctx.lineTo(posX + 6 * scale, posY - 5 * scale);
+    ctx.lineTo(posX + 6 * scale, posY + 3 * scale);
+    ctx.lineTo(posX + 3 * scale, posY + 3 * scale);
+    ctx.lineTo(posX, posY + 6 * scale);
+    ctx.lineTo(posX - 3 * scale, posY + 3 * scale);
+    ctx.lineTo(posX - 5 * scale, posY + 3 * scale);
+    ctx.closePath();
+    ctx.stroke();
+    ctx.globalAlpha = 0.5;
+    ctx.fillStyle = color;
+    ctx.fill();
+    ctx.globalAlpha = 1;
+};
+/** internal */
+export const renderStickyNote = (ctx, scale, rect, fillColor, strokeColor) => {
+    const w = rect.w;
+    const h1 = rect.h * 0.8;
+    const h2 = rect.h;
+    const r = rect.w / 6;
+    const s = rect.w / 10;
+    const x1 = rect.x;
+    const y1 = rect.y;
+    const x1r = x1 + r;
+    const y1r = y1 + r;
+    const x2 = x1 + w;
+    const y2 = y1 + h1;
+    const x2r = x2 - r;
+    const y2r = y2 - r;
+    const xs1 = x1r + r;
+    const xs2 = xs1 + r;
+    const xs3 = x1r + s;
+    const ys3 = y1 + h2;
+    ctx.beginPath();
+    ctx.moveTo(x1r, y1);
+    ctx.lineTo(x2r, y1);
+    ctx.arcTo(x2, y1, x2, y1r, r);
+    ctx.lineTo(x2, y2r);
+    ctx.arcTo(x2, y2, x2r, y2, r);
+    ctx.lineTo(xs2, y2);
+    ctx.lineTo(xs3, ys3);
+    ctx.lineTo(xs1, y2);
+    ctx.lineTo(x1r, y2);
+    ctx.arcTo(x1, y2, x1, y2r, r);
+    ctx.lineTo(x1, y1r);
+    ctx.arcTo(x1, y1, x1r, y1, r);
+    ctx.closePath();
+    ctx.lineWidth = 0.75 * scale;
+    ctx.fillStyle = fillColor;
+    ctx.strokeStyle = strokeColor;
+    ctx.fill();
+    ctx.stroke();
+    const x1l = x1r + 1 * scale;
+    const x2l = x2r - 1 * scale;
+    const x3l = x2r - r;
+    const y1l = y1r + 1 * scale;
+    const y3l = y2r - 1 * scale;
+    const y2l = y1l + (y3l - y1l) / 2;
+    ctx.beginPath();
+    ctx.moveTo(x1l, y1l);
+    ctx.lineTo(x2l, y1l);
+    ctx.closePath();
+    ctx.stroke();
+    ctx.beginPath();
+    ctx.moveTo(x1l, y2l);
+    ctx.lineTo(x2l, y2l);
+    ctx.closePath();
+    ctx.stroke();
+    ctx.beginPath();
+    ctx.moveTo(x1l, y3l);
+    ctx.lineTo(x3l, y3l);
+    ctx.closePath();
+    ctx.stroke();
+};

package/es6/pdf-viewer-canvas/view-layers/canvasUtlis.d.ts

@@ -0,0 +1,3 @@
+import { Point, Rect } from '../../pdf-viewer-api';
+/** internal */
+export declare const pointInRect: (p: Point, rect: Rect, padding?: number) => boolean;

package/es6/pdf-viewer-canvas/view-layers/canvasUtlis.js

@@ -0,0 +1,10 @@
+/** internal */
+export const pointInRect = (p, rect, padding) => {
+    if (padding) {
+        rect.x -= padding;
+        rect.y -= padding;
+        rect.w += 2 * padding;
+        rect.h += 2 * padding;
+    }
+    return p.x >= rect.x && p.x <= rect.x + rect.w && p.y >= rect.y && p.y <= rect.y + rect.h;
+};

package/es6/pdf-viewer-canvas/view-layers/views/AnnotationBorder.d.ts

@@ -0,0 +1,52 @@
+import { Rect, Point, Annotation } from '../../../pdf-viewer-api';
+import { WebViewerOptions } from '../../../pdf-web-viewer/WebViewerOptions';
+import { ViewerCanvasStore } from 'pdf-viewer-canvas/state/store';
+/** internal */
+export declare const MIN_SIZE = 10;
+/** internal */
+export declare class AnnotationBorder {
+    private annotationId;
+    private movable;
+    private resizable;
+    private aspectRatio;
+    private pageRect;
+    private options;
+    private store;
+    private isViewOnly;
+    private element;
+    private border;
+    private dragElement;
+    private dragHandler;
+    private resizeElementNw;
+    private resizeElementNe;
+    private resizeElementSw;
+    private resizeElementSe;
+    private resizeHandlerNw;
+    private resizeHandlerNe;
+    private resizeHandlerSw;
+    private resizeHandlerSe;
+    private dragOffsetX;
+    private dragOffsetY;
+    private containerOffsetX;
+    private containerOffsetY;
+    private onMoved;
+    private onResized;
+    private onDblClick;
+    private resizeDir;
+    private minSize;
+    constructor(element: HTMLElement, onMoved: (id: number, newPosition: Point) => void, onResized: (id: number, newRect: Rect) => void, onDblClick: (id: number) => void, options: WebViewerOptions, store: ViewerCanvasStore, isViewOnly: boolean);
+    setAnnotation(annotation: Annotation, pageRect: Rect): void;
+    deselectAnnotation(): void;
+    updatePageRect(pageRect: Rect): void;
+    private click;
+    private dblClick;
+    private startResize;
+    private resizing;
+    private updateMinSize;
+    private resizeNoAspectRatio;
+    private resizeWithAspectRatio;
+    private endResize;
+    private startMove;
+    private moving;
+    private endMove;
+}