@datagrok-libraries/dock-spawn-dg 0.0.1

package/src/Point.ts

@@ -0,0 +1,10 @@
+export class Point {
+
+    x: number;
+    y: number;
+    
+    constructor(x: number, y: number) {
+        this.x = x;
+        this.y = y;
+    }
+}

package/src/ResizableContainer.ts

@@ -0,0 +1,293 @@
+import { Dialog } from "./Dialog.js";
+import { ResizeHandle } from "./ResizeHandle.js";
+import { EventHandler } from "./EventHandler.js";
+import { DockManager } from "./DockManager.js";
+import { IDockContainer } from "./interfaces/IDockContainer.js";
+import { ContainerType } from "./ContainerType.js";
+import { Point } from "./Point.js";
+import { Utils } from "./Utils.js";
+import { IThickness } from "./interfaces/IThickness.js";
+import { IState } from "./interfaces/IState.js";
+
+/**
+ * Decorates a dock container with resizer handles around its base element
+ * This enables the container to be resized from all directions
+ */
+export class ResizableContainer implements IDockContainer {
+
+    topLevelElement: HTMLElement;
+    dialog: Dialog;
+    delegate: IDockContainer;
+    dockManager: DockManager;
+    containerElement: HTMLElement;
+    containerType: ContainerType;
+    minimumAllowedChildNodes: number;
+    readyToProcessNextResize: boolean;
+    dockSpawnResizedEvent: CustomEvent<{}>;
+    resizeHandles: ResizeHandle[];
+    previousMousePosition: Point;
+    private iframeEventHandlers: EventHandler[];
+    private disableResize: boolean;
+
+    constructor(dialog: Dialog, delegate: IDockContainer, topLevelElement: HTMLElement, disableResize: boolean = false) {
+        this.dialog = dialog;
+        this.disableResize = disableResize;
+        this.delegate = delegate;
+        this.containerElement = delegate.containerElement;
+        this.dockManager = delegate.dockManager;
+        this.topLevelElement = topLevelElement;
+        this.containerType = delegate.containerType;
+        this.topLevelElement.style.left = this.topLevelElement.offsetLeft + 'px';
+        this.topLevelElement.style.top = this.topLevelElement.offsetTop + 'px';
+        this.minimumAllowedChildNodes = delegate.minimumAllowedChildNodes;
+        this._buildResizeHandles();
+        this.readyToProcessNextResize = true;
+        this.dockSpawnResizedEvent = new CustomEvent("DockSpawnResizedEvent", { composed: true, bubbles: true });
+        this.iframeEventHandlers = [];
+    }
+
+    setActiveChild(/*child*/) {
+    }
+
+    _buildResizeHandles() {
+        this.resizeHandles = [];
+        //    this._buildResizeHandle(true, false, true, false); // Dont need the corner resizer near the close button
+        if (!this.disableResize) {
+            this._buildResizeHandle(false, true, true, false);
+            this._buildResizeHandle(true, false, false, true);
+            this._buildResizeHandle(false, true, false, true);
+
+            this._buildResizeHandle(true, false, false, false);
+            this._buildResizeHandle(false, true, false, false);
+            this._buildResizeHandle(false, false, true, false);
+            this._buildResizeHandle(false, false, false, true);
+        }
+    }
+
+    _buildResizeHandle(east: boolean, west: boolean, north: boolean, south: boolean) {
+        let handle = new ResizeHandle();
+        handle.east = east;
+        handle.west = west;
+        handle.north = north;
+        handle.south = south;
+
+        // Create an invisible div for the handle
+        handle.element = document.createElement('div');
+        this.topLevelElement.appendChild(handle.element);
+
+        // Build the class name for the handle
+        let verticalClass = '';
+        let horizontalClass = '';
+        if (north) verticalClass = 'n';
+        if (south) verticalClass = 's';
+        if (east) horizontalClass = 'e';
+        if (west) horizontalClass = 'w';
+        let cssClass = 'resize-handle-' + verticalClass + horizontalClass;
+        if (verticalClass.length > 0 && horizontalClass.length > 0)
+            handle.corner = true;
+
+        handle.element.classList.add(handle.corner ? 'resize-handle-corner' : 'resize-handle');
+        handle.element.classList.add(cssClass);
+        this.resizeHandles.push(handle);
+
+        handle.mouseDownHandler = new EventHandler(handle.element, 'mousedown', (e) => { this.onMouseDown(handle, <MouseEvent>e); });
+        handle.touchDownHandler = new EventHandler(handle.element, 'touchstart', (e) => { this.onMouseDown(handle, <TouchEvent>e); });
+    }
+
+    saveState(state: IState) {
+        this.delegate.saveState(state);
+    }
+
+    loadState(state: IState) {
+        this.delegate.loadState(state);
+    }
+
+    get width(): number {
+        return this.delegate.width;
+    }
+
+    get height(): number {
+        return this.delegate.height;
+    }
+
+    get name() {
+        return this.delegate.name;
+    }
+    set name(value) {
+        if (value)
+            this.delegate.name = value;
+    }
+
+    resize(width: number, height: number) {
+        this.delegate.resize(width, height);
+        this._adjustResizeHandles(width, height);
+        document.dispatchEvent(this.dockSpawnResizedEvent);
+    }
+
+    _adjustResizeHandles(width: number, height: number) {
+        this.resizeHandles.forEach((handle) => {
+            handle.adjustSize(width, height);
+        });
+    }
+
+    performLayout(children) {
+        this.delegate.performLayout(children, false);
+    }
+
+    destroy() {
+        this.removeDecorator();
+        this.delegate.destroy();
+    }
+
+    removeDecorator() {
+    }
+
+    onMouseMovedIframe(handle, e: MouseEvent, iframe: HTMLIFrameElement) {
+        let posIf = iframe.getBoundingClientRect();
+        this.onMouseMoved(handle, e, { x: posIf.x, y: posIf.y });
+    }
+
+    onMouseMoved(handle: ResizeHandle, event: TouchEvent | MouseEvent, iframeOffset?: { x: number, y: number }) {
+        let touchOrMouseData: { clientX: number, clientY: number } = null;
+        if ((<TouchEvent>event).changedTouches) {
+            if ((<TouchEvent>event).changedTouches.length > 1)
+                return;
+            touchOrMouseData = (<TouchEvent>event).changedTouches[0];
+        } else {
+            touchOrMouseData = <MouseEvent>event;
+        }
+
+        if (!this.readyToProcessNextResize)
+            return;
+        this.readyToProcessNextResize = false;
+
+        if (this.dialog.panel)
+            this.dockManager.suspendLayout(this.dialog.panel);
+        let currentMousePosition = new Point(touchOrMouseData.clientX, touchOrMouseData.clientY);
+        if (iframeOffset)
+            currentMousePosition = new Point(touchOrMouseData.clientX + iframeOffset.x, touchOrMouseData.clientY + iframeOffset.y);
+        let dx = this.dockManager.checkXBounds(this.topLevelElement, currentMousePosition, this.previousMousePosition, handle.west, handle.east);
+        let dy = this.dockManager.checkYBounds(this.topLevelElement, currentMousePosition, this.previousMousePosition, handle.north, handle.south);
+        this._performDrag(handle, dx, dy);
+        this.previousMousePosition = currentMousePosition;
+        this.readyToProcessNextResize = true;
+        if (this.dialog.panel)
+            this.dockManager.resumeLayout(this.dialog.panel);
+
+        this.dockManager.notifyOnContainerResized(this);
+    }
+
+    onMouseDown(handle, event: TouchEvent | MouseEvent) {
+        let touchOrMouseData: { clientX: number, clientY: number } = null;
+        if ((<TouchEvent>event).touches) {
+            if ((<TouchEvent>event).touches.length > 1)
+                return;
+            touchOrMouseData = (<TouchEvent>event).touches[0];
+        } else {
+            touchOrMouseData = <MouseEvent>event;
+        }
+
+        this.previousMousePosition = new Point(touchOrMouseData.clientX, touchOrMouseData.clientY);
+        if (handle.mouseMoveHandler) {
+            handle.mouseMoveHandler.cancel();
+            delete handle.mouseMoveHandler;
+        }
+        if (handle.touchMoveHandler) {
+            handle.touchMoveHandler.cancel();
+            delete handle.touchMoveHandler;
+        }
+        if (handle.mouseUpHandler) {
+            handle.mouseUpHandler.cancel();
+            delete handle.mouseUpHandler;
+        }
+        if (handle.touchUpHandler) {
+            handle.touchUpHandler.cancel();
+            delete handle.touchUpHandler;
+        }
+        for (let e of this.iframeEventHandlers) {
+            e.cancel();
+        }
+        this.iframeEventHandlers = [];
+
+        // Create the mouse event handlers
+        handle.mouseMoveHandler = new EventHandler(window, 'mousemove', (e) => { this.onMouseMoved(handle, <MouseEvent>e); });
+        handle.touchMoveHandler = new EventHandler(window, 'touchmove', (e) => { this.onMouseMoved(handle, <TouchEvent>e); });
+        handle.mouseUpHandler = new EventHandler(window, 'mouseup', (e) => { this.onMouseUp(handle); });
+        handle.touchUpHandler = new EventHandler(window, 'touchend', (e) => { this.onMouseUp(handle); });
+
+        if (this.dockManager.iframes) {
+            for (let f of this.dockManager.iframes) {
+                let mmi = this.onMouseMovedIframe.bind(this);
+                this.iframeEventHandlers.push(new EventHandler(f.contentWindow, 'mousemove', (e) => mmi(handle, e, f)));
+                this.iframeEventHandlers.push(new EventHandler(f.contentWindow, 'mouseup', (e) => this.onMouseUp(handle)));
+                this.iframeEventHandlers.push(new EventHandler(f.contentWindow, 'touchmove', (e) => mmi(handle, e, f)));
+                this.iframeEventHandlers.push(new EventHandler(f.contentWindow, 'touchend', (e) => this.onMouseUp(handle)));
+            }
+        }
+
+        Utils.disableGlobalTextSelection(this.dockManager.config.dialogRootElement);
+    }
+
+    onMouseUp(handle) {
+        handle.mouseMoveHandler.cancel();
+        handle.touchMoveHandler.cancel();
+        handle.mouseUpHandler.cancel();
+        handle.touchUpHandler.cancel();
+        delete handle.mouseMoveHandler;
+        delete handle.touchMoveHandler;
+        delete handle.mouseUpHandler;
+        delete handle.touchUpHandler;
+        for (let e of this.iframeEventHandlers) {
+            e.cancel();
+        }
+        this.iframeEventHandlers = [];
+
+        Utils.enableGlobalTextSelection(this.dockManager.config.dialogRootElement);
+    }
+
+    _performDrag(handle, dx: number, dy: number) {
+        let bounds: IThickness = {};
+        bounds.left = Utils.getPixels(this.topLevelElement.style.left);
+        bounds.top = Utils.getPixels(this.topLevelElement.style.top);
+        bounds.width = this.topLevelElement.clientWidth;
+        bounds.height = this.topLevelElement.clientHeight;
+
+        if (handle.east) this._resizeEast(dx, bounds);
+        if (handle.west) this._resizeWest(dx, bounds);
+        if (handle.north) this._resizeNorth(dy, bounds);
+        if (handle.south) this._resizeSouth(dy, bounds);
+    }
+
+    _resizeWest(dx: number, bounds: IThickness) {
+        this._resizeContainer(dx, 0, -dx, 0, bounds);
+    }
+
+    _resizeEast(dx: number, bounds: IThickness) {
+        this._resizeContainer(0, 0, dx, 0, bounds);
+    }
+
+    _resizeNorth(dy: number, bounds: IThickness) {
+        this._resizeContainer(0, dy, 0, -dy, bounds);
+    }
+
+    _resizeSouth(dy: number, bounds: IThickness) {
+        this._resizeContainer(0, 0, 0, dy, bounds);
+    }
+
+    _resizeContainer(leftDelta: number, topDelta: number, widthDelta: number, heightDelta: number, bounds: IThickness) {
+        bounds.left += leftDelta;
+        bounds.top += topDelta;
+        bounds.width += widthDelta;
+        bounds.height += heightDelta;
+
+        let minWidth = 50;  // TODO: Move to external configuration
+        let minHeight = 50;  // TODO: Move to external configuration
+        bounds.width = Math.max(bounds.width, minWidth);
+        bounds.height = Math.max(bounds.height, minHeight);
+
+        this.topLevelElement.style.left = bounds.left + 'px';
+        this.topLevelElement.style.top = bounds.top + 'px';
+
+        this.resize(bounds.width, bounds.height);
+    }
+}

