@leafer-ui/paint 1.6.2 → 1.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer-ui/paint",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "description": "@leafer-ui/paint",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -22,11 +22,11 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/core": "1.6.2",
-    "@leafer-ui/draw": "1.6.2"
+    "@leafer/core": "1.6.4",
+    "@leafer-ui/draw": "1.6.4"
   },
   "devDependencies": {
-    "@leafer/interface": "1.6.2",
-    "@leafer-ui/interface": "1.6.2"
+    "@leafer/interface": "1.6.4",
+    "@leafer-ui/interface": "1.6.4"
   }
 }

package/src/Compute.ts

@@ -1,46 +1,74 @@
+import { DataHelper } from '@leafer/core'
+
 import { IUI, IPaint, ILeafPaint, IRGB, IBooleanMap, IObject, IPaintAttr } from '@leafer-ui/interface'
 import { ColorConvert, PaintImage, PaintGradient } from '@leafer-ui/draw'
 
 
 let recycleMap: IBooleanMap
+const { stintSet } = DataHelper, { hasTransparent } = ColorConvert
 
 export function compute(attrName: IPaintAttr, ui: IUI): void {
     const data = ui.__, leafPaints: ILeafPaint[] = []
 
-    let paints: IPaint[] = data.__input[attrName], hasOpacityPixel: boolean
+    let paints: IPaint[] = data.__input[attrName], isAlphaPixel: boolean, isTransparent: boolean
     if (!(paints instanceof Array)) paints = [paints]
 
     recycleMap = PaintImage.recycleImage(attrName, data)
 
     for (let i = 0, len = paints.length, item: ILeafPaint; i < len; i++) {
-        item = getLeafPaint(attrName, paints[i], ui)
-        if (item) leafPaints.push(item)
+        (item = getLeafPaint(attrName, paints[i], ui)) && leafPaints.push(item)
     }
 
     (data as IObject)['_' + attrName] = leafPaints.length ? leafPaints : undefined
 
-    if (leafPaints.length && leafPaints[0].image) hasOpacityPixel = leafPaints[0].image.hasOpacityPixel
-    attrName === 'fill' ? data.__pixelFill = hasOpacityPixel : data.__pixelStroke = hasOpacityPixel
+    if (leafPaints.length) {
+        if (leafPaints.every(item => item.isTransparent)) {
+            if (leafPaints.some(item => item.image)) isAlphaPixel = true
+            isTransparent = true
+        }
+    }
+
+    if (attrName === 'fill') {
+        stintSet(data, '__isAlphaPixelFill', isAlphaPixel)
+        stintSet(data, '__isTransparentFill', isTransparent)
+    } else {
+        stintSet(data, '__isAlphaPixelStroke', isAlphaPixel)
+        stintSet(data, '__isTransparentStroke', isTransparent)
+    }
 }
 
 
 function getLeafPaint(attrName: string, paint: IPaint, ui: IUI): ILeafPaint {
     if (typeof paint !== 'object' || paint.visible === false || paint.opacity === 0) return undefined
+
+    let data: ILeafPaint
     const { boxBounds } = ui.__layout
 
     switch (paint.type) {
-        case 'solid':
-            let { type, blendMode, color, opacity } = paint
-            return { type, blendMode, style: ColorConvert.string(color, opacity) }
         case 'image':
-            return PaintImage.image(ui, attrName, paint, boxBounds, !recycleMap || !recycleMap[paint.url])
+            data = PaintImage.image(ui, attrName, paint, boxBounds, !recycleMap || !recycleMap[paint.url])
+            break
         case 'linear':
-            return PaintGradient.linearGradient(paint, boxBounds)
+            data = PaintGradient.linearGradient(paint, boxBounds)
+            break
         case 'radial':
-            return PaintGradient.radialGradient(paint, boxBounds)
+            data = PaintGradient.radialGradient(paint, boxBounds)
+            break
         case 'angular':
-            return PaintGradient.conicGradient(paint, boxBounds)
+            data = PaintGradient.conicGradient(paint, boxBounds)
+            break
+        case 'solid':
+            const { type, color, opacity } = paint
+            data = { type, style: ColorConvert.string(color, opacity) }
+            break
         default:
-            return (paint as IRGB).r !== undefined ? { type: 'solid', style: ColorConvert.string(paint) } : undefined
+            if ((paint as IRGB).r !== undefined) data = { type: 'solid', style: ColorConvert.string(paint) }
     }
+
+    if (data) {
+        if (typeof data.style === 'string' && hasTransparent(data.style)) data.isTransparent = true
+        if (paint.blendMode) data.blendMode = paint.blendMode
+    }
+
+    return data
 }

package/src/Stroke.ts

