@node-projects/web-component-designer 0.0.95 → 0.0.98

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

@@ -0,0 +1,283 @@
+import { EventNames } from "../../../../enums/EventNames";
+import { PointerActionType } from "../../../../enums/PointerActionType";
+import { DesignItem } from "../../../item/DesignItem";
+import { ExtensionType } from "../extensions/ExtensionType";
+import { NamedTools } from './NamedTools';
+export class PointerTool {
+    cursor = 'default';
+    _movedSinceStartedAction = false;
+    _initialPoint;
+    _actionType;
+    _actionStartedDesignItem;
+    _previousEventName;
+    _dragOverExtensionItem;
+    _dragExtensionItem;
+    _moveItemsOffset = { x: 0, y: 0 };
+    _initialOffset;
+    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;
+                }
+            }
+            const designItem = DesignItem.GetOrCreateDesignItem(event.target, 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.button == 2) {
+            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;
+                break;
+            case EventNames.PointerUp:
+                event.target.releasePointerCapture(event.pointerId);
+                designerCanvas.releaseActiveTool();
+                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;
+                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._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);
+        }
+    }
+    _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 };
+                    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]);
+                    }
+                    if (designerCanvas.alignOnSnap)
+                        designerCanvas.snapLines.calculateSnaplines(designerCanvas.instanceServiceContainer.selectionService.selectedElements);
+                    break;
+                }
+            case EventNames.PointerMove:
+                {
+                    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);
+                                this._dragExtensionItem = dragItem;
+                            }
+                            else {
+                                designerCanvas.extensionManager.refreshExtension(dragItem, ExtensionType.ContainerDrag);
+                            }
+                            const canLeave = currentContainerService.canLeave(this._actionStartedDesignItem.parent, [this._actionStartedDesignItem]);
+                            let newContainerElementDesignItem = null;
+                            let newContainerService = null;
+                            if (canLeave) {
+                                const elementsFromPoint = designerCanvas.elementsFromPoint(event.x, event.y);
+                                for (let e of elementsFromPoint) {
+                                    if (e == this._actionStartedDesignItem.element) {
+                                        continue;
+                                    }
+                                    else if (e == this._actionStartedDesignItem.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, [this._actionStartedDesignItem])) {
+                                                break;
+                                            }
+                                            else {
+                                                newContainerElementDesignItem = null;
+                                                newContainerService = null;
+                                                continue;
+                                            }
+                                        }
+                                    }
+                                }
+                                //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);
+                                        this._dragOverExtensionItem = newContainerElementDesignItem;
+                                    }
+                                    else {
+                                        designerCanvas.extensionManager.refreshExtension(newContainerElementDesignItem, ExtensionType.ContainerDragOver);
+                                    }
+                                }
+                                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._actionStartedDesignItem]);
+                                newContainerElementDesignItem._insertChildInternal(this._actionStartedDesignItem);
+                                const cp = { x: currentPoint.x - this._moveItemsOffset.x, y: currentPoint.y - this._moveItemsOffset.y };
+                                newContainerService.enterContainer(newContainerElementDesignItem, [this._actionStartedDesignItem]);
+                                newContainerService.place(event, designerCanvas, this._actionStartedDesignItem.parent, this._initialPoint, this._initialOffset, cp, designerCanvas.instanceServiceContainer.selectionService.selectedElements);
+                            }
+                            else {
+                                const cp = { x: currentPoint.x - this._moveItemsOffset.x, y: currentPoint.y - this._moveItemsOffset.y };
+                                currentContainerService.place(event, designerCanvas, this._actionStartedDesignItem.parent, this._initialPoint, this._initialOffset, cp, designerCanvas.instanceServiceContainer.selectionService.selectedElements);
+                            }
+                            designerCanvas.extensionManager.refreshExtensions(designerCanvas.instanceServiceContainer.selectionService.selectedElements);
+                        }
+                    }
+                    break;
+                }
+            case EventNames.PointerUp:
+                {
+                    if (!this._movedSinceStartedAction || this._actionType == PointerActionType.DragOrSelect) {
+                        if (this._previousEventName == EventNames.PointerDown && !event.shiftKey && !event.ctrlKey)
+                            designerCanvas.instanceServiceContainer.selectionService.setSelectedElements([this._actionStartedDesignItem]);
+                        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) {
+                            let cg = designerCanvas.rootDesignItem.openGroup("Move Elements", designerCanvas.instanceServiceContainer.selectionService.selectedElements);
+                            containerService.finishPlace(event, designerCanvas, this._actionStartedDesignItem.parent, this._initialPoint, this._initialOffset, cp, designerCanvas.instanceServiceContainer.selectionService.selectedElements);
+                            cg.commit();
+                        }
+                        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);
+                    break;
+                }
+        }
+    }
+    keyboardEventHandler(designerCanvas, event, currentElement) { }
+}