package/src/ResizeHandle.ts

@@ -0,0 +1,59 @@
+import { EventHandler } from "./EventHandler.js";
+
+export class ResizeHandle {
+
+    element: HTMLElement;
+    handleSize: number;
+    cornerSize: number;
+    east: boolean;
+    west: boolean;
+    north: boolean;
+    south: boolean;
+    corner: boolean;
+    mouseDownHandler: EventHandler;
+    touchDownHandler: EventHandler;
+
+    constructor() {
+        this.element = undefined;
+        this.handleSize = 6;   // TODO: Get this from DOM
+        this.cornerSize = 12;  // TODO: Get this from DOM
+        this.east = false;
+        this.west = false;
+        this.north = false;
+        this.south = false;
+        this.corner = false;
+    }
+
+    adjustSize(clientWidth: number, clientHeight: number) {
+        if (this.corner) {
+            if (this.west) this.element.style.left = '0px';
+            if (this.east) this.element.style.left = (clientWidth - this.cornerSize) + 'px';
+            if (this.north) this.element.style.top = '0px';
+            if (this.south) this.element.style.top = (clientHeight - this.cornerSize) + 'px';
+        }
+        else {
+            if (this.west) {
+                this.element.style.left = '0px';
+                this.element.style.top = this.cornerSize + 'px';
+            }
+            if (this.east) {
+                this.element.style.left = (clientWidth - this.handleSize) + 'px';
+                this.element.style.top = this.cornerSize + 'px';
+            }
+            if (this.north) {
+                this.element.style.left = this.cornerSize + 'px';
+                this.element.style.top = '0px';
+            }
+            if (this.south) {
+                this.element.style.left = this.cornerSize + 'px';
+                this.element.style.top = (clientHeight - this.handleSize) + 'px';
+            }
+
+            if (this.west || this.east) {
+                this.element.style.height = (clientHeight - this.cornerSize * 2) + 'px';
+            } else {
+                this.element.style.width = (clientWidth - this.cornerSize * 2) + 'px';
+            }
+        }
+    }
+}

