ranger-compiler 3.5.0 → 3.5.2

package/dist/lib/evg/EVGRuler.rgr

@@ -0,0 +1,232 @@
+; SPDX-License-Identifier: MIT
+
+; ==============================================================================
+; EVGRuler — where the paper starts, where the text starts, and how far along
+; ==============================================================================
+;
+; A word processor without a ruler can be typed into but not laid out. It is
+; the one place a reader can SEE that the page has margins, that the paragraph
+; they are in is indented, and by how much — and the one place they can say so
+; without opening a dialog and knowing the word "indent" first.
+;
+; This is the geometry only: where the band is, where the ticks fall, where
+; the three markers sit and which one the pointer is on. The drawing is
+; `EVGRulerView`, and the split is the same one `EVGToolbar` has, for the same
+; reason — the numbers can be checked without a font, a canvas or a window,
+; and they are the half that is easy to get wrong.
+;
+; Everything is in SCREEN pixels except `pxPerUnit`, which is how many of them
+; a ruler unit is. An inch at 96 dpi is the default because that is the unit
+; Word's own ruler is marked in and the unit its measurements arrive in; a
+; caller working in centimetres passes 37.8 and gets a centimetre ruler with
+; no other change.
+;
+;   npm run evg:ruler:test
+; ==============================================================================
+
+class EVGRuler {
+    ; The band itself.
+    def x:int 0
+    def y:int 0
+    def w:int 0
+    def h:int 22
+
+    ; Where the paper is inside it. The ruler is as wide as the window and the
+    ; paper is not, so the two are separate: the numbers count from the left
+    ; edge of the PAPER, and the band beyond the paper is dead space.
+    def pageX:int 0
+    def pageW:int 0
+
+    ; The text column inside the paper, in pixels from the paper's left edge.
+    def marginL:int 0
+    def marginR:int 0
+
+    ; The paragraph's own indents, in pixels, measured from the text column —
+    ; not from the paper. That is what they are in the file and it is why a
+    ; hanging indent is a negative first line.
+    def indentFirst:int 0
+    def indentLeft:int 0
+    def indentRight:int 0
+
+    def pxPerUnit:double 96.0
+    ; Eight ticks to the unit: the eighths of an inch a Word ruler shows.
+    def ticksPerUnit:int 8
+
+    Constructor () {
+    }
+
+    ; --- the paper, in screen coordinates ------------------------------------
+
+    fn textLeftX:int () {
+        return ((pageX + marginL) + indentLeft)
+    }
+
+    fn textRightX:int () {
+        return (((pageX + pageW) - marginR) - indentRight)
+    }
+
+    ; The first line can start left of the rest of the paragraph — that is a
+    ; hanging indent, and it is why this is not clamped to the others.
+    fn firstLineX:int () {
+        return (((pageX + marginL) + indentLeft) + indentFirst)
+    }
+
+    fn marginLeftX:int () {
+        return (pageX + marginL)
+    }
+
+    fn marginRightX:int () {
+        return ((pageX + pageW) - marginR)
+    }
+
+    ; --- the marks ------------------------------------------------------------
+
+    ; How many ticks fit across the paper. Counted over the PAPER rather than
+    ; the band, because a ruler numbered from the window edge measures nothing
+    ; anybody cares about.
+    fn tickCount:int () {
+        if (pxPerUnit <= 0.0) {
+            return 0
+        }
+        def per:double (pxPerUnit / (to_double ticksPerUnit))
+        if (per <= 0.0) {
+            return 0
+        }
+        return ((to_int ((to_double pageW) / per)) + 1)
+    }
+
+    fn tickX:int (i:int) {
+        def per:double (pxPerUnit / (to_double ticksPerUnit))
+        return (pageX + (to_int ((to_double i) * per)))
+    }
+
+    ; A whole unit gets a number; the eighths get a mark and no number.
+    fn tickIsUnit:boolean (i:int) {
+        if (ticksPerUnit <= 0) {
+            return false
+        }
+        return ((i % ticksPerUnit) == 0)
+    }
+
+    ; Half units are drawn taller than eighths, which is what makes a ruler
+    ; countable at a glance rather than a row of identical scratches.
+    fn tickIsHalf:boolean (i:int) {
+        if (ticksPerUnit <= 0) {
+            return false
+        }
+        def half:int (idiv ticksPerUnit 2)
+        if (half <= 0) {
+            return false
+        }
+        return ((i % half) == 0)
+    }
+
+    fn tickLabel:int (i:int) {
+        if (ticksPerUnit <= 0) {
+            return 0
+        }
+        return (idiv i ticksPerUnit)
+    }
+
+    ; --- the markers ----------------------------------------------------------
+    ; 0 the first line, 1 the left indent, 2 the right indent, -1 none.
+
+    sfn markerFirst:int () { return 0 }
+    sfn markerLeft:int ()  { return 1 }
+    sfn markerRight:int () { return 2 }
+
+    fn markerX:int (which:int) {
+        if (which == 0) {
+            return (this.firstLineX())
+        }
+        if (which == 1) {
+            return (this.textLeftX())
+        }
+        return (this.textRightX())
+    }
+
+    ; Which marker the pointer is on, or -1.
+    ;
+    ; The first line and the left indent sit at the same x whenever the
+    ; paragraph has no first-line indent, which is most paragraphs. The FIRST
+    ; LINE wins there, because it is the one at the top of the band and the
+    ; one under the pointer coming down onto it — a hit test that answered the
+    ; left indent would make the top marker undraggable in the common case and
+    ; leave nobody able to say why.
+    fn hitMarker:int (px:int py:int) {
+        if (py < y) {
+            return -1
+        }
+        if (py >= (y + h)) {
+            return -1
+        }
+        def half:int (idiv h 2)
+        def top:boolean (py < (y + half))
+        if top {
+            if (this.nearX(px (this.firstLineX()))) {
+                return 0
+            }
+        } {
+            if (this.nearX(px (this.textLeftX()))) {
+                return 1
+            }
+        }
+        if (this.nearX(px (this.textRightX()))) {
+            return 2
+        }
+        return -1
+    }
+
+    fn nearX:boolean (px:int at:int) {
+        def d:int (px - at)
+        if (d < 0) {
+            d = (0 - d)
+        }
+        return (d <= 6)
+    }
+
+    ; Where a marker dragged to `px` puts its indent, in pixels from the text
+    ; column. Clamped so a marker cannot be dragged off its own paper: an
+    ; indent wider than the column is a paragraph with no width at all, and
+    ; the file will happily hold one.
+    fn indentFor:int (which:int px:int) {
+        def colL:int (pageX + marginL)
+        def colR:int ((pageX + pageW) - marginR)
+        def span:int (colR - colL)
+        if (span < 1) {
+            return 0
+        }
+        if (which == 2) {
+            def r:int (colR - px)
+            if (r < 0) {
+                r = 0
+            }
+            if (r > (span - 1)) {
+                r = (span - 1)
+            }
+            return r
+        }
+        def v:int (px - colL)
+        if (which == 1) {
+            if (v < 0) {
+                v = 0
+            }
+            if (v > (span - 1)) {
+                v = (span - 1)
+            }
+            return v
+        }
+        ; The first line is relative to the left indent and may be negative —
+        ; that is a hanging indent, and clamping it to zero is what makes a
+        ; bulleted list impossible to express.
+        def f:int ((px - colL) - indentLeft)
+        def lo:int (0 - (indentLeft + 1))
+        if (f < lo) {
+            f = lo
+        }
+        if (f > (span - 1)) {
+            f = (span - 1)
+        }
+        return f
+    }
+}

