@leafer/layout 1.0.0-rc.3 → 1.0.0-rc.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/layout",
-  "version": "1.0.0-rc.3",
+  "version": "1.0.0-rc.30",
   "description": "@leafer/layout",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -15,17 +15,18 @@
     "type": "git",
     "url": "https://github.com/leaferjs/leafer.git"
   },
-  "homepage": "https://github.com/leaferjs/leafer/tree/main/packages/layout",
+  "homepage": "https://github.com/leaferjs/leafer/tree/main/packages/display-module/layout",
   "bugs": "https://github.com/leaferjs/leafer/issues",
   "keywords": [
     "leafer",
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/math": "1.0.0-rc.3",
-    "@leafer/platform": "1.0.0-rc.3"
+    "@leafer/math": "1.0.0-rc.30",
+    "@leafer/helper": "1.0.0-rc.30",
+    "@leafer/platform": "1.0.0-rc.30"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-rc.3"
+    "@leafer/interface": "1.0.0-rc.30"
   }
 }

package/src/LeafLayout.ts

@@ -1,41 +1,61 @@
-import { ILeaf, ILeafLayout, ILayoutLocationType, ILayoutBoundsType, IBoundsData, IMatrixData } from '@leafer/interface'
-import { BoundsHelper } from '@leafer/math'
+import { ILeaf, ILeafLayout, ILocationType, IBoundsType, IBoundsData, IMatrixData, ILayoutBoundsData, IPointData } from '@leafer/interface'
+import { Bounds, BoundsHelper, MatrixHelper, PointHelper } from '@leafer/math'
+import { LeafHelper } from '@leafer/helper'
 import { Platform } from '@leafer/platform'
 
 
