@docmentis/udoc-viewer 0.3.0 → 0.4.0

package/dist/src/ui/viewer/components/Viewport.js

@@ -112,7 +112,21 @@ function getScrollbarSize() {
     cachedScrollbarSize = { width, height };
     return cachedScrollbarSize;
 }
-function computeScale(slice, metrics, spreads) {
+/**
+ * Computes the zoom scale for fit modes.
+ *
+ * For fit-spread-width mode, we predict whether a vertical scrollbar will be needed
+ * and adjust the available width accordingly. This prevents the feedback loop where:
+ * 1. Scale is calculated based on viewport width
+ * 2. Content is taller than viewport, scrollbar appears
+ * 3. Scrollbar reduces viewport width, causing recalculation
+ *
+ * @param slice - Viewport state slice
+ * @param metrics - Current viewport metrics
+ * @param spreads - Array of spreads to layout
+ * @param scrollbarVisible - Whether vertical scrollbar is currently visible
+ */
+function computeScale(slice, metrics, spreads, scrollbarVisible) {
     if (slice.zoomMode === "custom")
         return slice.zoom;
     if (metrics.innerWidth <= 0 || metrics.innerHeight <= 0)
@@ -132,7 +146,13 @@ function computeScale(slice, metrics, spreads) {
     // Round to the nearest device pixel to avoid scrollbar feedback loops.
     const snappedSpacing = snapToDevice(slice.spreadSpacing);
     const snappedViewportHeight = snapToDevice(metrics.innerHeight);
-    const snappedViewportWidth = snapToDevice(metrics.innerWidth);
+    const scrollbar = getScrollbarSize();
+    // Calculate the "base" viewport width (without scrollbar).
+    // If scrollbar is currently visible, metrics.innerWidth already excludes it,
+    // so we add it back to get the full available width.
+    const baseViewportWidth = scrollbarVisible
+        ? snapToDevice(metrics.innerWidth + scrollbar.width)
+        : snapToDevice(metrics.innerWidth);
     const verticalSpacing = snappedSpacing * 2;
     // Add 1 pixel buffer to compensate for device pixel rounding in layout calculations.
     // Without this, the spread may be slightly smaller than the viewport, allowing
@@ -140,22 +160,51 @@ function computeScale(slice, metrics, spreads) {
     // The same buffer is used in spread mode for consistency when switching modes.
     // Scrollbar overflow in spread mode is handled by applySingleLayout using viewport height.
     const targetHeight = Math.max(0, snappedViewportHeight - verticalSpacing + 1);
-    const widthScale = snappedViewportWidth / maxWidth;
-    const heightScale = targetHeight / maxHeight;
     switch (slice.zoomMode) {
-        case "fit-spread-width":
-            return widthScale;
+        case "fit-spread-width": {
+            // Calculate scale assuming full viewport width (no scrollbar)
+            const fullWidthScale = baseViewportWidth / maxWidth;
+            // Predict if vertical scrollbar will be needed at this scale.
+            // For continuous mode: check if total content height exceeds viewport.
+            // For spread mode: check if tallest spread + spacing exceeds viewport.
+            let needsScrollbar;
+            if (slice.scrollMode === "continuous") {
+                // In continuous mode, calculate total content height
+                // Total height = sum of all spread heights + spacing between spreads
+                let totalHeight = 0;
+                for (const spread of spreads) {
+                    const dims = getSpreadDimensions(spread, slice.pageInfos, fullWidthScale, slice.pageSpacing, slice.dpi, slice.pageRotation);
+                    totalHeight += dims.height;
+                }
+                totalHeight += snappedSpacing * (spreads.length + 1); // spacing before first, between, and after last
+                needsScrollbar = totalHeight > snappedViewportHeight;
+            }
+            else {
+                // In spread mode, check if the tallest spread + spacing exceeds viewport
+                const scaledMaxHeight = maxHeight * fullWidthScale;
+                needsScrollbar = scaledMaxHeight + verticalSpacing > snappedViewportHeight;
+            }
+            if (needsScrollbar && scrollbar.width > 0) {
+                // Scrollbar will be needed, calculate scale with reduced viewport width
+                const adjustedWidth = baseViewportWidth - scrollbar.width;
+                return adjustedWidth / maxWidth;
+            }
+            // No scrollbar needed, use full width
+            return fullWidthScale;
+        }
         case "fit-spread-height":
-            return heightScale;
+            // Content fits height by design, no vertical scrollbar needed
+            return targetHeight / maxHeight;
         case "fit-spread":
-            return Math.min(widthScale, heightScale);
+            // Content fits both dimensions by design, no scrollbar needed
+            return Math.min(baseViewportWidth / maxWidth, targetHeight / maxHeight);
         default:
             return slice.zoom;
     }
 }
-function buildLayout(slice, metrics) {
+function buildLayout(slice, metrics, scrollbarVisible) {
     const spreads = calculateSpreads(slice.pageCount, slice.layoutMode);
-    const scale = computeScale(slice, metrics, spreads);
+    const scale = computeScale(slice, metrics, spreads, scrollbarVisible);
     const layout = calculateSpreadLayouts(spreads, slice.pageInfos, scale, slice.pageSpacing, slice.spreadSpacing, slice.dpi, slice.pageRotation);
     return {
         spreads,
@@ -165,12 +214,13 @@ function buildLayout(slice, metrics) {
         scale
     };
 }
-function computeViewportUpdate(prevSlice, nextSlice, prevMetrics, nextMetrics, lastScrollMode) {
+function computeViewportUpdate(prevSlice, nextSlice, prevMetrics, nextMetrics) {
     const metricsChanged = !prevMetrics || !metricsEqual(prevMetrics, nextMetrics);
     const layoutChanged = !prevSlice ||
         nextSlice.docId !== prevSlice.docId ||
         nextSlice.pageCount !== prevSlice.pageCount ||
         nextSlice.pageInfos !== prevSlice.pageInfos ||
+        nextSlice.scrollMode !== prevSlice.scrollMode ||
         nextSlice.layoutMode !== prevSlice.layoutMode ||
         nextSlice.zoomMode !== prevSlice.zoomMode ||
         nextSlice.zoom !== prevSlice.zoom ||
@@ -179,32 +229,23 @@ function computeViewportUpdate(prevSlice, nextSlice, prevMetrics, nextMetrics, l
         nextSlice.pageSpacing !== prevSlice.pageSpacing ||
         nextSlice.spreadSpacing !== prevSlice.spreadSpacing ||
         metricsChanged;
-    const modeChanged = !prevSlice || nextSlice.scrollMode !== prevSlice.scrollMode;
     const zoomModeChanged = !prevSlice || nextSlice.zoomMode !== prevSlice.zoomMode;
-    const fitZoomChanged = nextSlice.zoomMode !== "custom" && (!prevSlice || nextSlice.zoom !== prevSlice.zoom);
     const spreadsChanged = !prevSlice ||
         nextSlice.docId !== prevSlice.docId ||
         nextSlice.pageCount !== prevSlice.pageCount ||
         nextSlice.pageInfos !== prevSlice.pageInfos ||
         nextSlice.layoutMode !== prevSlice.layoutMode;
     const shouldClearSpreads = layoutChanged && spreadsChanged;
-    const shouldCaptureAnchor = layoutChanged &&
-        !spreadsChanged &&
-        nextSlice.scrollMode === "continuous" &&
-        !fitZoomChanged &&
-        !zoomModeChanged;
-    const shouldCenterOnModeChange = modeChanged && lastScrollMode !== null && lastScrollMode !== "continuous";
-    const shouldScrollToPage = spreadsChanged || zoomModeChanged || fitZoomChanged;
-    const shouldResetSingleScroll = (modeChanged && lastScrollMode === "continuous") ||
-        spreadsChanged ||
-        (layoutChanged && nextSlice.zoomMode !== "custom");
+    // Scroll to page on document change or zoom mode change (explicit user actions)
+    const shouldScrollToPage = spreadsChanged || zoomModeChanged;
+    // Restore tracked viewport position when layout changes but document structure is the same
+    // This maintains scroll position across mode switches, zoom changes, and viewport resizes
+    const shouldRestorePosition = layoutChanged && !spreadsChanged && !zoomModeChanged;
     return {
         layoutChanged,
         shouldClearSpreads,
-        shouldCaptureAnchor,
-        shouldCenterOnModeChange,
-        shouldScrollToPage,
-        shouldResetSingleScroll
+        shouldRestorePosition,
+        shouldScrollToPage
     };
 }
 export function createViewport() {
@@ -216,13 +257,118 @@ export function createViewport() {
     const container = document.createElement("div");
     container.className = "udoc-viewport__container";
     scrollArea.appendChild(container);
-    const watermark = document.createElement("a");
-    watermark.className = "udoc-viewport__watermark";
-    watermark.href = "https://docmentis.com";
-    watermark.target = "_blank";
-    watermark.rel = "noopener";
-    watermark.textContent = "Powered by docMentis";
+    // Watermark with tamper protection - random class name on each instantiation
+    const wmClass = "_" + Math.random().toString(36).slice(2, 10) + Math.random().toString(36).slice(2, 10);
+    const wmHref = "https://docmentis.com";
+    const wmText = "Powered by docMentis";
+    const wmAttrs = { target: "_blank", rel: "noopener" };
+    // Inject dynamic styles for the random class name
+    const wmStyle = document.createElement("style");
+    wmStyle.textContent = `
+        .${wmClass} {
+            position: absolute;
+            right: 18px;
+            bottom: 4px;
+            padding: 2px 6px;
+            font-size: 12px;
+            font-weight: 500;
+            color: rgba(0, 0, 0, 0.3);
+            text-decoration: none;
+            text-shadow: 0 1px 2px rgba(255, 255, 255, 0.5);
+            z-index: 10;
+            transition: color 0.15s ease;
+        }
+        .${wmClass}:hover {
+            color: rgba(0, 0, 0, 0.6);
+        }
+        @media (max-width: 768px) {
+            .${wmClass} {
+                bottom: 48px;
+                right: 10px;
+                font-size: 11px;
+            }
+        }
+    `;
+    el.appendChild(wmStyle);
+    function createWatermark() {
+        const wm = document.createElement("a");
+        wm.className = wmClass;
+        wm.href = wmHref;
+        wm.target = wmAttrs.target;
+        wm.rel = wmAttrs.rel;
+        wm.textContent = wmText;
+        return wm;
+    }
+    let watermark = createWatermark();
     el.appendChild(watermark);
+    // Protect watermark against removal and modification
+    const wmObserver = new MutationObserver((mutations) => {
+        let needsRestore = false;
+        // Check if watermark was removed from DOM
+        if (!el.contains(watermark)) {
+            needsRestore = true;
+        }
+        // Check if style element was removed
+        if (!el.contains(wmStyle)) {
+            el.appendChild(wmStyle);
+        }
+        // Check for attribute tampering on the watermark itself
+        for (const mutation of mutations) {
+            if (mutation.target === watermark) {
+                if (mutation.type === "attributes") {
+                    needsRestore = true;
+                }
+                else if (mutation.type === "characterData" || mutation.type === "childList") {
+                    needsRestore = true;
+                }
+            }
+            // Check if watermark's text content was changed
+            if (mutation.target.parentNode === watermark && mutation.type === "characterData") {
+                needsRestore = true;
+            }
+        }
+        if (needsRestore) {
+            // Remove old watermark if still in DOM but corrupted
+            if (el.contains(watermark)) {
+                watermark.remove();
+            }
+            // Create fresh watermark
+            watermark = createWatermark();
+            el.appendChild(watermark);
+        }
+    });
+    // Observe the parent for child removal and the watermark for attribute/content changes
+    wmObserver.observe(el, { childList: true, subtree: false });
+    wmObserver.observe(watermark, {
+        attributes: true,
+        childList: true,
+        characterData: true,
+        subtree: true
+    });
+    // Periodic integrity check (catches CSS-based hiding)
+    const wmIntegrityCheck = setInterval(() => {
+        // Restore style element if removed
+        if (!el.contains(wmStyle)) {
+            el.appendChild(wmStyle);
+        }
+        // Restore watermark if removed
+        if (!el.contains(watermark)) {
+            watermark = createWatermark();
+            el.appendChild(watermark);
+            wmObserver.observe(watermark, {
+                attributes: true,
+                childList: true,
+                characterData: true,
+                subtree: true
+            });
+        }
+        // Reset any inline style tampering
+        watermark.style.cssText = "";
+        watermark.removeAttribute("hidden");
+        if (watermark.className !== wmClass) {
+            watermark.className = wmClass;
+        }
+    }, 1000);
     const floatingToolbar = createFloatingToolbar();
     let workerClient = null;
     let storeRef = null;
@@ -238,13 +384,15 @@ export function createViewport() {
     let layoutDirty = false;
     let lastVisibleRange = { start: 0, end: -1 };
     let containerSize = { width: 0, height: 0 };
-    let lastScrollMode = null;
     let lastOverflowX = null;
     let lastOverflowY = null;
+    // Track the document position at viewport top edge for consistent positioning across mode switches
+    let viewportTopPosition = null;
     let updateRaf = 0;
     let scrollRaf = 0;
     let renderDebounceTimer = 0;
     let rendersPaused = false;
+    let resumeRenderAfterResize = false;
     const RENDER_DEBOUNCE_MS = 50;
     const unsubEvents = [];
     function mount(parent, store, wc) {
@@ -261,7 +409,7 @@ export function createViewport() {
             equality: viewportSliceEqual
         });
         unsubScroll = on(scrollArea, "scroll", () => {
-            if (!currentSlice || currentSlice.scrollMode !== "continuous")
+            if (!currentSlice || !layoutState)
                 return;
             if (scrollRaf)
                 return;
@@ -269,14 +417,22 @@ export function createViewport() {
                 scrollRaf = 0;
                 if (!currentSlice || !layoutState || !lastMetrics)
                     return;
-                updateVisibleSpreads(currentSlice, lastMetrics, layoutState);
+                if (currentSlice.scrollMode === "continuous") {
+                    updateVisibleSpreads(currentSlice, lastMetrics, layoutState);
+                }
+                // Keep viewport position tracking up to date on scroll (both modes)
+                updateViewportTopPosition(currentSlice, layoutState);
             });
         });
-        // Resize handler: layout updates immediately, but renders are debounced
-        // to avoid excessive WASM calls during panel animations
+        // Resize handler: layout updates immediately, but renders are only paused
+        // when resize events keep firing (e.g. dragging panel width). This avoids
+        // a one-off "flash" when panels are simply toggled.
         const handleResize = () => {
-            // Pause renders during resize
-            rendersPaused = true;
+            const isOngoingResize = renderDebounceTimer !== 0;
+            if (isOngoingResize) {
+                rendersPaused = true;
+                resumeRenderAfterResize = true;
+            }
             // Clear any pending render timer
             if (renderDebounceTimer) {
                 clearTimeout(renderDebounceTimer);
@@ -284,9 +440,12 @@ export function createViewport() {
             // Schedule render after resize settles
             renderDebounceTimer = window.setTimeout(() => {
                 renderDebounceTimer = 0;
-                rendersPaused = false;
-                // Trigger re-render of visible spreads
-                scheduleUpdate();
+                if (resumeRenderAfterResize) {
+                    resumeRenderAfterResize = false;
+                    rendersPaused = false;
+                    // Trigger re-render of visible spreads
+                    scheduleUpdate();
+                }
             }, RENDER_DEBOUNCE_MS);
             // Layout updates immediately
             scheduleUpdate();
@@ -420,57 +579,71 @@ export function createViewport() {
             scrollArea.style.overflowY = "hidden";
             layoutState = null;
             lastVisibleRange = { start: 0, end: -1 };
+            viewportTopPosition = null;
             syncEffectiveZoom(slice, null);
             lastSlice = slice;
             lastMetrics = metrics;
-            lastScrollMode = slice.scrollMode;
             return;
         }
-        const plan = computeViewportUpdate(lastSlice, slice, lastMetrics, metrics, lastScrollMode);
+        const plan = computeViewportUpdate(lastSlice, slice, lastMetrics, metrics);
         if (plan.shouldClearSpreads) {
             clearSpreads();
             lastVisibleRange = { start: 0, end: -1 };
+            viewportTopPosition = null;
         }
-        const anchor = (plan.shouldCaptureAnchor && layoutState)
-            ? captureScrollAnchor(metrics, layoutState)
-            : null;
         if (plan.layoutChanged || !layoutState) {
-            layoutState = buildLayout(slice, metrics);
+            layoutState = buildLayout(slice, metrics, lastOverflowY ?? false);
             layoutDirty = true;
-            // Only update lastMetrics when layout rebuilds, so small changes accumulate
-            // until they exceed the epsilon threshold (important for fit-page modes)
             lastMetrics = metrics;
         }
         syncEffectiveZoom(slice, layoutState);
         if (slice.scrollMode === "continuous") {
             applyContinuousLayout(metrics, layoutState);
-            if (plan.shouldCenterOnModeChange) {
-                // When switching from single to continuous, center the page to maintain position
-                scrollToPage(slice.page, metrics, true);
-            }
-            else if (plan.shouldScrollToPage) {
+            if (plan.shouldScrollToPage) {
                 scrollToPage(slice.page, metrics);
             }
-            else if (anchor) {
-                restoreScrollAnchor(anchor, metrics);
+            else if (plan.shouldRestorePosition && viewportTopPosition) {
+                restoreViewportPosition(viewportTopPosition, metrics, layoutState);
             }
             updateVisibleSpreads(slice, metrics, layoutState);
         }
         else {
             applySingleLayout(slice, metrics, layoutState);
-            if (plan.shouldResetSingleScroll) {
+            if (plan.shouldScrollToPage) {
                 scrollArea.scrollTop = 0;
                 scrollArea.scrollLeft = 0;
-                // Reset overflow state when switching to spread mode to avoid
-                // hysteresis from continuous mode keeping scrollbar visible
+                lastOverflowX = null;
+                lastOverflowY = null;
+            }
+            else if (plan.shouldRestorePosition && viewportTopPosition) {
+                // In spread mode, restore position by showing the correct page
+                const targetPage = viewportTopPosition.page;
+                if (slice.page !== targetPage && storeRef) {
+                    storeRef.dispatch({ type: "SET_PAGE", page: targetPage });
+                }
+                // Reset scroll and try to restore position within the spread if it's scrollable
+                scrollArea.scrollLeft = 0;
+                const spreadIndex = findSpreadForPage(layoutState.spreads, targetPage);
+                const layout = layoutState.layouts[spreadIndex];
+                if (layout && layout.height > metrics.innerHeight && !viewportTopPosition.inSpacing) {
+                    // Spread is larger than viewport and we have a content offset
+                    // Calculate scroll position to show the same relative position
+                    const spreadTopInContainer = getCenteredOffset(containerSize.height, layout.height);
+                    const offsetPixels = viewportTopPosition.offset * layout.height;
+                    scrollArea.scrollTop = Math.max(0, spreadTopInContainer + offsetPixels);
+                }
+                else {
+                    scrollArea.scrollTop = 0;
+                }
                 lastOverflowX = null;
                 lastOverflowY = null;
             }
             showSingleSpread(slice, metrics, layoutState);
         }
         updateOverflow(slice, metrics);
+        // Update tracked viewport position after layout is applied
+        updateViewportTopPosition(slice, layoutState);
         lastSlice = slice;
-        lastScrollMode = slice.scrollMode;
     }
     function updateOverflow(slice, metrics) {
         const epsilon = 1;
@@ -528,33 +701,89 @@ export function createViewport() {
             return;
         storeRef.dispatch({ type: "SET_EFFECTIVE_ZOOM", zoom: nextZoom });
     }
-    function captureScrollAnchor(metrics, state) {
-        if (state.layouts.length === 0 || state.spreads.length === 0)
-            return null;
-        const scrollTop = scrollArea.scrollTop;
-        const viewportCenter = scrollTop + metrics.innerHeight / 2;
-        const focusPage = findFocusPage(viewportCenter, state);
-        if (focusPage === null)
-            return null;
-        const spreadIndex = findSpreadForPage(state.spreads, focusPage);
-        const layout = state.layouts[spreadIndex];
-        if (!layout)
-            return null;
-        const spreadCenter = layout.top + layout.height / 2;
-        return {
-            page: focusPage,
-            offset: spreadCenter - scrollTop
-        };
-    }
-    function restoreScrollAnchor(anchor, metrics) {
-        if (!layoutState)
+    /**
+     * Updates the tracked viewport top position based on current scroll state.
+     * This captures which page is at the viewport top and how far into it we are.
+     */
+    function updateViewportTopPosition(slice, state) {
+        if (state.layouts.length === 0 || state.spreads.length === 0) {
+            viewportTopPosition = null;
             return;
-        const spreadIndex = findSpreadForPage(layoutState.spreads, anchor.page);
-        const layout = layoutState.layouts[spreadIndex];
+        }
+        let viewportTopInLayout;
+        if (slice.scrollMode === "continuous") {
+            // In continuous mode, viewport top position is directly from scrollTop
+            viewportTopInLayout = scrollArea.scrollTop;
+        }
+        else {
+            // In spread mode, the spread is centered in the viewport
+            // Calculate where the viewport top would be in layout coordinates
+            const spreadIndex = findSpreadForPage(state.spreads, slice.page);
+            const layout = state.layouts[spreadIndex];
+            if (!layout) {
+                viewportTopPosition = null;
+                return;
+            }
+            // The spread is positioned at getCenteredOffset from container top
+            const spreadTopInContainer = getCenteredOffset(containerSize.height, layout.height);
+            // Account for any scroll within spread mode (for large spreads)
+            const viewportTopInContainer = scrollArea.scrollTop;
+            // Map to layout coordinates: layout.top is where this spread is in continuous layout
+            viewportTopInLayout = layout.top - spreadTopInContainer + viewportTopInContainer;
+        }
+        // Find which spread the viewport top is associated with
+        for (let i = 0; i < state.layouts.length; i++) {
+            const layout = state.layouts[i];
+            const spread = state.spreads[i];
+            if (!spread)
+                continue;
+            const spreadTop = layout.top;
+            const spreadBottom = layout.top + layout.height;
+            const offsetFromSpreadTop = viewportTopInLayout - spreadTop;
+            // Check if viewport is in the spacing area before this spread
+            if (viewportTopInLayout < spreadTop) {
+                // We're in the spacing above this spread
+                // Store the absolute pixel offset (negative) since spacing doesn't scale
+                viewportTopPosition = {
+                    page: getSpreadPrimaryPage(spread),
+                    offset: offsetFromSpreadTop, // negative value
+                    inSpacing: true
+                };
+                return;
+            }
+            // Check if viewport is within this spread's content
+            if (viewportTopInLayout < spreadBottom || i === state.layouts.length - 1) {
+                // We're within the spread content
+                // Store as ratio of spread height so it scales correctly
+                const offsetRatio = layout.height > 0 ? offsetFromSpreadTop / layout.height : 0;
+                viewportTopPosition = {
+                    page: getSpreadPrimaryPage(spread),
+                    offset: offsetRatio,
+                    inSpacing: false
+                };
+                return;
+            }
+        }
+        viewportTopPosition = null;
+    }
+    /**
+     * Restores the viewport to a previously tracked position.
+     */
+    function restoreViewportPosition(position, metrics, state) {
+        const spreadIndex = findSpreadForPage(state.spreads, position.page);
+        const layout = state.layouts[spreadIndex];
         if (!layout)
             return;
-        const spreadCenter = layout.top + layout.height / 2;
-        const targetScrollTop = spreadCenter - anchor.offset;
+        let targetScrollTop;
+        if (position.inSpacing) {
+            // In spacing area: offset is absolute pixels (negative), doesn't scale
+            targetScrollTop = layout.top + position.offset;
+        }
+        else {
+            // In spread content: offset is ratio of spread height, scales with zoom
+            const offsetPixels = position.offset * layout.height;
+            targetScrollTop = layout.top + offsetPixels;
+        }
         const maxScrollTop = Math.max(0, containerSize.height - metrics.innerHeight);
         scrollArea.scrollTop = clamp(targetScrollTop, 0, maxScrollTop);
     }
@@ -680,6 +909,11 @@ export function createViewport() {
                 scale: state.scale,
                 dpi: slice.dpi
             });
+            // Prerender adjacent pages for smooth page flipping
+            const dpr = getDevicePixelRatio();
+            const pointsToPixels = getPointsToPixels(slice.dpi);
+            const renderScale = pointsToPixels * state.scale * dpr;
+            workerClient.prerenderAdjacentPages(slice.docId, slice.page, renderScale, slice.pageInfos.length);
         }
         lastVisibleRange = { start: spreadIndex, end: spreadIndex };
         // Only clear layoutDirty if renders actually happened
@@ -806,6 +1040,8 @@ export function createViewport() {
             cancelAnimationFrame(scrollRaf);
         if (renderDebounceTimer)
             clearTimeout(renderDebounceTimer);
+        wmObserver.disconnect();
+        clearInterval(wmIntegrityCheck);
         floatingToolbar.destroy();
         clearSpreads();
         workerClient = null;