package/dist/lib/evg/EVGRulerTest.rgr

@@ -0,0 +1,172 @@
+; SPDX-License-Identifier: MIT
+
+; ==============================================================================
+; EVGRulerTest — the numbers on the ruler, without a font in sight
+; ==============================================================================
+;
+; The ruler is split into geometry and drawing for exactly this: the numbers
+; can be checked without a canvas, and they are the half that is easy to get
+; wrong. What is checked here is what a reader would notice within a minute of
+; using it:
+;
+;   * the numbers count from the left edge of the PAPER, not of the window
+;   * the marks are the eighths of a unit, with the halves taller and the
+;     whole units taller still and numbered
+;   * a hanging indent puts the first line LEFT of the rest of the paragraph,
+;     which is the case a clamp to zero silently destroys
+;   * the two left markers sit on top of each other when there is no
+;     first-line indent, and the hit test still tells them apart
+;   * a marker dragged off the paper stops at the edge of the text column
+;
+;   npm run evg:ruler:test
+; ==============================================================================
+
+Import "EVGRuler.rgr"
+
+class RulerCheck {
+    def passed:int 0
+    def failed:int 0
+
+    fn ok:void (name:string cond:boolean) {
+        if cond {
+            passed = (passed + 1)
+            print ("  PASS  " + name)
+        } {
+            failed = (failed + 1)
+            print ("  FAIL  " + name)
+        }
+    }
+
+    fn eqInt:void (name:string got:int want:int) {
+        this.ok(((((name + " (got ") + (to_string got)) + " want ") + ((to_string want) + ")")) (got == want))
+    }
+}
+
+class EVGRulerTest {
+    def c:RulerCheck (new RulerCheck)
+
+    sfn main:void () {
+        def t (new EVGRulerTest())
+        t.run()
+    }
+
+    ; A letter page at 96 dpi: 8.5 inches of paper with a one-inch margin
+    ; each side, sitting in a window wider than it.
+    sfn page:EVGRuler () {
+        def r (new EVGRuler)
+        r.x = 0
+        r.y = 40
+        r.w = 1000
+        r.h = 22
+        r.pageX = 100
+        r.pageW = 816
+        r.marginL = 96
+        r.marginR = 96
+        r.pxPerUnit = 96.0
+        return r
+    }
+
+    fn run:void () {
+        print "=== EVGRulerTest ==="
+        this.testColumn()
+        this.testTicks()
+        this.testIndents()
+        this.testHit()
+        this.testDrag()
+        print ""
+        print (("passed = " + (to_string c.passed)) + ("  failed = " + (to_string c.failed)))
+        if (c.failed == 0) {
+            print "ALL PASS"
+        } {
+            print "SOME FAILED"
+        }
+    }
+
+    fn testColumn:void () {
+        print "--- where the paper and the text are ---"
+        def r:EVGRuler (EVGRulerTest.page())
+        c.eqInt("the text column starts an inch into the paper" (r.marginLeftX()) 196)
+        c.eqInt("and ends an inch before its right edge" (r.marginRightX()) 820)
+        c.eqInt("with no indents the text starts at the margin" (r.textLeftX()) 196)
+        c.eqInt("and ends at the other one" (r.textRightX()) 820)
+    }
+
+    fn testTicks:void () {
+        print "--- the marks ---"
+        def r:EVGRuler (EVGRulerTest.page())
+        ; Counted over the PAPER: a ruler numbered from the window edge
+        ; measures nothing anybody cares about.
+        c.eqInt("the first tick is at the left edge of the paper" (r.tickX(0)) 100)
+        c.eqInt("the eighth is one inch along" (r.tickX(8)) 196)
+        c.ok("and it is a whole unit" (r.tickIsUnit(8)))
+        c.eqInt("numbered 1" (r.tickLabel(8)) 1)
+        c.ok("a half is a half and not a unit"
+            ((r.tickIsHalf(4)) && ((r.tickIsUnit(4)) == false)))
+        c.ok("an eighth is neither"
+            (((r.tickIsHalf(3)) == false) && ((r.tickIsUnit(3)) == false)))
+        c.ok("the marks cover the paper" ((r.tickCount()) >= 68))
+    }
+
+    fn testIndents:void () {
+        print "--- and the paragraph's own indents ---"
+        def r:EVGRuler (EVGRulerTest.page())
+        r.indentLeft = 48
+        r.indentRight = 24
+        c.eqInt("a left indent moves the text in" (r.textLeftX()) 244)
+        c.eqInt("a right indent brings the other end in" (r.textRightX()) 796)
+        c.eqInt("and the first line follows the left one" (r.firstLineX()) 244)
+
+        ; A HANGING indent: the first line starts left of the rest, which is
+        ; how every bulleted list in every document is built. A first-line
+        ; indent clamped to zero cannot express it.
+        r.indentFirst = -24
+        c.eqInt("a hanging first line starts left of the paragraph" (r.firstLineX()) 220)
+        c.ok("which is left of the body" ((r.firstLineX()) < (r.textLeftX())))
+    }
+
+    fn testHit:void () {
+        print "--- which marker the pointer is on ---"
+        def r:EVGRuler (EVGRulerTest.page())
+        c.eqInt("the top half of the band is the first line"
+            (r.hitMarker(196 (r.y + 3))) (EVGRuler.markerFirst()))
+        ; The two left markers are at the SAME x when there is no first-line
+        ; indent, which is most paragraphs. The band is split top and bottom
+        ; so both stay reachable — a hit test that answered one of them for
+        ; the whole band would make the other undraggable and leave nobody
+        ; able to say why.
+        c.eqInt("the bottom half is the left indent"
+            (r.hitMarker(196 ((r.y + r.h) - 3))) (EVGRuler.markerLeft()))
+        c.eqInt("the right indent is at the other end"
+            (r.hitMarker(820 ((r.y + r.h) - 3))) (EVGRuler.markerRight()))
+        c.eqInt("the middle of the ruler is no marker"
+            (r.hitMarker(500 (r.y + 8))) -1)
+        c.eqInt("and neither is a point above the band"
+            (r.hitMarker(196 (r.y - 4))) -1)
+        ; A few pixels off still counts: a marker six pixels wide that only
+        ; answers its exact centre is a marker nobody can grab.
+        c.eqInt("a near miss still finds it"
+            (r.hitMarker(200 (r.y + 3))) (EVGRuler.markerFirst()))
+    }
+
+    fn testDrag:void () {
+        print "--- and where dragging one puts it ---"
+        def r:EVGRuler (EVGRulerTest.page())
+        c.eqInt("dragging the left indent an inch in" (r.indentFor(1 292)) 96)
+        c.eqInt("dragging the right indent an inch in" (r.indentFor(2 724)) 96)
+
+        ; Off the paper in either direction stops at the column.
+        c.eqInt("dragged off the left edge it stops at the margin" (r.indentFor(1 0)) 0)
+        c.eqInt("dragged off the right edge it stops too" (r.indentFor(2 5000)) 0)
+        def colR:int (r.marginRightX())
+        def colL:int (r.marginLeftX())
+        c.ok("and cannot be dragged past the far side"
+            ((r.indentFor(1 5000)) < (colR - colL)))
+
+        ; The first line may go negative — that is the hanging indent — but
+        ; not so far that it leaves the paper.
+        r.indentLeft = 48
+        c.eqInt("the first line can be dragged left of the paragraph"
+            (r.indentFor(0 220)) -24)
+        c.ok("but not off the paper" ((r.indentFor(0 0)) >= (0 - 49)))
+    }
+}

