@aurigma/design-atoms/Services/ProductPreview/PreviewCanvas.js

Design Atoms is a part of Customer's Canvas SDK which allows for manipulating individual design elements through your code.

import { PointF, Environment, PrintAreaBoundsType } from "@aurigma/design-atoms-model";
import { HandlerFactoryByItem, RenderState } from "../../ItemHandlers";
import { SurfaceHandler } from "../SurfaceHandler";
import { Translations } from "../../Viewer";
import { PreviewTextEditorController } from "./PreviewTextEditorController";
import { LayerCollection } from "../../LayerCollection";
import { CanvasData } from "../../CanvasData";
import { Layer } from "../../Layer";
import { CanvasRendererStyle } from "../../Canvas/CanvasRendererStyle";
import { RenderingConfigProvider } from "../../RenderingConfigProvider";
export class PreviewCanvas {
    constructor(sourceSurface, previewContainersSourceFactory, zoom, mul, renderer, designAtomsApiClient, colorPreviewService, service, viewerConfigurationContext, colorParser) {
        this._onPreviewContainersChanged = () => {
            this._updateLayers();
        };
        this._onLayerCollectionChanged = () => {
            this._unsubscribeLayersEvents();
            this._subscribeLayersEvents();
        };
        this._onItemHandlersChanged = () => {
            this._updateHandlers();
        };
        this._sourceSurface = sourceSurface;
        this._previewContainersSource = previewContainersSourceFactory.create(this._sourceSurface);
        this._surfaceHandler = new SurfaceHandler(this._sourceSurface);
        this._layers = new LayerCollection(this);
        this._zoom = zoom;
        this._mul = mul;
        this._renderer = renderer;
        this._designAtomsApiClient = designAtomsApiClient;
        this._colorPreviewService = colorPreviewService;
        this._service = service;
        this._viewerConfigurationContext = viewerConfigurationContext;
        this._colorParser = colorParser;
        this._handlerFactory = new HandlerFactoryByItem(this, {
            create: () => new PreviewTextEditorController()
        }, this._colorPreviewService, this._colorParser);
        this._renderingConfigProvider = new RenderingConfigProvider(this);
        this._previewContainersSource.addPreviewContainersChanged(this._onPreviewContainersChanged);
        this.layers.add_collectionChanged(this._onLayerCollectionChanged);
        this._updateLayers();
        this._style = new CanvasRendererStyle();
    }
    get layers() {
        return this._layers;
    }
    get width() {
        return this.workspaceWidth * this.zoom * Environment.screenDpi / 72;
    }
    get height() {
        return this.workspaceHeight * this.zoom * Environment.screenDpi / 72;
    }
    get workspaceWidth() {
        return this._workspaceSize.width;
    }
    get workspaceHeight() {
        return this._workspaceSize.height;
    }
    get workspace() {
        return {
            width: this.workspaceWidth,
            height: this.workspaceHeight,
            zoom: this.zoom
        };
    }
    get canvasElementSize() {
        return {};
    }
    get currentItemHandler() {
        return null;
    }
    get ignorePermissionsMode() {
        return false;
    }
    get service() {
        return this._service;
    }
    get isInitialized() {
        return true;
    }
    get initialization() {
        return false;
    }
    get zoom() {
        return this._zoom;
    }
    get mul() {
        return this._mul;
    }
    get disableSmoothing() {
        return false;
    }
    get hitTestManager() {
        return null;
    }
    get previewMode() {
        return false;
    }
    get designAtomsApiClient() {
        return this._designAtomsApiClient;
    }
    get textEditor() {
        return null;
    }
    get textWhizz() {
        return null;
    }
    get fontRegistry() {
        return null;
    }
    get frontEndTextRenderingEnabled() {
        return false;
    }
    get minFontSize() {
        return 0.1;
    }
    get maxFontSize() {
        return 100;
    }
    get minLeading() {
        return 0;
    }
    get maxLeading() {
        return 100;
    }
    get isSelectionLocked() {
        return false;
    }
    get isSelectionResizing() { return false; }
    get isSelectionDragging() { return false; }
    get isSelectionRotating() { return false; }
    get isSelectionIdle() { return false; }
    get viewerConfiguration() {
        return this._viewerConfigurationContext.configuration;
    }
    get offset() {
        return new PointF();
    }
    get history() {
        return null;
    }
    get rgbColorProfileFileId() {
        return null;
    }
    get cmykColorProfileFileId() {
        return null;
    }
    get grayscaleColorProfileFileId() {
        return null;
    }
    get targetDpi() {
        return null;
    }
    get resizeGripColor() {
        return "";
    }
    get rotationGripColor() {
        return "";
    }
    get resizeGripSize() {
        return 0;
    }
    get rotationGripSize() {
        return 0;
    }
    get tags() {
        return {};
    }
    get selectionColor() {
        return "";
    }
    get selectionWidth() {
        return 0;
    }
    get resizeGripLineColor() {
        return "";
    }
    get rotationGripLineColor() {
        return "";
    }
    get rotationGripLineLength() {
        return 0;
    }
    get translations() {
        return new Translations();
    }
    get multipleSelectionEnabled() {
        return false;
    }
    get mouseMoveTimeout() {
        return 0;
    }
    get goodViolationIconCssClass() {
        return "";
    }
    get warningViolationIconCssClass() {
        return "";
    }
    get badViolationIconCssClass() {
        return "";
    }
    get qualityBadToWarningChangeScaleBarCssClass() {
        return "";
    }
    get qualityWarningToGoodChangeScaleBarCssClass() {
        return "";
    }
    get qualityBadToGoodChangeScaleBarCssClass() {
        return "";
    }
    get qualityNoAnimationChangeScaleBarCssClass() {
        return "";
    }
    get qualityChangeScaleBarCssClass() {
        return "";
    }
    get placeholderButtonGroupCssClass() {
        return "";
    }
    get handleButtonCssClass() {
        return "";
    }
    get doneButtonCssClass() {
        return "";
    }
    get qualityChangeContainerCssClass() {
        return "";
    }
    get qualityChangeInfoBarCssClass() {
        return "";
    }
    get violationContainerCssClass() {
        return "";
    }
    get violationWarningButtonCssClass() {
        return "";
    }
    get bigButtonGroupCssClass() {
        return "";
    }
    get contentAngle() {
        return 0;
    }
    get sourceSurface() {
        return this._sourceSurface;
    }
    get style() {
        return this._style;
    }
    get hoverHandler() {
        return null;
    }
    get renderingConfig() {
        return this.viewerConfiguration.renderingConfig;
    }
    get renderingConfigProvider() {
        return this._renderingConfigProvider;
    }
    get _workspaceSize() {
        return this._surfaceHandler.getBounds(PrintAreaBoundsType.Total);
    }
    get _allItemHandlers() {
        return this.layers
            .selectMany(layer => layer.flatItemHandlers.toArray())
            .toArray();
    }
    getItemHandler(item) {
        return this._handlerFactory.get(item);
    }
    deleteItemHandler(itemHandler) {
        this._handlerFactory.delete(itemHandler);
    }
    getData(forService, layerId) {
        return new CanvasData(this, forService, layerId);
    }
    drawWaitClock(context, center) {
        this._renderer.drawWaitClock(context, center, this.mul);
    }
    doesContainItem(item) {
        return this._sourceSurface.getAllItems().contains(item);
    }
    updateSelection(force) {
    }
    redraw() {
    }
    pauseRedraw() {
    }
    continueRedraw() {
    }
    redrawDesign() {
    }
    redrawActiveTexts() {
    }
    updateTexts() {
    }
    updateViolationContainers(updatePosition, onlyVisible) {
    }
    updateViolationContainer(itemHandler, updatePosition) {
    }
    updateViolationContainerPosition(itemHandler) {
    }
    addViolationContainer(itemHandler) {
    }
    removeViolationContainer(itemHandler) {
    }
    isOnlyThisItemHandlerSelected(itemHandler) {
        return false;
    }
    isItemHandlerSelected(itemHandler) {
        return false;
    }
    addSelectedItemHandler(itemHandler) {
    }
    removeSelectedItemHandler(itemHandler) {
    }
    setSelectedItemHandlers(itemHandlers) {
    }
    clearSelectedItemHandlers() {
    }
    add_zoomChanged(listener) {
    }
    remove_zoomChanged(listener) {
    }
    waitFontRegistryInitialized() {
        return Promise.resolve();
    }
    addPlaceholderButtonGroup(placeholder) {
    }
    removePlaceholderButtonGroup(placeholder) {
    }
    updatePlaceholderButtonGroup(placeholder) {
    }
    updatePlaceholderButtonGroups() {
    }
    updatePlaceholderButtonGroupPosition(placeholder) {
    }
    isDragSource(itemHandler) {
        return false;
    }
    isDragTarget(itemHandler) {
        return false;
    }
    updateButtonGroups(options) {
    }
    waitUpdate(itemHandlers) {
        const allItemHandlers = itemHandlers !== null && itemHandlers !== void 0 ? itemHandlers : this._allItemHandlers;
        return Promise.all(allItemHandlers
            .filter(itemHandler => itemHandler.isVisible())
            .map(async (itemHandler) => {
            await itemHandler.waitUpdate();
            await this._waitHandlerReady(itemHandler);
        }));
    }
    async waitUpdateAndExecute(callback) {
        await this._previewContainersSource.ensureUpdatedAndExecuteAsync(async () => {
            await this.waitUpdate();
            callback();
        });
    }
    onLayerTextureLoaded() {
    }
    pauseUpdateTexts() {
    }
    resumeUpdateTexts() {
    }
    enableSelection() {
    }
    disableSelection() {
    }
    unsubscribeLimitsMessage() {
    }
    subscribeLimitsMessage() {
    }
    add_onScroll(handler) {
    }
    remove_onScroll(handler) {
    }
    add_selectedItemHandlerChanged(handler) {
    }
    remove_selectedItemHandlerChanged(handler) {
    }
    add_onSelectionLocked(handler) {
    }
    remove_onSelectionLocked(handler) {
    }
    ensureFocus() {
    }
    setCursor(value, onBody) {
    }
    getAllItemHandlers(options) {
        return this._allItemHandlers;
    }
    violationWarningButtonHitTestObject(pt) {
        throw new Error("Method not implemented.");
    }
    getButtonGroupRectInGripsDiv(div, ignoreRotate) {
        throw new Error("Method not implemented.");
    }
    dispose() {
        this._previewContainersSource.removePreviewContainersChanged(this._onPreviewContainersChanged);
        this._layers.remove_collectionChanged(this._onLayerCollectionChanged);
        this._layers.clear();
        this._handlerFactory.clear();
    }
    _subscribeLayersEvents() {
        for (const layer of this.layers) {
            layer.itemHandlers.add_collectionChanged(this._onItemHandlersChanged);
        }
    }
    _unsubscribeLayersEvents() {
        for (const layer of this.layers) {
            layer.itemHandlers.remove_collectionChanged(this._onItemHandlersChanged);
        }
    }
    _updateLayers() {
        this._layers.clear();
        const layers = this._previewContainersSource.getPreviewContainers()
            .map(container => new Layer(container, this));
        this._layers.addRange(layers);
        this._updateHandlers();
    }
    _updateHandlers() {
        for (const itemHandler of this._allItemHandlers) {
            itemHandler.renderState = itemHandler.isVisible ? RenderState.Bottom : RenderState.Hidden;
        }
    }
    _waitHandlerReady(itemHandler) {
        if (itemHandler.ready) {
            return Promise.resolve();
        }
        return new Promise(resolve => {
            itemHandler.addReady(() => resolve());
        });
    }
}
//# sourceMappingURL=PreviewCanvas.js.map