@node-projects/web-component-designer 0.0.216 → 0.0.217

package/dist/elements/widgets/designerView/tools/PointerTool.js

@@ -1,397 +1,397 @@
-import { EventNames } from '../../../../enums/EventNames.js';
-import { PointerActionType } from '../../../../enums/PointerActionType.js';
-import { DesignItem } from '../../../item/DesignItem.js';
-import { ExtensionType } from '../extensions/ExtensionType.js';
-import { NamedTools } from './NamedTools.js';
-export class PointerTool {
-    cursor = 'default';
-    _movedSinceStartedAction = false;
-    _initialPoint;
-    _actionType;
-    _actionStartedDesignItem;
-    _actionStartedDesignItems;
-    _clonedItems;
-    _copiedItemsInserted = false;
-    _previousEventName;
-    _dragOverExtensionItem;
-    _dragExtensionItem;
-    _moveItemsOffset = { x: 0, y: 0 };
-    _initialOffset;
-    _started = false;
-    ;
-    _firstTimeInMove;
-    _secondTimeInMove;
-    _changeGroup;
-    constructor() {
-    }
-    activated(serviceContainer) {
-    }
-    dispose() {
-    }
-    _showContextMenu(event, designerCanvas) {
-        event.preventDefault();
-        if (!event.shiftKey) {
-            let items = designerCanvas.elementsFromPoint(event.x, event.y);
-            for (let e of designerCanvas.instanceServiceContainer.selectionService.selectedElements) {
-                if (items.indexOf(e.element) >= 0) {
-                    designerCanvas.showDesignItemContextMenu(designerCanvas.instanceServiceContainer.selectionService.primarySelection, event);
-                    return;
-                }
-            }
-            let newEl = designerCanvas.serviceContainer.elementAtPointService.getElementAtPoint(designerCanvas, { x: event.x, y: event.y });
-            const designItem = DesignItem.GetOrCreateDesignItem(newEl, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
-            if (!designerCanvas.instanceServiceContainer.selectionService.isSelected(designItem)) {
-                designerCanvas.instanceServiceContainer.selectionService.setSelectedElements([designItem]);
-            }
-            designerCanvas.showDesignItemContextMenu(designItem, event);
-        }
-    }
-    pointerEventHandler(designerCanvas, event, currentElement) {
-        if (event.ctrlKey)
-            this.cursor = 'copy';
-        else
-            this.cursor = 'default';
-        const interactionServices = designerCanvas.serviceContainer.elementInteractionServices;
-        if (interactionServices)
-            for (let s of interactionServices) {
-                if (s.stopEventHandling(designerCanvas, event, currentElement))
-                    return;
-            }
-        if (event.button == 2 && event.type == EventNames.PointerDown) {
-            this._showContextMenu(event, designerCanvas);
-            return;
-        }
-        if (((event.ctrlKey || event.metaKey) && event.shiftKey) || event.buttons == 4) {
-            const panTool = designerCanvas.serviceContainer.designerTools.get(NamedTools.Pan);
-            if (panTool) {
-                panTool.pointerEventHandler(designerCanvas, event, currentElement);
-                return;
-            }
-        }
-        switch (event.type) {
-            case EventNames.PointerDown:
-                event.target.setPointerCapture(event.pointerId);
-                designerCanvas.captureActiveTool(this);
-                this._movedSinceStartedAction = false;
-                this._copiedItemsInserted = false;
-                this._clonedItems = null;
-                this._firstTimeInMove = false;
-                this._secondTimeInMove = false;
-                break;
-            case EventNames.PointerUp:
-                event.target.releasePointerCapture(event.pointerId);
-                designerCanvas.releaseActiveTool();
-                this._copiedItemsInserted = false;
-                this._clonedItems = null;
-                this._firstTimeInMove = false;
-                this._secondTimeInMove = false;
-                break;
-            case EventNames.PointerMove:
-                if (this._firstTimeInMove)
-                    this._secondTimeInMove = true;
-                if (this._secondTimeInMove)
-                    this._firstTimeInMove = false;
-                else
-                    this._firstTimeInMove = true;
-                break;
-        }
-        if (!currentElement)
-            return;
-        const currentPoint = designerCanvas.getNormalizedEventCoordinates(event);
-        const currentDesignItem = DesignItem.GetOrCreateDesignItem(currentElement, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
-        if (this._actionType == null) {
-            this._initialPoint = currentPoint;
-            this._initialOffset = designerCanvas.getNormalizedOffsetInElement(event, currentElement);
-            if (event.type == EventNames.PointerDown) {
-                this._actionStartedDesignItem = currentDesignItem;
-                this._actionStartedDesignItems = [...designerCanvas.instanceServiceContainer.selectionService.selectedElements];
-                designerCanvas.snapLines.clearSnaplines();
-                if (currentDesignItem !== designerCanvas.rootDesignItem) {
-                    this._actionType = PointerActionType.Drag;
-                }
-                else if (currentElement === designerCanvas || currentElement === designerCanvas.rootDesignItem.element || currentElement == null) {
-                    designerCanvas.instanceServiceContainer.selectionService.setSelectedElements(null);
-                    this._actionType = PointerActionType.DrawSelection;
-                }
-                else {
-                    this._actionType = PointerActionType.DragOrSelect;
-                }
-            }
-        }
-        if (event.type === EventNames.PointerMove) {
-            this._movedSinceStartedAction = this._movedSinceStartedAction || currentPoint.x != this._initialPoint.x || currentPoint.y != this._initialPoint.y;
-            if (this._actionType == PointerActionType.DrawSelection)
-                this._actionType = PointerActionType.DrawingSelection;
-        }
-        if (this._actionType == PointerActionType.DrawSelection || this._actionType == PointerActionType.DrawingSelection) {
-            this._pointerActionTypeDrawSelection(designerCanvas, event, currentElement);
-        }
-        else if (this._actionType == PointerActionType.DragOrSelect || this._actionType == PointerActionType.Drag) {
-            this._pointerActionTypeDragOrSelect(designerCanvas, event, currentDesignItem, currentPoint);
-        }
-        if (event.type == EventNames.PointerUp) {
-            designerCanvas.snapLines.clearSnaplines();
-            if (this._actionType == PointerActionType.DrawSelection) {
-                if (currentDesignItem !== designerCanvas.rootDesignItem)
-                    designerCanvas.instanceServiceContainer.selectionService.setSelectedElements([currentDesignItem]);
-            }
-            this._resetTool();
-        }
-        this._previousEventName = event.type;
-    }
-    _resetTool() {
-        this._actionType = null;
-        this._actionStartedDesignItem = null;
-        this._actionStartedDesignItems = null;
-        this._movedSinceStartedAction = false;
-        this._initialPoint = null;
-    }
-    _pointerActionTypeDrawSelection(designerView, event, currentElement) {
-        const drawSelectionTool = designerView.serviceContainer.designerTools.get(NamedTools.DrawSelection);
-        if (drawSelectionTool) {
-            this._resetTool();
-            drawSelectionTool.pointerEventHandler(designerView, event, currentElement);
-        }
-    }
-    async _pointerActionTypeDragOrSelect(designerCanvas, event, currentDesignItem, currentPoint) {
-        if (event.altKey) {
-            if (event.type == EventNames.PointerDown) {
-                const currentSelection = designerCanvas.instanceServiceContainer.selectionService.primarySelection;
-                if (currentSelection) {
-                    const elements = designerCanvas.elementsFromPoint(event.x, event.y);
-                    let idx = elements.indexOf(currentSelection.element);
-                    if (idx >= 0) {
-                        idx++;
-                    }
-                    let currentElement = elements[idx];
-                    if (currentElement)
-                        currentDesignItem = DesignItem.GetOrCreateDesignItem(currentElement, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
-                }
-            }
-        }
-        switch (event.type) {
-            case EventNames.PointerDown:
-                {
-                    this._actionStartedDesignItem = currentDesignItem;
-                    this._moveItemsOffset = { x: 0, y: 0 };
-                    this._actionStartedDesignItems = [...designerCanvas.instanceServiceContainer.selectionService.selectedElements];
-                    if (designerCanvas.alignOnSnap)
-                        designerCanvas.snapLines.calculateSnaplines(designerCanvas.instanceServiceContainer.selectionService.selectedElements);
-                    break;
-                }
-            case EventNames.PointerMove:
-                {
-                    if (event.buttons == 0) {
-                        return;
-                    }
-                    if (this._firstTimeInMove) {
-                        if (!currentDesignItem.instanceServiceContainer.selectionService.selectedElements.includes(currentDesignItem)) {
-                            if (event.ctrlKey || event.shiftKey)
-                                currentDesignItem.instanceServiceContainer.selectionService.setSelectedElements([...currentDesignItem.instanceServiceContainer.selectionService.selectedElements, currentDesignItem]);
-                            else
-                                currentDesignItem.instanceServiceContainer.selectionService.setSelectedElements([currentDesignItem]);
-                            this._actionStartedDesignItems = [...designerCanvas.instanceServiceContainer.selectionService.selectedElements];
-                            if (designerCanvas.alignOnSnap)
-                                designerCanvas.snapLines.calculateSnaplines(designerCanvas.instanceServiceContainer.selectionService.selectedElements);
-                        }
-                    }
-                    // *** Copy Items via Ctrl Drag ***
-                    if (!this._clonedItems) {
-                        this._clonedItems = [];
-                        for (let d of this._actionStartedDesignItems) {
-                            const clone = await d.clone();
-                            if (this._clonedItems && clone)
-                                this._clonedItems.push(clone);
-                        }
-                    }
-                    if (!this._actionStartedDesignItem)
-                        return;
-                    if (event.ctrlKey && !this._copiedItemsInserted) {
-                        this._copiedItemsInserted = true;
-                        if (!this._changeGroup)
-                            this._changeGroup = designerCanvas.rootDesignItem.openGroup("Copy Elements");
-                        for (let i = 0; i < this._clonedItems.length; i++) {
-                            this._actionStartedDesignItems[i].insertAdjacentElement(this._clonedItems[i], 'beforebegin');
-                        }
-                        designerCanvas.instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'added', designItems: this._clonedItems });
-                    }
-                    else if (!event.ctrlKey && this._copiedItemsInserted) {
-                        for (let d of this._clonedItems) {
-                            d.remove();
-                        }
-                        this._copiedItemsInserted = false;
-                        designerCanvas.instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'removed', designItems: this._clonedItems });
-                    }
-                    // *** End Copy Items Part ***
-                    const elementMoved = currentPoint.x != this._initialPoint.x || currentPoint.y != this._initialPoint.y;
-                    if (this._actionType != PointerActionType.Drag && elementMoved) {
-                        this._actionType = PointerActionType.Drag;
-                    }
-                    if (this._movedSinceStartedAction) {
-                        const containerStyle = getComputedStyle(this._actionStartedDesignItem.parent.element);
-                        const currentContainerService = designerCanvas.serviceContainer.getLastServiceWhere('containerService', x => x.serviceForContainer(this._actionStartedDesignItem.parent, containerStyle));
-                        if (currentContainerService) {
-                            const dragItem = this._actionStartedDesignItem.parent;
-                            if (this._dragExtensionItem != dragItem) {
-                                designerCanvas.extensionManager.removeExtension(this._dragExtensionItem, ExtensionType.ContainerDrag);
-                                designerCanvas.extensionManager.applyExtension(dragItem, ExtensionType.ContainerDrag, event);
-                                this._dragExtensionItem = dragItem;
-                            }
-                            else {
-                                designerCanvas.extensionManager.refreshExtension(dragItem, ExtensionType.ContainerDrag);
-                            }
-                            const canLeave = currentContainerService.canLeave(this._actionStartedDesignItem.parent, this._actionStartedDesignItems);
-                            let newContainerElementDesignItem = null;
-                            let newContainerService = null;
-                            if (canLeave) {
-                                [newContainerElementDesignItem, newContainerService] = PointerTool.FindPossibleContainer(this._actionStartedDesignItem, this._actionStartedDesignItems, event);
-                                //if we found a new enterable container create extensions 
-                                if (newContainerElementDesignItem != null) {
-                                    if (this._dragOverExtensionItem != newContainerElementDesignItem) {
-                                        designerCanvas.extensionManager.removeExtension(this._dragOverExtensionItem, ExtensionType.ContainerDragOver);
-                                        designerCanvas.extensionManager.applyExtension(newContainerElementDesignItem, ExtensionType.ContainerDragOver, event);
-                                        this._dragOverExtensionItem = newContainerElementDesignItem;
-                                    }
-                                    else {
-                                        designerCanvas.extensionManager.refreshExtension(newContainerElementDesignItem, ExtensionType.ContainerDragOver, event);
-                                    }
-                                }
-                                else {
-                                    if (this._dragOverExtensionItem) {
-                                        designerCanvas.extensionManager.removeExtension(this._dragOverExtensionItem, ExtensionType.ContainerDragOver);
-                                        this._dragOverExtensionItem = null;
-                                    }
-                                }
-                            }
-                            if (newContainerService && event.altKey) {
-                                //TODO: all items, fix position
-                                const oldOffset = currentContainerService.getElementOffset(this._actionStartedDesignItem.parent, this._actionStartedDesignItem);
-                                const newOffset = newContainerService.getElementOffset(newContainerElementDesignItem, this._actionStartedDesignItem);
-                                this._moveItemsOffset = { x: newOffset.x - oldOffset.x + this._moveItemsOffset.x, y: newOffset.y - oldOffset.y + this._moveItemsOffset.y };
-                                currentContainerService.leaveContainer(this._actionStartedDesignItem.parent, this._actionStartedDesignItems);
-                                for (let di of this._actionStartedDesignItems)
-                                    newContainerElementDesignItem._insertChildInternal(di); //todo -> maybe in enter container???
-                                const cp = { x: currentPoint.x - this._moveItemsOffset.x, y: currentPoint.y - this._moveItemsOffset.y };
-                                newContainerService.enterContainer(newContainerElementDesignItem, this._actionStartedDesignItems);
-                                newContainerService.place(event, designerCanvas, this._actionStartedDesignItem.parent, this._initialPoint, this._initialOffset, cp, this._actionStartedDesignItems);
-                            }
-                            else {
-                                const cp = { x: currentPoint.x - this._moveItemsOffset.x, y: currentPoint.y - this._moveItemsOffset.y };
-                                if (!this._started) {
-                                    for (const item of this._actionStartedDesignItems) {
-                                        designerCanvas.extensionManager.removeExtension(item, ExtensionType.Placement);
-                                        designerCanvas.extensionManager.removeExtension(item, ExtensionType.MouseOver);
-                                        designerCanvas.extensionManager.applyExtension(item, ExtensionType.Placement, event);
-                                    }
-                                    currentContainerService.startPlace(event, designerCanvas, this._actionStartedDesignItem.parent, this._initialPoint, this._initialOffset, cp, this._actionStartedDesignItems);
-                                    this._started = true;
-                                }
-                                currentContainerService.place(event, designerCanvas, this._actionStartedDesignItem.parent, this._initialPoint, this._initialOffset, cp, this._actionStartedDesignItems);
-                            }
-                            designerCanvas.extensionManager.refreshExtensions(this._actionStartedDesignItems, null, event);
-                        }
-                    }
-                    break;
-                }
-            case EventNames.PointerUp:
-                {
-                    this._started = false;
-                    if (!this._movedSinceStartedAction || this._actionType == PointerActionType.DragOrSelect) {
-                        if (this._previousEventName == EventNames.PointerDown && !event.shiftKey && !event.ctrlKey) {
-                            designerCanvas.instanceServiceContainer.selectionService.setSelectedElements([this._actionStartedDesignItem]);
-                        }
-                        else {
-                            this.checkSelectElement(event, designerCanvas, currentDesignItem);
-                        }
-                        return;
-                    }
-                    if (this._movedSinceStartedAction) {
-                        const containerStyle = getComputedStyle(this._actionStartedDesignItem.parent.element);
-                        let containerService = designerCanvas.serviceContainer.getLastServiceWhere('containerService', x => x.serviceForContainer(this._actionStartedDesignItem.parent, containerStyle));
-                        const cp = { x: currentPoint.x - this._moveItemsOffset.x, y: currentPoint.y - this._moveItemsOffset.y };
-                        if (containerService) {
-                            if (!this._changeGroup)
-                                this._changeGroup = designerCanvas.rootDesignItem.openGroup("Move Elements");
-                            containerService.finishPlace(event, designerCanvas, this._actionStartedDesignItem.parent, this._initialPoint, this._initialOffset, cp, designerCanvas.instanceServiceContainer.selectionService.selectedElements);
-                            this._changeGroup.commit();
-                            this._changeGroup = null;
-                            for (const item of this._actionStartedDesignItems) {
-                                designerCanvas.extensionManager.applyExtension(item, ExtensionType.MouseOver, event);
-                                designerCanvas.extensionManager.removeExtension(item, ExtensionType.Placement);
-                            }
-                        }
-                        designerCanvas.extensionManager.removeExtension(this._dragExtensionItem, ExtensionType.ContainerDrag);
-                        this._dragExtensionItem = null;
-                        designerCanvas.extensionManager.removeExtension(this._dragOverExtensionItem, ExtensionType.ContainerDragOver);
-                        this._dragOverExtensionItem = null;
-                        this._moveItemsOffset = { x: 0, y: 0 };
-                    }
-                    designerCanvas.extensionManager.refreshExtensions(designerCanvas.instanceServiceContainer.selectionService.selectedElements, null, event);
-                    if (this._changeGroup) {
-                        this._changeGroup.abort();
-                        this._changeGroup = null;
-                    }
-                    break;
-                }
-        }
-    }
-    checkSelectElement(event, designerCanvas, currentDesignItem) {
-        if (event.shiftKey || event.ctrlKey) {
-            const index = designerCanvas.instanceServiceContainer.selectionService.selectedElements.indexOf(currentDesignItem);
-            if (index >= 0) {
-                let newSelectedList = designerCanvas.instanceServiceContainer.selectionService.selectedElements.slice(0);
-                newSelectedList.splice(index, 1);
-                designerCanvas.instanceServiceContainer.selectionService.setSelectedElements(newSelectedList);
-            }
-            else {
-                let newSelectedList = designerCanvas.instanceServiceContainer.selectionService.selectedElements.slice(0);
-                newSelectedList.push(currentDesignItem);
-                designerCanvas.instanceServiceContainer.selectionService.setSelectedElements(newSelectedList);
-            }
-        }
-        else {
-            if (designerCanvas.instanceServiceContainer.selectionService.selectedElements.indexOf(currentDesignItem) < 0)
-                designerCanvas.instanceServiceContainer.selectionService.setSelectedElements([currentDesignItem]);
-        }
-    }
-    static FindPossibleContainer(designItem, designItems, event) {
-        let newContainerElementDesignItem = null;
-        let newContainerService = null;
-        const designerCanvas = designItem.instanceServiceContainer.designerCanvas;
-        const elementsFromPoint = designerCanvas.elementsFromPoint(event.x, event.y);
-        for (let e of elementsFromPoint) {
-            if (e == designItem.element) {
-                continue;
-            }
-            else if (e == designItem.parent.element) {
-                break;
-            }
-            else if (e == designerCanvas.rootDesignItem.element) {
-                newContainerElementDesignItem = designerCanvas.rootDesignItem;
-                const containerStyle = getComputedStyle(newContainerElementDesignItem.element);
-                newContainerService = designerCanvas.serviceContainer.getLastServiceWhere('containerService', x => x.serviceForContainer(newContainerElementDesignItem, containerStyle));
-                break;
-            }
-            else if (false) {
-                //check we don't try to move a item over one of its children..
-            }
-            else {
-                newContainerElementDesignItem = DesignItem.GetOrCreateDesignItem(e, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
-                const containerStyle = getComputedStyle(newContainerElementDesignItem.element);
-                newContainerService = designerCanvas.serviceContainer.getLastServiceWhere('containerService', x => x.serviceForContainer(newContainerElementDesignItem, containerStyle));
-                if (newContainerService) {
-                    if (newContainerService.canEnter(newContainerElementDesignItem, designItems)) {
-                        break;
-                    }
-                    else {
-                        newContainerElementDesignItem = null;
-                        newContainerService = null;
-                        continue;
-                    }
-                }
-            }
-        }
-        return [newContainerElementDesignItem, newContainerService];
-    }
-    keyboardEventHandler(designerCanvas, event, currentElement) { }
-}
+import { EventNames } from '../../../../enums/EventNames.js';
+import { PointerActionType } from '../../../../enums/PointerActionType.js';
+import { DesignItem } from '../../../item/DesignItem.js';
+import { ExtensionType } from '../extensions/ExtensionType.js';
+import { NamedTools } from './NamedTools.js';
+export class PointerTool {
+    cursor = 'default';
+    _movedSinceStartedAction = false;
+    _initialPoint;
+    _actionType;
+    _actionStartedDesignItem;
+    _actionStartedDesignItems;
+    _clonedItems;
+    _copiedItemsInserted = false;
+    _previousEventName;
+    _dragOverExtensionItem;
+    _dragExtensionItem;
+    _moveItemsOffset = { x: 0, y: 0 };
+    _initialOffset;
+    _started = false;
+    ;
+    _firstTimeInMove;
+    _secondTimeInMove;
+    _changeGroup;
+    constructor() {
+    }
+    activated(serviceContainer) {
+    }
+    dispose() {
+    }
+    _showContextMenu(event, designerCanvas) {
+        event.preventDefault();
+        if (!event.shiftKey) {
+            let items = designerCanvas.elementsFromPoint(event.x, event.y);
+            for (let e of designerCanvas.instanceServiceContainer.selectionService.selectedElements) {
+                if (items.indexOf(e.element) >= 0) {
+                    designerCanvas.showDesignItemContextMenu(designerCanvas.instanceServiceContainer.selectionService.primarySelection, event);
+                    return;
+                }
+            }
+            let newEl = designerCanvas.serviceContainer.elementAtPointService.getElementAtPoint(designerCanvas, { x: event.x, y: event.y });
+            const designItem = DesignItem.GetOrCreateDesignItem(newEl, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
+            if (!designerCanvas.instanceServiceContainer.selectionService.isSelected(designItem)) {
+                designerCanvas.instanceServiceContainer.selectionService.setSelectedElements([designItem]);
+            }
+            designerCanvas.showDesignItemContextMenu(designItem, event);
+        }
+    }
+    pointerEventHandler(designerCanvas, event, currentElement) {
+        if (event.ctrlKey)
+            this.cursor = 'copy';
+        else
+            this.cursor = 'default';
+        const interactionServices = designerCanvas.serviceContainer.elementInteractionServices;
+        if (interactionServices)
+            for (let s of interactionServices) {
+                if (s.stopEventHandling(designerCanvas, event, currentElement))
+                    return;
+            }
+        if (event.button == 2 && event.type == EventNames.PointerDown) {
+            this._showContextMenu(event, designerCanvas);
+            return;
+        }
+        if (((event.ctrlKey || event.metaKey) && event.shiftKey) || event.buttons == 4) {
+            const panTool = designerCanvas.serviceContainer.designerTools.get(NamedTools.Pan);
+            if (panTool) {
+                panTool.pointerEventHandler(designerCanvas, event, currentElement);
+                return;
+            }
+        }
+        switch (event.type) {
+            case EventNames.PointerDown:
+                event.target.setPointerCapture(event.pointerId);
+                designerCanvas.captureActiveTool(this);
+                this._movedSinceStartedAction = false;
+                this._copiedItemsInserted = false;
+                this._clonedItems = null;
+                this._firstTimeInMove = false;
+                this._secondTimeInMove = false;
+                break;
+            case EventNames.PointerUp:
+                event.target.releasePointerCapture(event.pointerId);
+                designerCanvas.releaseActiveTool();
+                this._copiedItemsInserted = false;
+                this._clonedItems = null;
+                this._firstTimeInMove = false;
+                this._secondTimeInMove = false;
+                break;
+            case EventNames.PointerMove:
+                if (this._firstTimeInMove)
+                    this._secondTimeInMove = true;
+                if (this._secondTimeInMove)
+                    this._firstTimeInMove = false;
+                else
+                    this._firstTimeInMove = true;
+                break;
+        }
+        if (!currentElement)
+            return;
+        const currentPoint = designerCanvas.getNormalizedEventCoordinates(event);
+        const currentDesignItem = DesignItem.GetOrCreateDesignItem(currentElement, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
+        if (this._actionType == null) {
+            this._initialPoint = currentPoint;
+            this._initialOffset = designerCanvas.getNormalizedOffsetInElement(event, currentElement);
+            if (event.type == EventNames.PointerDown) {
+                this._actionStartedDesignItem = currentDesignItem;
+                this._actionStartedDesignItems = [...designerCanvas.instanceServiceContainer.selectionService.selectedElements];
+                designerCanvas.snapLines.clearSnaplines();
+                if (currentDesignItem !== designerCanvas.rootDesignItem) {
+                    this._actionType = PointerActionType.Drag;
+                }
+                else if (currentElement === designerCanvas || currentElement === designerCanvas.rootDesignItem.element || currentElement == null) {
+                    designerCanvas.instanceServiceContainer.selectionService.setSelectedElements(null);
+                    this._actionType = PointerActionType.DrawSelection;
+                }
+                else {
+                    this._actionType = PointerActionType.DragOrSelect;
+                }
+            }
+        }
+        if (event.type === EventNames.PointerMove) {
+            this._movedSinceStartedAction = this._movedSinceStartedAction || currentPoint.x != this._initialPoint.x || currentPoint.y != this._initialPoint.y;
+            if (this._actionType == PointerActionType.DrawSelection)
+                this._actionType = PointerActionType.DrawingSelection;
+        }
+        if (this._actionType == PointerActionType.DrawSelection || this._actionType == PointerActionType.DrawingSelection) {
+            this._pointerActionTypeDrawSelection(designerCanvas, event, currentElement);
+        }
+        else if (this._actionType == PointerActionType.DragOrSelect || this._actionType == PointerActionType.Drag) {
+            this._pointerActionTypeDragOrSelect(designerCanvas, event, currentDesignItem, currentPoint);
+        }
+        if (event.type == EventNames.PointerUp) {
+            designerCanvas.snapLines.clearSnaplines();
+            if (this._actionType == PointerActionType.DrawSelection) {
+                if (currentDesignItem !== designerCanvas.rootDesignItem)
+                    designerCanvas.instanceServiceContainer.selectionService.setSelectedElements([currentDesignItem]);
+            }
+            this._resetTool();
+        }
+        this._previousEventName = event.type;
+    }
+    _resetTool() {
+        this._actionType = null;
+        this._actionStartedDesignItem = null;
+        this._actionStartedDesignItems = null;
+        this._movedSinceStartedAction = false;
+        this._initialPoint = null;
+    }
+    _pointerActionTypeDrawSelection(designerView, event, currentElement) {
+        const drawSelectionTool = designerView.serviceContainer.designerTools.get(NamedTools.DrawSelection);
+        if (drawSelectionTool) {
+            this._resetTool();
+            drawSelectionTool.pointerEventHandler(designerView, event, currentElement);
+        }
+    }
+    async _pointerActionTypeDragOrSelect(designerCanvas, event, currentDesignItem, currentPoint) {
+        if (event.altKey) {
+            if (event.type == EventNames.PointerDown) {
+                const currentSelection = designerCanvas.instanceServiceContainer.selectionService.primarySelection;
+                if (currentSelection) {
+                    const elements = designerCanvas.elementsFromPoint(event.x, event.y);
+                    let idx = elements.indexOf(currentSelection.element);
+                    if (idx >= 0) {
+                        idx++;
+                    }
+                    let currentElement = elements[idx];
+                    if (currentElement)
+                        currentDesignItem = DesignItem.GetOrCreateDesignItem(currentElement, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
+                }
+            }
+        }
+        switch (event.type) {
+            case EventNames.PointerDown:
+                {
+                    this._actionStartedDesignItem = currentDesignItem;
+                    this._moveItemsOffset = { x: 0, y: 0 };
+                    this._actionStartedDesignItems = [...designerCanvas.instanceServiceContainer.selectionService.selectedElements];
+                    if (designerCanvas.alignOnSnap)
+                        designerCanvas.snapLines.calculateSnaplines(designerCanvas.instanceServiceContainer.selectionService.selectedElements);
+                    break;
+                }
+            case EventNames.PointerMove:
+                {
+                    if (event.buttons == 0) {
+                        return;
+                    }
+                    if (this._firstTimeInMove) {
+                        if (!currentDesignItem.instanceServiceContainer.selectionService.selectedElements.includes(currentDesignItem)) {
+                            if (event.ctrlKey || event.shiftKey)
+                                currentDesignItem.instanceServiceContainer.selectionService.setSelectedElements([...currentDesignItem.instanceServiceContainer.selectionService.selectedElements, currentDesignItem]);
+                            else
+                                currentDesignItem.instanceServiceContainer.selectionService.setSelectedElements([currentDesignItem]);
+                            this._actionStartedDesignItems = [...designerCanvas.instanceServiceContainer.selectionService.selectedElements];
+                            if (designerCanvas.alignOnSnap)
+                                designerCanvas.snapLines.calculateSnaplines(designerCanvas.instanceServiceContainer.selectionService.selectedElements);
+                        }
+                    }
+                    // *** Copy Items via Ctrl Drag ***
+                    if (!this._clonedItems) {
+                        this._clonedItems = [];
+                        for (let d of this._actionStartedDesignItems) {
+                            const clone = await d.clone();
+                            if (this._clonedItems && clone)
+                                this._clonedItems.push(clone);
+                        }
+                    }
+                    if (!this._actionStartedDesignItem)
+                        return;
+                    if (event.ctrlKey && !this._copiedItemsInserted) {
+                        this._copiedItemsInserted = true;
+                        if (!this._changeGroup)
+                            this._changeGroup = designerCanvas.rootDesignItem.openGroup("Copy Elements");
+                        for (let i = 0; i < this._clonedItems.length; i++) {
+                            this._actionStartedDesignItems[i].insertAdjacentElement(this._clonedItems[i], 'beforebegin');
+                        }
+                        designerCanvas.instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'added', designItems: this._clonedItems });
+                    }
+                    else if (!event.ctrlKey && this._copiedItemsInserted) {
+                        for (let d of this._clonedItems) {
+                            d.remove();
+                        }
+                        this._copiedItemsInserted = false;
+                        designerCanvas.instanceServiceContainer.contentService.onContentChanged.emit({ changeType: 'removed', designItems: this._clonedItems });
+                    }
+                    // *** End Copy Items Part ***
+                    const elementMoved = currentPoint.x != this._initialPoint.x || currentPoint.y != this._initialPoint.y;
+                    if (this._actionType != PointerActionType.Drag && elementMoved) {
+                        this._actionType = PointerActionType.Drag;
+                    }
+                    if (this._movedSinceStartedAction) {
+                        const containerStyle = getComputedStyle(this._actionStartedDesignItem.parent.element);
+                        const currentContainerService = designerCanvas.serviceContainer.getLastServiceWhere('containerService', x => x.serviceForContainer(this._actionStartedDesignItem.parent, containerStyle));
+                        if (currentContainerService) {
+                            const dragItem = this._actionStartedDesignItem.parent;
+                            if (this._dragExtensionItem != dragItem) {
+                                designerCanvas.extensionManager.removeExtension(this._dragExtensionItem, ExtensionType.ContainerDrag);
+                                designerCanvas.extensionManager.applyExtension(dragItem, ExtensionType.ContainerDrag, event);
+                                this._dragExtensionItem = dragItem;
+                            }
+                            else {
+                                designerCanvas.extensionManager.refreshExtension(dragItem, ExtensionType.ContainerDrag);
+                            }
+                            const canLeave = currentContainerService.canLeave(this._actionStartedDesignItem.parent, this._actionStartedDesignItems);
+                            let newContainerElementDesignItem = null;
+                            let newContainerService = null;
+                            if (canLeave) {
+                                [newContainerElementDesignItem, newContainerService] = PointerTool.FindPossibleContainer(this._actionStartedDesignItem, this._actionStartedDesignItems, event);
+                                //if we found a new enterable container create extensions 
+                                if (newContainerElementDesignItem != null) {
+                                    if (this._dragOverExtensionItem != newContainerElementDesignItem) {
+                                        designerCanvas.extensionManager.removeExtension(this._dragOverExtensionItem, ExtensionType.ContainerDragOver);
+                                        designerCanvas.extensionManager.applyExtension(newContainerElementDesignItem, ExtensionType.ContainerDragOver, event);
+                                        this._dragOverExtensionItem = newContainerElementDesignItem;
+                                    }
+                                    else {
+                                        designerCanvas.extensionManager.refreshExtension(newContainerElementDesignItem, ExtensionType.ContainerDragOver, event);
+                                    }
+                                }
+                                else {
+                                    if (this._dragOverExtensionItem) {
+                                        designerCanvas.extensionManager.removeExtension(this._dragOverExtensionItem, ExtensionType.ContainerDragOver);
+                                        this._dragOverExtensionItem = null;
+                                    }
+                                }
+                            }
+                            if (newContainerService && event.altKey) {
+                                //TODO: all items, fix position
+                                const oldOffset = currentContainerService.getElementOffset(this._actionStartedDesignItem.parent, this._actionStartedDesignItem);
+                                const newOffset = newContainerService.getElementOffset(newContainerElementDesignItem, this._actionStartedDesignItem);
+                                this._moveItemsOffset = { x: newOffset.x - oldOffset.x + this._moveItemsOffset.x, y: newOffset.y - oldOffset.y + this._moveItemsOffset.y };
+                                currentContainerService.leaveContainer(this._actionStartedDesignItem.parent, this._actionStartedDesignItems);
+                                for (let di of this._actionStartedDesignItems)
+                                    newContainerElementDesignItem._insertChildInternal(di); //todo -> maybe in enter container???
+                                const cp = { x: currentPoint.x - this._moveItemsOffset.x, y: currentPoint.y - this._moveItemsOffset.y };
+                                newContainerService.enterContainer(newContainerElementDesignItem, this._actionStartedDesignItems);
+                                newContainerService.place(event, designerCanvas, this._actionStartedDesignItem.parent, this._initialPoint, this._initialOffset, cp, this._actionStartedDesignItems);
+                            }
+                            else {
+                                const cp = { x: currentPoint.x - this._moveItemsOffset.x, y: currentPoint.y - this._moveItemsOffset.y };
+                                if (!this._started) {
+                                    for (const item of this._actionStartedDesignItems) {
+                                        designerCanvas.extensionManager.removeExtension(item, ExtensionType.Placement);
+                                        designerCanvas.extensionManager.removeExtension(item, ExtensionType.MouseOver);
+                                        designerCanvas.extensionManager.applyExtension(item, ExtensionType.Placement, event);
+                                    }
+                                    currentContainerService.startPlace(event, designerCanvas, this._actionStartedDesignItem.parent, this._initialPoint, this._initialOffset, cp, this._actionStartedDesignItems);
+                                    this._started = true;
+                                }
+                                currentContainerService.place(event, designerCanvas, this._actionStartedDesignItem.parent, this._initialPoint, this._initialOffset, cp, this._actionStartedDesignItems);
+                            }
+                            designerCanvas.extensionManager.refreshExtensions(this._actionStartedDesignItems, null, event);
+                        }
+                    }
+                    break;
+                }
+            case EventNames.PointerUp:
+                {
+                    this._started = false;
+                    if (!this._movedSinceStartedAction || this._actionType == PointerActionType.DragOrSelect) {
+                        if (this._previousEventName == EventNames.PointerDown && !event.shiftKey && !event.ctrlKey) {
+                            designerCanvas.instanceServiceContainer.selectionService.setSelectedElements([this._actionStartedDesignItem]);
+                        }
+                        else {
+                            this.checkSelectElement(event, designerCanvas, currentDesignItem);
+                        }
+                        return;
+                    }
+                    if (this._movedSinceStartedAction) {
+                        const containerStyle = getComputedStyle(this._actionStartedDesignItem.parent.element);
+                        let containerService = designerCanvas.serviceContainer.getLastServiceWhere('containerService', x => x.serviceForContainer(this._actionStartedDesignItem.parent, containerStyle));
+                        const cp = { x: currentPoint.x - this._moveItemsOffset.x, y: currentPoint.y - this._moveItemsOffset.y };
+                        if (containerService) {
+                            if (!this._changeGroup)
+                                this._changeGroup = designerCanvas.rootDesignItem.openGroup("Move Elements");
+                            containerService.finishPlace(event, designerCanvas, this._actionStartedDesignItem.parent, this._initialPoint, this._initialOffset, cp, designerCanvas.instanceServiceContainer.selectionService.selectedElements);
+                            this._changeGroup.commit();
+                            this._changeGroup = null;
+                            for (const item of this._actionStartedDesignItems) {
+                                designerCanvas.extensionManager.applyExtension(item, ExtensionType.MouseOver, event);
+                                designerCanvas.extensionManager.removeExtension(item, ExtensionType.Placement);
+                            }
+                        }
+                        designerCanvas.extensionManager.removeExtension(this._dragExtensionItem, ExtensionType.ContainerDrag);
+                        this._dragExtensionItem = null;
+                        designerCanvas.extensionManager.removeExtension(this._dragOverExtensionItem, ExtensionType.ContainerDragOver);
+                        this._dragOverExtensionItem = null;
+                        this._moveItemsOffset = { x: 0, y: 0 };
+                    }
+                    designerCanvas.extensionManager.refreshExtensions(designerCanvas.instanceServiceContainer.selectionService.selectedElements, null, event);
+                    if (this._changeGroup) {
+                        this._changeGroup.abort();
+                        this._changeGroup = null;
+                    }
+                    break;
+                }
+        }
+    }
+    checkSelectElement(event, designerCanvas, currentDesignItem) {
+        if (event.shiftKey || event.ctrlKey) {
+            const index = designerCanvas.instanceServiceContainer.selectionService.selectedElements.indexOf(currentDesignItem);
+            if (index >= 0) {
+                let newSelectedList = designerCanvas.instanceServiceContainer.selectionService.selectedElements.slice(0);
+                newSelectedList.splice(index, 1);
+                designerCanvas.instanceServiceContainer.selectionService.setSelectedElements(newSelectedList);
+            }
+            else {
+                let newSelectedList = designerCanvas.instanceServiceContainer.selectionService.selectedElements.slice(0);
+                newSelectedList.push(currentDesignItem);
+                designerCanvas.instanceServiceContainer.selectionService.setSelectedElements(newSelectedList);
+            }
+        }
+        else {
+            if (designerCanvas.instanceServiceContainer.selectionService.selectedElements.indexOf(currentDesignItem) < 0)
+                designerCanvas.instanceServiceContainer.selectionService.setSelectedElements([currentDesignItem]);
+        }
+    }
+    static FindPossibleContainer(designItem, designItems, event) {
+        let newContainerElementDesignItem = null;
+        let newContainerService = null;
+        const designerCanvas = designItem.instanceServiceContainer.designerCanvas;
+        const elementsFromPoint = designerCanvas.elementsFromPoint(event.x, event.y);
+        for (let e of elementsFromPoint) {
+            if (e == designItem.element) {
+                continue;
+            }
+            else if (e == designItem.parent.element) {
+                break;
+            }
+            else if (e == designerCanvas.rootDesignItem.element) {
+                newContainerElementDesignItem = designerCanvas.rootDesignItem;
+                const containerStyle = getComputedStyle(newContainerElementDesignItem.element);
+                newContainerService = designerCanvas.serviceContainer.getLastServiceWhere('containerService', x => x.serviceForContainer(newContainerElementDesignItem, containerStyle));
+                break;
+            }
+            else if (false) {
+                //check we don't try to move a item over one of its children..
+            }
+            else {
+                newContainerElementDesignItem = DesignItem.GetOrCreateDesignItem(e, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
+                const containerStyle = getComputedStyle(newContainerElementDesignItem.element);
+                newContainerService = designerCanvas.serviceContainer.getLastServiceWhere('containerService', x => x.serviceForContainer(newContainerElementDesignItem, containerStyle));
+                if (newContainerService) {
+                    if (newContainerService.canEnter(newContainerElementDesignItem, designItems)) {
+                        break;
+                    }
+                    else {
+                        newContainerElementDesignItem = null;
+                        newContainerService = null;
+                        continue;
+                    }
+                }
+            }
+        }
+        return [newContainerElementDesignItem, newContainerService];
+    }
+    keyboardEventHandler(designerCanvas, event, currentElement) { }
+}