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

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

@@ -0,0 +1,48 @@
+import { ViewLayerBase } from './ViewLayerBase';
+import { ViewerCanvasState } from '../state/store';
+/** internal */
+export declare class ScrollLayer extends ViewLayerBase {
+    private htmlLayerElement;
+    private horizontalScrollEnabled;
+    private horizontalScrollBar;
+    private horizontalScrollHandle;
+    private horizontalScrollBarVisible;
+    private horizontalScrollRatio;
+    private horizontalScrollBarSize;
+    private horizontalScrollHandleSize;
+    private horizontalScrollHandlePos;
+    private horizontalScrollTimer;
+    private horizontalScrollExpanded;
+    private verticalScrollEnabled;
+    private verticalScrollBar;
+    private verticalScrollHandle;
+    private verticalScrollBarVisible;
+    private verticalScrollRatio;
+    private verticalScrollBarSize;
+    private verticalScrollHandleSize;
+    private verticalScrollHandlePos;
+    private verticalScrollTimer;
+    private verticalScrollExpanded;
+    private canScrollDown;
+    private canScrollUp;
+    private canScrollRight;
+    private canScrollLeft;
+    private isTouchScrolling;
+    private recentTouchPos;
+    private touchScrollAxis;
+    private autoscrollLastTimestamp;
+    private autoscrollDist;
+    private autoscrollDistTime;
+    private autoscrollDx;
+    constructor();
+    create(): void;
+    render(timestamp: number, state: ViewerCanvasState): void;
+    private updateCanScrollVertical;
+    private updateCanScrollHorizontal;
+    private startVerticalScroll;
+    private verticalScroll;
+    private endVerticalScroll;
+    private startHorizontalScroll;
+    private horizontalScroll;
+    private endHorizontalScroll;
+}

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