package/dist/elements/widgets/designerView/toolBar/RectangleSelectorTool.d.ts

@@ -0,0 +1,12 @@
+import { ServiceContainer } from '../../../services/ServiceContainer.js';
+import { IDesignerCanvas } from '../IDesignerCanvas';
+import { ITool } from './ITool';
+export declare class RectangleSelectorTool implements ITool {
+    cursor: string;
+    private _rect;
+    private _initialPoint;
+    activated(serviceContainer: ServiceContainer): void;
+    pointerEventHandler(designerCanvas: IDesignerCanvas, event: PointerEvent, currentElement: Element): void;
+    keyboardEventHandler(designerCanvas: IDesignerCanvas, event: KeyboardEvent, currentElement: Element): void;
+    dispose(): void;
+}

package/dist/elements/widgets/designerView/toolBar/RectangleSelectorTool.js

@@ -0,0 +1,84 @@
+import { EventNames } from '../../../../enums/EventNames';
+import { DesignItem } from '../../../item/DesignItem';
+import { OverlayLayer } from '../extensions/OverlayLayer.js';
+export class RectangleSelectorTool {
+    cursor = 'progress';
+    _rect;
+    _initialPoint;
+    activated(serviceContainer) {
+    }
+    pointerEventHandler(designerCanvas, event, currentElement) {
+        const currentPoint = designerCanvas.getNormalizedEventCoordinates(event);
+        switch (event.type) {
+            case EventNames.PointerDown:
+                event.target.setPointerCapture(event.pointerId);
+                designerCanvas.captureActiveTool(this);
+                this._initialPoint = currentPoint;
+                if (!this._rect)
+                    this._rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+                this._rect.setAttribute('class', 'svg-selector');
+                this._rect.setAttribute('x', (this._initialPoint.x * designerCanvas.scaleFactor));
+                this._rect.setAttribute('y', (this._initialPoint.y * designerCanvas.scaleFactor));
+                this._rect.setAttribute('width', 0);
+                this._rect.setAttribute('height', 0);
+                designerCanvas.overlayLayer.addOverlay(this._rect, OverlayLayer.Foregorund);
+                break;
+            case EventNames.PointerMove:
+                if (this._initialPoint) {
+                    let w = currentPoint.x - this._initialPoint.x;
+                    let h = currentPoint.y - this._initialPoint.y;
+                    if (w >= 0) {
+                        this._rect.setAttribute('x', this._initialPoint.x);
+                        this._rect.setAttribute('width', w);
+                    }
+                    else {
+                        this._rect.setAttribute('x', currentPoint.x);
+                        this._rect.setAttribute('width', (-1 * w));
+                    }
+                    if (h >= 0) {
+                        this._rect.setAttribute('y', this._initialPoint.y);
+                        this._rect.setAttribute('height', h);
+                    }
+                    else {
+                        this._rect.setAttribute('y', currentPoint.y);
+                        this._rect.setAttribute('height', (-1 * h));
+                    }
+                }
+                break;
+            case EventNames.PointerUp:
+                event.target.releasePointerCapture(event.pointerId);
+                designerCanvas.releaseActiveTool();
+                const elements = designerCanvas.rootDesignItem.element.querySelectorAll('*');
+                const inSelectionElements = [];
+                let point = designerCanvas.overlayLayer.createPoint();
+                for (let e of elements) {
+                    let elementRect = designerCanvas.getNormalizedElementCoordinates(e);
+                    point.x = elementRect.x;
+                    point.y = elementRect.y;
+                    const p1 = this._rect.isPointInFill(point);
+                    point.x = elementRect.x + elementRect.width;
+                    point.y = elementRect.y;
+                    const p2 = p1 && this._rect.isPointInFill(point);
+                    point.x = elementRect.x;
+                    point.y = elementRect.y + elementRect.height;
+                    const p3 = p2 && this._rect.isPointInFill(point);
+                    point.x = elementRect.x + elementRect.width;
+                    point.y = elementRect.y + elementRect.height;
+                    const p4 = p3 && this._rect.isPointInFill(point);
+                    if (p4) {
+                        const desItem = DesignItem.GetOrCreateDesignItem(e, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
+                        inSelectionElements.push(desItem);
+                    }
+                }
+                designerCanvas.overlayLayer.removeOverlay(this._rect);
+                this._rect = null;
+                this._initialPoint = null;
+                designerCanvas.instanceServiceContainer.selectionService.setSelectedElements(inSelectionElements);
+                designerCanvas.serviceContainer.globalContext.finishedWithTool(this);
+                break;
+        }
+    }
+    keyboardEventHandler(designerCanvas, event, currentElement) { }
+    dispose() {
+    }
+}

package/dist/elements/widgets/designerView/toolBar/TextTool.d.ts

@@ -0,0 +1,11 @@
+import { ServiceContainer } from '../../../services/ServiceContainer.js';
+import { IDesignerCanvas } from '../IDesignerCanvas';
+import { ITool } from './ITool';
+export declare class TextTool implements ITool {
+    constructor();
+    activated(serviceContainer: ServiceContainer): void;
+    dispose(): void;
+    readonly cursor = "text";
+    pointerEventHandler(designerCanvas: IDesignerCanvas, event: PointerEvent, currentElement: Element): void;
+    keyboardEventHandler(designerCanvas: IDesignerCanvas, event: KeyboardEvent, currentElement: Element): void;
+}

package/dist/elements/widgets/designerView/toolBar/TextTool.js

@@ -0,0 +1,33 @@
+import { EventNames } from '../../../../enums/EventNames.js';
+import { DesignItem } from '../../../item/DesignItem.js';
+import { InsertAction } from '../../../services/undoService/transactionItems/InsertAction.js';
+import { ExtensionType } from '../extensions/ExtensionType.js';
+export class TextTool {
+    constructor() {
+    }
+    activated(serviceContainer) {
+    }
+    dispose() {
+    }
+    cursor = 'text';
+    pointerEventHandler(designerCanvas, event, currentElement) {
+        const currentPoint = designerCanvas.getNormalizedEventCoordinates(event);
+        switch (event.type) {
+            case EventNames.PointerDown:
+                const span = document.createElement('span');
+                const di = DesignItem.createDesignItemFromInstance(span, designerCanvas.serviceContainer, designerCanvas.instanceServiceContainer);
+                di.setStyle('position', 'absolute');
+                di.setStyle('left', currentPoint.x + 'px');
+                di.setStyle('top', currentPoint.y + 'px');
+                designerCanvas.instanceServiceContainer.undoService.execute(new InsertAction(designerCanvas.rootDesignItem, designerCanvas.rootDesignItem.childCount, di));
+                designerCanvas.serviceContainer.globalContext.finishedWithTool(this);
+                //TODO - don't apply doubleclick extension (maybe it is not the doubleclick one) - apply edit text extesion directly
+                designerCanvas.extensionManager.applyExtension(di, ExtensionType.Doubleclick);
+                setTimeout(() => {
+                    span.focus();
+                }, 50);
+                break;
+        }
+    }
+    keyboardEventHandler(designerCanvas, event, currentElement) { }
+}

package/dist/elements/widgets/designerView/toolBar/ZoomTool.d.ts

@@ -0,0 +1,17 @@
+import { ServiceContainer } from '../../../services/ServiceContainer.js';
+import { IDesignerCanvas } from '../IDesignerCanvas';
+import { ITool } from './ITool';
+export declare class ZoomTool implements ITool {
+    cursor: string;
+    private _rect;
+    private _startPoint;
+    private _endPoint;
+    private _pointerMovementTolerance;
+    private _zoomStepSize;
+    activated(serviceContainer: ServiceContainer): void;
+    pointerEventHandler(designerCanvas: IDesignerCanvas, event: PointerEvent, currentElement: Element): void;
+    private _zoomOnto;
+    private _isPositionEqual;
+    keyboardEventHandler(designerCanvas: IDesignerCanvas, event: KeyboardEvent, currentElement: Element): void;
+    dispose(): void;
+}

package/dist/elements/widgets/designerView/toolBar/ZoomTool.js

@@ -0,0 +1,79 @@
+import { EventNames, OverlayLayer } from '../../../../index.js';
+export class ZoomTool {
+    cursor = 'zoom-in';
+    _rect;
+    _startPoint;
+    _endPoint;
+    _pointerMovementTolerance = 5;
+    _zoomStepSize = 0.2; //number x 100 = Scale in percent
+    activated(serviceContainer) {
+    }
+    pointerEventHandler(designerCanvas, event, currentElement) {
+        const eventPoint = designerCanvas.getNormalizedEventCoordinates(event);
+        switch (event.type) {
+            case EventNames.PointerDown:
+                this._startPoint = eventPoint;
+                if (!this._rect)
+                    this._rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+                this._rect.setAttribute('class', 'svg-selector');
+                this._rect.setAttribute('x', (this._startPoint.x * designerCanvas.zoomFactor));
+                this._rect.setAttribute('y', (this._startPoint.y * designerCanvas.zoomFactor));
+                this._rect.setAttribute('width', 0);
+                this._rect.setAttribute('height', 0);
+                designerCanvas.overlayLayer.addOverlay(this._rect, OverlayLayer.Foregorund);
+                break;
+            case EventNames.PointerMove:
+                if (this._startPoint) {
+                    let width = eventPoint.x - this._startPoint.x;
+                    let height = eventPoint.y - this._startPoint.y;
+                    if (width >= 0) {
+                        this._rect.setAttribute('x', this._startPoint.x);
+                        this._rect.setAttribute('width', width);
+                    }
+                    else {
+                        this._rect.setAttribute('x', eventPoint.x);
+                        this._rect.setAttribute('width', (-1 * width));
+                    }
+                    if (height >= 0) {
+                        this._rect.setAttribute('y', this._startPoint.y);
+                        this._rect.setAttribute('height', height);
+                    }
+                    else {
+                        this._rect.setAttribute('y', eventPoint.y);
+                        this._rect.setAttribute('height', (-1 * height));
+                    }
+                }
+                break;
+            case EventNames.PointerUp:
+                this._endPoint = eventPoint;
+                let isLeftClick = event.button == 0;
+                switch (event.button) {
+                    case 0: //Left-Click
+                    case 2: //Right-Click
+                        this._zoomOnto(isLeftClick, this._startPoint, this._endPoint, designerCanvas);
+                        break;
+                }
+                designerCanvas.overlayLayer.removeOverlay(this._rect);
+                this._rect = null;
+                this._startPoint = null;
+                break;
+        }
+    }
+    _zoomOnto(isZoomInto, startPoint, endPoint, designerCanvas) {
+        if (this._isPositionEqual(startPoint, endPoint)) {
+            const oldZoom = designerCanvas.zoomFactor;
+            const newZoom = isZoomInto ? oldZoom + this._zoomStepSize : oldZoom - this._zoomStepSize;
+            designerCanvas.zoomTowardsPoint(endPoint, newZoom);
+        }
+        else {
+            designerCanvas.zoomOntoRectangle(startPoint, endPoint);
+        }
+    }
+    _isPositionEqual(startPoint, endPoint) {
+        let tolerance = this._pointerMovementTolerance;
+        return Math.abs(startPoint.x - endPoint.x) <= tolerance && Math.abs(startPoint.y - endPoint.y) <= tolerance;
+    }
+    keyboardEventHandler(designerCanvas, event, currentElement) { }
+    dispose() {
+    }
+}

package/dist/elements/widgets/designerView/toolBar/designerToolbarGenerics/designerToolRenderer.d.ts

@@ -0,0 +1,5 @@
+import { ToolPopupCategoryCollection } from "./designerToolsButtons";
+export declare abstract class DesignerToolRenderer {
+    static createToolFromObject(tool: ToolPopupCategoryCollection): ChildNode;
+    static createObjectFromTool(tool: HTMLDivElement): ToolPopupCategoryCollection;
+}

package/dist/elements/widgets/designerView/toolBar/designerToolbarGenerics/designerToolRenderer.js

@@ -0,0 +1,19 @@
+//TODO: rename, this is no renderer, it's a static class so more a helper
+export class DesignerToolRenderer {
+    static createToolFromObject(tool) {
+        let template = document.createElement('template');
+        template.innerHTML = "<div class='tool' data-command='setTool' data-command-parameter=" + tool.command_parameter + " popup=" + tool.category + " title=" + tool.title + " style='background-image:" + tool.background_url + ";" + (tool.margin ? "margin: " + tool.margin + ";" : "") + "'></div>";
+        return template.content.childNodes[0];
+    }
+    static createObjectFromTool(tool) {
+        let collector = {
+            category: tool.getAttribute("popup"),
+            command: tool.getAttribute("data-command"),
+            command_parameter: tool.getAttribute("data-command-parameter"),
+            title: tool.getAttribute("title"),
+            tool: tool.getAttribute("data-command-parameter"),
+            background_url: tool.style.backgroundImage,
+        };
+        return collector;
+    }
+}

package/dist/elements/widgets/designerView/toolBar/designerToolbarGenerics/designerToolbarPopup.d.ts

@@ -0,0 +1,8 @@
+import { BaseCustomWebComponentConstructorAppend } from "@node-projects/base-custom-webcomponent";
+export declare abstract class DesignerToolbarPopup extends BaseCustomWebComponentConstructorAppend {
+    static readonly style: CSSStyleSheet;
+    static readonly template: HTMLTemplateElement;
+    ready(): void;
+    protected _setTitle(title: string): void;
+    protected _setContent(elements: HTMLElement[]): void;
+}

package/dist/elements/widgets/designerView/toolBar/designerToolbarGenerics/designerToolbarPopup.js

@@ -0,0 +1,41 @@
+import { BaseCustomWebComponentConstructorAppend, css, html } from "@node-projects/base-custom-webcomponent";
+export class DesignerToolbarPopup extends BaseCustomWebComponentConstructorAppend {
+    static style = css `
+        .container {
+            width: 150px;
+            min-height: 200px;
+            color: white;
+            background-color: rgb(64, 64, 64);
+            border: 1px solid black;
+        }
+
+        header {
+            text-align: center;
+        }
+
+        * {
+          pointer-events: auto;
+        }
+    `;
+    static template = html `
+        <div class="container">
+            <header><h2 id="title" style="margin: 0;"></h2></header>
+            <main id="content-area"></main>
+        </div>
+    `;
+    //TODO: remove this class,
+    //     i think the popups need no base, okay if they need one the should at least be normal elmeents
+    // and also the expicit popup should set the size, not the base class. maybe one needs to be bigger, one smaller...
+    ready() {
+        this._setTitle(this.getAttribute("title"));
+    }
+    _setTitle(title) {
+        this._getDomElement("title").innerHTML = title;
+    }
+    _setContent(elements) {
+        let contentArea = this._getDomElement("content-area");
+        for (let elem of elements) {
+            contentArea.appendChild(elem);
+        }
+    }
+}

package/dist/elements/widgets/designerView/toolBar/designerToolbarGenerics/designerToolbarPopupToolSelect.d.ts

@@ -0,0 +1,9 @@
+import { BaseCustomWebComponentConstructorAppend } from "@node-projects/base-custom-webcomponent";
+export declare class DesignerToolbarPopupToolSelect extends BaseCustomWebComponentConstructorAppend {
+    static readonly style: CSSStyleSheet;
+    static readonly template: HTMLTemplateElement;
+    private _popupToolSelected;
+    constructor();
+    insertToolContent(template: HTMLTemplateElement): Promise<void>;
+    private _setupEventHandler;
+}