Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-svg

Source of release 0.9.2

0.9.2 / src / svg / values.lucb

#==============================================================================================
#
#   svg/values - Parsers for SVG's attribute values
#
#   DESCRIPTION:
#       The microsyntaxes attribute values are written in, each parser public so other
#       code can share one spec-correct reading: numbers (an exponent never swallows the
#       `e` of `em` or `ex`), lengths with their units, length and number lists,
#       transform lists (matrix, translate, scale, rotate, skewX, skewY), angles,
#       viewBoxes and preserveAspectRatio. Each answers none for text that does not
#       parse as a whole; the rules follow resvg's svgtypes, so the two read files alike.
#
#==============================================================================================

# mark: Scanning ==============================================================================

## A position in a value being parsed.
struct Scanner:
    var data: const u8[]
    var pos: usize = 0

    func at_end() -> bool:
        return self.pos >= self.data.length

    func peek() -> u8:
        return self.data[self.pos] if self.pos < self.data.length else 0

    func peek_at(offset: usize) -> u8:
        return self.data[self.pos + offset] if self.pos + offset < self.data.length else 0

    func starts_with(text: str) -> bool:
        if self.pos + text.length > self.data.length:
            return false
        for index in 0..<text.length:
            if self.data[self.pos + index] != text.bytes[index]:
                return false
        return true

    func skip_spaces():
        while self.pos < self.data.length and is_space(self.data[self.pos]):
            self.pos += 1

    ## Skip spaces, then one comma if there is one.
    func skip_separator():
        self.skip_spaces()
        if self.peek() == ',':
            self.pos += 1

    ## A number as SVG writes it: sign, digits, fraction, exponent.
    func number() -> f64?:
        self.skip_spaces()
        let start = self.pos
        var byte = self.peek()
        if byte == '+' or byte == '-':
            self.pos += 1
            byte = self.peek()
        if is_digit(byte):
            while is_digit(self.peek()):
                self.pos += 1
        elif byte != '.':
            self.pos = start
            return none
        if self.peek() == '.':
            self.pos += 1
            while is_digit(self.peek()):
                self.pos += 1
        byte = self.peek()
        if byte == 'e' or byte == 'E':
            let next = self.peek_at(1)
            if next != 'm' and next != 'x':
                if next == '+' or next == '-':
                    self.pos += 2
                elif is_digit(next):
                    self.pos += 1
                else:
                    self.pos = start
                    return none
                if not is_digit(self.peek()):
                    self.pos = start
                    return none
                while is_digit(self.peek()):
                    self.pos += 1
        let text = (str)self.data[start..<self.pos]
        if text == "." or text == "+" or text == "-" or text == "+." or text == "-.":
            self.pos = start
            return none
        let value = strings.parse_f64(text) catch _:
            self.pos = start
            recover 0.0
        if self.pos == start or not math.is_finite(value):
            self.pos = start
            return none
        return value

    ## A number from a list: the number, then spaces and an optional comma.
    func list_number() -> f64?:
        let value = self.number() else return none
        self.skip_separator()
        return value

    ## A length: a number and its unit.
    func length() -> Length?:
        let value = self.number() else return none
        var found_unit = Unit.plain
        let units: str[9] = ["%", "em", "ex", "px", "in", "cm", "mm", "pt", "pc"]
        let kinds: Unit[9] = [Unit.percent, Unit.em, Unit.ex, Unit.px, Unit.inch, Unit.cm, Unit.mm, Unit.pt, Unit.pc]
        for index in 0..<units.length:
            if self.starts_with(units[index]):
                found_unit = kinds[index]
                self.pos += units[index].length
                break
        return Length(number = value, unit = found_unit)

    ## An identifier: letters, digits, `-` and `_`.
    func identifier() -> str:
        let start = self.pos
        while self.pos < self.data.length and (is_alpha(self.data[self.pos]) or is_digit(self.data[self.pos]) or self.data[self.pos] == '-' or self.data[self.pos] == '_'):
            self.pos += 1
        return (str)self.data[start..<self.pos]