@@ -0,0 +1,308 @@
+import { ViewLayerBase } from './ViewLayerBase';
+import { DragMoveHandler } from '../../common/DragMoveHandler';
+import { ViewerMode } from '../state/viewer';
+/** internal */
+export class ScrollLayer extends ViewLayerBase {
+    constructor() {
+        super();
+        this.horizontalScrollEnabled = false;
+        this.horizontalScrollBarVisible = false;
+        this.horizontalScrollRatio = 0;
+        this.horizontalScrollBarSize = 0;
+        this.horizontalScrollHandleSize = 0;
+        this.horizontalScrollHandlePos = 0;
+        this.horizontalScrollTimer = 0;
+        this.horizontalScrollExpanded = false;
+        this.verticalScrollEnabled = false;
+        this.verticalScrollBarVisible = false;
+        this.verticalScrollRatio = 0;
+        this.verticalScrollBarSize = 0;
+        this.verticalScrollHandleSize = 0;
+        this.verticalScrollHandlePos = 0;
+        this.verticalScrollTimer = 0;
+        this.verticalScrollExpanded = false;
+        this.canScrollDown = false;
+        this.canScrollUp = false;
+        this.canScrollRight = false;
+        this.canScrollLeft = false;
+        this.isTouchScrolling = false;
+        this.recentTouchPos = [];
+        this.touchScrollAxis = null;
+        this.autoscrollLastTimestamp = 0;
+        this.autoscrollDist = 0;
+        this.autoscrollDistTime = 0;
+        this.autoscrollDx = 0;
+        this.startVerticalScroll = this.startVerticalScroll.bind(this);
+        this.verticalScroll = this.verticalScroll.bind(this);
+        this.endVerticalScroll = this.endVerticalScroll.bind(this);
+        this.startHorizontalScroll = this.startHorizontalScroll.bind(this);
+        this.horizontalScroll = this.horizontalScroll.bind(this);
+        this.endHorizontalScroll = this.endHorizontalScroll.bind(this);
+        this.horizontalScrollBar = document.createElement('div');
+        this.horizontalScrollBar.style.display = 'none';
+        this.horizontalScrollBar.classList.add('pwv-horizontal-scrollbar');
+        this.horizontalScrollHandle = document.createElement('div');
+        this.horizontalScrollHandle.classList.add('pwv-scrollbar-handle');
+        this.horizontalScrollBar.appendChild(this.horizontalScrollHandle);
+        this.verticalScrollBar = document.createElement('div');
+        this.verticalScrollBar.style.display = 'none';
+        this.verticalScrollBar.classList.add('pwv-vertical-scrollbar');
+        this.verticalScrollHandle = document.createElement('div');
+        this.verticalScrollHandle.classList.add('pwv-scrollbar-handle');
+        this.verticalScrollBar.appendChild(this.verticalScrollHandle);
+        new DragMoveHandler(this.verticalScrollHandle, this.startVerticalScroll, this.verticalScroll, this.endVerticalScroll);
+        new DragMoveHandler(this.horizontalScrollHandle, this.startHorizontalScroll, this.horizontalScroll, this.endHorizontalScroll);
+    }
+    create() {
+        this.htmlLayerElement = this.createHtmlLayer();
+        this.htmlLayerElement.appendChild(this.horizontalScrollBar);
+        this.htmlLayerElement.appendChild(this.verticalScrollBar);
+    }
+    render(timestamp, state) {
+        const canvasHeight = state.canvas.height.cssPixels;
+        const documentHeight = state.document.height.cssPixels;
+        // update vertical scroll bar size & visibility
+        if (state.document.heightChanged || state.canvas.heightChanged) {
+            this.verticalScrollEnabled = documentHeight > canvasHeight;
+            if (this.verticalScrollEnabled !== this.verticalScrollBarVisible) {
+                this.verticalScrollBar.style.display = this.verticalScrollEnabled ? 'block' : 'none';
+                this.verticalScrollBarVisible = this.verticalScrollEnabled;
+            }
+            if (this.verticalScrollEnabled) {
+                this.verticalScrollBarSize = this.verticalScrollBar.clientHeight;
+                this.verticalScrollHandleSize = (this.verticalScrollBarSize * canvasHeight) / documentHeight;
+                if (this.verticalScrollHandleSize < 50) {
+                    this.verticalScrollHandleSize = 50;
+                }
+                this.verticalScrollHandle.style.height = this.verticalScrollHandleSize + 'px';
+                this.verticalScrollRatio =
+                    (this.verticalScrollBarSize - this.verticalScrollHandleSize) /
+                        (documentHeight - canvasHeight);
+            }
+            this.updateCanScrollVertical(state);
+        }
+        // update vertical scroll handle position
+        if (state.scroll.topPositionChanged) {
+            this.verticalScrollHandlePos = state.scroll.top.cssPixels * this.verticalScrollRatio;
+            this.verticalScrollHandle.style.top = this.verticalScrollHandlePos + 'px';
+            if (this.verticalScrollTimer) {
+                clearTimeout(this.verticalScrollTimer);
+            }
+            else {
+                this.verticalScrollBar.classList.add('pwv-scrollbar-scrolling');
+            }
+            this.verticalScrollTimer = window.setTimeout(() => {
+                this.verticalScrollTimer = 0;
+                this.verticalScrollBar.classList.remove('pwv-scrollbar-scrolling');
+            }, 500);
+            this.updateCanScrollVertical(state);
+        }
+        const canvasWidth = state.canvas.width.cssPixels;
+        const documentWidth = state.document.width.cssPixels;
+        // update horizontal scroll bar size & visibility
+        if (state.document.widthChanged || state.canvas.widthChanged) {
+            this.horizontalScrollEnabled = documentWidth > canvasWidth;
+            if (this.horizontalScrollEnabled !== this.horizontalScrollBarVisible) {
+                this.horizontalScrollBar.style.display = this.horizontalScrollEnabled ? 'block' : 'none';
+                this.horizontalScrollBarVisible = this.horizontalScrollEnabled;
+            }
+            if (this.horizontalScrollEnabled) {
+                this.horizontalScrollBarSize = this.horizontalScrollBar.clientWidth;
+                this.horizontalScrollHandleSize =
+                    (this.horizontalScrollBarSize * canvasWidth) / documentWidth;
+                if (this.horizontalScrollHandleSize < 50) {
+                    this.horizontalScrollHandleSize = 50;
+                }
+                this.horizontalScrollHandle.style.width = this.horizontalScrollHandleSize + 'px';
+                this.horizontalScrollRatio =
+                    (this.horizontalScrollBarSize - this.horizontalScrollHandleSize) /
+                        (documentWidth - canvasWidth);
+            }
+            this.updateCanScrollHorizontal(state);
+        }
+        // update horizontal scroll handle position
+        if (state.scroll.leftPositionChanged) {
+            this.horizontalScrollHandlePos = state.scroll.left.cssPixels * this.horizontalScrollRatio;
+            this.horizontalScrollHandle.style.left = this.horizontalScrollHandlePos + 'px';
+            if (this.horizontalScrollTimer) {
+                clearTimeout(this.horizontalScrollTimer);
+            }
+            else {
+                this.horizontalScrollBar.classList.add('pwv-scrollbar-scrolling');
+            }
+            this.horizontalScrollTimer = window.setTimeout(() => {
+                this.horizontalScrollTimer = 0;
+                this.horizontalScrollBar.classList.remove('pwv-scrollbar-scrolling');
+            }, 500);
+            this.updateCanScrollHorizontal(state);
+        }
+        if (state.pointer.positionChanged) {
+            const pointerX = state.pointer.x.cssPixels;
+            const pointerY = state.pointer.y.cssPixels;
+            const xPos = canvasWidth - 40;
+            const yPos = canvasHeight - 40;
+            if (!this.verticalScrollExpanded && pointerX > xPos && pointerY < yPos) {
+                this.verticalScrollBar.classList.add('pwv-scrollbar-hover');
+                this.verticalScrollExpanded = true;
+            }
+            else if (this.verticalScrollExpanded && (pointerX < xPos || pointerY > yPos)) {
+                this.verticalScrollBar.classList.remove('pwv-scrollbar-hover');
+                this.verticalScrollExpanded = false;
+            }
+            if (!this.horizontalScrollExpanded && pointerY > yPos && pointerX < xPos) {
+                this.horizontalScrollBar.classList.add('pwv-scrollbar-hover');
+                this.horizontalScrollExpanded = true;
+            }
+            else if (this.horizontalScrollExpanded && (pointerY < yPos || pointerX > xPos)) {
+                this.horizontalScrollBar.classList.remove('pwv-scrollbar-hover');
+                this.horizontalScrollExpanded = false;
+            }
+        }
+        // touchscroll
+        const pointer = state.pointer;
+        const touchScrollEnabled = pointer.type === 'touch' &&
+            (state.viewer.mode === ViewerMode.DEFAULT ||
+                state.viewer.mode === ViewerMode.ANNOTATION_SELECTED);
+        if (touchScrollEnabled && this.viewerCanvas) {
+            if (state.pointer.isDown) {
+                if (!this.isTouchScrolling) {
+                    this.isTouchScrolling = true;
+                    this.autoscrollDx = 0;
+                    this.touchScrollAxis = null;
+                    this.recentTouchPos = [];
+                    this.recentTouchPos.unshift({
+                        x: pointer.x.cssPixels,
+                        y: pointer.y.cssPixels,
+                        time: timestamp,
+                    });
+                }
+                else if (pointer.positionChanged) {
+                    this.recentTouchPos.unshift({
+                        x: pointer.x.cssPixels,
+                        y: pointer.y.cssPixels,
+                        time: timestamp,
+                    });
+                    if (this.recentTouchPos.length > 3) {
+                        this.recentTouchPos.pop();
+                    }
+                    const diffX = this.recentTouchPos[1].x - this.recentTouchPos[0].x;
+                    const diffY = this.recentTouchPos[1].y - this.recentTouchPos[0].y;
+                    const diffXabs = Math.abs(diffX);
+                    const diffYabs = Math.abs(diffY);
+                    const scrollAxis = this.touchScrollAxis !== null
+                        ? this.touchScrollAxis
+                        : diffYabs > diffXabs
+                            ? 'y'
+                            : diffXabs > diffYabs
+                                ? 'x'
+                                : null;
+                    if (this.verticalScrollEnabled && scrollAxis === 'y') {
+                        if ((diffY > 0 && this.canScrollDown) || (diffY < 0 && this.canScrollUp)) {
+                            this.viewerCanvas.scrollDown(diffY);
+                        }
+                    }
+                    else if (this.horizontalScrollEnabled && this.touchScrollAxis === 'x') {
+                        if ((diffX > 0 && this.canScrollRight) || (diffX < 0 && this.canScrollLeft)) {
+                            this.viewerCanvas.scrollRight(diffX);
+                        }
+                    }
+                    // lock scroll axis
+                    if (this.touchScrollAxis === null && this.recentTouchPos.length >= 3) {
+                        this.touchScrollAxis = diffYabs > diffXabs ? 'y' : diffXabs > diffYabs ? 'x' : null;
+                    }
+                }
+            }
+            else if (this.isTouchScrolling) {
+                this.isTouchScrolling = false;
+                if (this.touchScrollAxis === 'x') {
+                    this.autoscrollDist = this.recentTouchPos[2].x - this.recentTouchPos[0].x;
+                    this.autoscrollDistTime = this.recentTouchPos[0].time - this.recentTouchPos[2].time;
+                    this.autoscrollDx = Math.abs(this.autoscrollDist / this.autoscrollDistTime);
+                    this.autoscrollLastTimestamp = timestamp;
+                }
+                else if (this.touchScrollAxis === 'y') {
+                    this.autoscrollDist = this.recentTouchPos[2].y - this.recentTouchPos[0].y;
+                    this.autoscrollDistTime = this.recentTouchPos[0].time - this.recentTouchPos[2].time;
+                    this.autoscrollDx = Math.abs(this.autoscrollDist / this.autoscrollDistTime);
+                    this.autoscrollLastTimestamp = timestamp;
+                }
+            }
+        }
+        // auto scroll
+        if (this.viewerCanvas && this.autoscrollDx !== 0) {
+            const time = timestamp - this.autoscrollLastTimestamp;
+            if (time > 1000 / 70) {
+                if (this.autoscrollDx > 3) {
+                    this.autoscrollDx = 3;
+                }
+                if (this.touchScrollAxis === 'y' &&
+                    ((this.autoscrollDist > 0 && !this.canScrollDown) ||
+                        (this.autoscrollDist < 0 && !this.canScrollUp))) {
+                    this.autoscrollDx = 0;
+                }
+                else if (this.touchScrollAxis === 'x' &&
+                    ((this.autoscrollDist > 0 && !this.canScrollRight) ||
+                        (this.autoscrollDist < 0 && !this.canScrollLeft))) {
+                    this.autoscrollDx = 0;
+                }
+                else {
+                    const direction = Math.sign(this.autoscrollDist);
+                    const distance = Math.abs(this.autoscrollDist);
+                    const timeFactor = time / this.autoscrollDistTime;
+                    const diff = Math.min(100, distance * this.autoscrollDx) * timeFactor;
+                    const scrollDiff = diff * direction;
+                    if (Math.abs(scrollDiff) < 1) {
+                        this.autoscrollDx = 0;
+                    }
+                    else {
+                        if (this.touchScrollAxis === 'y') {
+                            this.viewerCanvas.scrollDown(scrollDiff);
+                        }
+                        else {
+                            this.viewerCanvas.scrollRight(scrollDiff);
+                        }
+                    }
+                    const throttleDiff = this.autoscrollDx * 0.08 * timeFactor;
+                    this.autoscrollDx = this.autoscrollDx - throttleDiff;
+                    this.autoscrollLastTimestamp = timestamp;
+                }
+            }
+        }
+    }
+    updateCanScrollVertical(state) {
+        this.canScrollUp = state.scroll.top.cssPixels > 0;
+        this.canScrollDown =
+            state.scroll.top.cssPixels + state.canvas.height.cssPixels <
+                state.document.height.cssPixels - 1;
+    }
+    updateCanScrollHorizontal(state) {
+        this.canScrollLeft = state.scroll.left.cssPixels > 0;
+        this.canScrollRight =
+            state.scroll.left.cssPixels + state.canvas.width.cssPixels <
+                state.document.width.cssPixels - 1;
+    }
+    startVerticalScroll(e) {
+        this.verticalScrollBar.classList.add('pwv-scrollbar-dragging');
+    }
+    verticalScroll(e) {
+        if (this.viewerCanvas) {
+            const scrollDiv = e.movementY / this.verticalScrollRatio;
+            this.viewerCanvas.scrollDown(scrollDiv);
+        }
+    }
+    endVerticalScroll(e) {
+        this.verticalScrollBar.classList.remove('pwv-scrollbar-dragging');
+    }
+    startHorizontalScroll(e) {
+        this.horizontalScrollBar.classList.add('pwv-scrollbar-dragging');
+    }
+    horizontalScroll(e) {
+        if (this.viewerCanvas) {
+            const scrollDiv = e.movementX / this.horizontalScrollRatio;
+            this.viewerCanvas.scrollRight(scrollDiv);
+        }
+    }
+    endHorizontalScroll(e) {
+        this.horizontalScrollBar.classList.remove('pwv-scrollbar-dragging');
+    }
+}

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