@@ -1,59 +1,30 @@
 import { ILeaferCanvas } from '@leafer/interface'
 
 import { IUI, ILeafPaint } from '@leafer-ui/interface'
+import { Paint } from '@leafer-ui/draw'
 
-import { strokeText, drawStrokesStyle } from './StrokeText'
+import { strokeText, drawStrokesStyle, copyWorld } from './StrokeText'
 
 
 export function stroke(stroke: string, ui: IUI, canvas: ILeaferCanvas): void {
-    const options = ui.__
-    const { __strokeWidth, strokeAlign, __font } = options
-    if (!__strokeWidth) return
+    const data = ui.__
+    if (!data.__strokeWidth) return
 
-    if (__font) {
+    if (data.__font) {
 
         strokeText(stroke, ui, canvas)
 
     } else {
 
-        switch (strokeAlign) {
-
+        switch (data.strokeAlign) {
             case 'center':
-
-                canvas.setStroke(stroke, __strokeWidth, options)
-                canvas.stroke()
-
-                if (options.__useArrow) strokeArrow(ui, canvas)
-
+                drawCenter(stroke, 1, ui, canvas)
                 break
-
             case 'inside':
-
-                canvas.save()
-                canvas.setStroke(stroke, __strokeWidth * 2, options)
-
-                options.windingRule ? canvas.clip(options.windingRule) : canvas.clip()
-                canvas.stroke()
-
-                canvas.restore()
-
+                drawInside(stroke, ui, canvas)
                 break
-
             case 'outside':
-                const out = canvas.getSameCanvas(true, true)
-                out.setStroke(stroke, __strokeWidth * 2, options)
-
-                ui.__drawRenderPath(out)
-
-                out.stroke()
-
-                options.windingRule ? out.clip(options.windingRule) : out.clip()
-                out.clearWorld(ui.__layout.renderBounds)
-
-                if (ui.__worldFlipped) canvas.copyWorldByReset(out, ui.__nowWorld)
-                else canvas.copyWorldToInner(out, ui.__nowWorld, ui.__layout.renderBounds)
-
-                out.recycle(ui.__nowWorld)
+                drawOutside(stroke, ui, canvas)
                 break
         }
 
@@ -62,64 +33,45 @@ export function stroke(stroke: string, ui: IUI, canvas: ILeaferCanvas): void {
 
 
 export function strokes(strokes: ILeafPaint[], ui: IUI, canvas: ILeaferCanvas): void {
-    const options = ui.__
-    const { __strokeWidth, strokeAlign, __font } = options
-    if (!__strokeWidth) return
-
-    if (__font) {
-
-        strokeText(strokes, ui, canvas)
+    stroke(strokes as any, ui, canvas)
+}
 
-    } else {
 
-        switch (strokeAlign) {
+function drawCenter(stroke: string | ILeafPaint[], strokeWidthScale: number, ui: IUI, canvas: ILeaferCanvas) {
+    const data = ui.__
+    canvas.setStroke(!data.__isStrokes && stroke as string, data.__strokeWidth * strokeWidthScale, data)
+    data.__isStrokes ? drawStrokesStyle(stroke as ILeafPaint[], false, ui, canvas) : canvas.stroke()
 
-            case 'center':
-                canvas.setStroke(undefined, __strokeWidth, options)
-                drawStrokesStyle(strokes, false, ui, canvas)
+    if (data.__useArrow) Paint.strokeArrow(stroke, ui, canvas)
 
-                if (options.__useArrow) strokeArrow(ui, canvas)
-                break
+}
 
-            case 'inside':
-                canvas.save()
-                canvas.setStroke(undefined, __strokeWidth * 2, options)
-                options.windingRule ? canvas.clip(options.windingRule) : canvas.clip()
+function drawInside(stroke: string | ILeafPaint[], ui: IUI, canvas: ILeaferCanvas) {
+    canvas.save()
+    canvas.clipUI(ui)
 
-                drawStrokesStyle(strokes, false, ui, canvas)
+    drawCenter(stroke, 2, ui, canvas)
+    canvas.restore()
+}
 
-                canvas.restore()
-                break
+function drawOutside(stroke: string | ILeafPaint[], ui: IUI, canvas: ILeaferCanvas) {
+    const data = ui.__
+    if (data.__fillAfterStroke) {
 
-            case 'outside':
-                const { renderBounds } = ui.__layout
-                const out = canvas.getSameCanvas(true, true)
-                ui.__drawRenderPath(out)
+        drawCenter(stroke, 2, ui, canvas)
 
-                out.setStroke(undefined, __strokeWidth * 2, options)
-
-                drawStrokesStyle(strokes, false, ui, out)
+    } else {
+        const { renderBounds } = ui.__layout
+        const out = canvas.getSameCanvas(true, true)
+        ui.__drawRenderPath(out)
 
-                options.windingRule ? out.clip(options.windingRule) : out.clip()
-                out.clearWorld(renderBounds)
+        drawCenter(stroke, 2, ui, out)
 
-                if (ui.__worldFlipped) canvas.copyWorldByReset(out, ui.__nowWorld)
-                else canvas.copyWorldToInner(out, ui.__nowWorld, renderBounds)
+        out.clipUI(data)
+        out.clearWorld(renderBounds)
 
-                out.recycle(ui.__nowWorld)
-                break
-        }
+        copyWorld(canvas, out, ui)
 
+        out.recycle(ui.__nowWorld)
     }
-
 }
-
-
-function strokeArrow(ui: IUI, canvas: ILeaferCanvas): void {
-    if (ui.__.dashPattern) {  // fix: dashPattern Arrow
-        canvas.beginPath()
-        ui.__drawPathByData(canvas, ui.__.__pathForArrow)
-        canvas.dashPattern = null
-        canvas.stroke()
-    }
-}

package/src/StrokeText.ts

@@ -1,4 +1,5 @@
 import { ILeaferCanvas } from '@leafer/interface'
+import { Platform } from "@leafer/core"
 
 import { IUI, ITextRowData, ILeafPaint, IStrokeAlign, ILeafStrokePaint } from '@leafer-ui/interface'
 import { PaintImage } from "@leafer-ui/draw"
@@ -7,41 +8,46 @@ import { fillText } from './FillText'
 
 
 export function strokeText(stroke: string | ILeafPaint[], ui: IUI, canvas: ILeaferCanvas): void {
-    const { strokeAlign } = ui.__
-    const isStrokes = typeof stroke !== 'string'
-    switch (strokeAlign) {
+    switch (ui.__.strokeAlign) {
         case 'center':
-            canvas.setStroke(isStrokes ? undefined : stroke, ui.__.strokeWidth, ui.__)
-            isStrokes ? drawStrokesStyle(stroke as ILeafPaint[], true, ui, canvas) : drawTextStroke(ui, canvas)
+            drawCenter(stroke, 1, ui, canvas)
             break
         case 'inside':
-            drawAlignStroke('inside', stroke, isStrokes, ui, canvas)
+            drawAlign(stroke, 'inside', ui, canvas)
             break
         case 'outside':
-            drawAlignStroke('outside', stroke, isStrokes, ui, canvas)
+            ui.__.__fillAfterStroke ? drawCenter(stroke, 2, ui, canvas) : drawAlign(stroke, 'outside', ui, canvas)
             break
     }
 }
 
-function drawAlignStroke(align: IStrokeAlign, stroke: string | ILeafPaint[], isStrokes: boolean, ui: IUI, canvas: ILeaferCanvas): void {
-    const { __strokeWidth, __font } = ui.__
+function drawCenter(stroke: string | ILeafPaint[], strokeWidthScale: number, ui: IUI, canvas: ILeaferCanvas): void {
+    const data = ui.__
+    canvas.setStroke(!data.__isStrokes && stroke as string, data.strokeWidth * strokeWidthScale, data)
+    data.__isStrokes ? drawStrokesStyle(stroke as ILeafPaint[], true, ui, canvas) : drawTextStroke(ui, canvas)
+}
 
+function drawAlign(stroke: string | ILeafPaint[], align: IStrokeAlign, ui: IUI, canvas: ILeaferCanvas): void {
     const out = canvas.getSameCanvas(true, true)
-    out.setStroke(isStrokes ? undefined : stroke, __strokeWidth * 2, ui.__)
-
-    out.font = __font
-    isStrokes ? drawStrokesStyle(stroke as ILeafPaint[], true, ui, out) : drawTextStroke(ui, out)
+    out.font = ui.__.__font
+    drawCenter(stroke, 2, ui, out)
 
     out.blendMode = align === 'outside' ? 'destination-out' : 'destination-in'
     fillText(ui, out)
     out.blendMode = 'normal'
 
-    if (ui.__worldFlipped) canvas.copyWorldByReset(out, ui.__nowWorld)
-    else canvas.copyWorldToInner(out, ui.__nowWorld, ui.__layout.renderBounds)
+    copyWorld(canvas, out, ui)
 
     out.recycle(ui.__nowWorld)
 }
 
+
+export function copyWorld(canvas: ILeaferCanvas, out: ILeaferCanvas, ui: IUI): void {
+    if (ui.__worldFlipped || Platform.fullImageShadow) canvas.copyWorldByReset(out, ui.__nowWorld)
+    else canvas.copyWorldToInner(out, ui.__nowWorld, ui.__layout.renderBounds)
+}
+
+
 export function drawTextStroke(ui: IUI, canvas: ILeaferCanvas): void {
 
     let row: ITextRowData, data = ui.__.__textDrawData