package/src/SplitterBar.ts

@@ -0,0 +1,157 @@
+import { IDockContainer } from "./interfaces/IDockContainer.js";
+import { EventHandler } from "./EventHandler.js";
+import { Utils } from "./Utils.js";
+import { IMouseOrTouchEvent } from "./interfaces/IMouseOrTouchEvent.js";
+
+export class SplitterBar {
+    previousContainer: IDockContainer;
+    nextContainer: IDockContainer;
+    stackedVertical: boolean;
+    barElement: HTMLDivElement;
+    pointerDownHandler: EventHandler;
+    minPanelSize: number;
+    readyToProcessNextDrag: boolean;
+    dockSpawnResizedEvent: CustomEvent<{}>;
+    previousMouseEvent: { x: number, y: number };
+    pointerMovedHandler: EventHandler;
+    pointerUpHandler: EventHandler;
+
+    private iframeEventHandlers: EventHandler[];
+
+    constructor(previousContainer: IDockContainer, nextContainer: IDockContainer, stackedVertical: boolean) {
+        // The panel to the left/top side of the bar, depending on the bar orientation
+        this.previousContainer = previousContainer;
+        // The panel to the right/bottom side of the bar, depending on the bar orientation
+        this.nextContainer = nextContainer;
+        this.stackedVertical = stackedVertical;
+        this.barElement = document.createElement('div');
+        this.barElement.classList.add(stackedVertical ? 'splitbar-horizontal' : 'splitbar-vertical');
+        this.pointerDownHandler = new EventHandler(this.barElement, 'pointerdown', this.onPointerDown.bind(this));
+        this.minPanelSize = 50; // TODO: Get from container configuration
+        this.readyToProcessNextDrag = true;
+        this.dockSpawnResizedEvent = new CustomEvent("DockSpawnResizedEvent", { composed: true, bubbles: true });
+        this.iframeEventHandlers = [];
+    }
+
+    onPointerDown(e: PointerEvent) {
+        this.barElement.setPointerCapture(e.pointerId);
+        this._startDragging(e);
+    }
+
+    onPointerUp(e: PointerEvent) {
+        this.barElement.releasePointerCapture(e.pointerId);
+        this._stopDragging();
+    }
+
+    onPointerMovedIframe(e: IMouseOrTouchEvent, iframe: HTMLIFrameElement) {
+        if (e.changedTouches != null) {
+            e = e.changedTouches[0];
+        }
+        let posIf = iframe.getBoundingClientRect();
+        this.handleMoveEvent({ x: parseInt("" + e.clientX + posIf.x), y: parseInt("" + e.clientY + posIf.y) });
+    }
+
+    onPointerMoved(e: IMouseOrTouchEvent) {
+        if (e.changedTouches != null) {
+            e = e.changedTouches[0];
+        }
+        this.handleMoveEvent({ x: parseInt("" + e.clientX), y: parseInt("" + e.clientY) });
+    }
+
+    handleMoveEvent(pos: { x: number, y: number }) {
+        if (!this.readyToProcessNextDrag)
+            return;
+        this.readyToProcessNextDrag = false;
+
+        let dockManager = this.previousContainer.dockManager;
+        dockManager.suspendLayout(this.previousContainer);
+        dockManager.suspendLayout(this.nextContainer);
+        let dx = pos.x - this.previousMouseEvent.x;
+        let dy = pos.y - this.previousMouseEvent.y;
+        this._performDrag(dx, dy);
+        this.previousMouseEvent = pos;
+        this.readyToProcessNextDrag = true;
+        dockManager.resumeLayout(this.previousContainer);
+        dockManager.resumeLayout(this.nextContainer);
+    }
+
+    _performDrag(dx: number, dy: number) {
+        let previousWidth = this.previousContainer.containerElement.clientWidth;
+        let previousHeight = this.previousContainer.containerElement.clientHeight;
+        let nextWidth = this.nextContainer.containerElement.clientWidth;
+        let nextHeight = this.nextContainer.containerElement.clientHeight;
+
+        let previousPanelSize = this.stackedVertical ? previousHeight : previousWidth;
+        let nextPanelSize = this.stackedVertical ? nextHeight : nextWidth;
+        let deltaMovement = this.stackedVertical ? dy : dx;
+        let newPreviousPanelSize = previousPanelSize + deltaMovement;
+        let newNextPanelSize = nextPanelSize - deltaMovement;
+
+        if (newPreviousPanelSize < this.minPanelSize || newNextPanelSize < this.minPanelSize) {
+            // One of the panels is smaller than it should be.
+            // In that case, check if the small panel's size is being increased
+            let continueProcessing = (newPreviousPanelSize < this.minPanelSize && newPreviousPanelSize > previousPanelSize) ||
+                (newNextPanelSize < this.minPanelSize && newNextPanelSize > nextPanelSize);
+
+            if (!continueProcessing)
+                return;
+        }
+
+        if (this.stackedVertical) {
+            this.previousContainer.resize(previousWidth, newPreviousPanelSize);
+            this.nextContainer.resize(nextWidth, newNextPanelSize);
+        }
+        else {
+            if (deltaMovement < 0) {
+                this.previousContainer.resize(newPreviousPanelSize, previousHeight);
+                this.nextContainer.resize(newNextPanelSize, nextHeight);
+            } else {
+                this.nextContainer.resize(newNextPanelSize, nextHeight);
+                this.previousContainer.resize(newPreviousPanelSize, previousHeight);
+                this.nextContainer.resize(newNextPanelSize, nextHeight);
+            }
+        }
+
+        document.dispatchEvent(this.dockSpawnResizedEvent);
+    }
+
+    _startDragging(e: IMouseOrTouchEvent) {
+        Utils.disableGlobalTextSelection(this.previousContainer.dockManager.config.dialogRootElement);
+        if (this.pointerMovedHandler) {
+            this.pointerMovedHandler.cancel();
+            delete this.pointerMovedHandler;
+        }
+        if (this.pointerUpHandler) {
+            this.pointerUpHandler.cancel();
+            delete this.pointerUpHandler;
+        }
+        this.pointerMovedHandler = new EventHandler(window, 'pointermove', this.onPointerMoved.bind(this));
+        this.pointerUpHandler = new EventHandler(window, 'pointerup', this.onPointerUp.bind(this));
+
+        if (this.previousContainer.dockManager.iframes) {
+            for (let f of this.previousContainer.dockManager.iframes) {
+                let mmi = this.onPointerMovedIframe.bind(this);
+                this.iframeEventHandlers.push(new EventHandler(f.contentWindow, 'pointermove', (e) => mmi(e, f)));
+                this.iframeEventHandlers.push(new EventHandler(f.contentWindow, 'pointerup', this.onPointerUp.bind(this)));
+            }
+        }
+
+        this.previousMouseEvent = { x: e.clientX, y: e.clientY };
+    }
+
+    _stopDragging() {
+        Utils.enableGlobalTextSelection(this.previousContainer.dockManager.config.dialogRootElement);
+        if (this.pointerMovedHandler) {
+            this.pointerMovedHandler.cancel();
+            delete this.pointerMovedHandler;
+        }
+        if (this.pointerUpHandler) {
+            this.pointerUpHandler.cancel();
+            delete this.pointerUpHandler;
+        }
+        for (let e of this.iframeEventHandlers) {
+            e.cancel();
+        }
+        this.iframeEventHandlers = [];
+    }
+}

