@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.

var __values = (this && this.__values) || function(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
var __spread = (this && this.__spread) || function () {
    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
    return ar;
};
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";
var EventManager = /** @class */ (function () {
    function EventManager(_product, _viewer) {
        var _this = this;
        this._product = _product;
        this._viewer = _viewer;
        this._notifyContainerCollectionChanged = function (args) { return _this._containerCollectionChangedEvent.notify(args); };
        this._notifySurfaceCollectionChanged = function () { return _this._surfaceCollectionChangedEvent.notify(); };
        this._notifyItemHanderCollectionChanged = function () { return _this._itemHanderCollectionChangedEvent.notify(); };
        this._notifyLayerCollectionChanged = function () { return _this._layerCollectionChangedEvent.notify(); };
        this._notifyPrintAreaCollectionChanged = function () { return _this._printAreaCollectionChangedEvent.notify(); };
        this._notifyItemCollectionChanged = function () { return _this._itemCollectionChangedEvent.notify(); };
        this._notifyItemAdded = function (args) { return _this._itemAddedEvent.notify(args); };
        this._notifyItemRemoved = function (args) { return _this._itemRemovedEvent.notify(args); };
        this._notifyItemMoved = function (args) { return _this._itemMovedEvent.notify(args); };
        this._notifyUnderMockupCollectionChanged = function () { return _this._underMockupContainerCollectionChangedEvent.notify(); };
        this._notifyOverMockupCollectionChanged = function () { return _this._overMockupContainerCollectionChangedEvent.notify(); };
        this._notifyPreviewMockupCollectionChanged = function () { return _this._previewMockupContainerCollectionChangedEvent.notify(); };
        this._notifyPrintAreaPropertyChanged = function (sender, propertyName) { return _this._printAreaPropertyChangedEvent.notify(sender, propertyName); };
        this._notifyItemPropertyChanged = function (sender, propertyName) { return _this._itemPropertyChangedEvent.notify(sender.item, propertyName); };
        this._notifyItemChanged = function (sender) { return _this._itemChangedEvent.notify(sender.item); };
        this._notifyItemChanging = function (sender) { return _this._itemChangingEvent.notify(sender); };
        this._notifySelectButtonClick = function (PlaceholderItemHandler) { return _this._selectButtonClickEvent.notify(PlaceholderItemHandler.item); };
        this._notifyViolationWarningButtonClick = function (itemHanlder) { return _this._violationWarningButtonClickEvent.notify(itemHanlder.item); };
        this._notifyDoubleClick = function (itemHandler, e) { return _this._doubleClickEvent.notify(itemHandler.item); };
        this._notifyShapePathLoaded = function () { return _this._shapePathLoadedEvent.notify(); };
        this._notifyEnteredEditMode = function (itemHandler) { return _this._enteredEditModeEvent.notify(itemHandler.item); };
        this._notifyExitedEditMode = function (itemHandler) { return _this._exitedEditModeEvent.notify(itemHandler.item); };
        this._notifyCurrentItemChanged = function (itemHandler) { return _this._currentItemChangedEvent.notify(itemHandler != null ? itemHandler.item : null); };
        this._notifySelectedItemChanged = function () { return _this._selectedItemChangedEvent.notify(_this._viewer.selectedItems); };
        this._notifyDragNDropDone = function (data) { return _this._dragNDropDoneEvent.notify(data); };
        this._notifyDragNDropStarting = function (data) { return _this._dragNDropStartingEvent.notify(data); };
        this._notifyDragNDropPerformed = function (data) { return _this._dragNDropPerformedEvent.notify(data); };
        this._notifyReady = function () { return _this._readyEvent.notify(); };
        this._notifyWorkspaceSizeChanged = function () { return _this._workspaceSizeChangedEvent.notify(); };
        this._notifyIsEditingChanged = function (phHandler) { return _this._isEditingChangedEvent.notify(phHandler); };
        this._notifyBeforeReplaceItemHandler = function (itemHandler) {
            _this._unsubscribeFromItemHandlerEvents(itemHandler);
            _this._beforeReplaceItemHandlerEvent.notify(itemHandler);
        };
        this._notifyAfterReplaceItemHandler = function (itemHandler) {
            _this._subscribeToItemHandlerEvents(itemHandler);
            _this._afterReplaceItemHandlerEvent.notify(itemHandler);
        };
        this._subscribeToProductEvents = function (product) {
            var e_1, _a;
            if (product == null)
                return;
            product.surfaces.add_collectionChanged(_this._notifySurfaceCollectionChanged);
            product.surfaces.add_collectionChanged(_this._onSurfaceCollectionChanged);
            try {
                for (var _b = __values(product.surfaces), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var surface = _c.value;
                    _this._subscribeToSurfaceEvents(surface);
                }
            }
            catch (e_1_1) { e_1 = { error: e_1_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_1) throw e_1.error; }
            }
        };
        this._unsubscribeFromProductEvents = function (product) {
            var e_2, _a;
            if (product == null)
                return;
            product.surfaces.remove_collectionChanged(_this._notifySurfaceCollectionChanged);
            product.surfaces.remove_collectionChanged(_this._onSurfaceCollectionChanged);
            try {
                for (var _b = __values(product.surfaces), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var surface = _c.value;
                    _this._unsubscribeFromSurfaceEvents(surface);
                }
            }
            catch (e_2_1) { e_2 = { error: e_2_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_2) throw e_2.error; }
            }
        };
        this._onSurfaceCollectionChanged = function (args) {
            if (args.type === CollectionChangeType.Move)
                return;
            if (args.type === CollectionChangeType.Remove) {
                var removeArgs = args;
                _this._unsubscribeFromSurfaceEvents(removeArgs.item);
                return;
            }
            if (args.type === CollectionChangeType.Add) {
                var removeArgs = args;
                _this._subscribeToSurfaceEvents(removeArgs.item);
                return;
            }
        };
        this._onLayerCollectionChanged = function (args) {
            if (args.type === CollectionChangeType.Move)
                return;
            if (args.type === CollectionChangeType.Remove) {
                var removeArgs = args;
                _this._unsubscribeFromLayerEvents(removeArgs.item);
                return;
            }
            if (args.type === CollectionChangeType.Add) {
                var removeArgs = args;
                _this._subscribeToLayerEvents(removeArgs.item);
                return;
            }
        };
        this._onItemHanderCollectionChanged = function (args) {
            if (args.type === CollectionChangeType.Move)
                return;
            if (args.type === CollectionChangeType.Remove) {
                var removeArgs = args;
                _this._unsubscribeFromItemHandlerEvents(removeArgs.item);
                return;
            }
            if (args.type === CollectionChangeType.Add) {
                var removeArgs = args;
                _this._subscribeToItemHandlerEvents(removeArgs.item);
                return;
            }
        };
        this._subscribeToSurfaceEvents = function (surface) {
            var e_3, _a;
            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);
            var containers = __spread(surface.containers, surface.mockup.underContainers, surface.mockup.overContainers);
            try {
                for (var containers_1 = __values(containers), containers_1_1 = containers_1.next(); !containers_1_1.done; containers_1_1 = containers_1.next()) {
                    var container = containers_1_1.value;
                    _this._subscribeToContainerEvents(container);
                }
            }
            catch (e_3_1) { e_3 = { error: e_3_1 }; }
            finally {
                try {
                    if (containers_1_1 && !containers_1_1.done && (_a = containers_1.return)) _a.call(containers_1);
                }
                finally { if (e_3) throw e_3.error; }
            }
            surface.printAreas.forEach(_this._subscribeToPrintAreaEvents);
            surface.printAreas.add_collectionChanged(_this._notifyPrintAreaCollectionChanged);
            surface.printAreas.add_collectionChanged(_this._onPrintAreaCollectionChanged);
        };
        this._unsubscribeFromSurfaceEvents = function (surface) {
            var e_4, _a;
            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);
            var containers = __spread(surface.containers, surface.mockup.underContainers, surface.mockup.overContainers);
            try {
                for (var containers_2 = __values(containers), containers_2_1 = containers_2.next(); !containers_2_1.done; containers_2_1 = containers_2.next()) {
                    var container = containers_2_1.value;
                    _this._unsubscribeFromContainerEvents(container);
                }
            }
            catch (e_4_1) { e_4 = { error: e_4_1 }; }
            finally {
                try {
                    if (containers_2_1 && !containers_2_1.done && (_a = containers_2.return)) _a.call(containers_2);
                }
                finally { if (e_4) throw e_4.error; }
            }
            surface.printAreas.forEach(_this._unsubscribeFromPrintAreaEvents);
            surface.printAreas.remove_collectionChanged(_this._notifyPrintAreaCollectionChanged);
            surface.printAreas.remove_collectionChanged(_this._onPrintAreaCollectionChanged);
        };
        this._onContainerCollectionChanged = function (args) {
            if (args.type === CollectionChangeType.Move)
                return;
            if (args.type === CollectionChangeType.Remove) {
                var removeArgs = args;
                _this._unsubscribeFromContainerEvents(removeArgs.item);
                return;
            }
            if (args.type === CollectionChangeType.Add) {
                var removeArgs = args;
                _this._subscribeToContainerEvents(removeArgs.item);
                return;
            }
        };
        this._subscribeToContainerEvents = function (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 = function (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 = function (args) {
            if (args.type === CollectionChangeType.Move)
                return;
            if (args.type === CollectionChangeType.Remove) {
                var removeArgs = args;
                _this._unsubscribeFromPrintAreaEvents(removeArgs.item);
                return;
            }
            if (args.type === CollectionChangeType.Add) {
                var removeArgs = args;
                _this._subscribeToPrintAreaEvents(removeArgs.item);
                return;
            }
        };
        this._subscribeToPrintAreaEvents = function (printArea) {
            if (printArea == null)
                return;
            printArea.addPropertyChanged(_this._notifyPrintAreaPropertyChanged);
        };
        this._unsubscribeFromPrintAreaEvents = function (printArea) {
            if (printArea == null)
                return;
            printArea.removePropertyChanged(_this._notifyPrintAreaPropertyChanged);
        };
        this._onItemCollectionChanged = function (args) {
            if (args.type === CollectionChangeType.Move)
                return;
            if (args.type === CollectionChangeType.Remove) {
                var removeArgs = args;
                _this._unsubscribeFromItemEvents(removeArgs.item);
                return;
            }
            if (args.type === CollectionChangeType.Add) {
                var removeArgs = args;
                _this._subscribeToItemEvents(removeArgs.item);
                return;
            }
        };
        this._subscribeToItemEvents = function (item) {
            if (item == null)
                return;
            if (item instanceof GroupItem) {
                item.items.forEach(function (item) { return _this._subscribeToItemEvents(item); });
                item.items.add_itemAdded(_this._notifyItemAdded);
                item.items.add_itemRemoved(_this._notifyItemRemoved);
                item.items.add_collectionChanged(_this._onItemCollectionChanged);
            }
        };
        this._subscribeToItemHandlerEvents = function (itemHandler) {
            var e_5, _a;
            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) {
                try {
                    for (var _b = __values(itemHandler.getNestedItemHandlers()), _c = _b.next(); !_c.done; _c = _b.next()) {
                        var innerHandler = _c.value;
                        if (innerHandler instanceof BaseRectangleItemHandler)
                            _this._subscribeToItemHandlerEvents(innerHandler);
                    }
                }
                catch (e_5_1) { e_5 = { error: e_5_1 }; }
                finally {
                    try {
                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                    }
                    finally { if (e_5) throw e_5.error; }
                }
            }
        };
        this._unsubscribeFromItemEvents = function (item) {
            if (item == null)
                return;
            if (item instanceof GroupItem && item.items != null) {
                item.items.forEach(function (item) { return _this._unsubscribeFromItemEvents(item); });
                item.items.remove_itemAdded(_this._notifyItemAdded);
                item.items.remove_itemRemoved(_this._notifyItemRemoved);
                item.items.remove_collectionChanged(_this._onItemCollectionChanged);
            }
        };
        this._unsubscribeFromItemHandlerEvents = function (itemHandler) {
            var e_6, _a;
            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) {
                try {
                    for (var _b = __values(itemHandler.getNestedItemHandlers()), _c = _b.next(); !_c.done; _c = _b.next()) {
                        var innerHandler = _c.value;
                        if (innerHandler instanceof BaseRectangleItemHandler)
                            _this._unsubscribeFromItemHandlerEvents(innerHandler);
                    }
                }
                catch (e_6_1) { e_6 = { error: e_6_1 }; }
                finally {
                    try {
                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                    }
                    finally { if (e_6) throw e_6.error; }
                }
            }
        };
        this._subscribeOnCanvasEvents = function (canvas) {
            var e_7, _a;
            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);
            try {
                for (var _b = __values(canvas.layers), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var layer = _c.value;
                    _this._subscribeToLayerEvents(layer);
                }
            }
            catch (e_7_1) { e_7 = { error: e_7_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_7) throw e_7.error; }
            }
        };
        this._unsubscribeFromCanvasEvents = function (canvas) {
            var e_8, _a;
            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);
            try {
                for (var _b = __values(canvas.layers), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var layer = _c.value;
                    _this._unsubscribeFromLayerEvents(layer);
                }
            }
            catch (e_8_1) { e_8 = { error: e_8_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_8) throw e_8.error; }
            }
        };
        this._subscribeToLayerEvents = function (layer) {
            var e_9, _a;
            if (layer == null)
                return;
            layer.itemHandlers.add_collectionChanged(_this._notifyItemHanderCollectionChanged);
            layer.itemHandlers.add_collectionChanged(_this._onItemHanderCollectionChanged);
            try {
                for (var _b = __values(layer.itemHandlers.cast()), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var itemHandler = _c.value;
                    _this._subscribeToItemHandlerEvents(itemHandler);
                }
            }
            catch (e_9_1) { e_9 = { error: e_9_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_9) throw e_9.error; }
            }
        };
        this._unsubscribeFromLayerEvents = function (layer) {
            var e_10, _a;
            if (layer == null)
                return;
            layer.itemHandlers.remove_collectionChanged(_this._notifyItemHanderCollectionChanged);
            layer.itemHandlers.remove_collectionChanged(_this._onItemHanderCollectionChanged);
            try {
                for (var _b = __values(layer.itemHandlers.cast()), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var itemHandler = _c.value;
                    _this._unsubscribeFromItemHandlerEvents(itemHandler);
                }
            }
            catch (e_10_1) { e_10 = { error: e_10_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_10) throw e_10.error; }
            }
        };
        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);
    }
    Object.defineProperty(EventManager.prototype, "canvas", {
        get: function () { return this._canvas; },
        set: function (value) {
            this._unsubscribeFromCanvasEvents(this._canvas);
            this._canvas = value;
            this._subscribeOnCanvasEvents(this._canvas);
        },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.setProduct = function (product) {
        if (product == this._product)
            return;
        this._unsubscribeFromProductEvents(this._product);
        this._product = product;
        this._subscribeToProductEvents(this._product);
    };
    Object.defineProperty(EventManager.prototype, "itemChangedEvent", {
        get: function () { return this._itemChangedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addItemChanged = function (listener) { this._itemChangedEvent.add(listener); };
    ;
    EventManager.prototype.removeItemChanged = function (listener) { this._itemChangedEvent.remove(listener); };
    ;
    Object.defineProperty(EventManager.prototype, "itemChangingEvent", {
        get: function () { return this._itemChangingEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addItemChanging = function (listener) { this._itemChangingEvent.add(listener); };
    ;
    EventManager.prototype.removeItemChanging = function (listener) { this._itemChangingEvent.remove(listener); };
    ;
    Object.defineProperty(EventManager.prototype, "itemPropertyChangedEvent", {
        get: function () { return this._itemPropertyChangedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addItemPropertyChanged = function (listener) { this._itemPropertyChangedEvent.add(listener); };
    ;
    EventManager.prototype.removeItemPropertyChanged = function (listener) { this._itemPropertyChangedEvent.remove(listener); };
    ;
    Object.defineProperty(EventManager.prototype, "surfaceChangedEvent", {
        get: function () { return this._changeSurfaceEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addSurfaceChanged = function (listener) { this._changeSurfaceEvent.add(listener); };
    EventManager.prototype.removeSurfaceChanged = function (listener) { this._changeSurfaceEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "itemAddedEvent", {
        get: function () { return this._itemAddedEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addItemAdded = function (listener) { this._itemAddedEvent.add(listener); };
    EventManager.prototype.removeItemAdded = function (listener) { this._itemAddedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "itemRemovedEvent", {
        get: function () { return this._itemRemovedEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addItemRemoved = function (listener) { this._itemRemovedEvent.add(listener); };
    EventManager.prototype.removeItemRemoved = function (listener) { this._itemRemovedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "itemMovedEvent", {
        get: function () { return this._itemMovedEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addItemMoved = function (listener) { this._itemMovedEvent.add(listener); };
    EventManager.prototype.removeItemMoved = function (listener) { this._itemMovedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "imageContentChangedEvent", {
        get: function () { return this._imageContentChangedEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addImageContentChanged = function (listener) { this._imageContentChangedEvent.add(listener); };
    EventManager.prototype.removeImageContentChanged = function (listener) { this._imageContentChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "snapshotLoadedEvent", {
        get: function () { return this._snapshotLoadedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addSnapshotLoadedEvent = function (listener) { this._snapshotLoadedEvent.add(listener); };
    EventManager.prototype.removeSnapshotLoadedEvent = function (listener) { this._snapshotLoadedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "beforeSnapshotLoad", {
        get: function () { return this._beforeSnapshotLoad; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addBeforeSnapshotLoad = function (listener) { this._beforeSnapshotLoad.add(listener); };
    EventManager.prototype.removeBeforeSnapshotLoad = function (listener) { this._beforeSnapshotLoad.remove(listener); };
    Object.defineProperty(EventManager.prototype, "surfaceCollectionChangedEvent", {
        get: function () { return this._surfaceCollectionChangedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addSurfaceCollectionChanged = function (listener) { this._surfaceCollectionChangedEvent.add(listener); };
    EventManager.prototype.removeSurfaceCollectionChanged = function (listener) { this._surfaceCollectionChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "layerCollectionChangedEvent", {
        get: function () { return this._layerCollectionChangedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addLayerCollectionChanged = function (listener) { this._layerCollectionChangedEvent.add(listener); };
    EventManager.prototype.removeLayerCollectionChanged = function (listener) { this._layerCollectionChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "itemHanderCollectionChangedEvent", {
        get: function () { return this._itemHanderCollectionChangedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addIItemHandelrCollectionChanged = function (listener) { this._itemHanderCollectionChangedEvent.add(listener); };
    EventManager.prototype.removeItemHandlerCollectionChanged = function (listener) { this._itemHanderCollectionChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "containerCollectionChangedEvent", {
        get: function () { return this._containerCollectionChangedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addContainerCollectionChanged = function (listener) { this._containerCollectionChangedEvent.add(listener); };
    EventManager.prototype.removeContainerCollectionChanged = function (listener) { this._containerCollectionChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "itemCollectionChangedEvent", {
        get: function () { return this._itemCollectionChangedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addItemCollectionChanged = function (listener) { this._itemCollectionChangedEvent.add(listener); };
    EventManager.prototype.removeItemCollectionChanged = function (listener) { this._itemCollectionChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "underMockupContainerCollectionChangedEvent", {
        get: function () { return this._underMockupContainerCollectionChangedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addUnderMockupContainerCollectionChanged = function (listener) { this._underMockupContainerCollectionChangedEvent.add(listener); };
    EventManager.prototype.removeUnderMockupContainerCollectionChanged = function (listener) { this._underMockupContainerCollectionChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "overMockupContainerCollectionChangedEvent", {
        get: function () { return this._overMockupContainerCollectionChangedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addOverMockupContainerCollectionChanged = function (listener) { this._overMockupContainerCollectionChangedEvent.add(listener); };
    EventManager.prototype.removeOverMockupContainerCollectionChanged = function (listener) { this._overMockupContainerCollectionChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "previewMockupContainerCollectionChangedEvent", {
        get: function () { return this._previewMockupContainerCollectionChangedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addPreviewMockupContainerCollectionChanged = function (listener) { this._previewMockupContainerCollectionChangedEvent.add(listener); };
    EventManager.prototype.removePreviewMockupContainerCollectionChanged = function (listener) { this._previewMockupContainerCollectionChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "deleteToolbarButtonClickEvent", {
        get: function () { return this._deleteToolbarButtonClickEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addDeleteToolbarButtonClick = function (listener) { this._deleteToolbarButtonClickEvent.add(listener); };
    EventManager.prototype.removeDeleteToolbarButtonClick = function (listener) { this._deleteToolbarButtonClickEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "handleToolbarButtonClickEvent", {
        get: function () { return this._handleToolbarButtonClickEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addHandleToolbarButtonClick = function (listener) { this._handleToolbarButtonClickEvent.add(listener); };
    EventManager.prototype.removeHandleToolbarButtonClick = function (listener) { this._handleToolbarButtonClickEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "selectToolbarButtonClickEvent", {
        get: function () { return this._selectToolbarButtonClickEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addSelectToolbarButtonClick = function (listener) { this._selectToolbarButtonClickEvent.add(listener); };
    EventManager.prototype.removeSelectToolbarButtonClick = function (listener) { this._selectToolbarButtonClickEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "enteredEditModeEvent", {
        get: function () { return this._enteredEditModeEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addEnteredEditMode = function (listener) { this._enteredEditModeEvent.add(listener); };
    EventManager.prototype.removeEnteredEditMode = function (listener) { this._enteredEditModeEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "exitedEditModeEvent", {
        get: function () { return this._exitedEditModeEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addExitedEditMode = function (listener) { this._exitedEditModeEvent.add(listener); };
    EventManager.prototype.removeExitedEditMode = function (listener) { this._exitedEditModeEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "editToolbarButtonClickEvent", {
        get: function () { return this._editToolbarButtonClickEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addEditToolbarButtonClick = function (listener) { this._editToolbarButtonClickEvent.add(listener); };
    EventManager.prototype.removeEditToolbarButtonClick = function (listener) { this._editToolbarButtonClickEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "selectButtonClickEvent", {
        get: function () { return this._selectButtonClickEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addSelectButtonClick = function (listener) { this._selectButtonClickEvent.add(listener); };
    EventManager.prototype.removeSelectButtonClick = function (listener) { this._selectButtonClickEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "violationWarningButtonClickEvent", {
        get: function () { return this._violationWarningButtonClickEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addViolationWarningButtonClick = function (listener) { this._violationWarningButtonClickEvent.add(listener); };
    EventManager.prototype.removeViolationWarningButtonClick = function (listener) { this._violationWarningButtonClickEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "doubleClickEvent", {
        get: function () { return this._doubleClickEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addDoubleClick = function (listener) { this._doubleClickEvent.add(listener); };
    EventManager.prototype.removeDoubleClick = function (listener) { this._doubleClickEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "shapePathLoadedEvent", {
        get: function () { return this._shapePathLoadedEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addShapePathLoaded = function (listener) { this._shapePathLoadedEvent.add(listener); };
    EventManager.prototype.removeShapePathLoaded = function (listener) { this._shapePathLoadedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "currentItemChangedEvent", {
        get: function () { return this._currentItemChangedEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addCurrentItemChanged = function (listener) { this._currentItemChangedEvent.add(listener); };
    EventManager.prototype.removeCurrentItemChanged = function (listener) { this._currentItemChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "selectedItemChangedEvent", {
        get: function () { return this._selectedItemChangedEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addSelectedItemChanged = function (listener) { this._selectedItemChangedEvent.add(listener); };
    EventManager.prototype.removeSelectedItemChanged = function (listener) { this._selectedItemChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "dragNDropDoneEvent", {
        get: function () { return this._dragNDropDoneEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addDragNDropDone = function (listener) { this._dragNDropDoneEvent.add(listener); };
    EventManager.prototype.removeDragNDropDone = function (listener) { this._dragNDropDoneEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "dragNDropStartingEvent", {
        get: function () { return this._dragNDropStartingEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addDragNDropStarting = function (listener) { this._dragNDropStartingEvent.add(listener); };
    EventManager.prototype.removeDragNDropStarting = function (listener) { this._dragNDropStartingEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "dragNDropPerformedEvent", {
        get: function () { return this._dragNDropPerformedEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addDragNDropPerformed = function (listener) { this._dragNDropPerformedEvent.add(listener); };
    EventManager.prototype.removeDragNDropPerformed = function (listener) { this._dragNDropPerformedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "readyEvent", {
        get: function () { return this._readyEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addReady = function (listener) { this._readyEvent.add(listener); };
    EventManager.prototype.removeReady = function (listener) { this._readyEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "workspaceSizeChangedEvent", {
        get: function () { return this._workspaceSizeChangedEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addWorkspaceSizeChanged = function (listener) { this._workspaceSizeChangedEvent.add(listener); };
    EventManager.prototype.removeWorkspaceSizeChanged = function (listener) { this._workspaceSizeChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "productThemeChangedEvent", {
        get: function () { return this._productThemeChangedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addProductThemeChanged = function (listener) { this._productThemeChangedEvent.add(listener); };
    EventManager.prototype.removeProductThemeChanged = function (listener) { this._productThemeChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "userEditContainerChangedEvent", {
        get: function () { return this._userEditContainerChangedEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addUserEditContainerChanged = function (listener) { this._userEditContainerChangedEvent.add(listener); };
    EventManager.prototype.removeUserEditContainerChanged = function (listener) { this._userEditContainerChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "createInputHandlerFinishedEvent", {
        get: function () { return this._createInputHandlerFinishedEvent; },
        enumerable: true,
        configurable: true
    });
    EventManager.prototype.addcreateInputHandlerFinished = function (listener) { this._createInputHandlerFinishedEvent.add(listener); };
    EventManager.prototype.removecreateInputHandlerFinished = function (listener) { this._createInputHandlerFinishedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "printAreaCollectionChangedEvent", {
        get: function () { return this._printAreaCollectionChangedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addPrintAreaCollectionChanged = function (listener) { this._printAreaCollectionChangedEvent.add(listener); };
    EventManager.prototype.removePrintAreaCollectionChanged = function (listener) { this._printAreaCollectionChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "printAreaPropertyChangedEvent", {
        get: function () { return this._printAreaPropertyChangedEvent; },
        enumerable: true,
        configurable: true
    });
    ;
    EventManager.prototype.addPrintAreaPropertyChanged = function (listener) { this._printAreaPropertyChangedEvent.add(listener); };
    EventManager.prototype.removePrintAreaPropertyChanged = function (listener) { this._printAreaPropertyChangedEvent.remove(listener); };
    Object.defineProperty(EventManager.prototype, "selectPixelFinished", {
        get: function () { return this._selectPixelFinishedEvent; },
        enumerable: true,
        c