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(©)
error(failure.code, failure.message)
strings.release(copy.name)
copy.name = named
var list = copied_list(self.records[index].elements) catch failure:
release_element(©)
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)