# mark: Numbers and lengths ===================================================================

## A length's unit.
pub enum Unit:
    plain
    percent
    em
    ex
    px
    inch
    cm
    mm
    pt
    pc

## A length as written: a number and its unit.
pub struct Length:
    pub var number: f64 = 0.0
    pub var unit: Unit = Unit.plain

## `text` as one number (spaces around it allowed), or none.
pub func parse_number(text: str) -> f64?:
    var scanner = Scanner(data = text.bytes)
    let value = scanner.number() else return none
    scanner.skip_spaces()
    if not scanner.at_end():
        return none
    return value

## `text` as one length (spaces around it allowed), or none.
pub func parse_length(text: str) -> Length?:
    var scanner = Scanner(data = text.bytes)
    let value = scanner.length() else return none
    scanner.skip_spaces()
    if not scanner.at_end():
        return none
    return value

## An angle in degrees: a number, optionally in deg, grad, rad or turn.
pub func parse_angle(text: str) -> f64?:
    var scanner = Scanner(data = text.bytes)
    let value = scanner.number() else return none
    var degrees = value
    if scanner.starts_with("deg"):
        scanner.pos += 3
    elif scanner.starts_with("grad"):
        scanner.pos += 4
        degrees = value * 0.9
    elif scanner.starts_with("rad"):
        scanner.pos += 3
        degrees = value * 180.0 / math.pi
    elif scanner.starts_with("turn"):
        scanner.pos += 4
        degrees = value * 360.0
    scanner.skip_spaces()
    if not scanner.at_end():
        return none
    return degrees

# mark: Transforms ============================================================================

## A transform list (`matrix`, `translate`, `scale`, `rotate`, `skewX`, `skewY`, separated
## by spaces or commas) composed left to right, or none when any part is malformed.
pub func parse_transform_list(text: str) -> Matrix?:
    var scanner = Scanner(data = text.bytes)
    var result = Matrix()
    while true:
        scanner.skip_spaces()
        while scanner.peek() == ',':
            scanner.pos += 1
            scanner.skip_spaces()
        if scanner.at_end():
            break
        let name = scanner.identifier()
        scanner.skip_spaces()
        if scanner.peek() != '(':
            return none
        scanner.pos += 1
        var values: f64[6] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
        var count: usize = 0
        while true:
            scanner.skip_spaces()
            if scanner.peek() == ')':
                scanner.pos += 1
                break
            if count >= 6:
                return none
            let value = scanner.list_number() else return none
            values[count] = value
            count += 1
        let step = transform_step(name, values, count) else return none
        result = multiply(result, step)
    return result

## One transform function with `count` arguments, or none when the count is wrong.
func transform_step(name: str, values: f64[6], count: usize) -> Matrix?:
    if name == "matrix":
        if count != 6:
            return none
        return Matrix(a = values[0], b = values[1], c = values[2], d = values[3], e = values[4], f = values[5])
    if name == "translate":
        if count != 1 and count != 2:
            return none
        return Matrix(e = values[0], f = values[1] if count == 2 else 0.0)
    if name == "scale":
        if count != 1 and count != 2:
            return none
        return Matrix(a = values[0], d = values[1] if count == 2 else values[0])
    if name == "rotate":
        if count != 1 and count != 3:
            return none
        let rotation = rotation_matrix(values[0])
        if count == 3:
            return multiply(multiply(Matrix(e = values[1], f = values[2]), rotation), Matrix(e = -values[1], f = -values[2]))
        return rotation
    if name == "skewX":
        if count != 1:
            return none
        return Matrix(c = math.tan(values[0] * math.pi / 180.0))
    if name == "skewY":
        if count != 1:
            return none
        return Matrix(b = math.tan(values[0] * math.pi / 180.0))
    return none

