flexlayout-react 0.7.15 → 0.8.1

package/src/model/BorderSet.ts

@@ -1,129 +1,80 @@
+import { DockLocation } from "../DockLocation";
 import { DropInfo } from "../DropInfo";
-import { Orientation } from "../Orientation";
-import { Rect } from "../Rect";
 import { BorderNode } from "./BorderNode";
 import { IDraggable } from "./IDraggable";
-import { Model, ILayoutMetrics } from "./Model";
+import { Model } from "./Model";
 import { Node } from "./Node";
 
 export class BorderSet {
     /** @internal */
-    static _fromJson(json: any, model: Model) {
+    static fromJson(json: any, model: Model) {
         const borderSet = new BorderSet(model);
-        borderSet._borders = json.map((borderJson: any) => BorderNode._fromJson(borderJson, model));
+        borderSet.borders = json.map((borderJson: any) => BorderNode.fromJson(borderJson, model));
+        for (const border of borderSet.borders) {
+            borderSet.borderMap.set(border.getLocation(), border);
+        }
         return borderSet;
     }
     /** @internal */
-    private _model: Model;
+    private borders: BorderNode[];
+    /** @internal */
+    private borderMap: Map<DockLocation, BorderNode>;
     /** @internal */
-    private _borders: BorderNode[];
+    private layoutHorizontal: boolean;
 
     /** @internal */
-    constructor(model: Model) {
-        this._model = model;
-        this._borders = [];
+    constructor(_model: Model) {
+        this.borders = [];
+        this.borderMap = new Map<DockLocation, BorderNode>();
+        this.layoutHorizontal = true;
     }
 
-    getBorders() {
-        return this._borders;
+    toJson() {
+        return this.borders.map((borderNode) => borderNode.toJson());
     }
 
     /** @internal */
-    _forEachNode(fn: (node: Node, level: number) => void) {
-        for (const borderNode of this._borders) {
-            fn(borderNode, 0);
-            for (const node of borderNode.getChildren()) {
-                node._forEachNode(fn, 1);
-            }
-        }
+    getLayoutHorizontal () {
+        return this.layoutHorizontal;
     }
 
     /** @internal */
-    _toJson() {
-        return this._borders.map((borderNode) => borderNode.toJson());
+    getBorders() {
+        return this.borders;
     }
 
     /** @internal */
-    _layoutBorder(outerInnerRects: { inner: Rect; outer: Rect }, metrics: ILayoutMetrics) {
-        const rect = outerInnerRects.outer;
-        const rootRow = this._model.getRoot();
-        let height = Math.max(0, rect.height - rootRow.getMinHeight());
-        let width = Math.max(0, rect.width - rootRow.getMinWidth());
-        let sumHeight = 0;
-        let sumWidth = 0;
-        let adjustableHeight = 0;
-        let adjustableWidth = 0;
-
-        const showingBorders = this._borders.filter((border) => border.isShowing());
+    getBorderMap() {
+        return this.borderMap;
+    }
 
-        // sum size of borders to see they will fit
-        for (const border of showingBorders) {
-            border._setAdjustedSize(border.getSize());
-            const visible = border.getSelected() !== -1;
-            if (border.getLocation().getOrientation() === Orientation.HORZ) {
-                sumWidth += border.getBorderBarSize();
-                if (visible) {
-                    width -= this._model.getSplitterSize();
-                    sumWidth += border.getSize();
-                    adjustableWidth += border.getSize();
-                }
-            } else {
-                sumHeight += border.getBorderBarSize();
-                if (visible) {
-                    height -= this._model.getSplitterSize();
-                    sumHeight += border.getSize();
-                    adjustableHeight += border.getSize();
-                }
+    /** @internal */
+    forEachNode(fn: (node: Node, level: number) => void) {
+        for (const borderNode of this.borders) {
+            fn(borderNode, 0);
+            for (const node of borderNode.getChildren()) {
+                node.forEachNode(fn, 1);
             }
         }
+    }
 
-        // adjust border sizes if too large
-        let j = 0;
-        let adjusted = false;
-        while ((sumWidth > width && adjustableWidth > 0) || (sumHeight > height && adjustableHeight > 0)) {
-            const border = showingBorders[j];
-            if (border.getSelected() !== -1) {
-                // visible
-                const size = border._getAdjustedSize();
-                if (sumWidth > width && adjustableWidth > 0 && border.getLocation().getOrientation() === Orientation.HORZ && size > 0
-                    && size > border.getMinSize()) {
-                    border._setAdjustedSize(size - 1);
-                    sumWidth--;
-                    adjustableWidth--;
-                    adjusted = true;
-                } else if (sumHeight > height && adjustableHeight > 0 && border.getLocation().getOrientation() === Orientation.VERT && size > 0
-                    && size > border.getMinSize()) {
-                    border._setAdjustedSize(size - 1);
-                    sumHeight--;
-                    adjustableHeight--;
-                    adjusted = true;
-                }
-            }
-            j = (j + 1) % showingBorders.length;
-            if (j === 0) {
-                if (adjusted) {
-                    adjusted = false;
-                } else {
-                    break;
+        /** @internal */
+        setPaths() {
+            for (const borderNode of this.borders) {
+                const path = "/border/" + borderNode.getLocation().getName();
+                borderNode.setPath(path);
+                let i = 0;
+                for (const node of borderNode.getChildren()) {
+                    node.setPath( path + "/t" + i);
+                    i++;
                 }
             }
         }
 
-        for (const border of showingBorders) {
-            outerInnerRects.outer = border._layoutBorderOuter(outerInnerRects.outer, metrics);
-        }
-
-        outerInnerRects.inner = outerInnerRects.outer;
-
-        for (const border of showingBorders) {
-            outerInnerRects.inner = border._layoutBorderInner(outerInnerRects.inner, metrics);
-        }
-        return outerInnerRects;
-    }
 
     /** @internal */
-    _findDropTargetNode(dragNode: Node & IDraggable, x: number, y: number): DropInfo | undefined {
-        for (const border of this._borders) {
+    findDropTargetNode(dragNode: Node & IDraggable, x: number, y: number): DropInfo | undefined {
+        for (const border of this.borders) {
             if (border.isShowing()) {
                 const dropInfo = border.canDrop(dragNode, x, y);
                 if (dropInfo !== undefined) {