ranger-compiler 3.5.1 → 3.5.2

package/dist/lib/evg/EVGConnector.rgr

@@ -0,0 +1,541 @@
+; SPDX-License-Identifier: MIT
+
+; ==============================================================================
+; EVGConnector — a line between two elements, solved after layout
+; ==============================================================================
+;
+; A `path` is geometry the author owns: `d` says exactly where it goes, and a
+; responsive layout moves everything around it. That is how the arrow on the
+; Northwind dashboard came to be written `left: 171px; top: 148px` — correct at
+; 390 wide and wrong at every other width.
+;
+; A `connector` turns that around. The author says which two boxes it joins and
+; how it should look; the LAYOUT writes its `d`, from the rectangles those two
+; boxes came out as, on every pass. Move the cards, reflow the grid, stack them
+; on a phone — the line is re-solved and still joins them.
+;
+;     from / to           an anchor name (`--orders`) or an id (`#orders`)
+;     from-side/to-side   left right top bottom center + the four corners,
+;                         or `auto`, which picks the facing pair
+;     routing             straight | orthogonal | bezier
+;     arrow-start/-end    none | open | triangle,  arrow-size
+;
+; Everything about how it LOOKS is the stroke vocabulary a `path` already has —
+; `stroke`, `stroke-width`, `stroke-linecap`, `stroke-linejoin`,
+; `stroke-dasharray`. Nothing here invents a style property.
+;
+; The output is an ordinary path: `svgPath` in page coordinates with a `viewBox`
+; equal to the element's own box, so the fit is 1:1 and every renderer that
+; draws a `path` draws this with no changes of its own.
+; ==============================================================================
+
+Import "EVGElement.rgr"
+
+; A point on a box's edge, with the direction that edge faces. The normal is
+; what `orthogonal` turns along and what an offset pushes out by.
+class ConnPt {
+    def x:double 0.0
+    def y:double 0.0
+    def nx:double 0.0
+    def ny:double 0.0
+}
+
+class EVGConnector {
+
+    ; Every connector in the tree, re-solved. Returns what could not be
+    ; resolved, for the layout to report with its other warnings.
+    sfn resolveAll:[string] (root:EVGElement) {
+        def names:[string]
+        def nodes:[EVGElement]
+        EVGConnector.collectAnchors(root names nodes)
+        return (EVGConnector.resolveWith(root names nodes))
+    }
+
+    ; The same, against a table of names somebody else already collected —
+    ; which the layout has, because the surfaces are anchored by the same
+    ; names and one walk is enough for both.
+    sfn resolveWith:[string] (root:EVGElement names:[string] nodes:[EVGElement]) {
+        def warnings:[string]
+        def conns:[EVGElement]
+        EVGConnector.collect(root conns)
+        if ((array_length conns) == 0) {
+            return warnings
+        }
+        def i:int 0
+        while (i < (array_length conns)) {
+            def c:EVGElement (itemAt conns i)
+            EVGConnector.solve(c names nodes warnings)
+            i = (i + 1)
+        }
+        return warnings
+    }
+
+    sfn collect:void (el:EVGElement out:[EVGElement]) {
+        if (el.tagName == "connector") {
+            push out el
+        }
+        def i:int 0
+        def n:int (el.getChildCount())
+        while (i < n) {
+            def kid:EVGElement (el.getChild(i))
+            EVGConnector.collect(kid out)
+            i = (i + 1)
+        }
+    }
+
+    ; Both vocabularies in one table: `anchor-name` as written, and `#id` for
+    ; a document that never adopted anchor names.
+    sfn collectAnchors:void (el:EVGElement names:[string] nodes:[EVGElement]) {
+        if ((strlen el.anchorName) > 0) {
+            push names el.anchorName
+            push nodes el
+        }
+        if ((strlen el.id) > 0) {
+            push names ("#" + el.id)
+            push nodes el
+        }
+        def i:int 0
+        def n:int (el.getChildCount())
+        while (i < n) {
+            def kid:EVGElement (el.getChild(i))
+            EVGConnector.collectAnchors(kid names nodes)
+            i = (i + 1)
+        }
+    }
+
+    ; Not `find`: the compiler resolves that name elsewhere and every call
+    ; site fails with "does not have method find".
+    sfn lookup@(optional):EVGElement (key:string names:[string] nodes:[EVGElement]) {
+        def miss@(optional):EVGElement
+        def k:string (trim key)
+        if ((strlen k) == 0) {
+            return miss
+        }
+        def i:int 0
+        def n:int (array_length names)
+        while (i < n) {
+            def nm:string (itemAt names i)
+            if (nm == k) {
+                def hit@(optional):EVGElement (itemAt nodes i)
+                return hit
+            }
+            i = (i + 1)
+        }
+        return miss
+    }
+
+    ; The point named by a side, and the direction that side faces.
+    sfn pointOn:ConnPt (el:EVGElement side:string) {
+        def p (new ConnPt())
+        def x:double el.calculatedX
+        def y:double el.calculatedY
+        def w:double el.calculatedWidth
+        def h:double el.calculatedHeight
+        def cx:double (x + (w / 2.0))
+        def cy:double (y + (h / 2.0))
+        p.x = cx
+        p.y = cy
+        p.nx = 0.0
+        p.ny = 0.0
+        if (side == "left") {
+            p.x = x
+            p.nx = (0.0 - 1.0)
+        }
+        if (side == "right") {
+            p.x = (x + w)
+            p.nx = 1.0
+        }
+        if (side == "top") {
+            p.y = y
+            p.ny = (0.0 - 1.0)
+        }
+        if (side == "bottom") {
+            p.y = (y + h)
+            p.ny = 1.0
+        }
+        if (side == "top-left") {
+            p.x = x
+            p.y = y
+            p.nx = (0.0 - 0.7071)
+            p.ny = (0.0 - 0.7071)
+        }
+        if (side == "top-right") {
+            p.x = (x + w)
+            p.y = y
+            p.nx = 0.7071
+            p.ny = (0.0 - 0.7071)
+        }
+        if (side == "bottom-left") {
+            p.x = x
+            p.y = (y + h)
+            p.nx = (0.0 - 0.7071)
+            p.ny = 0.7071
+        }
+        if (side == "bottom-right") {
+            p.x = (x + w)
+            p.y = (y + h)
+            p.nx = 0.7071
+            p.ny = 0.7071
+        }
+        return p
+    }
+
+    sfn knownSide:boolean (side:string) {
+        if (((side == "left") || (side == "right")) || (side == "top")) {
+            return true
+        }
+        if (((side == "bottom") || (side == "center")) || (side == "top-left")) {
+            return true
+        }
+        if (((side == "top-right") || (side == "bottom-left")) || (side == "bottom-right")) {
+            return true
+        }
+        return false
+    }
+
+    ; A path number. `to_string` on a double prints differently per target —
+    ; 7 in JavaScript, 7.0 in Python — and a `d` string is compared in tests,
+    ; so it is written here once, to two decimals, the same everywhere.
+    sfn num:string (v:double) {
+        def x:double v
+        def neg:boolean false
+        if (x < 0.0) {
+            neg = true
+            x = (0.0 - x)
+        }
+        def scaled:int (to_int ((x * 100.0) + 0.5))
+        def whole:int (idiv scaled 100)
+        def frac:int (scaled - (whole * 100))
+        def out:string (to_string whole)
+        if (frac > 0) {
+            def fs:string (to_string frac)
+            if (frac < 10) {
+                fs = ("0" + fs)
+            }
+            if ((frac - ((idiv frac 10) * 10)) == 0) {
+                fs = (to_string (idiv frac 10))
+            }
+            out = ((out + ".") + fs)
+        }
+        if neg {
+            out = ("-" + out)
+        }
+        return out
+    }
+
+    sfn moveTo:string (x:double y:double) {
+        return ((("M " + (EVGConnector.num(x))) + " ") + (EVGConnector.num(y)))
+    }
+
+    sfn lineTo:string (x:double y:double) {
+        return (((" L " + (EVGConnector.num(x))) + " ") + (EVGConnector.num(y)))
+    }
+
+    ; One arrowhead at (tx,ty), pointing along (dx,dy). `open` is two barbs
+    ; stroked; `triangle` is a closed head, filled by the fill the solver turns
+    ; on for it.
+    sfn arrowHead:string (kind:string tx:double ty:double dx:double dy:double size:double) {
+        def len:double (sqrt ((dx * dx) + (dy * dy)))
+        if (len < 0.000001) {
+            return ""
+        }
+        def ux:double (dx / len)
+        def uy:double (dy / len)
+        ; The barbs are the direction turned ±150°, which is 30° of overhang
+        ; either side of the shaft — the proportions of an ordinary arrow.
+        def ca:double (0.0 - 0.8660254)
+        def sa:double 0.5
+        def b1x:double (tx + (size * ((ux * ca) - (uy * sa))))
+        def b1y:double (ty + (size * ((ux * sa) + (uy * ca))))
+        def b2x:double (tx + (size * ((ux * ca) + (uy * sa))))
+        def b2y:double (ty + (size * ((0.0 - (ux * sa)) + (uy * ca))))
+        if (kind == "triangle") {
+            def tri:string (EVGConnector.moveTo(tx ty))
+            tri = (tri + (EVGConnector.lineTo(b1x b1y)))
+            tri = (tri + (EVGConnector.lineTo(b2x b2y)))
+            tri = (tri + " Z")
+            return tri
+        }
+        def open:string (EVGConnector.moveTo(b1x b1y))
+        open = (open + (EVGConnector.lineTo(tx ty)))
+        open = (open + (EVGConnector.lineTo(b2x b2y)))
+        return open
+    }
+
+    sfn wantsArrow:boolean (kind:string) {
+        if ((strlen kind) == 0) {
+            return false
+        }
+        if (kind == "none") {
+            return false
+        }
+        if (kind == "false") {
+            return false
+        }
+        return true
+    }
+
+    sfn headKind:string (kind:string) {
+        if (kind == "open") {
+            return "open"
+        }
+        return "triangle"
+    }
+
+    sfn solve:void (c:EVGElement names:[string] nodes:[EVGElement] warnings:[string]) {
+        c.connectorResolved = false
+        if ((strlen c.connectorFrom) == 0) {
+            push warnings "connector: `from` names no element"
+            c.svgPath = ""
+            c.arrowPath = ""
+            return
+        }
+        if ((strlen c.connectorTo) == 0) {
+            push warnings "connector: `to` names no element"
+            c.svgPath = ""
+            c.arrowPath = ""
+            return
+        }
+        def fromEl@(optional):EVGElement (EVGConnector.lookup(c.connectorFrom names nodes))
+        def toEl@(optional):EVGElement (EVGConnector.lookup(c.connectorTo names nodes))
+        if (null? fromEl) {
+            push warnings (("connector: nothing is called \"" + c.connectorFrom) + "\" — give the target an anchor-name or an id")
+            c.svgPath = ""
+            c.arrowPath = ""
+            return
+        }
+        if (null? toEl) {
+            push warnings (("connector: nothing is called \"" + c.connectorTo) + "\" — give the target an anchor-name or an id")
+            c.svgPath = ""
+            c.arrowPath = ""
+            return
+        }
+        def a:EVGElement (unwrap fromEl)
+        def b:EVGElement (unwrap toEl)
+
+        def acx:double (a.calculatedX + (a.calculatedWidth / 2.0))
+        def acy:double (a.calculatedY + (a.calculatedHeight / 2.0))
+        def bcx:double (b.calculatedX + (b.calculatedWidth / 2.0))
+        def bcy:double (b.calculatedY + (b.calculatedHeight / 2.0))
+        def dx:double (bcx - acx)
+        def dy:double (bcy - acy)
+        def horizontal:boolean ((fabs dx) >= (fabs dy))
+
+        ; `auto` is the whole responsive story: the same connector leaves the
+        ; right edge when the cards sit side by side and the bottom edge when
+        ; the same layout stacks them.
+        def fs:string (EVGConnector.resolveSide(c.connectorFromSide horizontal dx dy false warnings))
+        def ts:string (EVGConnector.resolveSide(c.connectorToSide horizontal dx dy true warnings))
+
+        def p0:ConnPt (EVGConnector.pointOn(a fs))
+        def p1:ConnPt (EVGConnector.pointOn(b ts))
+        p0.x = (p0.x + (p0.nx * c.connectorFromOffset))
+        p0.y = (p0.y + (p0.ny * c.connectorFromOffset))
+        p1.x = (p1.x + (p1.nx * c.connectorToOffset))
+        p1.y = (p1.y + (p1.ny * c.connectorToOffset))
+
+        ; The vertices, in page coordinates. Bezier keeps its two controls
+        ; beside them: they are not on the line, but they bound it.
+        def xs:[double]
+        def ys:[double]
+        def routing:string c.connectorRouting
+        if ((strlen routing) == 0) {
+            routing = "straight"
+        }
+        def bezier:boolean (routing == "bezier")
+        def c0x:double 0.0
+        def c0y:double 0.0
+        def c1x:double 0.0
+        def c1y:double 0.0
+
+        push xs p0.x
+        push ys p0.y
+        if (routing == "orthogonal") {
+            def turnsHorizontally:boolean ((fabs p0.nx) > 0.000001)
+            if (((fabs p0.nx) < 0.000001) && ((fabs p0.ny) < 0.000001)) {
+                turnsHorizontally = horizontal
+            }
+            if turnsHorizontally {
+                def midX:double ((p0.x + p1.x) / 2.0)
+                push xs midX
+                push ys p0.y
+                push xs midX
+                push ys p1.y
+            } {
+                def midY:double ((p0.y + p1.y) / 2.0)
+                push xs p0.x
+                push ys midY
+                push xs p1.x
+                push ys midY
+            }
+        }
+        if bezier {
+            def span:double (sqrt ((dx * dx) + (dy * dy)))
+            def k:double (span * 0.4)
+            if (k < 40.0) {
+                k = 40.0
+            }
+            c0x = (p0.x + (p0.nx * k))
+            c0y = (p0.y + (p0.ny * k))
+            c1x = (p1.x + (p1.nx * k))
+            c1y = (p1.y + (p1.ny * k))
+        }
+        push xs p1.x
+        push ys p1.y
+
+        def count:int (array_length xs)
+        ; Which way the head at each end points, and where it sits.
+        def endDx:double (p1.x - (itemAt xs (count - 2)))
+        def endDy:double (p1.y - (itemAt ys (count - 2)))
+        def startDx:double (p0.x - (itemAt xs 1))
+        def startDy:double (p0.y - (itemAt ys 1))
+        if bezier {
+            endDx = (p1.x - c1x)
+            endDy = (p1.y - c1y)
+            startDx = (p0.x - c0x)
+            startDy = (p0.y - c0y)
+        }
+
+        def headEnd:boolean (EVGConnector.wantsArrow(c.arrowEnd))
+        def headStart:boolean (EVGConnector.wantsArrow(c.arrowStart))
+        ; The shaft: stroked, never filled. The heads are built below into
+        ; `arrowPath`, which is the element's filled half — see
+        ; `EVGElement.arrowPath` for why the two cannot share one `d`.
+        def d:string (EVGConnector.moveTo(p0.x p0.y))
+        if bezier {
+            d = (d + (EVGConnector.curveTo(c0x c0y c1x c1y p1.x p1.y)))
+        } {
+            def i:int 1
+            while (i < count) {
+                d = (d + (EVGConnector.lineTo((itemAt xs i) (itemAt ys i))))
+                i = (i + 1)
+            }
+        }
+
+        def size:double c.arrowSize
+        if (size <= 0.0) {
+            size = 10.0
+        }
+        ; An `open` head is two strokes, so it belongs on the shaft's own
+        ; path and inherits its cap and join. A `triangle` is filled, so it
+        ; goes on the filled path beside it.
+        def heads:string ""
+        if headEnd {
+            def kindE:string (EVGConnector.headKind(c.arrowEnd))
+            def head:string (EVGConnector.arrowHead(kindE p1.x p1.y endDx endDy size))
+            if ((strlen head) > 0) {
+                if (kindE == "triangle") {
+                    heads = (heads + head)
+                } {
+                    d = ((d + " ") + head)
+                }
+            }
+        }
+        if headStart {
+            def kindS:string (EVGConnector.headKind(c.arrowStart))
+            def head2:string (EVGConnector.arrowHead(kindS p0.x p0.y startDx startDy size))
+            if ((strlen head2) > 0) {
+                if (kindS == "triangle") {
+                    if ((strlen heads) > 0) {
+                        heads = (heads + " ")
+                    }
+                    heads = (heads + head2)
+                } {
+                    d = ((d + " ") + head2)
+                }
+            }
+        }
+        c.arrowPath = heads
+
+        ; The box. It is the geometry's own bounds, grown by what a stroke and
+        ; a head put outside them, and the viewBox is set to exactly the same
+        ; rectangle — so the path is drawn 1:1 where it was solved, with no
+        ; fitting of any kind.
+        def minX:double (itemAt xs 0)
+        def maxX:double minX
+        def minY:double (itemAt ys 0)
+        def maxY:double minY
+        def k2:int 0
+        while (k2 < count) {
+            def px:double (itemAt xs k2)
+            def py:double (itemAt ys k2)
+            if (px < minX) { minX = px }
+            if (px > maxX) { maxX = px }
+            if (py < minY) { minY = py }
+            if (py > maxY) { maxY = py }
+            k2 = (k2 + 1)
+        }
+        if bezier {
+            if (c0x < minX) { minX = c0x }
+            if (c0x > maxX) { maxX = c0x }
+            if (c1x < minX) { minX = c1x }
+            if (c1x > maxX) { maxX = c1x }
+            if (c0y < minY) { minY = c0y }
+            if (c0y > maxY) { maxY = c0y }
+            if (c1y < minY) { minY = c1y }
+            if (c1y > maxY) { maxY = c1y }
+        }
+        def pad:double ((c.strokeWidth / 2.0) + 1.0)
+        if (headEnd || headStart) {
+            pad = (pad + size)
+        }
+        minX = (minX - pad)
+        minY = (minY - pad)
+        maxX = (maxX + pad)
+        maxY = (maxY + pad)
+
+        def bw:double (maxX - minX)
+        def bh:double (maxY - minY)
+        c.svgPath = d
+        c.viewBox = (((((EVGConnector.num(minX)) + " ") + (EVGConnector.num(minY))) + " ") + (((EVGConnector.num(bw)) + " ") + (EVGConnector.num(bh))))
+        c.calculatedX = minX
+        c.calculatedY = minY
+        c.calculatedWidth = bw
+        c.calculatedHeight = bh
+        c.calculatedInnerWidth = bw
+        c.calculatedInnerHeight = bh
+        c.connectorResolved = true
+    }
+
+    sfn curveTo:string (ax:double ay:double bx:double by:double ex:double ey:double) {
+        def out:string (" C " + (EVGConnector.num(ax)))
+        out = ((out + " ") + (EVGConnector.num(ay)))
+        out = ((out + " ") + (EVGConnector.num(bx)))
+        out = ((out + " ") + (EVGConnector.num(by)))
+        out = ((out + " ") + (EVGConnector.num(ex)))
+        out = ((out + " ") + (EVGConnector.num(ey)))
+        return out
+    }
+
+    ; `auto`, or a side the author named. An unknown side is reported and
+    ; treated as auto rather than silently drawing from the middle.
+    sfn resolveSide:string (declared:string horizontal:boolean dx:double dy:double isTarget:boolean warnings:[string]) {
+        def s:string (trim declared)
+        if ((strlen s) > 0) {
+            if ((s == "auto") == false) {
+                if (EVGConnector.knownSide(s)) {
+                    return s
+                }
+                push warnings (("connector: unknown side \"" + s) + "\" — use left, right, top, bottom, center, a corner, or auto")
+            }
+        }
+        def forward:double dx
+        if (horizontal == false) {
+            forward = dy
+        }
+        def positive:boolean (forward >= 0.0)
+        if isTarget {
+            positive = (positive == false)
+        }
+        if horizontal {
+            if positive {
+                return "right"
+            }
+            return "left"
+        }
+        if positive {
+            return "bottom"
+        }
+        return "top"
+    }
+}