@leafer/display-module 1.0.0-alpha.21 → 1.0.0-alpha.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/display-module",
-  "version": "1.0.0-alpha.21",
+  "version": "1.0.0-alpha.30",
   "description": "@leafer/display-module",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -19,10 +19,10 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/event": "1.0.0-alpha.21",
-    "@leafer/math": "1.0.0-alpha.21"
+    "@leafer/event": "1.0.0-alpha.30",
+    "@leafer/math": "1.0.0-alpha.30"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-alpha.21"
+    "@leafer/interface": "1.0.0-alpha.30"
   }
 }

package/src/LeafBounds.ts

@@ -2,7 +2,7 @@ import { ILeafBoundsModule } from '@leafer/interface'
 import { BoundsHelper } from '@leafer/math'
 
 
-const { toWorld, copyAndSpread } = BoundsHelper
+const { toOuterOf, copyAndSpread } = BoundsHelper
 
 export const LeafBounds: ILeafBoundsModule = {
 
@@ -27,36 +27,36 @@ export const LeafBounds: ILeafBoundsModule = {
 
             if (layout.localBoxBoundsChanged) { // position change
 
-                this.__updateRelativeBoxBounds()
+                this.__updateLocalBoxBounds()
                 layout.localBoxBoundsChanged = false
 
-                if (layout.eventBoundsSpreadWidth) layout.eventBoundsChanged = true
+                if (layout.strokeBoundsSpreadWidth) layout.strokeBoundsChanged = true
                 if (layout.renderBoundsSpreadWidth) layout.renderBoundsChanged = true
                 this.parent?.__layout.boxBoundsChange()
             }
 
 
-            if (layout.eventBoundsChanged) {
+            if (layout.strokeBoundsChanged) {
 
-                layout.eventBoundsSpreadWidth = this.__updateEventBoundsSpreadWidth()
+                layout.strokeBoundsSpreadWidth = this.__updateStrokeBoundsSpreadWidth()
 
-                if (layout.eventBoundsSpreadWidth) {
+                if (layout.strokeBoundsSpreadWidth) {
 
-                    if (layout.eventBounds === layout.boxBounds) {
-                        layout.eventBoundsSpread()
+                    if (layout.strokeBounds === layout.boxBounds) {
+                        layout.strokeBoundsSpread()
                     }
 
-                    this.__updateEventBounds()
-                    this.__updateRelativeEventBounds()
-                    layout.eventBoundsChanged = false
-
-                    if (layout.renderBoundsSpreadWidth) layout.renderBoundsChanged = true
+                    this.__updateStrokeBounds()
+                    this.__updateLocalStrokeBounds()
 
                 } else {
-                    layout.eventBoundsSpreadCancel()
+                    layout.strokeBoundsSpreadCancel()
                 }
 
-                this.parent?.__layout.eventBoundsChange()
+                layout.strokeBoundsChanged = false
+                if (layout.renderBoundsSpreadWidth) layout.renderBoundsChanged = true
+
+                if (this.parent) this.parent.__layout.strokeBoundsChange()
                 resize || (resize = true)
             }
 
@@ -67,44 +67,45 @@ export const LeafBounds: ILeafBoundsModule = {
 
                 if (layout.renderBoundsSpreadWidth) {
 
-                    if (layout.renderBounds === layout.boxBounds || layout.renderBounds === layout.eventBounds) {
+                    if (layout.renderBounds === layout.boxBounds || layout.renderBounds === layout.strokeBounds) {
                         layout.renderBoundsSpread()
                     }
 
                     this.__updateRenderBounds()
-                    this.__updateRelativeRenderBounds()
-                    layout.renderBoundsChanged = false
+                    this.__updateLocalRenderBounds()
 
                 } else {
                     layout.renderBoundsSpreadCancel()
                 }
 
-                this.parent?.__layout.renderBoundsChange()
+                layout.renderBoundsChanged = false
+
+                if (this.parent) this.parent.__layout.renderBoundsChange()
             }
 
 
             layout.boundsChanged = false
 
-            toWorld(this.__layout.renderBounds, this.__world, this.__world)
+            toOuterOf(this.__layout.renderBounds, this.__world, this.__world)
 
             if (resize) this.__onUpdateSize()
 
         } else {
-            toWorld(this.__layout.renderBounds, this.__world, this.__world)
+            toOuterOf(this.__layout.renderBounds, this.__world, this.__world)
         }
 
     },
 
-    __updateRelativeBoxBounds(): void {
-        toWorld(this.__layout.boxBounds, this.__relative, this.__relative)
+    __updateLocalBoxBounds(): void {
+        toOuterOf(this.__layout.boxBounds, this.__local, this.__local)
     },
 
-    __updateRelativeEventBounds(): void {
-        toWorld(this.__layout.eventBounds, this.__relative, this.__layout.relativeEventBounds)
+    __updateLocalStrokeBounds(): void {
+        toOuterOf(this.__layout.strokeBounds, this.__local, this.__layout.localStrokeBounds)
     },
 
-    __updateRelativeRenderBounds(): void {
-        toWorld(this.__layout.renderBounds, this.__relative, this.__layout.relativeRenderBounds)
+    __updateLocalRenderBounds(): void {
+        toOuterOf(this.__layout.renderBounds, this.__local, this.__layout.localRenderBounds)
     },
 
 
@@ -116,12 +117,12 @@ export const LeafBounds: ILeafBoundsModule = {
         b.height = this.__.height
     },
 
-    __updateEventBounds(): void {
-        copyAndSpread(this.__layout.eventBounds, this.__layout.boxBounds, this.__layout.eventBoundsSpreadWidth)
+    __updateStrokeBounds(): void {
+        copyAndSpread(this.__layout.strokeBounds, this.__layout.boxBounds, this.__layout.strokeBoundsSpreadWidth)
     },
 
     __updateRenderBounds(): void {
-        copyAndSpread(this.__layout.renderBounds, this.__layout.eventBounds, this.__layout.renderBoundsSpreadWidth)
+        copyAndSpread(this.__layout.renderBounds, this.__layout.strokeBounds, this.__layout.renderBoundsSpreadWidth)
     },
 
 }

package/src/LeafDataProxy.ts

@@ -1,30 +1,23 @@
 import { ILeafDataProxyModule } from '@leafer/interface'
-import { AttrEvent } from '@leafer/event'
+import { PropertyEvent } from '@leafer/event'
 
 
 export const LeafDataProxy: ILeafDataProxyModule = {
 
-    __set(attrName: string, newValue: unknown): void {
-        if (this.root) {
-            const oldValue = this.__.__getInput(attrName)
-            if (oldValue !== newValue) {
-                this.__[attrName] = newValue
-                this.root.emitEvent(new AttrEvent(AttrEvent.CHANGE, this, attrName, oldValue, newValue))
-            }
+    __setAttr(name: string, newValue: unknown): void {
+        if (this.leafer && this.leafer.ready) {
+            this.__[name] = newValue
+            const { CHANGE } = PropertyEvent
+            const event = new PropertyEvent(CHANGE, this, name, this.__.__get(name), newValue)
+            if (this.hasEvent(CHANGE) && !this.isLeafer) this.emitEvent(event)
+            this.leafer.emitEvent(event)
         } else {
-            this.__[attrName] = newValue
+            this.__[name] = newValue
         }
     },
 
-    __get(attrName: string): unknown {
-        return this.__.__getInput(attrName)
-    },
-
-    __updateAttr(attrName: string): void {
-        if (this.root) {
-            const value = this.__.__getInput(attrName)
-            this.root.emitEvent(new AttrEvent(AttrEvent.CHANGE, this, attrName, value, value))
-        }
+    __getAttr(name: string): unknown {
+        return this.__.__get(name)
     }
 
 }

package/src/LeafEventer.ts

@@ -1,7 +1,5 @@
 import { IEventListener, IEventListenerOptions, IEventListenerMap, IEventListenerItem, IEventListenerId, IEvent, IObject, IEventTarget, ILeafEventerModule } from '@leafer/interface'
-import { Debug } from '@leafer/debug'
 
-const debug = Debug.get('Life')
 const empty = {}
 
 export const LeafEventer: ILeafEventerModule = {
@@ -71,8 +69,6 @@ export const LeafEventer: ILeafEventerModule = {
     },
 
     emit(type: string, event?: IEvent | IObject, capture?: boolean): void {
-        if (Debug.enable) debug.log(type)
-
         const map = __getListenerMap(this, capture)
         const list = map[type]
         if (list) {

package/src/LeafHit.ts

@@ -1,24 +1,23 @@
-import { ILeafHitModule, IRadiusPointData } from '@leafer/interface'
+import { ILeafHitModule, IRadiusPointData, ILeaferCanvas } from '@leafer/interface'
 import { PointHelper } from '@leafer/math'
 
 
-const { toLocalRadiusPoint } = PointHelper
-const local = {} as IRadiusPointData
+const { toInnerRadiusPointOf } = PointHelper
+const inner = {} as IRadiusPointData
 
 export const LeafHit: ILeafHitModule = {
 
-    __updateHitCanvas(): void {
-        if (!this.__hitCanvas) this.__hitCanvas = this.leafer.hitCanvasManager.getPathType(this)
-        this.__drawRenderPath(this.__hitCanvas)
-    },
-
     __hitWorld(point: IRadiusPointData): boolean {
         if (this.__layout.hitCanvasChanged) {
             this.__updateHitCanvas()
             this.__layout.hitCanvasChanged = false
         }
-        toLocalRadiusPoint(point, this.__world, local)
-        return this.__hit(local)
+        toInnerRadiusPointOf(point, this.__world, inner)
+        return this.__hit(inner)
+    },
+
+    __drawHitPath(canvas: ILeaferCanvas): void {
+        this.__drawRenderPath(canvas)
     }
 
 }

package/src/LeafMask.ts

@@ -0,0 +1,33 @@
+import { ILeaf, ILeaferCanvas, ILeafMaskModule } from '@leafer/interface'
+
+
+export const LeafMask: ILeafMaskModule = {
+
+    __updateMask(value?: boolean): void {
+        this.__hasMask = value ? true : this.children.some(item => item.__.isMask)
+    },
+
+    __renderMask(canvas: ILeaferCanvas, content: ILeaferCanvas, mask: ILeaferCanvas): void {
+        content.resetTransform()
+        content.useMask(mask)
+        canvas.resetTransform()
+        canvas.copyWorld(content)
+    },
+
+    __removeMask(child?: ILeaf): void {
+        if (child) {
+            child.isMask = false
+            this.remove(child)
+        } else {
+            const { children } = this
+            for (let i = 0, len = children.length; i < len; i++) {
+                child = children[i]
+                if (child.isMask) {
+                    this.__removeMask(child)
+                    len--, i--
+                }
+            }
+        }
+    }
+
+}

package/src/LeafMatrix.ts

@@ -10,10 +10,10 @@ export const LeafMatrix: ILeafMatrixModule = {
     __updateWorldMatrix(): void {
 
         const pw = this.parent ? this.parent.__world : defaultMatrix
-        const r = this.__relative
+        const r = this.__local
         const w = this.__world
 
-        if (this.__layout.matrixChanged) this.__updateRelativeMatrix()
+        if (this.__layout.matrixChanged) this.__updateLocalMatrix()
 
         if (this.__layout.affectScaleOrRotation) {
             w.a = r.a * pw.a + r.b * pw.c
@@ -32,9 +32,9 @@ export const LeafMatrix: ILeafMatrixModule = {
         }
     },
 
-    __updateRelativeMatrix(): void {
+    __updateLocalMatrix(): void {
 
-        const r = this.__relative
+        const r = this.__local
         const layout = this.__layout
 
         if (layout.affectScaleOrRotation) {

package/src/index.ts

@@ -4,4 +4,5 @@ export { LeafMatrix } from './LeafMatrix'
 export { LeafBounds } from './LeafBounds'
 export { LeafHit } from './LeafHit'
 export { LeafRender } from './LeafRender'
+export { LeafMask } from './LeafMask'