flexlayout-react 0.7.14 → 0.8.0

package/src/model/Node.ts

@@ -5,117 +5,110 @@ import { Orientation } from "../Orientation";
 import { Rect } from "../Rect";
 import { IDraggable } from "./IDraggable";
 import { IJsonBorderNode, IJsonRowNode, IJsonTabNode, IJsonTabSetNode } from "./IJsonModel";
-import { Model, ILayoutMetrics } from "./Model";
+import { Model } from "./Model";
 
 export abstract class Node {
     /** @internal */
-    protected _model: Model;
+    protected model: Model;
     /** @internal */
-    protected _attributes: Record<string, any>;
+    protected attributes: Record<string, any>;
     /** @internal */
-    protected _parent?: Node;
+    protected parent?: Node;
     /** @internal */
-    protected _children: Node[];
+    protected children: Node[];
     /** @internal */
-    protected _fixed: boolean;
+    protected rect: Rect;
     /** @internal */
-    protected _rect: Rect;
+    protected path: string;
     /** @internal */
-    protected _visible: boolean;
-    /** @internal */
-    protected _listeners: Record<string, (params: any) => void>;
-    /** @internal */
-    protected _dirty: boolean = false;
-    /** @internal */
-    protected _tempSize: number = 0;
+    protected listeners: Map<string, (params: any) => void>;
 
     /** @internal */
-    protected constructor(model: Model) {
-        this._model = model;
-        this._attributes = {};
-        this._children = [];
-        this._fixed = false;
-        this._rect = Rect.empty();
-        this._visible = false;
-        this._listeners = {};
+    protected constructor(_model: Model) {
+        this.model = _model;
+        this.attributes = {};
+        this.children = [];
+        this.rect = Rect.empty();
+        this.listeners = new Map();
+        this.path = "";
     }
 
     getId() {
-        let id = this._attributes.id;
+        let id = this.attributes.id;
         if (id !== undefined) {
             return id as string;
         }
 
-        id = this._model._nextUniqueId();
-        this._setId(id);
+        id = this.model.nextUniqueId();
+        this.setId(id);
 
         return id as string;
     }
 
     getModel() {
-        return this._model;
+        return this.model;
     }
 
     getType() {
-        return this._attributes.type as string;
+        return this.attributes.type as string;
     }
 
     getParent() {
-        return this._parent;
+        return this.parent;
     }
 
     getChildren() {
-        return this._children;
+        return this.children;
     }
 
     getRect() {
-        return this._rect;
+        return this.rect;
     }
 
-    isVisible() {
-        return this._visible;
+    getPath() {
+        return this.path;
     }
 
     getOrientation(): Orientation {
-        if (this._parent === undefined) {
-            return this._model.isRootOrientationVertical() ? Orientation.VERT : Orientation.HORZ;
+        if (this.parent === undefined) {
+            return this.model.isRootOrientationVertical() ? Orientation.VERT : Orientation.HORZ;
         } else {
-            return Orientation.flip(this._parent.getOrientation());
+            return Orientation.flip(this.parent.getOrientation());
         }
     }
 
     // event can be: resize, visibility, maximize (on tabset), close
     setEventListener(event: string, callback: (params: any) => void) {
-        this._listeners[event] = callback;
+        this.listeners.set(event, callback);
     }
 
     removeEventListener(event: string) {
-        delete this._listeners[event];
+        this.listeners.delete(event);
     }
 
     abstract toJson(): IJsonRowNode | IJsonBorderNode | IJsonTabSetNode | IJsonTabNode | undefined;
 
     /** @internal */
-    _setId(id: string) {
-        this._attributes.id = id;
+    setId(id: string) {
+        this.attributes.id = id;
     }
 
     /** @internal */
-    _fireEvent(event: string, params: any) {
+    fireEvent(event: string, params: any) {
         // console.log(this._type, " fireEvent " + event + " " + JSON.stringify(params));
-        if (this._listeners[event] !== undefined) {
-            this._listeners[event](params);
+        if (this.listeners.has(event)) {
+            this.listeners.get(event)!(params);
         }
     }
 
     /** @internal */
-    _getAttr(name: string) {
-        let val = this._attributes[name];
+    getAttr(name: string) {
+        let val = this.attributes[name];
 
         if (val === undefined) {
-            const modelName = this._getAttributeDefinitions().getModelName(name);
+            const modelName = this.getAttributeDefinitions().getModelName(name);
             if (modelName !== undefined) {
-                val = this._model._getAttribute(modelName);
+                val = this.model.getAttribute(modelName);
             }
         }
 
@@ -124,69 +117,76 @@ export abstract class Node {
     }
 
     /** @internal */
-    _forEachNode(fn: (node: Node, level: number) => void, level: number) {
+    forEachNode(fn: (node: Node, level: number) => void, level: number) {
         fn(this, level);
         level++;
-        for (const node of this._children) {
-            node._forEachNode(fn, level);
+        for (const node of this.children) {
+            node.forEachNode(fn, level);
         }
     }
 
     /** @internal */
-    _setVisible(visible: boolean) {
-        if (visible !== this._visible) {
-            this._fireEvent("visibility", { visible });
-            this._visible = visible;
-        }
-    }
+    setPaths(path: string) {
+        let i = 0;
 
-    /** @internal */
-    _getDrawChildren(): Node[] | undefined {
-        return this._children;
-    }
+        for (const node of this.children) {
+            let newPath = path;
+            if (node.getType() === "row") {
+                if (node.getOrientation() === Orientation.VERT) {
+                    newPath += "/c" + i;
+                } else {
+                    newPath += "/r" + i;
+                }
+            } else if (node.getType() === "tabset") {
+                newPath += "/ts" + i;
+            } else if (node.getType() === "tab") {
+                newPath += "/t" + i;
+            }
 
-    /** @internal */
-    _setParent(parent: Node) {
-        this._parent = parent;
+            node.path = newPath;
+
+            node.setPaths(newPath);
+            i++;
+        }
     }
 
     /** @internal */
-    _setRect(rect: Rect) {
-        this._rect = rect;
+    setParent(parent: Node) {
+        this.parent = parent;
     }
 
     /** @internal */
-    _setWeight(weight: number) {
-        this._attributes.weight = weight;
+    setRect(rect: Rect) {
+        this.rect = rect;
     }
 
     /** @internal */
-    _setSelected(index: number) {
-        this._attributes.selected = index;
+    setPath(path: string) {
+        this.path = path;
     }
 
     /** @internal */
-    _isFixed() {
-        return this._fixed;
+    setWeight(weight: number) {
+        this.attributes.weight = weight;
     }
 
     /** @internal */
-    _layout(rect: Rect, metrics: ILayoutMetrics) {
-        this._rect = rect;
+    setSelected(index: number) {
+        this.attributes.selected = index;
     }
 
     /** @internal */
-    _findDropTargetNode(dragNode: Node & IDraggable, x: number, y: number): DropInfo | undefined {
+    findDropTargetNode(windowId: string, dragNode: Node & IDraggable, x: number, y: number): DropInfo | undefined {
         let rtn: DropInfo | undefined;
-        if (this._rect.contains(x, y)) {
-            if (this._model.getMaximizedTabset() !== undefined) {
-                rtn = this._model.getMaximizedTabset()!.canDrop(dragNode, x, y);
+        if (this.rect.contains(x, y)) {
+            if (this.model.getMaximizedTabset(windowId) !== undefined) {
+                rtn = this.model.getMaximizedTabset(windowId)!.canDrop(dragNode, x, y);
             } else {
                 rtn = this.canDrop(dragNode, x, y);
                 if (rtn === undefined) {
-                    if (this._children.length !== 0) {
-                        for (const child of this._children) {
-                            rtn = child._findDropTargetNode(dragNode, x, y);
+                    if (this.children.length !== 0) {
+                        for (const child of this.children) {
+                            rtn = child.findDropTargetNode(windowId, dragNode, x, y);
                             if (rtn !== undefined) {
                                 break;
                             }
@@ -205,7 +205,7 @@ export abstract class Node {
     }
 
     /** @internal */
-    _canDockInto(dragNode: Node & IDraggable, dropInfo: DropInfo | undefined): boolean {
+    canDockInto(dragNode: Node & IDraggable, dropInfo: DropInfo | undefined): boolean {
         if (dropInfo != null) {
             if (dropInfo.location === DockLocation.CENTER && dropInfo.node.isEnableDrop() === false) {
                 return false;
@@ -221,58 +221,45 @@ export abstract class Node {
             }
 
             // finally check model callback to check if drop allowed
-            if (this._model._getOnAllowDrop()) {
-                return (this._model._getOnAllowDrop() as (dragNode: Node, dropInfo: DropInfo) => boolean)(dragNode, dropInfo);
+            if (this.model.getOnAllowDrop()) {
+                return (this.model.getOnAllowDrop() as (dragNode: Node, dropInfo: DropInfo) => boolean)(dragNode, dropInfo);
             }
         }
         return true;
     }
 
     /** @internal */
-    _removeChild(childNode: Node) {
-        const pos = this._children.indexOf(childNode);
+    removeChild(childNode: Node) {
+        const pos = this.children.indexOf(childNode);
         if (pos !== -1) {
-            this._children.splice(pos, 1);
+            this.children.splice(pos, 1);
         }
-        this._dirty = true;
         return pos;
     }
 
     /** @internal */
-    _addChild(childNode: Node, pos?: number) {
+    addChild(childNode: Node, pos?: number) {
         if (pos != null) {
-            this._children.splice(pos, 0, childNode);
+            this.children.splice(pos, 0, childNode);
         } else {
-            this._children.push(childNode);
-            pos = this._children.length - 1;
+            this.children.push(childNode);
+            pos = this.children.length - 1;
         }
-        childNode._parent = this;
-        this._dirty = true;
+        childNode.parent = this;
         return pos;
     }
 
     /** @internal */
-    _removeAll() {
-        this._children = [];
-        this._dirty = true;
+    removeAll() {
+        this.children = [];
     }
 
     /** @internal */
-    _styleWithPosition(style?: Record<string, any>) {
+    styleWithPosition(style?: Record<string, any>) {
         if (style == null) {
             style = {};
         }
-        return this._rect.styleWithPosition(style);
-    }
-
-    /** @internal */
-    _getTempSize() {
-        return this._tempSize;
-    }
-
-    /** @internal */
-    _setTempSize(value: number) {
-        this._tempSize = value;
+        return this.rect.styleWithPosition(style);
     }
 
     /** @internal */
@@ -281,13 +268,13 @@ export abstract class Node {
     }
 
     /** @internal */
-    _toAttributeString() {
-        return JSON.stringify(this._attributes, undefined, "\t");
+    toAttributeString() {
+        return JSON.stringify(this.attributes, undefined, "\t");
     }
 
     // implemented by subclasses
     /** @internal */
-    abstract _updateAttrs(json: any): void;
+    abstract updateAttrs(json: any): void;
     /** @internal */
-    abstract _getAttributeDefinitions(): AttributeDefinitions;
+    abstract getAttributeDefinitions(): AttributeDefinitions;
 }