@@ -0,0 +1,19 @@
+import { ViewLayerBase } from './ViewLayerBase';
+import { ViewerCanvasState } from '../state/store';
+/** internal */
+export declare class TextSelectionLayer extends ViewLayerBase {
+    private startPoint;
+    private selecting;
+    private contextBarElement;
+    private selectionType;
+    constructor();
+    create(): void;
+    render(timestamp: number, state: ViewerCanvasState): void;
+    clearSelection(): void;
+    private clearHtmlDocumentSelection;
+    private startSelection;
+    private endSelection;
+    private selectionCreated;
+    private createAnnotation;
+    private copyTextSelection;
+}

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

@@ -0,0 +1,289 @@
+import { ViewLayerBase } from './ViewLayerBase';
+import { PdfItemType, } from '../../pdf-viewer-api';
+import { createTextSelectionContextBar } from './views/TextSelectionContextBar';
+import { Color } from '../../common/Color';
+import { ViewerMode, CursorStyle, copyTextToClipboard } from '../state/viewer';
+import { addHistoryEntry } from '../../custom/history';
+/** internal */
+export class TextSelectionLayer extends ViewLayerBase {
+    constructor() {
+        super();
+        this.startPoint = null;
+        this.selecting = false;
+        this.contextBarElement = null;
+        this.selectionType = null;
+        this.createAnnotation = this.createAnnotation.bind(this);
+        this.copyTextSelection = this.copyTextSelection.bind(this);
+    }
+    create() { }
+    render(timestamp, state) {
+        var _a;
+        if (state.viewer.mode !== ViewerMode.TEXT_SELECTED) {
+            if (this.contextBarElement) {
+                this.removeHtmlElements();
+                this.contextBarElement = null;
+            }
+        }
+        if (state.viewer.mode === ViewerMode.MODULE_SELECTED) {
+            return;
+        }
+        let updateContextBarPos = true;
+        if (state.pointer.action === 'click') {
+            this.endSelection();
+            // dbl click word selection
+        }
+        else if (state.pointer.action === 'dblclick') {
+            const clickPos = this.pdfViewerApi.transformScreenPointToPdfPoint({
+                x: state.pointer.x.devicePixels,
+                y: state.pointer.y.devicePixels,
+            });
+            const wordSelection = this.pdfViewerApi.getWordOnPoint(clickPos.pdfPoint);
+            this.store.viewer.setTextSelection({ selection: wordSelection, type: 'normal' });
+            this.selectionCreated();
+        }
+        // start new selection
+        else if (state.viewer.mode === ViewerMode.DEFAULT &&
+            !this.selecting &&
+            ((state.pointer.type === 'mouse' && state.pointer.action === 'startdrag') ||
+                state.pointer.action === 'longpress')) {
+            const screenPos = {
+                x: state.startPointer.x.devicePixels,
+                y: state.startPointer.y.devicePixels,
+            };
+            const startPos = this.pdfViewerApi.transformScreenPointToPdfPoint(screenPos);
+            const textOnPoint = this.pdfViewerApi.getTextFragmentOnPoint(screenPos);
+            if (this.options.viewer.general.rectangularTextSelection === 'automatic') {
+                this.selectionType = textOnPoint ? 'normal' : 'rectangular';
+                this.startSelection(startPos.pdfPoint);
+            }
+            else {
+                if (textOnPoint) {
+                    this.startSelection(startPos.pdfPoint);
+                }
+            }
+        }
+        else if (this.selecting) {
+            if (state.pointer.isDown) {
+                if (state.pointer.positionChanged) {
+                    const mousePos = this.pdfViewerApi.getClosestPointOnPdfByScreenPoint({
+                        x: state.pointer.x.devicePixels,
+                        y: state.pointer.y.devicePixels,
+                    });
+                    if (this.startPoint) {
+                        const textSelection = this.selectionType === 'rectangular'
+                            ? this.pdfViewerApi.getRectangularTextSelection(this.startPoint, mousePos)
+                            : this.pdfViewerApi.getTextSelection(this.startPoint, mousePos);
+                        this.store.viewer.setTextSelection({
+                            selection: textSelection,
+                            type: this.selectionType,
+                        });
+                        this.store.viewer.setTextSelectionState('selecting');
+                    }
+                }
+            }
+            else {
+                if ((_a = state.viewer.textSelection) === null || _a === void 0 ? void 0 : _a.quadrilaterals.length) {
+                    this.selectionCreated();
+                }
+                else {
+                    this.endSelection();
+                }
+            }
+        }
+        // auto scroll
+        if (this.selecting && state.pointer.y.devicePixels > -1) {
+            const padding = 30;
+            const dxScroll = 20;
+            if (state.pointer.y.devicePixels > state.canvas.height.devicePixels - padding) {
+                this.pdfViewerApi.setScrollPosition({
+                    x: state.scroll.left.devicePixels,
+                    y: state.scroll.top.devicePixels + dxScroll,
+                });
+            }
+            else if (state.pointer.y.devicePixels < padding) {
+                this.pdfViewerApi.setScrollPosition({
+                    x: state.scroll.left.devicePixels,
+                    y: state.scroll.top.devicePixels - dxScroll,
+                });
+            }
+            else if (state.pointer.x.devicePixels > state.canvas.width.devicePixels - padding) {
+                this.pdfViewerApi.setScrollPosition({
+                    x: state.scroll.left.devicePixels + dxScroll,
+                    y: state.scroll.top.devicePixels,
+                });
+            }
+            else if (state.pointer.x.devicePixels < padding) {
+                this.pdfViewerApi.setScrollPosition({
+                    x: state.scroll.left.devicePixels - dxScroll,
+                    y: state.scroll.top.devicePixels,
+                });
+            }
+        }
+        // update contextbar position
+        if (updateContextBarPos && this.contextBarElement && state.viewer.textSelectionRects) {
+            const padding = 25;
+            let barTopPos = padding;
+            let barLeftPos = 0;
+            let isTopPos = false;
+            let isBottomPos = false;
+            let screenRect = null;
+            const { firstVisiblePage, lastVisiblePage } = state.document;
+            Object.keys(state.viewer.textSelectionRects).forEach((page) => {
+                const pageNumber = parseInt(page);
+                if (pageNumber >= firstVisiblePage && pageNumber <= lastVisiblePage) {
+                    if (state.viewer.textSelectionRects) {
+                        const pageScreenRect = this.pdfViewerApi.transformPdfPageRectToScreenRect(state.viewer.textSelectionRects[page]);
+                        if (pageScreenRect) {
+                            screenRect = {
+                                x1: pageScreenRect.x / devicePixelRatio,
+                                y1: pageScreenRect.y / devicePixelRatio,
+                                x2: pageScreenRect.x / devicePixelRatio + pageScreenRect.w / devicePixelRatio,
+                                y2: pageScreenRect.y / devicePixelRatio + pageScreenRect.h / devicePixelRatio,
+                            };
+                        }
+                    }
+                }
+            });
+            if (screenRect) {
+                const { x1, y1, x2, y2 } = screenRect;
+                if (y1 > 90) {
+                    barTopPos = y1 - 65;
+                    isTopPos = true;
+                }
+                else if (state.canvas.height.cssPixels / 2 > y2) {
+                    barTopPos = y2 + 15;
+                    isBottomPos = true;
+                }
+                const barWidth = this.contextBarElement.clientWidth;
+                barLeftPos = x1 + (x2 - x1 - barWidth) / 2;
+                if (barLeftPos < 0) {
+                    barLeftPos = 0;
+                }
+            }
+            else {
+                barTopPos = -90;
+            }
+            this.contextBarElement.style.top = barTopPos + 'px';
+            this.contextBarElement.style.left = barLeftPos + 'px';
+            if (isTopPos) {
+                this.contextBarElement.classList.add('pwv-contextbar-top');
+            }
+            else {
+                this.contextBarElement.classList.remove('pwv-contextbar-top');
+            }
+            if (isBottomPos) {
+                this.contextBarElement.classList.add('pwv-contextbar-bottom');
+            }
+            else {
+                this.contextBarElement.classList.remove('pwv-contextbar-bottom');
+            }
+        }
+    }
+    clearSelection() {
+        this.endSelection();
+    }
+    clearHtmlDocumentSelection() {
+        const documentSelection = document.getSelection();
+        if (documentSelection) {
+            documentSelection.empty();
+        }
+    }
+    startSelection(startPoint) {
+        this.clearHtmlDocumentSelection();
+        this.removeHtmlElements();
+        this.contextBarElement = null;
+        this.selecting = true;
+        if (this.startPoint === null) {
+            this.startPoint = startPoint;
+        }
+        this.store.viewer.setCursorStyle(CursorStyle.TEXT);
+    }
+    endSelection() {
+        this.removeHtmlElements();
+        this.contextBarElement = null;
+        this.selecting = false;
+        this.startPoint = null;
+        this.clearHtmlDocumentSelection();
+        window.setTimeout(() => {
+            this.selectionType = null;
+            this.store.viewer.setTextSelection({ selection: null, type: null });
+            this.store.viewer.setTextSelectionState(null);
+        }, 50);
+    }
+    selectionCreated() {
+        var _a;
+        this.selecting = false;
+        if (this.contextBarElement) {
+            this.removeHtmlElements();
+        }
+        this.store.viewer.setCursorStyle(CursorStyle.DEFAULT);
+        this.store.viewer.setTextSelectionState('textSelected');
+        const isViewOnly = !((_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.licenseFeatures.annotate);
+        const allowCopyText = this.options.viewer.permissions.allowCopyText;
+        if (isViewOnly && !allowCopyText) {
+            return;
+        }
+        this.contextBarElement = this.createHtmlLayer();
+        this.contextBarElement.classList.add('pwv-textselection-contextbar');
+        this.contextBarElement.classList.add('pwv-contextbar-top');
+        createTextSelectionContextBar({
+            highlightColors: this.options.annotation.colors.highlightColors,
+            onCreateAnnotation: this.createAnnotation,
+            onCopyText: this.copyTextSelection,
+            isViewOnly,
+            allowCopyText,
+        }, this.contextBarElement);
+        this.viewerCanvas.onTextSelected();
+    }
+    createAnnotation(itemType, color) {
+        if (this.pdfViewerApi && this.store) {
+            const selection = this.store.getState().viewer.textSelection;
+            if (selection) {
+                const selectionByPage = [];
+                for (let i = 0; i < selection.quadrilaterals.length; i++) {
+                    const quadrilateral = selection.quadrilaterals[i];
+                    if (!selectionByPage[quadrilateral.pageNumber]) {
+                        selectionByPage[quadrilateral.pageNumber] = [];
+                    }
+                    selectionByPage[quadrilateral.pageNumber].push(quadrilateral);
+                }
+                if (itemType === PdfItemType.HIGHLIGHT) {
+                    const colorObj = new Color(color);
+                    colorObj.setOpacity(this.options.annotation.highlightOpacity);
+                    color = colorObj.toRgba();
+                }
+                for (let i = 0; i < selectionByPage.length; i++) {
+                    if (selectionByPage[i]) {
+                        const quadrilaterals = selectionByPage[i];
+                        const args = {
+                            itemType,
+                            page: i,
+                            pdfRect: {
+                                pdfX: 0,
+                                pdfY: 0,
+                                pdfW: 0,
+                                pdfH: 0,
+                                page: i,
+                            },
+                            color,
+                            author: this.options.viewer.general.user,
+                            quadrilaterals,
+                        };
+                        this.pdfViewerApi.createItem(args).then((annotation) => {
+                            if (this.options.annotation.trackHistory) {
+                                addHistoryEntry(annotation, 'create', this.options.viewer.general.user);
+                                this.pdfViewerApi.updateItem(annotation);
+                            }
+                        });
+                        this.endSelection();
+                    }
+                }
+            }
+        }
+    }
+    copyTextSelection() {
+        var _a;
+        const selectedText = (_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.getSelectedText();
+        copyTextToClipboard(selectedText || '');
+    }
+}