package/dist/lib/evg/EVGSelectChrome.rgr

@@ -0,0 +1,178 @@
+; SPDX-License-Identifier: MIT
+
+; ==============================================================================
+; EVGSelectChrome - where the handles are, for any editor that has a selection
+; ==============================================================================
+;
+; Eight handles round a box, numbered clockwise from the top-left:
+;
+;     0 ── 1 ── 2
+;     │         │
+;     7         3
+;     │         │
+;     6 ── 5 ── 4
+;
+; That numbering is not arbitrary once it exists: a resize is implemented by
+; asking which edges a handle owns, and two editors that number their handles
+; differently cannot share a single line of that code. The slide editor picked
+; this order first; the book editor uses the same one, and both ask here rather
+; than each carrying its own copy of "handle 3 is the right edge".
+;
+; Pure geometry, in whatever unit the caller works in - slide points, page
+; points or window pixels. Nothing here knows what a slide or a page is.
+; ==============================================================================
+
+class EVGSelectChrome {
+    ; The centre of handle `idx` on a box spanning x0..x1, y0..y1.
+    sfn handleCx:double (x0:double x1:double idx:int) {
+        def mid:double ((x0 + x1) * 0.5)
+        if (idx == 1) {
+            return mid
+        }
+        if (idx == 5) {
+            return mid
+        }
+        if (idx == 2) {
+            return x1
+        }
+        if (idx == 3) {
+            return x1
+        }
+        if (idx == 4) {
+            return x1
+        }
+        return x0
+    }
+
+    sfn handleCy:double (y0:double y1:double idx:int) {
+        def mid:double ((y0 + y1) * 0.5)
+        if (idx == 3) {
+            return mid
+        }
+        if (idx == 7) {
+            return mid
+        }
+        if (idx == 4) {
+            return y1
+        }
+        if (idx == 5) {
+            return y1
+        }
+        if (idx == 6) {
+            return y1
+        }
+        return y0
+    }
+
+    ; Which edges handle `idx` moves. A resize is these four answers and
+    ; nothing else, which is why they are here rather than written out again
+    ; in every editor's applyResize.
+    sfn movesWest:boolean (idx:int) {
+        if (idx == 0) {
+            return true
+        }
+        if (idx == 6) {
+            return true
+        }
+        return (idx == 7)
+    }
+
+    sfn movesEast:boolean (idx:int) {
+        if (idx == 2) {
+            return true
+        }
+        if (idx == 4) {
+            return true
+        }
+        return (idx == 3)
+    }
+
+    sfn movesNorth:boolean (idx:int) {
+        if (idx == 0) {
+            return true
+        }
+        if (idx == 2) {
+            return true
+        }
+        return (idx == 1)
+    }
+
+    sfn movesSouth:boolean (idx:int) {
+        if (idx == 4) {
+            return true
+        }
+        if (idx == 6) {
+            return true
+        }
+        return (idx == 5)
+    }
+
+    ; The handle under a point, or -1. `grab` is the half-width of a handle's
+    ; hit area - deliberately larger than the drawn square, because a handle
+    ; you cannot reliably hit is worse than one you cannot see.
+    sfn handleAt:int (x0:double y0:double x1:double y1:double px:double py:double grab:double) {
+        def i:int 0
+        while (i < 8) {
+            def hx:double (EVGSelectChrome.handleCx(x0 x1 i))
+            def hy:double (EVGSelectChrome.handleCy(y0 y1 i))
+            def dx:double (px - hx)
+            def dy:double (py - hy)
+            if (dx < 0.0) {
+                dx = (0.0 - dx)
+            }
+            if (dy < 0.0) {
+                dy = (0.0 - dy)
+            }
+            if ((dx <= grab) && (dy <= grab)) {
+                return i
+            }
+            i = (i + 1)
+        }
+        return -1
+    }
+
+    ; A drag from (ax, ay) to (bx, by) as a positive rectangle: x, y, w, h.
+    ; A marquee dragged up and to the left is the same rectangle as one
+    ; dragged down and to the right, and only one of them has positive sides.
+    sfn marquee:[double] (ax:double ay:double bx:double by:double) {
+        def out:[double]
+        def x0:double ax
+        def x1:double bx
+        if (bx < ax) {
+            x0 = bx
+            x1 = ax
+        }
+        def y0:double ay
+        def y1:double by
+        if (by < ay) {
+            y0 = by
+            y1 = ay
+        }
+        push out x0
+        push out y0
+        push out (x1 - x0)
+        push out (y1 - y0)
+        return out
+    }
+
+    ; Do two boxes overlap at all? A marquee selects what it touches.
+    sfn overlaps:boolean (ax:double ay:double aw:double ah:double bx:double by:double bw:double bh:double) {
+        def ax1:double (ax + aw)
+        def ay1:double (ay + ah)
+        def bx1:double (bx + bw)
+        def by1:double (by + bh)
+        if (ax1 < bx) {
+            return false
+        }
+        if (bx1 < ax) {
+            return false
+        }
+        if (ay1 < by) {
+            return false
+        }
+        if (by1 < ay) {
+            return false
+        }
+        return true
+    }
+}