@aurigma/design-atoms/Services/EventManager.js

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

import { EventObject, EventWithSenderArg } from "@aurigma/design-atoms-model/EventObject";
import { GroupItem } from "@aurigma/design-atoms-model/Product/Items";
import { BaseRectangleItemHandler, GroupItemHandler, NewBaseTextItemHandler, PlaceholderItemHandler, ShapeItemHandler } from "../ItemHandlers";
import { CollectionChangeType } from "@aurigma/design-atoms-model/ICollectionChangeEventArgs";
export class EventManager {
    constructor(_product, _viewer) {
        this._product = _product;
        this._viewer = _viewer;
        this._notifyContainerCollectionChanged = (args) => this._containerCollectionChangedEvent.notify(args);
        this._notifySurfaceCollectionChanged = () => this._surfaceCollectionChangedEvent.notify();
        this._notifyItemHanderCollectionChanged = () => this._itemHanderCollectionChangedEvent.notify();
        this._notifyLayerCollectionChanged = () => this._layerCollectionChangedEvent.notify();
        this._notifyPrintAreaCollectionChanged = () => this._printAreaCollectionChangedEvent.notify();
        this._notifyItemCollectionChanged = () => this._itemCollectionChangedEvent.notify();
        this._notifyItemAdded = (args) => this._itemAddedEvent.notify(args);
        this._notifyItemRemoved = (args) => this._itemRemovedEvent.notify(args);
        this._notifyItemMoved = (args) => this._itemMovedEvent.notify(args);
        this._notifyUnderMockupCollectionChanged = () => this._underMockupContainerCollectionChangedEvent.notify();
        this._notifyOverMockupCollectionChanged = () => this._overMockupContainerCollectionChangedEvent.notify();
        this._notifyPreviewMockupCollectionChanged = () => this._previewMockupContainerCollectionChangedEvent.notify();
        this._notifyPrintAreaPropertyChanged = (sender, propertyName) => this._printAreaPropertyChangedEvent.notify(sender, propertyName);
        this._notifyItemPropertyChanged = (sender, propertyName) => this._itemPropertyChangedEvent.notify(sender.item, propertyName);
        this._notifyItemChanged = (sender) => this._itemChangedEvent.notify(sender.item);
        this._notifyItemChanging = (sender) => this._itemChangingEvent.notify(sender);
        this._notifySelectButtonClick = (PlaceholderItemHandler) => this._selectButtonClickEvent.notify(PlaceholderItemHandler.item);
        this._notifyViolationWarningButtonClick = (itemHanlder) => this._violationWarningButtonClickEvent.notify(itemHanlder.item);
        this._notifyDoubleClick = (itemHandler, e) => this._doubleClickEvent.notify(itemHandler.item);
        this._notifyShapePathLoaded = () => this._shapePathLoadedEvent.notify();
        this._notifyEnteredEditMode = (itemHandler) => this._enteredEditModeEvent.notify(itemHandler.item);
        this._notifyExitedEditMode = (itemHandler) => this._exitedEditModeEvent.notify(itemHandler.item);
        this._notifyCurrentItemChanged = (itemHandler) => this._currentItemChangedEvent.notify(itemHandler != null ? itemHandler.item : null);
        this._notifySelectedItemChanged = () => this._selectedItemChangedEvent.notify(this._viewer.selectedItems);
        this._notifyDragNDropDone = (data) => this._dragNDropDoneEvent.notify(data);
        this._notifyDragNDropStarting = (data) => this._dragNDropStartingEvent.notify(data);
        this._notifyDragNDropPerformed = (data) => this._dragNDropPerformedEvent.notify(data);
        this._notifyReady = () => this._readyEvent.notify();
        this._notifyWorkspaceSizeChanged = () => this._workspaceSizeChangedEvent.notify();
        this._notifyIsEditingChanged = (phHandler) => this._isEditingChangedEvent.notify(phHandler);
        this._notifyBeforeReplaceItemHandler = (itemHandler) => {
            this._unsubscribeFromItemHandlerEvents(itemHandler);
            this._beforeReplaceItemHandlerEvent.notify(itemHandler);
        };
        this._notifyAfterReplaceItemHandler = (itemHandler) => {
            this._subscribeToItemHandlerEvents(itemHandler);
            this._afterReplaceItemHandlerEvent.notify(itemHandler);
        };
        this._subscribeToProductEvents = (product) => {
            if (product == null)
                return;
            product.surfaces.add_collectionChanged(this._notifySurfaceCollectionChanged);
            product.surfaces.add_collectionChanged(this._onSurfaceCollectionChanged);
            for (let surface of product.surfaces) {
                this._subscribeToSurfaceEvents(surface);
            }
        };
        this._unsubscribeFromProductEvents = (product) => {
            if (product == null)
                return;
            product.surfaces.remove_collectionChanged(this._notifySurfaceCollectionChanged);
            product.surfaces.remove_collectionChanged(this._onSurfaceCollectionChanged);
            for (let surface of product.surfaces) {
                this._unsubscribeFromSurfaceEvents(surface);
            }
        };
        this._onSurfaceCollectionChanged = (args) => {
            if (args.type === CollectionChangeType.Move)
                return;
            if (args.type === CollectionChangeType.Remove) {
                const removeArgs = args;
                this._unsubscribeFromSurfaceEvents(removeArgs.item);
                return;
            }
            if (args.type === CollectionChangeType.Add) {
                const removeArgs = args;
                this._subscribeToSurfaceEvents(removeArgs.item);
                return;
            }
        };
        this._onLayerCollectionChanged = (args) => {
            if (args.type === CollectionChangeType.Move)
                return;
            if (args.type === CollectionChangeType.Remove) {
                const removeArgs = args;
                this._unsubscribeFromLayerEvents(removeArgs.item);
                return;
            }
            if (args.type === CollectionChangeType.Add) {
                const removeArgs = args;
                this._subscribeToLayerEvents(removeArgs.item);
                return;
            }
        };
        this._onItemHanderCollectionChanged = (args) => {
            if (args.type === CollectionChangeType.Move)
                return;
            if (args.type === CollectionChangeType.Remove) {
                const removeArgs = args;
                this._unsubscribeFromItemHandlerEvents(removeArgs.item);
                return;
            }
            if (args.type === CollectionChangeType.Add) {
                const removeArgs = args;
                this._subscribeToItemHandlerEvents(removeArgs.item);
                return;
            }
        };
        this._subscribeToSurfaceEvents = (surface) => {
            if (surface == null)
                return;
            surface.containers.add_collectionChanged(this._notifyContainerCollectionChanged);
            surface.containers.add_collectionChanged(this._onContainerCollectionChanged);
            surface.mockup.underContainers.add_collectionChanged(this._notifyUnderMockupCollectionChanged);
            surface.mockup.underContainers.add_collectionChanged(this._onContainerCollectionChanged);
            surface.mockup.overContainers.add_collectionChanged(this._notifyOverMockupCollectionChanged);
            surface.mockup.overContainers.add_collectionChanged(this._onContainerCollectionChanged);
            surface.previewMockups.add_collectionChanged(this._notifyPreviewMockupCollectionChanged);
            const containers = [...surface.containers, ...surface.mockup.underContainers, ...surface.mockup.overContainers];
            for (let container of containers) {
                this._subscribeToContainerEvents(container);
            }
            surface.printAreas.forEach(this._subscribeToPrintAreaEvents);
            surface.printAreas.add_collectionChanged(this._notifyPrintAreaCollectionChanged);
            surface.printAreas.add_collectionChanged(this._onPrintAreaCollectionChanged);
        };
        this._unsubscribeFromSurfaceEvents = (surface) => {
            if (surface == null)
                return;
            surface.containers.remove_collectionChanged(this._notifyContainerCollectionChanged);
            surface.containers.remove_collectionChanged(this._onContainerCollectionChanged);
            surface.mockup.underContainers.remove_collectionChanged(this._notifyUnderMockupCollectionChanged);
            surface.mockup.underContainers.remove_collectionChanged(this._onContainerCollectionChanged);
            surface.mockup.overContainers.remove_collectionChanged(this._notifyOverMockupCollectionChanged);
            surface.mockup.overContainers.remove_collectionChanged(this._onContainerCollectionChanged);
            surface.previewMockups.remove_collectionChanged(this._notifyPreviewMockupCollectionChanged);
            const containers = [...surface.containers, ...surface.mockup.underContainers, ...surface.mockup.overContainers];
            for (let container of containers) {
                this._unsubscribeFromContainerEvents(container);
            }
            surface.printAreas.forEach(this._unsubscribeFromPrintAreaEvents);
            surface.printAreas.remove_collectionChanged(this._notifyPrintAreaCollectionChanged);
            surface.printAreas.remove_collectionChanged(this._onPrintAreaCollectionChanged);
        };
        this._onContainerCollectionChanged = (args) => {
            if (args.type === CollectionChangeType.Move)
                return;
            if (args.type === CollectionChangeType.Remove) {
                const removeArgs = args;
                this._unsubscribeFromContainerEvents(removeArgs.item);
                return;
            }
            if (args.type === CollectionChangeType.Add) {
                const removeArgs = args;
                this._subscribeToContainerEvents(removeArgs.item);
                return;
            }
        };
        this._subscribeToContainerEvents = (container) => {
            if (container == null)
                return;
            container.items.add_collectionChanged(this._notifyItemCollectionChanged);
            container.items.add_collectionChanged(this._onItemCollectionChanged);
            container.items.add_itemAdded(this._notifyItemAdded);
            container.items.add_itemRemoved(this._notifyItemRemoved);
            container.items.add_itemMoved(this._notifyItemMoved);
            container.items.forEach(this._subscribeToItemEvents);
        };
        this._unsubscribeFromContainerEvents = (container) => {
            if (container == null)
                return;
            container.items.remove_collectionChanged(this._notifyItemCollectionChanged);
            container.items.remove_collectionChanged(this._onItemCollectionChanged);
            container.items.remove_itemAdded(this._notifyItemAdded);
            container.items.remove_itemRemoved(this._notifyItemRemoved);
            container.items.remove_itemMoved(this._notifyItemMoved);
            container.items.forEach(this._unsubscribeFromItemEvents);
        };
        this._onPrintAreaCollectionChanged = (args) => {
            if (args.type === CollectionChangeType.Move)
                return;
            if (args.type === CollectionChangeType.Remove) {
                const removeArgs = args;
                this._unsubscribeFromPrintAreaEvents(removeArgs.item);
                return;
            }
            if (args.type === CollectionChangeType.Add) {
                const removeArgs = args;
                this._subscribeToPrintAreaEvents(removeArgs.item);
                return;
            }
        };
        this._subscribeToPrintAreaEvents = (printArea) => {
            if (printArea == null)
                return;
            printArea.addPropertyChanged(this._notifyPrintAreaPropertyChanged);
        };
        this._unsubscribeFromPrintAreaEvents = (printArea) => {
            if (printArea == null)
                return;
            printArea.removePropertyChanged(this._notifyPrintAreaPropertyChanged);
        };
        this._onItemCollectionChanged = (args) => {
            if (args.type === CollectionChangeType.Move)
                return;
            if (args.type === CollectionChangeType.Remove) {
                const removeArgs = args;
                this._unsubscribeFromItemEvents(removeArgs.item);
                return;
            }
            if (args.type === CollectionChangeType.Add) {
                const removeArgs = args;
                this._subscribeToItemEvents(removeArgs.item);
                return;
            }
        };
        this._subscribeToItemEvents = (item) => {
            if (item == null)
                return;
            if (item instanceof GroupItem) {
                item.items.forEach(item => this._subscribeToItemEvents(item));
                item.items.add_itemAdded(this._notifyItemAdded);
                item.items.add_itemRemoved(this._notifyItemRemoved);
                item.items.add_collectionChanged(this._onItemCollectionChanged);
            }
        };
        this._subscribeToItemHandlerEvents = (itemHandler) => {
            itemHandler.addItemPropertyChanged(this._notifyItemPropertyChanged);
            itemHandler.addChanged(this._notifyItemChanged);
            itemHandler.addChanging(this._notifyItemChanging);
            itemHandler.addDoubleClick(this._notifyDoubleClick);
            itemHandler.addViolationWarningButtonClick(this._notifyViolationWarningButtonClick);
            if (itemHandler instanceof PlaceholderItemHandler) {
                itemHandler.addSelectButtonClick(this._notifySelectButtonClick);
                itemHandler.addIsEditingChanged(this._notifyIsEditingChanged);
                if (itemHandler.content != null)
                    itemHandler.content.addItemPropertyChanged(this._notifyItemPropertyChanged);
            }
            if (itemHandler instanceof ShapeItemHandler)
                itemHandler.item.getPathLoadedEvent().add(this._notifyShapePathLoaded);
            if (itemHandler instanceof NewBaseTextItemHandler) {
                itemHandler.enteredEditModeEvent.add(this._notifyEnteredEditMode);
                itemHandler.exitedEditModeEvent.add(this._notifyExitedEditMode);
            }
            if (itemHandler instanceof GroupItemHandler) {
                for (const innerHandler of itemHandler.getNestedItemHandlers()) {
                    if (innerHandler instanceof BaseRectangleItemHandler)
                        this._subscribeToItemHandlerEvents(innerHandler);
                }
            }
        };
        this._unsubscribeFromItemEvents = (item) => {
            if (item == null)
                return;
            if (item instanceof GroupItem && item.items != null) {
                item.items.forEach(item => this._unsubscribeFromItemEvents(item));
                item.items.remove_itemAdded(this._notifyItemAdded);
                item.items.remove_itemRemoved(this._notifyItemRemoved);
                item.items.remove_collectionChanged(this._onItemCollectionChanged);
            }
        };
        this._unsubscribeFromItemHandlerEvents = (itemHandler) => {
            itemHandler.removeItemPropertyChanged(this._notifyItemPropertyChanged);
            itemHandler.removeChanged(this._notifyItemChanged);
            itemHandler.removeChanging(this._notifyItemChanging);
            itemHandler.removeDoubleClick(this._notifyDoubleClick);
            itemHandler.removeViolationWarningButtonClick(this._notifyViolationWarningButtonClick);
            if (itemHandler instanceof PlaceholderItemHandler) {
                itemHandler.removeSelectButtonClick(this._notifySelectButtonClick);
                itemHandler.removeIsEditingChanged(this._notifyIsEditingChanged);
                if (itemHandler.content != null)
                    itemHandler.content.removeItemPropertyChanged(this._notifyItemPropertyChanged);
            }
            if (itemHandler instanceof ShapeItemHandler)
                itemHandler.item.getPathLoadedEvent().remove(this._notifyShapePathLoaded);
            if (itemHandler instanceof NewBaseTextItemHandler) {
                itemHandler.enteredEditModeEvent.remove(this._notifyEnteredEditMode);
                itemHandler.exitedEditModeEvent.remove(this._notifyExitedEditMode);
            }
            if (itemHandler instanceof GroupItemHandler) {
                for (const innerHandler of itemHandler.getNestedItemHandlers()) {
                    if (innerHandler instanceof BaseRectangleItemHandler)
                        this._unsubscribeFromItemHandlerEvents(innerHandler);
                }
            }
        };
        this._subscribeOnCanvasEvents = (canvas) => {
            if (canvas == null)
                return;
            canvas.add_currentItemHandlerChanged(this._notifyCurrentItemChanged);
            canvas.add_selectedItemHandlerChanged(this._notifySelectedItemChanged);
            canvas.add_dragNDropDone(this._notifyDragNDropDone);
            canvas.add_dragNDropPerformed(this._notifyDragNDropPerformed);
            canvas.add_dragNDropStarting(this._notifyDragNDropStarting);
            canvas.add_ready(this._notifyReady);
            canvas.add_workspaceSizeChanged(this._notifyWorkspaceSizeChanged);
            canvas.add_beforeReplaceItemHandler(this._notifyBeforeReplaceItemHandler);
            canvas.add_afterReplaceItemHandler(this._notifyAfterReplaceItemHandler);
            canvas.layers.add_collectionChanged(this._notifyLayerCollectionChanged);
            canvas.layers.add_collectionChanged(this._onLayerCollectionChanged);
            for (let layer of canvas.layers) {
                this._subscribeToLayerEvents(layer);
            }
        };
        this._unsubscribeFromCanvasEvents = (canvas) => {
            if (canvas == null)
                return;
            canvas.remove_currentItemHandlerChanged(this._notifyCurrentItemChanged);
            canvas.remove_selectedItemHandlerChanged(this._notifySelectedItemChanged);
            canvas.remove_dragNDropDone(this._notifyDragNDropDone);
            canvas.remove_dragNDropPerformed(this._notifyDragNDropPerformed);
            canvas.remove_dragNDropStarting(this._notifyDragNDropStarting);
            canvas.remove_ready(this._notifyReady);
            canvas.remove_workspaceSizeChanged(this._notifyWorkspaceSizeChanged);
            canvas.remove_beforeReplaceItemHandler(this._notifyBeforeReplaceItemHandler);
            canvas.remove_afterReplaceItemHandler(this._notifyAfterReplaceItemHandler);
            canvas.layers.remove_collectionChanged(this._notifyLayerCollectionChanged);
            canvas.layers.remove_collectionChanged(this._onLayerCollectionChanged);
            for (let layer of canvas.layers) {
                this._unsubscribeFromLayerEvents(layer);
            }
        };
        this._subscribeToLayerEvents = (layer) => {
            if (layer == null)
                return;
            layer.itemHandlers.add_collectionChanged(this._notifyItemHanderCollectionChanged);
            layer.itemHandlers.add_collectionChanged(this._onItemHanderCollectionChanged);
            for (const itemHandler of layer.itemHandlers.cast()) {
                this._subscribeToItemHandlerEvents(itemHandler);
            }
        };
        this._unsubscribeFromLayerEvents = (layer) => {
            if (layer == null)
                return;
            layer.itemHandlers.remove_collectionChanged(this._notifyItemHanderCollectionChanged);
            layer.itemHandlers.remove_collectionChanged(this._onItemHanderCollectionChanged);
            for (const itemHandler of layer.itemHandlers.cast()) {
                this._unsubscribeFromItemHandlerEvents(itemHandler);
            }
        };
        this._itemChangedEvent = new EventObject();
        this._itemChangingEvent = new EventObject();
        this._itemPropertyChangedEvent = new EventWithSenderArg();
        this._changeSurfaceEvent = new EventObject();
        this._itemAddedEvent = new EventObject();
        this._itemRemovedEvent = new EventObject();
        this._itemMovedEvent = new EventObject();
        this._imageContentChangedEvent = new EventObject();
        this._snapshotLoadedEvent = new EventObject();
        this._beforeSnapshotLoad = new EventObject();
        this._surfaceCollectionChangedEvent = new EventObject();
        this._layerCollectionChangedEvent = new EventObject();
        this._itemHanderCollectionChangedEvent = new EventObject();
        this._containerCollectionChangedEvent = new EventObject();
        this._itemCollectionChangedEvent = new EventObject();
        this._underMockupContainerCollectionChangedEvent = new EventObject();
        this._overMockupContainerCollectionChangedEvent = new EventObject();
        this._previewMockupContainerCollectionChangedEvent = new EventObject();
        this._deleteToolbarButtonClickEvent = new EventObject();
        this._handleToolbarButtonClickEvent = new EventObject();
        this._selectToolbarButtonClickEvent = new EventObject();
        this._enteredEditModeEvent = new EventObject();
        this._exitedEditModeEvent = new EventObject();
        this._editToolbarButtonClickEvent = new EventObject();
        this._selectButtonClickEvent = new EventObject();
        this._violationWarningButtonClickEvent = new EventObject();
        this._doubleClickEvent = new EventObject();
        this._shapePathLoadedEvent = new EventObject();
        this._currentItemChangedEvent = new EventObject();
        this._selectedItemChangedEvent = new EventObject();
        this._dragNDropDoneEvent = new EventObject();
        this._dragNDropStartingEvent = new EventObject();
        this._dragNDropPerformedEvent = new EventObject();
        this._readyEvent = new EventObject();
        this._workspaceSizeChangedEvent = new EventObject();
        this._productThemeChangedEvent = new EventObject();
        this._userEditContainerChangedEvent = new EventObject();
        this._createInputHandlerFinishedEvent = new EventObject();
        this._printAreaCollectionChangedEvent = new EventObject();
        this._printAreaPropertyChangedEvent = new EventWithSenderArg();
        this._selectPixelFinishedEvent = new EventObject();
        this._beforeReplaceItemHandlerEvent = new EventObject();
        this._afterReplaceItemHandlerEvent = new EventObject();
        this._textWhizzReady = new EventObject();
        this._imageDpiChangedEvent = new EventObject();
        this._isEditingChangedEvent = new EventObject();
        this._contextMenuEvent = new EventObject();
        this._itemHandlerHoverEvent = new EventObject();
        this._dndStartedEvent = new EventObject();
        this._dndFinishedEvent = new EventObject();
        this._interactiveContainersChangedEvent = new EventObject();
        this._maskedContainersChangedEvent = new EventObject();
        this._interactiveZonesChangedEvent = new EventObject();
        this.canvas = _viewer.canvas;
        this._subscribeToProductEvents(_product);
    }
    get canvas() { return this._canvas; }
    set canvas(value) {
        this._unsubscribeFromCanvasEvents(this._canvas);
        this._canvas = value;
        this._subscribeOnCanvasEvents(this._canvas);
    }
    setProduct(product) {
        if (product == this._product)
            return;
        this._unsubscribeFromProductEvents(this._product);
        this._product = product;
        this._subscribeToProductEvents(this._product);
    }
    get itemChangedEvent() { return this._itemChangedEvent; }
    ;
    addItemChanged(listener) { this._itemChangedEvent.add(listener); }
    ;
    removeItemChanged(listener) { this._itemChangedEvent.remove(listener); }
    ;
    get itemChangingEvent() { return this._itemChangingEvent; }
    ;
    addItemChanging(listener) { this._itemChangingEvent.add(listener); }
    ;
    removeItemChanging(listener) { this._itemChangingEvent.remove(listener); }
    ;
    get itemPropertyChangedEvent() { return this._itemPropertyChangedEvent; }
    ;
    addItemPropertyChanged(listener) { this._itemPropertyChangedEvent.add(listener); }
    ;
    removeItemPropertyChanged(listener) { this._itemPropertyChangedEvent.remove(listener); }
    ;
    get surfaceChangedEvent() { return this._changeSurfaceEvent; }
    addSurfaceChanged(listener) { this._changeSurfaceEvent.add(listener); }
    removeSurfaceChanged(listener) { this._changeSurfaceEvent.remove(listener); }
    get itemAddedEvent() { return this._itemAddedEvent; }
    addItemAdded(listener) { this._itemAddedEvent.add(listener); }
    removeItemAdded(listener) { this._itemAddedEvent.remove(listener); }
    get itemRemovedEvent() { return this._itemRemovedEvent; }
    addItemRemoved(listener) { this._itemRemovedEvent.add(listener); }
    removeItemRemoved(listener) { this._itemRemovedEvent.remove(listener); }
    get itemMovedEvent() { return this._itemMovedEvent; }
    addItemMoved(listener) { this._itemMovedEvent.add(listener); }
    removeItemMoved(listener) { this._itemMovedEvent.remove(listener); }
    get imageContentChangedEvent() { return this._imageContentChangedEvent; }
    addImageContentChanged(listener) { this._imageContentChangedEvent.add(listener); }
    removeImageContentChanged(listener) { this._imageContentChangedEvent.remove(listener); }
    get snapshotLoadedEvent() { return this._snapshotLoadedEvent; }
    ;
    addSnapshotLoadedEvent(listener) { this._snapshotLoadedEvent.add(listener); }
    removeSnapshotLoadedEvent(listener) { this._snapshotLoadedEvent.remove(listener); }
    get beforeSnapshotLoad() { return this._beforeSnapshotLoad; }
    addBeforeSnapshotLoad(listener) { this._beforeSnapshotLoad.add(listener); }
    removeBeforeSnapshotLoad(listener) { this._beforeSnapshotLoad.remove(listener); }
    get surfaceCollectionChangedEvent() { return this._surfaceCollectionChangedEvent; }
    ;
    addSurfaceCollectionChanged(listener) { this._surfaceCollectionChangedEvent.add(listener); }
    removeSurfaceCollectionChanged(listener) { this._surfaceCollectionChangedEvent.remove(listener); }
    get layerCollectionChangedEvent() { return this._layerCollectionChangedEvent; }
    ;
    addLayerCollectionChanged(listener) { this._layerCollectionChangedEvent.add(listener); }
    removeLayerCollectionChanged(listener) { this._layerCollectionChangedEvent.remove(listener); }
    get itemHanderCollectionChangedEvent() { return this._itemHanderCollectionChangedEvent; }
    ;
    addIItemHandelrCollectionChanged(listener) { this._itemHanderCollectionChangedEvent.add(listener); }
    removeItemHandlerCollectionChanged(listener) { this._itemHanderCollectionChangedEvent.remove(listener); }
    get containerCollectionChangedEvent() { return this._containerCollectionChangedEvent; }
    ;
    addContainerCollectionChanged(listener) { this._containerCollectionChangedEvent.add(listener); }
    removeContainerCollectionChanged(listener) { this._containerCollectionChangedEvent.remove(listener); }
    get itemCollectionChangedEvent() { return this._itemCollectionChangedEvent; }
    ;
    addItemCollectionChanged(listener) { this._itemCollectionChangedEvent.add(listener); }
    removeItemCollectionChanged(listener) { this._itemCollectionChangedEvent.remove(listener); }
    get underMockupContainerCollectionChangedEvent() { return this._underMockupContainerCollectionChangedEvent; }
    ;
    addUnderMockupContainerCollectionChanged(listener) { this._underMockupContainerCollectionChangedEvent.add(listener); }
    removeUnderMockupContainerCollectionChanged(listener) { this._underMockupContainerCollectionChangedEvent.remove(listener); }
    get overMockupContainerCollectionChangedEvent() { return this._overMockupContainerCollectionChangedEvent; }
    ;
    addOverMockupContainerCollectionChanged(listener) { this._overMockupContainerCollectionChangedEvent.add(listener); }
    removeOverMockupContainerCollectionChanged(listener) { this._overMockupContainerCollectionChangedEvent.remove(listener); }
    get previewMockupContainerCollectionChangedEvent() { return this._previewMockupContainerCollectionChangedEvent; }
    ;
    addPreviewMockupContainerCollectionChanged(listener) { this._previewMockupContainerCollectionChangedEvent.add(listener); }
    removePreviewMockupContainerCollectionChanged(listener) { this._previewMockupContainerCollectionChangedEvent.remove(listener); }
    get deleteToolbarButtonClickEvent() { return this._deleteToolbarButtonClickEvent; }
    addDeleteToolbarButtonClick(listener) { this._deleteToolbarButtonClickEvent.add(listener); }
    removeDeleteToolbarButtonClick(listener) { this._deleteToolbarButtonClickEvent.remove(listener); }
    get handleToolbarButtonClickEvent() { return this._handleToolbarButtonClickEvent; }
    addHandleToolbarButtonClick(listener) { this._handleToolbarButtonClickEvent.add(listener); }
    removeHandleToolbarButtonClick(listener) { this._handleToolbarButtonClickEvent.remove(listener); }
    get selectToolbarButtonClickEvent() { return this._selectToolbarButtonClickEvent; }
    addSelectToolbarButtonClick(listener) { this._selectToolbarButtonClickEvent.add(listener); }
    removeSelectToolbarButtonClick(listener) { this._selectToolbarButtonClickEvent.remove(listener); }
    get enteredEditModeEvent() { return this._enteredEditModeEvent; }
    addEnteredEditMode(listener) { this._enteredEditModeEvent.add(listener); }
    removeEnteredEditMode(listener) { this._enteredEditModeEvent.remove(listener); }
    get exitedEditModeEvent() { return this._exitedEditModeEvent; }
    addExitedEditMode(listener) { this._exitedEditModeEvent.add(listener); }
    removeExitedEditMode(listener) { this._exitedEditModeEvent.remove(listener); }
    get editToolbarButtonClickEvent() { return this._editToolbarButtonClickEvent; }
    addEditToolbarButtonClick(listener) { this._editToolbarButtonClickEvent.add(listener); }
    removeEditToolbarButtonClick(listener) { this._editToolbarButtonClickEvent.remove(listener); }
    get selectButtonClickEvent() { return this._selectButtonClickEvent; }
    addSelectButtonClick(listener) { this._selectButtonClickEvent.add(listener); }
    removeSelectButtonClick(listener) { this._selectButtonClickEvent.remove(listener); }
    get violationWarningButtonClickEvent() { return this._violationWarningButtonClickEvent; }
    addViolationWarningButtonClick(listener) { this._violationWarningButtonClickEvent.add(listener); }
    removeViolationWarningButtonClick(listener) { this._violationWarningButtonClickEvent.remove(listener); }
    get doubleClickEvent() { return this._doubleClickEvent; }
    addDoubleClick(listener) { this._doubleClickEvent.add(listener); }
    removeDoubleClick(listener) { this._doubleClickEvent.remove(listener); }
    get shapePathLoadedEvent() { return this._shapePathLoadedEvent; }
    addShapePathLoaded(listener) { this._shapePathLoadedEvent.add(listener); }
    removeShapePathLoaded(listener) { this._shapePathLoadedEvent.remove(listener); }
    get currentItemChangedEvent() { return this._currentItemChangedEvent; }
    addCurrentItemChanged(listener) { this._currentItemChangedEvent.add(listener); }
    removeCurrentItemChanged(listener) { this._currentItemChangedEvent.remove(listener); }
    get selectedItemChangedEvent() { return this._selectedItemChangedEvent; }
    addSelectedItemChanged(listener) { this._selectedItemChangedEvent.add(listener); }
    removeSelectedItemChanged(listener) { this._selectedItemChangedEvent.remove(listener); }
    get dragNDropDoneEvent() { return this._dragNDropDoneEvent; }
    addDragNDropDone(listener) { this._dragNDropDoneEvent.add(listener); }
    removeDragNDropDone(listener) { this._dragNDropDoneEvent.remove(listener); }
    get dragNDropStartingEvent() { return this._dragNDropStartingEvent; }
    addDragNDropStarting(listener) { this._dragNDropStartingEvent.add(listener); }
    removeDragNDropStarting(listener) { this._dragNDropStartingEvent.remove(listener); }
    get dragNDropPerformedEvent() { return this._dragNDropPerformedEvent; }
    addDragNDropPerformed(listener) { this._dragNDropPerformedEvent.add(listener); }
    removeDragNDropPerformed(listener) { this._dragNDropPerformedEvent.remove(listener); }
    get readyEvent() { return this._readyEvent; }
    addReady(listener) { this._readyEvent.add(listener); }
    removeReady(listener) { this._readyEvent.remove(listener); }
    get workspaceSizeChangedEvent() { return this._workspaceSizeChangedEvent; }
    addWorkspaceSizeChanged(listener) { this._workspaceSizeChangedEvent.add(listener); }
    removeWorkspaceSizeChanged(listener) { this._workspaceSizeChangedEvent.remove(listener); }
    get productThemeChangedEvent() { return this._productThemeChangedEvent; }
    ;
    addProductThemeChanged(listener) { this._productThemeChangedEvent.add(listener); }
    removeProductThemeChanged(listener) { this._productThemeChangedEvent.remove(listener); }
    get userEditContainerChangedEvent() { return this._userEditContainerChangedEvent; }
    addUserEditContainerChanged(listener) { this._userEditContainerChangedEvent.add(listener); }
    removeUserEditContainerChanged(listener) { this._userEditContainerChangedEvent.remove(listener); }
    get createInputHandlerFinishedEvent() { return this._createInputHandlerFinishedEvent; }
    addcreateInputHandlerFinished(listener) { this._createInputHandlerFinishedEvent.add(listener); }
    removecreateInputHandlerFinished(listener) { this._createInputHandlerFinishedEvent.remove(listener); }
    get printAreaCollectionChangedEvent() { return this._printAreaCollectionChangedEvent; }
    ;
    addPrintAreaCollectionChanged(listener) { this._printAreaCollectionChangedEvent.add(listener); }
    removePrintAreaCollectionChanged(listener) { this._printAreaCollectionChangedEvent.remove(listener); }
    get printAreaPropertyChangedEvent() { return this._printAreaPropertyChangedEvent; }
    ;
    addPrintAreaPropertyChanged(listener) { this._printAreaPropertyChangedEvent.add(listener); }
    removePrintAreaPropertyChanged(listener) { this._printAreaPropertyChangedEvent.remove(listener); }
    get selectPixelFinished() { return this._selectPixelFinishedEvent; }
    addMouseSelectPixelFinished(listener) { this._selectPixelFinishedEvent.add(listener); }
    removeMouseSelectPixelFinished(listener) { this._selectPixelFinishedEvent.remove(listener); }
    get beforeReplaceItemHandlerEvent() { return this._beforeReplaceItemHandlerEvent; }
    addBeforeReplaceItemHandlerEvent(listener) { this._beforeReplaceItemHandlerEvent.add(listener); }
    removeBeforeReplaceItemHandlerEvent(listener) { this._beforeReplaceItemHandlerEvent.remove(listener); }
    get afterReplaceItemHandlerEvent() { return this._afterReplaceItemHandlerEvent; }
    addAfterReplaceItemHandlerEvent(listener) { this._afterReplaceItemHandlerEvent.add(listener); }
    removeAfterReplaceItemHandlerEvent(listener) { this._afterReplaceItemHandlerEvent.remove(listener); }
    get textWhizzReadyEvent() { return this._textWhizzReady; }
    addTextWhizzReady(listener) { this._textWhizzReady.add(listener); }
    removeTextWhizzReady(listener) { this._textWhizzReady.remove(listener); }
    get imageDpiChangedEvent() { return this._imageDpiChangedEvent; }
    addImageDpiChanged(listener) { this._imageDpiChangedEvent.add(listener); }
    removeImageDpiChanged(listener) { this._imageDpiChangedEvent.remove(listener); }
    addIsEditingChanged(listener) { this._isEditingChangedEvent.add(listener); }
    removeIsEditingChanged(listener) { this._isEditingChangedEvent.remove(listener); }
    get contextMenuEvent() { return this._contextMenuEvent; }
    addOnContextMenu(listener) { this._contextMenuEvent.add(listener); }
    removeOnContextMenu(listener) { this._contextMenuEvent.remove(listener); }
    get itemHandlerHoverEvent() { return this._itemHandlerHoverEvent; }
    addItemHandlerHover(listener) { this._itemHandlerHoverEvent.add(listener); }
    removeItemHandlerHover(listener) { this._itemHandlerHoverEvent.remove(listener); }
    get dndStartedEvent() { return this._dndStartedEvent; }
    addDndStarted(listener) { this._dndStartedEvent.add(listener); }
    removeDndStarted(listener) { this._dndStartedEvent.remove(listener); }
    get dndFinishedEvent() { return this._dndFinishedEvent; }
    addDndFinished(listener) { this._dndFinishedEvent.add(listener); }
    removeDndFinished(listener) { this._dndFinishedEvent.remove(listener); }
    get interactiveContainersChangedEvent() { return this._interactiveContainersChangedEvent; }
    addInteractiveContainersChanged(listener) { this._interactiveContainersChangedEvent.add(listener); }
    removeInteractiveContainersChanged(listener) { this._interactiveContainersChangedEvent.remove(listener); }
    get maskedContainersChangedEvent() { return this._maskedContainersChangedEvent; }
    addMaskedContainersChanged(listener) { this._maskedContainersChangedEvent.add(listener); }
    removeMaskedContainersChanged(listener) { this._maskedContainersChangedEvent.remove(listener); }
    get interactiveZonesChangedEvent() { return this._interactiveZonesChangedEvent; }
    addInteractiveZonesChanged(listener) {
        this._interactiveZonesChangedEvent.add(listener);
    }
    removeInteractiveZonesChanged(listener) {
        this._interactiveZonesChangedEvent.remove(listener);
    }
    dispose() {
        this._unsubscribeFromCanvasEvents(this._viewer.canvas);
        this._unsubscribeFromProductEvents(this._product);
    }
}
//# sourceMappingURL=EventManager.js.map