Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-image

Source of release 0.45.0

0.45.0 / src / canvas / vector_elements.lucb

#==============================================================================================
#
#   canvas/vector_elements - A vector layer's elements
#
#   DESCRIPTION:
#       A vector layer holds a list of elements, bottom first: shapes, pen paths and outlines
#       brought in from SVG, each with its own geometry, fill and stroke (a ShapeSpec), a name
#       and an eye. luce-vector draws them into the layer's tiles, and an edit draws again only
#       the cells the element it changed covered before or covers after (a CellMask). The
#       Vector panel lists them; one may be active, and then a move, a transform, the shape
#       options and the pen act on it alone.
#
#       The list is heap storage its record owns, copied with the record for the history and
#       freed with it. An edit builds the new list beside the old, draws from it, and only
#       then records the step and swaps it in, so an edit that cannot be drawn changes nothing.
#
#==============================================================================================

extend Canvas:
    ## How many vector elements the layer at `index` holds, bottom first.
    pub func element_count(index: i64) -> i64!:
        return (i64)(try self.record(index)).elements.length

    pub func element_name(index: i64, element: i64) -> str!:
        return (try element_of(try self.record(index), element)).name

    pub func element_visible(index: i64, element: i64) -> bool!:
        return (try element_of(try self.record(index), element)).visible

    ## Value `field` of element `element`, numbered as `layer_shape_value`'s;
    ## 22 is its anchor count, 23 its runs (0 for one), 24 whether it is closed.
    pub func element_value(index: i64, element: i64, field: i64) -> f64!:
        let spec = (try element_of(try self.record(index), element)).spec
        if field == 22:
            return (f64)(spec.path.length // anchor_values)
        if field == 23:
            return (f64)spec.subpaths.length
        if field == 24:
            return 1.0 if spec.closed else 0.0
        if field < 0 or field >= 22:
            error(invalid, "an element has values 0..24")
        return shape_values(spec)[(usize)field]

    ## The layer at `index`'s active element, -1 for none.
    pub func active_element(index: i64) -> i64!:
        let record = try self.record(index)
        return record.active if record.active < (i64)record.elements.length else -1

    ## Make element `element` of layer `id` the one edits act on (-1: none, the
    ## whole layer). Not a step: it is where the Vector panel points.
    pub func set_active_element(id: i64, element: i64) -> !:
        let index = try self.index((u64)id)
        if element < -1 or element >= (i64)self.records[index].elements.length:
            error(invalid, "no such vector element")
        self.records[index].active = element

    ## Show or hide element `element` of layer `id`. One step.
    pub func set_element_visible(id: i64, element: i64, visible: bool) -> !:
        let layer = (u64)id
        let index = try vector_index(&self, layer)
        let slot = try element_slot(&self, index, element)
        if self.records[index].elements[slot].visible == visible:
            return
        var dirty = try CellMask.create(self.extent_x, self.extent_y)
        defer dirty.close()
        try dirty.mark(self.records[index].elements[slot])
        let list = try copied_list(self.records[index].elements)
        list[slot].visible = visible
        try commit_elements(&self, index, list, &dirty, (i64)slot, "Show Vector" if visible else "Hide Vector", self.records[index].active)

    ## Element `element` of layer `id` called `name`; one step, nothing drawn.
    pub func rename_element(id: i64, element: i64, name: str) -> !:
        let layer = (u64)id
        let index = try vector_index(&self, layer)
        let slot = try element_slot(&self, index, element)
        if name.length == 0:
            error(invalid, "an element needs a name")
        var copied: str = ""
        with memory.heap:
            copied = try strings.copy(name)
        errdefer strings.release(copied)
        try self.remember_state("Rename Vector", 0)
        strings.release(self.records[index].elements[slot].name)
        self.records[index].elements[slot].name = copied

    ## Element `element` of layer `id` moved to place `to` (0 the bottom). One step.
    pub func move_element(id: i64, element: i64, to: i64) -> !:
        let layer = (u64)id
        let index = try vector_index(&self, layer)
        let slot = try element_slot(&self, index, element)
        let place = try element_slot(&self, index, to)
        if slot == place:
            return
        var dirty = try CellMask.create(self.extent_x, self.extent_y)
        defer dirty.close()
        try dirty.mark(self.records[index].elements[slot])
        let list = try copied_list(self.records[index].elements)
        let moving = list[slot]
        if place > slot:
            for step in slot..<place:
                list[step] = list[step + 1]
        else:
            var step = slot
            while step > place:
                list[step] = list[step - 1]
                step -= 1
        list[place] = moving
        let name = "Bring Forward" if place > slot else "Send Backward"
        try commit_elements(&self, index, list, &dirty, (i64)place, name, (i64)place)

    ## A copy of element `element` of layer `id` just above it, active; one step.
    pub func duplicate_element(id: i64, element: i64) -> !:
        let layer = (u64)id
        let index = try vector_index(&self, layer)
        let slot = try element_slot(&self, index, element)
        var copy = try copied_element(self.records[index].elements[slot])
        var text: u8[320]
        let wanted = strings.format(text, f"{copy.name} copy") catch _:
            recover "Vector copy"
        var named: str = ""
        with memory.heap:
            named = strings.copy(wanted) catch failure:
                release_element(&copy)
                error(failure.code, failure.message)
        strings.release(copy.name)
        copy.name = named
        var list = copied_list(self.records[index].elements) catch failure:
            release_element(&copy)
            error(failure.code, failure.message)
        list = try list_with(list, slot + 1, copy)
        var dirty = CellMask.create(self.extent_x, self.extent_y) catch failure:
            free_list(list)
            error(failure.code, failure.message)
        defer dirty.close()
        try commit_elements(&self, index, list, &dirty, (i64)slot + 1, "Duplicate Vector", (i64)slot + 1)

    ## Element `element` of layer `id` taken away; one step.
    pub func delete_element(id: i64, element: i64) -> !:
        let layer = (u64)id
        let index = try vector_index(&self, layer)
        let slot = try element_slot(&self, index, element)
        var dirty = try CellMask.create(self.extent_x, self.extent_y)
        defer dirty.close()
        try dirty.mark(self.records[index].elements[slot])
        var list = try copied_list(self.records[index].elements)
        list = try list_without(list, slot)
        let active = self.records[index].active
        let kept = -1 if active == (i64)slot else (active - 1 if active > (i64)slot else active)
        try commit_elements(&self, index, list, &dirty, -1, "Delete Vector", kept)

    ## Element `element` of layer `id` scaled, turned by `angle` degrees and
    ## moved about the pivot, as `preview_transform`'s box. One step.
    pub func transform_element(id: i64, element: i64, scale_x: f64, scale_y: f64, angle: f64, dx: f64, dy: f64, pivot_x: f64, pivot_y: f64) -> !:
        let layer = (u64)id
        let warp = try affine_warp(scale_x, scale_y, angle * math.pi / 180.0, dx, dy, pivot_x, pivot_y)
        let name = "Free Transform"
        let index = try vector_index(&self, layer)
        let slot = try element_slot(&self, index, element)
        let forward = try warp.forward((f64)self.extent_x * 0.5, (f64)self.extent_y * 0.5)
        var moved = transformed_shape(self.records[index].elements[slot].spec, forward) else error(invalid, "a vector element follows only an affine transform")
        # The moved spec shares the element's path: a copy of its own for the new element.
        copy_spec_path(&moved) catch failure:
            error(failure.code, failure.message)
        try replace_element_spec(&self, index, slot, moved, name, false)

## A record's elements and graph copied, for a copy of the record that owns its
## own; on failure it holds none.
func copy_elements(record: Record*) -> !:
    let source = record.elements
    var none_left: VectorElement[]
    record.elements = none_left
    try copy_graph_part(record)
    record.elements = copied_list(source) catch failure:
        release_graph_part(record)
        error(failure.code, failure.message)

## Free a record's elements and graph; it holds none.
func release_elements(record: Record*):
    free_list(record.elements)
    var none_left: VectorElement[]
    record.elements = none_left
    record.active = -1
    release_graph_part(record)

## The element edits without a choice act on: the active one, else the topmost.
func target_element(record: const Record*) -> usize?:
    let count = record.elements.length
    if count == 0:
        return none
    if record.active >= 0 and record.active < (i64)count:
        return (usize)record.active
    return count - 1

## Swap `list` in as the elements of the layer at `index`, as step `name`, its
## pixels drawn again where `dirty` marks and where element `changed` of the new
## list reaches (every cell when `dirty` is none), and `active` its active element.
## Takes the list over; freed, with nothing changed, when it cannot be drawn.
## `joins` lets a repeat of the same step on the layer coalesce (a slider dragged).
## The graph is kept, and drawn again where its output changes (a Path node
## follows its element).
func commit_elements(canvas: Canvas*, index: usize, list: VectorElement[], dirty: CellMask*?, changed: i64, name: str, active: i64, joins: bool = false) -> !:
    let graph = copied_graph(&canvas.records[index].graph) catch failure:
        free_list(list)
        error(failure.code, failure.message)
    try commit_layer(canvas, index, list, graph, dirty, changed, name, active, joins)

## `spec` drawn as element `at` of the layer at `index` instead of what it was,
## as step `name`; takes the spec over.
func replace_element_spec(canvas: Canvas*, index: usize, at: usize, spec: ShapeSpec, name: str, joins: bool = true) -> !:
    var owned = spec
    var dirty = CellMask.create(canvas.extent_x, canvas.extent_y) catch failure:
        release_spec_path(&owned)
        error(failure.code, failure.message)
    defer dirty.close()
    dirty.mark(canvas.records[index].elements[at]) catch failure:
        release_spec_path(&owned)
        error(failure.code, failure.message)
    let list = copied_list(canvas.records[index].elements) catch failure:
        release_spec_path(&owned)
        error(failure.code, failure.message)
    release_spec_path(&list[at].spec)
    list[at].spec = owned
    try commit_elements(canvas, index, list, &dirty, (i64)at, name, canvas.records[index].active, joins)

# mark: The Vector panel's edits ==============================================================

## The record index of vector layer `id`.
func vector_index(canvas: Canvas*, id: u64) -> usize!:
    try canvas.require_open()
    try canvas.require_idle()
    let index = try canvas.index(id)
    if not canvas.records[index].shaped:
        error(invalid, "the layer holds no vector elements")
    return index

## Element `at` of the layer at `index`, checked.
func element_slot(canvas: const Canvas*, index: usize, at: i64) -> usize!:
    if at < 0 or at >= (i64)canvas.records[index].elements.length:
        error(invalid, "no such vector element")
    return (usize)at

## `Canvas.add_element`: `spec` on top of layer `id`'s elements, named `name`
## (or after its kind), and active: one step. A pixel layer with nothing
## painted becomes a vector layer for it. Takes the spec over.
func add_vector_element(canvas: Canvas*, id: u64, spec: ShapeSpec, name: str, step: str) -> !:
    var owned = spec
    let index = element_target_layer(canvas, id) catch failure:
        release_spec_path(&owned)
        error(failure.code, failure.message)
    let element = try made_element(name if name.length > 0 else kind_name(spec.kind), owned)
    var list = copied_list(canvas.records[index].elements) catch failure:
        var dropped = element
        release_element(&dropped)
        error(failure.code, failure.message)
    let at = list.length
    list = try list_with(list, at, element)
    var dirty = CellMask.create(canvas.extent_x, canvas.extent_y) catch failure:
        free_list(list)
        error(failure.code, failure.message)
    defer dirty.close()
    # A pixel layer turning into a vector layer is drawn whole: its pixels give way.
    let whole = not canvas.records[index].shaped
    try commit_elements(canvas, index, list, none if whole else &dirty, (i64)at, step, (i64)at)

## A layer an element may be added to: a vector layer, or a pixel layer with nothing painted.
func element_target_layer(canvas: Canvas*, id: u64) -> usize!:
    try canvas.require_open()
    try canvas.require_idle()
    let index = try canvas.index(id)
    let record = canvas.records[index]
    if record.group or record.adjustment >= 0:
        error(invalid, "only a pixel layer can hold vector elements")
    if record.shaped:
        return index
    let document = canvas.document else error(invalid, "draw the document once before adding vectors")
    let layer = document.find(id) else error(invalid, "no such layer")
    if let tiles = layer.tiles():
        if tiles.occupied() != none:
            error(invalid, "a layer with pixels cannot hold vector elements")
    return index

## Every element of the layer at `index` (or the active one alone when
## `active_only` and it has one) moved by (`dx`, `dy`) in place, and the cells
## they left or reach drawn again. The step is the caller's.
func shift_vector_elements(canvas: Canvas*, index: usize, dx: f64, dy: f64, active_only: bool) -> !:
    var dirty = try CellMask.create(canvas.extent_x, canvas.extent_y)
    defer dirty.close()
    try fresh_output(&canvas.records[index])
    let count = canvas.records[index].elements.length
    let active = canvas.records[index].active
    let only = active_only and active >= 0 and active < (i64)count
    for at in 0..<count:
        if only and (i64)at != active:
            continue
        try dirty.mark(canvas.records[index].elements[at])
        canvas.records[index].elements[at].spec.matrix[4] += dx
        canvas.records[index].elements[at].spec.matrix[5] += dy
        try dirty.mark(canvas.records[index].elements[at])
    if only:
        try follow_elements(canvas, index, &dirty)
    else:
        try shift_generated(canvas, index, dx, dy, &dirty)
    try redraw_vector_cells(canvas, index, &dirty)

## Every element of the layer at `index` through `forward`, drawn again whole;
## false when some element cannot follow it (the layer should become pixels).
func transform_all_elements(canvas: Canvas*, index: usize, forward: Warp) -> bool!:
    let count = canvas.records[index].elements.length
    for at in 0..<count:
        if transformed_shape(canvas.records[index].elements[at].spec, forward) == none:
            return false
    # The output as it is, before the elements a Path node takes move.
    try fresh_output(&canvas.records[index])
    for at in 0..<count:
        if let moved = transformed_shape(canvas.records[index].elements[at].spec, forward):
            canvas.records[index].elements[at].spec = moved
    if let m = affine_of(forward):
        place_graph(&canvas.records[index], m)
    try redraw_vector(canvas, index)
    return true

## `imported`'s elements, taken over, as layer `id`'s, their top-left at
## (`left`, `top`), the layer drawn from them when the document is bound. The
## step is the caller's; on failure the caller still owns them.
func adopt_svg_vectors(canvas: Canvas*, id: u64, imported: SvgVectors*, left: f64, top: f64) -> !:
    try canvas.require_open()
    let index = try canvas.index(id)
    for at in 0..<imported.list.length:
        imported.list[at].spec.matrix[4] += left
        imported.list[at].spec.matrix[5] += top
    release_elements(&canvas.records[index])
    canvas.records[index].elements = imported.list
    canvas.records[index].shaped = true
    var none_left: VectorElement[]
    imported.list = none_left
    if canvas.document != none:
        try redraw_vector(canvas, index)

## Layer `id`'s pixels for `list`: when `dirty` marks cells, its tiles as they
## are with those cells drawn again; else every cell drawn afresh.
func vector_tiles(canvas: Canvas*, id: u64, list: const VectorElement[], dirty: CellMask*?) -> Tiles!:
    let device = canvas.device else error(invalid, "draw the document once before drawing a shape")
    var tiles = try starting_tiles(canvas, device, id, dirty)
    errdefer tiles.destroy()
    try draw_elements(&tiles, list, dirty)
    return tiles

## The tiles an edit starts from: the layer's own, shared, with the marked cells
## cleared; or none painted when every cell is drawn.
func starting_tiles(canvas: Canvas*, device: gpu.Device, id: u64, dirty: CellMask*?) -> Tiles!:
    let cells = dirty else return try Tiles.create(device, canvas.extent_x, canvas.extent_y)
    let document = canvas.document else error(invalid, "draw the document once before drawing a shape")
    let layer = document.find(id) else error(invalid, "no such layer")
    let current = layer.tiles() else error(invalid, "a group has no pixels")
    var tiles = try current.clone()
    errdefer tiles.destroy()
    for row in 0..<cells.rows:
        for column in 0..<cells.columns:
            if cells.marked(column, row):
                try tiles.clear(column, row)
    return tiles

## Draw the vector layer at `index` again whole from its elements and graph.
func redraw_vector(canvas: Canvas*, index: usize) -> !:
    try redraw_layer(canvas, index, none)

## Draw the vector layer at `index` again in the cells `dirty` marks.
func redraw_vector_cells(canvas: Canvas*, index: usize, dirty: CellMask*) -> !:
    try redraw_layer(canvas, index, dirty)

func redraw_layer(canvas: Canvas*, index: usize, dirty: CellMask*?) -> !:
    let document = canvas.document else error(invalid, "draw the document once before drawing a shape")
    let record = &canvas.records[index]
    try fresh_output(record)
    let view = try drawn_elements(record.elements, &record.generated)
    defer free_view(view)
    var tiles = try vector_tiles(canvas, record.id, view, dirty)
    errdefer tiles.destroy()
    try document.set_tiles(record.id, tiles)