-const { toOuterOf } = BoundsHelper
+const { getRelativeWorld } = LeafHelper
+const { toOuterOf, getPoints, copy } = BoundsHelper
+const localContent = '_localContentBounds'
+const worldContent = '_worldContentBounds', worldBox = '_worldBoxBounds', worldStroke = '_worldStrokeBounds'
 
 export class LeafLayout implements ILeafLayout {
 
     public leaf: ILeaf
 
-    public useZoomProxy: boolean
+    public proxyZoom: boolean
 
-    // local
+    // inner
 
+    public get contentBounds(): IBoundsData { return this._contentBounds || this.boxBounds }
+    public set contentBounds(bounds: IBoundsData) { this._contentBounds = bounds }
     public boxBounds: IBoundsData
-    public strokeBounds: IBoundsData
-    public renderBounds: IBoundsData
+    public get strokeBounds(): IBoundsData { return this._strokeBounds || this.boxBounds }
+    public get renderBounds(): IBoundsData { return this._renderBounds || this.boxBounds }
 
-    // auto layout
-    public marginBounds: IBoundsData
-    public contentBounds: IBoundsData
+    public _contentBounds: IBoundsData
+    public _strokeBounds: IBoundsData
+    public _renderBounds: IBoundsData
 
     // local
 
-    public localStrokeBounds: IBoundsData
-    public localRenderBounds: IBoundsData
+    public get localContentBounds(): IBoundsData { toOuterOf(this.contentBounds, this.leaf.__localMatrix, this[localContent] || (this[localContent] = {} as IBoundsData)); return this[localContent] }
+    // localBoxBounds: IBoundsData // use leaf.__localBoxBounds
+    public get localStrokeBounds(): IBoundsData { return this._localStrokeBounds || this }
+    public get localRenderBounds(): IBoundsData { return this._localRenderBounds || this }
+
+    protected _localContentBounds?: IBoundsData
+    protected _localStrokeBounds?: IBoundsData
+    protected _localRenderBounds?: IBoundsData
+
+    // world
+
+    public get worldContentBounds(): IBoundsData { toOuterOf(this.contentBounds, this.leaf.__world, this[worldContent] || (this[worldContent] = {} as IBoundsData)); return this[worldContent] }
+    public get worldBoxBounds(): IBoundsData { toOuterOf(this.boxBounds, this.leaf.__world, this[worldBox] || (this[worldBox] = {} as IBoundsData)); return this[worldBox] }
+    public get worldStrokeBounds(): IBoundsData { toOuterOf(this.strokeBounds, this.leaf.__world, this[worldStroke] || (this[worldStroke] = {} as IBoundsData)); return this[worldStroke] }
+    // worldRenderBounds: IBoundsData // use leaf.__world
 
-    // world temp
     protected _worldContentBounds: IBoundsData
     protected _worldBoxBounds: IBoundsData
     protected _worldStrokeBounds: IBoundsData
 
     // state
 
+    public resized: boolean
+    public waitAutoLayout: boolean
+
     // matrix changed
     public matrixChanged: boolean
-    public positionChanged: boolean
     public scaleChanged: boolean
     public rotationChanged: boolean
 
@@ -62,131 +82,221 @@ export class LeafLayout implements ILeafLayout {
     public affectChildrenSort?: boolean
 
     public strokeSpread: number
-    public renderSpread: number
     public strokeBoxSpread: number
+    public renderSpread: number
     public renderShapeSpread: number
 
+    // temp local
+    public get a() { return 1 }
+    public get b() { return 0 }
+    public get c() { return 0 }
+    public get d() { return 1 }
+    public get e() { return this.leaf.__.x }
+    public get f() { return this.leaf.__.y }
+    public get x() { return this.e + this.boxBounds.x }
+    public get y() { return this.f + this.boxBounds.y }
+    public get width() { return this.boxBounds.width }
+    public get height() { return this.boxBounds.height }
+
 
     constructor(leaf: ILeaf) {
         this.leaf = leaf
-        this.renderBounds = this.strokeBounds = this.boxBounds = { x: 0, y: 0, width: 0, height: 0 }
-        this.localRenderBounds = this.localStrokeBounds = leaf.__local
+        this.boxBounds = { x: 0, y: 0, width: 0, height: 0 }
+        if (this.leaf.__local) this._localRenderBounds = this._localStrokeBounds = this.leaf.__local
         this.boxChange()
-        this.positionChange()
+        this.matrixChange()
     }
 
+    public createLocal(): void {
+        const local = this.leaf.__local = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0, x: 0, y: 0, width: 0, height: 0 }
+        if (!this._localStrokeBounds) this._localStrokeBounds = local
+        if (!this._localRenderBounds) this._localRenderBounds = local
+    }
 
-    public checkUpdate(force?: boolean): void {
+    public update(): void {
         const { leafer } = this.leaf
         if (leafer) {
             if (leafer.ready) {
-                if ((Platform.realtimeLayout || force) && leafer.watcher.changed) leafer.layouter.layout()
+                if (leafer.watcher.changed) leafer.layouter.layout()
             } else {
                 leafer.start()
             }
         } else {
             let root = this.leaf
-            while (root.parent) { root = root.parent }
+            while (root.parent && !root.parent.leafer) { root = root.parent }
             Platform.layout(root)
         }
     }
 
-    public getTransform(locationType: ILayoutLocationType): IMatrixData {
-        this.checkUpdate()
-        return locationType === 'world' ? this.leaf.__world : this.leaf.__local
+    public getTransform(relative: ILocationType | ILeaf = 'world'): IMatrixData {
+        this.update()
+        const { leaf } = this
+        switch (relative) {
+            case 'world':
+                return leaf.__world
+            case 'local':
+                return leaf.__localMatrix
+            case 'inner':
+                return MatrixHelper.defaultMatrix
+            case 'page':
+                relative = leaf.zoomLayer
+            default:
+                return getRelativeWorld(leaf, relative)
+        }
     }
 
-    public getBounds(type: ILayoutBoundsType, locationType: ILayoutLocationType): IBoundsData {
-
-        this.checkUpdate()
+    public getBounds(type?: IBoundsType, relative: ILocationType | ILeaf = 'world'): IBoundsData {
+        this.update()
+        switch (relative) {
+            case 'world':
+                return this.getWorldBounds(type)
+            case 'local':
+                return this.getLocalBounds(type)
+            case 'inner':
+                return this.getInnerBounds(type)
+            case 'page':
+                relative = this.leaf.zoomLayer
+            default:
+                return new Bounds(this.getInnerBounds(type)).toOuterOf(this.getTransform(relative))
+        }
+    }
 
-        if (locationType === 'world') {
+    public getInnerBounds(type: IBoundsType = 'box'): IBoundsData {
+        switch (type) {
+            case 'render':
+                return this.renderBounds
+            case 'content':
+                if (this.contentBounds) return this.contentBounds
+            case 'box':
+                return this.boxBounds
+            case 'stroke':
+                return this.strokeBounds
+        }
+    }
 
-            switch (type) {
-                case 'render':
-                    return this.leaf.__world
-                case 'content':
-                    if (this.contentBounds) return this.getWorldContentBounds()
-                case 'margin':
-                case 'box':
-                    return this.getWorldBoxBounds()
-                case 'margin':
-                case 'stroke':
-                    return this.getWorldStrokeBounds()
-            }
+    public getLocalBounds(type: IBoundsType = 'box'): IBoundsData {
+        switch (type) {
+            case 'render':
+                return this.localRenderBounds
+            case 'stroke':
+                return this.localStrokeBounds
+            case 'content':
+                if (this.contentBounds) return this.localContentBounds
+            case 'box':
+                return this.leaf.__localBoxBounds
+        }
+    }
 
-        } else if (locationType === 'inner') {
-
-            switch (type) {
-                case 'render':
-                    return this.renderBounds
-                case 'content':
-                    if (this.contentBounds) return this.contentBounds
-                case 'margin':
-                case 'box':
-                    return this.boxBounds
-                case 'stroke':
-                    return this.strokeBounds
-            }
+    public getWorldBounds(type: IBoundsType = 'box'): IBoundsData {
+        switch (type) {
+            case 'render':
+                return this.leaf.__world
+            case 'stroke':
+                return this.worldStrokeBounds
+            case 'content':
+                if (this.contentBounds) return this.worldContentBounds
+            case 'box':
+                return this.worldBoxBounds
+        }
+    }
 
-        } else {
+    public getLayoutBounds(type?: IBoundsType, relative: ILocationType | ILeaf = 'world', unscale?: boolean): ILayoutBoundsData {
+        const { leaf } = this
+        let point: IPointData, matrix: IMatrixData, bounds: IBoundsData = this.getInnerBounds(type)
+
+        switch (relative) {
+            case 'world':
+                point = leaf.getWorldPoint(bounds)
+                matrix = leaf.__world
+                break
+            case 'local':
+                point = leaf.getLocalPointByInner(bounds)
+                matrix = leaf.__localMatrix
+                break
+            case 'inner':
+                point = bounds
+                matrix = MatrixHelper.defaultMatrix
+                break
+            case 'page':
+                relative = leaf.zoomLayer
+            default:
+                point = leaf.getWorldPoint(bounds, relative)
+                matrix = getRelativeWorld(leaf, relative, true)
+        }
 
-            switch (type) {
-                case 'render':
-                    return this.localRenderBounds
-                case 'margin':
-                case 'content':
-                case 'box':
-                    return this.leaf.__local
-                case 'stroke':
-                    return this.localStrokeBounds
+        const layoutBounds = MatrixHelper.getLayout(matrix) as ILayoutBoundsData
+        copy(layoutBounds, bounds)
+        PointHelper.copy(layoutBounds, point)
+
+        if (unscale) {
+            const { scaleX, scaleY } = layoutBounds
+            const uScaleX = Math.abs(scaleX)
+            const uScaleY = Math.abs(scaleY)
+            if (uScaleX !== 1 || uScaleY !== 1) {
+                layoutBounds.scaleX /= uScaleX
+                layoutBounds.scaleY /= uScaleY
+                layoutBounds.width *= uScaleX
+                layoutBounds.height *= uScaleY
             }
-
         }
 
+        return layoutBounds
     }
 
-    protected getWorldContentBounds(): IBoundsData {
-        this._worldContentBounds || (this._worldContentBounds = {} as IBoundsData)
-        toOuterOf(this.contentBounds, this.leaf.__world, this._worldContentBounds)
-        return this._worldContentBounds
-    }
-
-    protected getWorldBoxBounds(): IBoundsData {
-        this._worldBoxBounds || (this._worldBoxBounds = {} as IBoundsData)
-        toOuterOf(this.boxBounds, this.leaf.__world, this._worldBoxBounds)
-        return this._worldBoxBounds
-    }
-
-    protected getWorldStrokeBounds(): IBoundsData {
-        this._worldStrokeBounds || (this._worldStrokeBounds = {} as IBoundsData)
-        toOuterOf(this.strokeBounds, this.leaf.__world, this._worldStrokeBounds)
-        return this._worldStrokeBounds
+    public getLayoutPoints(type?: IBoundsType, relative: ILocationType | ILeaf = 'world'): IPointData[] {
+        const { leaf } = this
+        const points = getPoints(this.getInnerBounds(type))
+        let relativeLeaf: ILeaf
+        switch (relative) {
+            case 'world':
+                relativeLeaf = null
+                break
+            case 'local':
+                relativeLeaf = leaf.parent
+                break
+            case 'inner':
+                break
+            case 'page':
+                relative = leaf.zoomLayer
+            default:
+                relativeLeaf = relative
+        }
+        if (relativeLeaf !== undefined) points.forEach(point => leaf.innerToWorld(point, null, false, relativeLeaf))
+        return points
     }
 
     // 独立 / 引用 boxBounds
 
-    public spreadStrokeCancel(): void {
-        const same = this.renderBounds === this.strokeBounds
-        this.strokeBounds = this.boxBounds
-        this.localStrokeBounds = this.leaf.__local
-        if (same) this.spreadRenderCancel()
-    }
-    public spreadRenderCancel(): void {
-        this.renderBounds = this.strokeBounds
-        this.localRenderBounds = this.localStrokeBounds
+    public shrinkContent(): void {
+        const { x, y, width, height } = this.boxBounds
+        this._contentBounds = { x, y, width, height }
     }
 
     public spreadStroke(): void {
         const { x, y, width, height } = this.strokeBounds
-        this.strokeBounds = { x, y, width, height }
-        this.localStrokeBounds = { x, y, width, height }
+        this._strokeBounds = { x, y, width, height }
+        this._localStrokeBounds = { x, y, width, height }
         if (!this.renderSpread) this.spreadRenderCancel()
     }
     public spreadRender(): void {
         const { x, y, width, height } = this.renderBounds
-        this.renderBounds = { x, y, width, height }
-        this.localRenderBounds = { x, y, width, height }
+        this._renderBounds = { x, y, width, height }
+        this._localRenderBounds = { x, y, width, height }
+    }
+
+    public shrinkContentCancel(): void {
+        this._contentBounds = undefined
+    }
+
+    public spreadStrokeCancel(): void {
+        const same = this.renderBounds === this.strokeBounds
+        this._strokeBounds = this.boxBounds
+        this._localStrokeBounds = this.leaf.__localBoxBounds
+        if (same) this.spreadRenderCancel()
+    }
+    public spreadRenderCancel(): void {
+        this._renderBounds = this._strokeBounds
+        this._localRenderBounds = this._localStrokeBounds
     }
 
 
@@ -219,12 +329,6 @@ export class LeafLayout implements ILeafLayout {
 
     // matrix
 
-    public positionChange(): void {
-        this.positionChanged = true
-        this.matrixChanged = true
-        this.localBoxChanged || this.localBoxChange()
-    }
-
     public scaleChange(): void {
         this.scaleChanged = true
         this._scaleOrRotationChange()
@@ -238,6 +342,11 @@ export class LeafLayout implements ILeafLayout {
 
     protected _scaleOrRotationChange() {
         this.affectScaleOrRotation = true
+        this.matrixChange()
+        if (!this.leaf.__local) this.createLocal()
+    }
+
+    public matrixChange(): void {
         this.matrixChanged = true
         this.localBoxChanged || this.localBoxChange()
     }

package/types/index.d.ts

@@ -1,20 +1,31 @@
-import { ILeafLayout, ILeaf, IBoundsData, ILayoutLocationType, IMatrixData, ILayoutBoundsType } from '@leafer/interface';
+import { ILeafLayout, ILeaf, IBoundsData, ILocationType, IMatrixData, IBoundsType, ILayoutBoundsData, IPointData } from '@leafer/interface';
 
 declare class LeafLayout implements ILeafLayout {
     leaf: ILeaf;
-    useZoomProxy: boolean;
+    proxyZoom: boolean;
+    get contentBounds(): IBoundsData;
+    set contentBounds(bounds: IBoundsData);
     boxBounds: IBoundsData;
-    strokeBounds: IBoundsData;
-    renderBounds: IBoundsData;
-    marginBounds: IBoundsData;
-    contentBounds: IBoundsData;
-    localStrokeBounds: IBoundsData;
-    localRenderBounds: IBoundsData;
+    get strokeBounds(): IBoundsData;
+    get renderBounds(): IBoundsData;
+    _contentBounds: IBoundsData;
+    _strokeBounds: IBoundsData;
+    _renderBounds: IBoundsData;
+    get localContentBounds(): IBoundsData;
+    get localStrokeBounds(): IBoundsData;
+    get localRenderBounds(): IBoundsData;
+    protected _localContentBounds?: IBoundsData;
+    protected _localStrokeBounds?: IBoundsData;
+    protected _localRenderBounds?: IBoundsData;
+    get worldContentBounds(): IBoundsData;
+    get worldBoxBounds(): IBoundsData;
+    get worldStrokeBounds(): IBoundsData;
     protected _worldContentBounds: IBoundsData;
     protected _worldBoxBounds: IBoundsData;
     protected _worldStrokeBounds: IBoundsData;
+    resized: boolean;
+    waitAutoLayout: boolean;
     matrixChanged: boolean;
-    positionChanged: boolean;
     scaleChanged: boolean;
     rotationChanged: boolean;
     boundsChanged: boolean;
@@ -30,28 +41,43 @@ declare class LeafLayout implements ILeafLayout {
     affectRotation: boolean;
     affectChildrenSort?: boolean;
     strokeSpread: number;
-    renderSpread: number;
     strokeBoxSpread: number;
+    renderSpread: number;
     renderShapeSpread: number;
+    get a(): number;
+    get b(): number;
+    get c(): number;
+    get d(): number;
+    get e(): number;
+    get f(): number;
+    get x(): number;
+    get y(): number;
+    get width(): number;
+    get height(): number;
     constructor(leaf: ILeaf);
-    checkUpdate(force?: boolean): void;
-    getTransform(locationType: ILayoutLocationType): IMatrixData;
-    getBounds(type: ILayoutBoundsType, locationType: ILayoutLocationType): IBoundsData;
-    protected getWorldContentBounds(): IBoundsData;
-    protected getWorldBoxBounds(): IBoundsData;
-    protected getWorldStrokeBounds(): IBoundsData;
-    spreadStrokeCancel(): void;
-    spreadRenderCancel(): void;
+    createLocal(): void;
+    update(): void;
+    getTransform(relative?: ILocationType | ILeaf): IMatrixData;
+    getBounds(type?: IBoundsType, relative?: ILocationType | ILeaf): IBoundsData;
+    getInnerBounds(type?: IBoundsType): IBoundsData;
+    getLocalBounds(type?: IBoundsType): IBoundsData;
+    getWorldBounds(type?: IBoundsType): IBoundsData;
+    getLayoutBounds(type?: IBoundsType, relative?: ILocationType | ILeaf, unscale?: boolean): ILayoutBoundsData;
+    getLayoutPoints(type?: IBoundsType, relative?: ILocationType | ILeaf): IPointData[];
+    shrinkContent(): void;
     spreadStroke(): void;
     spreadRender(): void;
+    shrinkContentCancel(): void;
+    spreadStrokeCancel(): void;
+    spreadRenderCancel(): void;
     boxChange(): void;
     localBoxChange(): void;
     strokeChange(): void;
     renderChange(): void;
-    positionChange(): void;
     scaleChange(): void;
     rotationChange(): void;
     protected _scaleOrRotationChange(): void;
+    matrixChange(): void;
     surfaceChange(): void;
     opacityChange(): void;
     childrenSortChange(): void;