## A rotation by `degrees`, exact at the quarter turns.
func rotation_matrix(degrees: f64) -> Matrix:
    let turned = math.mod(degrees, 360.0)
    var cosine = math.cos(degrees * math.pi / 180.0)
    var sine = math.sin(degrees * math.pi / 180.0)
    if turned == 0.0:
        cosine = 1.0
        sine = 0.0
    elif turned == 90.0 or turned == -270.0:
        cosine = 0.0
        sine = 1.0
    elif turned == 180.0 or turned == -180.0:
        cosine = -1.0
        sine = 0.0
    elif turned == 270.0 or turned == -90.0:
        cosine = 0.0
        sine = -1.0
    return Matrix(a = cosine, b = sine, c = -sine, d = cosine)

# mark: Viewports =============================================================================

## A rectangle: its origin and size.
pub struct Rect:
    pub var x: f64 = 0.0
    pub var y: f64 = 0.0
    pub var w: f64 = 0.0
    pub var h: f64 = 0.0

    pub func right() -> f64:
        return self.x + self.w

    pub func bottom() -> f64:
        return self.y + self.h

## A viewBox: four numbers, the width and height positive; else none.
pub func parse_view_box(text: str) -> Rect?:
    var scanner = Scanner(data = text.bytes)
    var values: f64[4] = [0.0, 0.0, 0.0, 0.0]
    for index in 0..<(usize)4:
        values[index] = scanner.list_number() else return none
    scanner.skip_spaces()
    if not scanner.at_end() or not (values[2] > 0.0) or not (values[3] > 0.0):
        return none
    return Rect(x = values[0], y = values[1], w = values[2], h = values[3])

## How a viewBox is fitted into a viewport: its alignment on each axis (0 min, 1 mid,
## 2 max) or none at all (`stretch`), and whether it covers the viewport (`slice`)
## rather than fitting inside it (`meet`).
pub struct AspectRatio:
    pub var stretch: bool = false
    pub var align_x: u8 = 1
    pub var align_y: u8 = 1
    pub var slice: bool = false

## A preserveAspectRatio value, or none.
pub func parse_aspect_ratio(text: str) -> AspectRatio?:
    var scanner = Scanner(data = text.bytes)
    scanner.skip_spaces()
    if scanner.starts_with("defer"):
        scanner.pos += 5
        scanner.skip_spaces()
    let align = scanner.identifier()
    var result = AspectRatio()
    if align == "none":
        result.stretch = true
    elif align.length == 8 and align.bytes[0] == 'x' and align.bytes[4] == 'Y':
        result.align_x = align_place((str)align.bytes[1..<4]) else return none
        result.align_y = align_place((str)align.bytes[5..<8]) else return none
    else:
        return none
    scanner.skip_spaces()
    let mode = scanner.identifier()
    if mode == "slice":
        result.slice = true
    elif mode != "meet" and mode != "":
        return none
    scanner.skip_spaces()
    if not scanner.at_end():
        return none
    return result

func align_place(text: str) -> u8?:
    if text == "Min": return 0
    if text == "Mid": return 1
    if text == "Max": return 2
    return none

## The transform that fits `view` into a viewport of `width` by `height` at the origin
## as `aspect` says.
pub func view_box_transform(view: Rect, aspect: AspectRatio, width: f64, height: f64) -> Matrix:
    let sx = width / view.w
    let sy = height / view.h
    if aspect.stretch:
        return Matrix(a = sx, d = sy, e = -view.x * sx, f = -view.y * sy)
    let scale = math.max(sx, sy) if aspect.slice else math.min(sx, sy)
    let free_x = width - view.w * scale
    let free_y = height - view.h * scale
    let x = free_x * (f64)aspect.align_x * 0.5 - view.x * scale
    let y = free_y * (f64)aspect.align_y * 0.5 - view.y * scale
    return Matrix(a = scale, d = scale, e = x, f = y)