package/src/SplitterDockContainer.ts

@@ -0,0 +1,95 @@
+import { DockManager } from "./DockManager.js";
+import { SplitterPanel } from "./SplitterPanel.js";
+import { IDockContainer } from "./interfaces/IDockContainer.js";
+import { ContainerType } from "./ContainerType.js";
+import { ISize } from "./interfaces/ISize.js";
+import { IDockContainerWithSize } from "./interfaces/IDockContainerWithSize.js";
+import { IState } from "./interfaces/IState.js";
+
+export abstract class SplitterDockContainer implements IDockContainerWithSize {
+    name: string;
+    dockManager: DockManager;
+    minimumAllowedChildNodes: number;
+    splitterPanel: SplitterPanel;
+    stackedVertical: boolean;
+    containerElement: HTMLDivElement;
+    _cachedWidth: number;
+    _cachedHeight: number;
+    state: ISize;
+    containerType: ContainerType;
+
+    constructor(name: string, dockManager: DockManager, childContainers: IDockContainer[], stackedVertical: boolean) {
+        // for prototype inheritance purposes only
+        if (arguments.length === 0) {
+            return;
+        }
+
+        this.name = name;
+        this.dockManager = dockManager;
+        this.stackedVertical = stackedVertical;
+        this.splitterPanel = new SplitterPanel(childContainers, this.stackedVertical);
+        this.containerElement = this.splitterPanel.panelElement;
+        this.minimumAllowedChildNodes = 2;
+    }
+
+    resize(width: number, height: number) {
+        //    if (_cachedWidth === _cachedWidth && _cachedHeight === _height) {
+        //      // No need to resize
+        //      return;
+        //    }
+        this.splitterPanel.resize(width, height);
+        this._cachedWidth = width;
+        this._cachedHeight = height;
+    }
+
+    performLayout(childContainers: IDockContainer[], relayoutEvenIfEqual: boolean = false) {
+        this.splitterPanel.performLayout(childContainers, relayoutEvenIfEqual);
+    }
+
+    setActiveChild(/*child*/) {
+    }
+
+    destroy() {
+        this.splitterPanel.destroy();
+    }
+
+    /**
+     * Sets the percentage of space the specified [container] takes in the split panel
+     * The percentage is specified in [ratio] and is between 0..1
+     */
+    setContainerRatio(container: IDockContainer, ratio: number) {
+        this.splitterPanel.setContainerRatio(container, ratio);
+        this.resize(this.width, this.height);
+    }
+
+    getRatios(): number[] {
+        return this.splitterPanel.getRatios();
+    }
+
+    setRatios(ratios: number[]) {
+        this.splitterPanel.setRatios(ratios);
+        this.resize(this.width, this.height);
+    }
+
+    saveState(state: IState) {
+        state.width = this.width;
+        state.height = this.height;
+    }
+
+    loadState(state: IState) {
+        this.state = { width: state.width, height: state.height };
+        // this.resize(state.width, state.height);
+    }
+
+    get width(): number {
+        if (this._cachedWidth === undefined)
+            this._cachedWidth = this.splitterPanel.panelElement.clientWidth;
+        return this._cachedWidth;
+    }
+
+    get height(): number {
+        if (this._cachedHeight === undefined)
+            this._cachedHeight = this.splitterPanel.panelElement.clientHeight;
+        return this._cachedHeight;
+    }
+}