dymokomi/luced-3d
Source of release 0.11.8
## The Parameters pane: a compact node header (name, type and flags, what it
## does), then the node's parameters as one ParameterPanel built from the
## catalog, one line each after Houdini's parameter pane. The catalog's rows
## name the value or text slot each edits; an Edit node adds its component
## edit rows. A drag is live and one undo step on release.
from luce_ui.ui import VStack, HStack, Text, TextField, Font, Button, ParameterPanel, ParameterSpec, ParameterKind, Rect, Size, TextEditor
from code_editor import CodeEditor
from script_check import ScriptChecker
from luce_std.wake import Waker
import code_node
import code_cook
import script_cook
import script_node
from interop import Connection
from workspace import Workspace
from actions import Actions
from parameter_rows import Parameter, ramp_numbers, padded
from shader_nodes import is_shader
from node import Node, waiting
from shader_nodes import inputs as shader_inputs
import node_catalog
from edit_kinds import is_edit
from edit_types import point_level
import edit_cad
from usd_nodes import Composition, compose_usd
import node_commands
import feature_ops
import sketch_node
import sketch_commands
from sketch_commands import SketchDimension
import units
from angles import radians, degrees
import tool_prompts
import tool_picks
import tool_registry
import pick_kinds
from tool_record import Tool, Pick
import edit_held
pub class Inspector:
## A path row's Browse: pick a file for text slot `slot`.
pub var on_browse: func(int) -> unit!? = none
## The Render node's Render button.
pub var on_render: func() -> unit!? = none
pub let body: VStack
## The selected node's parameters.
pub let parameters: ParameterPanel
let workspace: Workspace
let actions: Actions
let name: TextField
let kind: Text
let stats: Text
let description: Text
let state_rows: VStack
let delete_button: Button
let generic_rows: VStack
## In place of the rows while nothing is selected.
pub let nothing: VStack
let connections: list[Connection]
## The catalog rows the panel shows, and what each row is to the inspector:
## "value", "text", "info", "reload", "clear", "edits",
## "operation", or a blend's "edges", "pick_edges" and "all_edges".
var rows: list[Parameter]
var roles: list[str]
## What the panel was built for: node kind, file format and edit count.
var built: str = ""
## A USD File node's composed stage, and the file, texts and revision
## it was composed for.
var stage: Composition? = none
var stage_key: str = ""
var showing: int = -2
## A Sketch node's dimensions, read once per text it has.
var dimensions_text: str = ""
## An Extrude's or Revolve's Operation items as last shown.
var operation_items: str = ""
var dimensions: list[SketchDimension]
## A Code node's body and header editors, shown for Code nodes; a Script
## node's code in the body editor, without a header.
let code_box: VStack
## The Code or Script node's code (public for captures).
pub let code_body: CodeEditor
let code_header: CodeEditor
let code_title: Text
let header_title: Text
## What the code's k.printf calls said in the last cook (many lines).
let console: TextEditor
## A Script node's check while typing, and the error of the text it held
## back ("" none), which the editor marks in place of the cook's.
let checker: ScriptChecker
var check_failure: str = ""
pub func init(self, workspace: Workspace, actions: Actions, font: Font) -> unit!:
self.dimensions = []
self.workspace = workspace
self.actions = actions
self.connections = []
self.rows = []
self.roles = []
self.name = TextField("", font = font, placeholder = "Node name", cells = 18.0)
self.connections.append(self.name.on_commit(func (name: str) -> unit!: node_commands.rename(workspace, name)))
self.kind = Text("", font = font, muted = true)
self.stats = Text("", font = font, muted = true)
self.description = Text("", font = font, muted = true)
self.parameters = ParameterPanel([], font = font)
self.connections.append(self.parameters.on_begin(func (index: int) -> unit!:
if self.roles[index] in ["value", "dimension", "angle_dimension", "ramp"]:
# A scrub previews as a viewport drag does; let go, it cooks
# in full (Workspace.commit).
workspace.begin_preview("Change " + self.rows[index].name)))
self.connections.append(self.parameters.on_change(self.changed))
self.connections.append(self.parameters.on_commit(func (index: int) -> unit!:
workspace.commit()))
self.connections.append(self.parameters.on_action(self.acted))
self.state_rows = VStack([
HStack([Button(action = actions.display, font = font), Button(action = actions.enabled, font = font)], spacing = 4.0)], spacing = 4.0)
self.delete_button = Button(action = actions.delete, font = font)
let header = VStack([self.name, self.kind, self.state_rows, self.description], spacing = 4.0, padding = 6.0)
let footer = VStack([self.stats, self.delete_button], spacing = 4.0, padding = 6.0)
self.code_body = CodeEditor(font)
self.code_header = CodeEditor(font)
self.code_body.editor.layout().set_limits(Size(240.0, 240.0), Size(16384.0, 420.0))
self.code_header.editor.layout().set_limits(Size(240.0, 90.0), Size(16384.0, 300.0))
self.code_body.on_commit = func (text: str) -> unit!: self.code_committed(code_cook.body_slot, text)
self.checker = ScriptChecker()
self.code_header.on_commit = func (text: str) -> unit!: self.code_committed(code_cook.header_slot, text)
self.code_header.part = 1
self.code_body.partner = self.code_header
self.code_header.partner = self.code_body
self.console = TextEditor("", read_only = true, line_numbers = false, font = font)
self.console.layout().set_limits(Size(240.0, 40.0), Size(16384.0, 200.0))
self.code_title = Text("Code (one element; it runs for all in parallel)", font = font, muted = true)
self.header_title = Text("Header (helper functions)", font = font, muted = true)
self.code_box = VStack([self.code_title, self.code_body.editor, self.console, self.header_title, self.code_header.editor], spacing = 4.0, padding = 6.0)
self.generic_rows = VStack([header, self.parameters, self.code_box, footer], spacing = 0.0)
self.nothing = VStack([Text("Nothing selected", font = font),
Text("Click a node or an object to edit it.", font = font, muted = true)], spacing = 4.0, padding = 6.0)
self.body = VStack([self.nothing, self.generic_rows], spacing = 0.0)
self.refresh()
## A parameter changed in the panel: its slots take the values (a vector
## its components), a text row its text.
func changed(self, index: int) -> unit!:
let role = self.roles[index]
let row = self.rows[index]
if role == "value":
let values: list[float] = []
for component in 0..<row.components:
values.append(self.parameters.component(index, component))
node_commands.set_row(self.workspace, row.slot, values)
elif role == "text":
let node = self.workspace.selected() else return
if node.kind == script_cook.kind_name and row.slot == script_cook.packages_slot:
script_node.set_packages(self.workspace, node.id, self.parameters.text(index))
else:
node_commands.set_text(self.workspace, row.slot, self.parameters.text(index))
elif role == "ramp":
let node = self.workspace.selected() else return
if row.value_ramp():
node_commands.set_parameters(self.workspace, row.slot, padded(self.parameters.ramp(index), row.components))
elif node.kind in [code_cook.kind_name, script_cook.kind_name]:
code_node.set_ramp(self.workspace, node.id, row.slot, self.parameters.ramp(index))
else:
node_commands.set_ramp_text(self.workspace, node.id, row.slot, self.parameters.ramp(index))
elif role == "dimension" or role == "angle_dimension":
let node = self.workspace.selected() else return
let value = self.parameters.value(index)
sketch_commands.set_dimension(self.workspace, node.id, row.slot, radians(value) if role == "angle_dimension" else value)
func acted(self, index: int) -> unit!:
let role = self.roles[index]
if role == "text":
if let callback = self.on_browse:
callback(self.rows[index].slot)
elif role == "reload":
node_commands.reload_file(self.workspace)
elif role == "render":
if let callback = self.on_render:
callback()
elif role == "clear":
self.actions.clear_edits.trigger()
elif role.starts_with("pick_button:"):
if let node = self.workspace.selected():
let found = self.pick_of(node.kind, role[12..]) else return
let (tool, at) = found
if tool.picks[at].kind == pick_kinds.profiles:
tool_prompts.pick_profiles(self.workspace, node.id)
else:
tool_picks.start(self.workspace, node, tool, at)
elif role.starts_with("pick_clear:"):
if let node = self.workspace.selected():
let found = self.pick_of(node.kind, role[11..]) else return
let (tool, at) = found
let pick = tool.picks[at]
node_commands.set_text(self.workspace, pick.slot, pick.holding(node.texts[pick.slot], ""))
elif role == "reselect":
if let node = self.workspace.selected(): tool_prompts.reselect(self.workspace, node.id)
elif role == "keep_ids":
if let node = self.workspace.selected(): node_commands.keep_ids(self.workspace, node.id)
## The field showing value slot `slot`, in window points; empty when none shows it.
pub func field_bounds(self, slot: int) -> Rect!:
let origin = self.parameters.layout().bounds()
for index in 0..<self.rows.length:
let row = self.rows[index]
if self.roles[index] == "value" and slot >= row.slot and slot < row.slot + row.components:
let field = self.parameters.field_bounds(index, slot - row.slot)
return Rect(origin.x + field.x, origin.y + field.y, field.width, field.height)
return Rect()
## The row showing text slot `slot`, in window points; empty when none shows it.
pub func text_bounds(self, slot: int) -> Rect!:
let origin = self.parameters.layout().bounds()
for index in 0..<self.rows.length:
if self.roles[index] == "text" and self.rows[index].slot == slot:
let row = self.parameters.row_bounds(index)
return Rect(origin.x + row.x, origin.y + row.y, row.width, row.height)
return Rect()
## The text the panel shows on the row of role `role` (Face's "face",
## Profiles' "profiles"…), "" when none shows.
pub func shown_text(self, role: str) -> str!:
for index in 0..<self.rows.length:
if self.roles[index] == role:
return self.parameters.text(index)
return ""
## The value the panel shows for slot `slot`.
pub func shown_value(self, slot: int) -> float!:
for index in 0..<self.rows.length:
let row = self.rows[index]
if self.roles[index] == "value" and slot >= row.slot and slot < row.slot + row.components:
return self.parameters.component(index, slot - row.slot)
return 0.0
## Rebuild the panel's rows for `node`: the catalog's, and an Edit node's edits.
func build(self, kind: str, path: str) -> unit!:
self.rows = []
self.roles = []
var specs: list[ParameterSpec] = []
let shown = units.document_unit(self.workspace)
var fields = node_catalog.fields(kind, path, self.stage)
# A Code or Script node's spare parameters, from its code.
if kind == code_cook.kind_name or kind == script_cook.kind_name:
if let node = self.workspace.selected():
fields = fields + code_node.spare_rows(node)
for row in fields:
if kind == edit_cad.kind_name and not self.cv_rows():
# Fusion's direct edits have no soft selection, symmetry or
# Keep selection: only Edit CAD's control vertices use them.
continue
specs.append(row.spec(shown))
self.rows.append(row)
self.roles.append("ramp" if row.kind in ["ramp", "color_ramp"] else "text" if row.kind in ["text", "path"] else (("render" if row.name == "Render" else "reload") if row.kind == "button" else ("info" if row.kind == "info" else "value")))
if is_edit(kind):
self.add(specs, "edits", ParameterSpec(name = "edits", label = "Edits", kind = ParameterKind.info))
if self.workspace.holds(kind):
self.add(specs, "clear", ParameterSpec(name = "clear", label = "Reload Input", kind = ParameterKind.button,
doc = "Start over from the input's result as it is now (what was modeled here goes; one undo step)."))
else:
self.add(specs, "clear", ParameterSpec(name = "clear", label = "Clear edits", kind = ParameterKind.button,
doc = "Remove every component edit of this node."))
# A verb node made from a selection: pick its components again, or keep
# its numbers on a changed topology (Houdini's behaviour).
# A blend's edges: references to them by their faces (luce-cad's
# names), which survive changes upstream; shown as a count.
# A CAD tool's picks (tool_picks.luc): what each holds, its button
# to pick it again, and one to forget it where empty means all.
if let tool = tool_registry.cad_node(kind):
for at in tool.picks_of(false):
let pick = tool.picks[at]
let key = pick.label.lower()
self.add(specs, "pick:" + key, ParameterSpec(name = key.replace(" ", "_"), label = pick.label, kind = ParameterKind.info, hide_when = pick.hide_when, doc = pick.doc))
let button = pick.button if pick.button != "" else pick.asking()
self.add(specs, "pick_button:" + key, ParameterSpec(name = button.lower().replace(" ", "_"), label = button, kind = ParameterKind.button, join = pick.clear != "", hide_when = pick.hide_when,
doc = f"Show the input and {"click the point" if pick.kind == pick_kinds.point else "pick it"} in the viewport."))
if pick.clear != "":
self.add(specs, "pick_clear:" + key, ParameterSpec(name = pick.clear.lower().replace(" ", "_").replace("-", "_"), label = pick.clear, kind = ParameterKind.button, hide_when = pick.hide_when,
doc = f"Forget what is picked: {pick.clear}."))
# A sketch's dimensions, each a row in the document's unit (an
# angle in degrees); its constraint is the row's slot.
if kind == sketch_node.kind_name:
for d in self.sketch_dimensions(path):
let label = d.name + (" (driven)" if d.driven else "")
if d.angle:
self.add(specs, "angle_dimension", ParameterSpec(name = d.name, label = label, value = degrees(d.value), minimum = -360.0, maximum = 360.0, step = 1.0, decimals = 2, suffix = "°",
doc = "An angle the sketch holds; change it and the sketch follows."), d.constraint)
else:
self.add(specs, "dimension", ParameterSpec(name = d.name, label = label, value = d.value, minimum = 0.0, maximum = 1000000.0, step = 1.0, decimals = 2, units = shown,
doc = "A length the sketch holds; change it and the sketch follows. Type any unit: 10 mm, 0.5 in."), d.constraint)
if node_catalog.is_mesh_verb(kind):
self.add(specs, "reselect", ParameterSpec(name = "reselect", label = "Reselect", kind = ParameterKind.button, join = true,
doc = "Show the input and pick the group's components again (Enter accepts)."))
self.add(specs, "keep_ids", ParameterSpec(name = "keep_ids", label = "Keep IDs", kind = ParameterKind.button,
doc = "Use the group's numbers on the input's current topology."))
self.parameters.set_specs(specs)
self.operation_items = ""
self.show_ramps()
## An inspector row of the Edit node; `slot` is an operation's index.
func add(self, specs: list[ParameterSpec], role: str, spec: ParameterSpec, slot: int = -1):
specs.append(spec)
self.rows.append(Parameter(spec.label, slot, 0.0))
self.roles.append(role)
## Whether Edit CAD shows the Edit framework's soft selection, symmetry
## and Keep rows: only at its CVs level, the one level they act on.
func cv_rows(self) -> bool:
return self.workspace.level_index() == point_level
## The CAD tool of node kind `kind` and its pick whose role key (its
## label, lower-cased) is `key`.
func pick_of(self, kind: str, key: str) -> (Tool, int)?:
let tool = tool_registry.cad_node(kind) else return none
for at in 0..<tool.picks.length:
if tool.picks[at].label.lower() == key:
return (tool, at)
return none
pub func refresh(self) -> unit!:
self.generic_rows.layout().set_visible(self.workspace.selected() != none)
self.nothing.layout().set_visible(self.workspace.selected() == none)
let node = self.workspace.selected() else return
let changed = node.id != self.showing
let file = node.kind == "File"
let format = node_catalog.file_format(node.texts[0]) if file else ""
let key = f"{node.kind}|{format}|{self.compose(node.texts, node.source_revision) if format == "usd" else ""}|{self.sketch_key(node.kind, node.texts[0])}|{node.texts[code_cook.spares_slot] + code_node.ramp_key(node) if node.kind in [code_cook.kind_name, script_cook.kind_name] else ""}|{self.workspace.network.units}|{self.cv_rows() if node.kind == edit_cad.kind_name else false}"
if key != self.built:
self.build(node.kind, node.texts[0])
self.built = key
if changed:
self.checker.stop()
self.check_failure = ""
self.showing = node.id
self.state_rows.layout().set_visible(not file)
let scripting = node.kind == script_cook.kind_name
let coding = node.kind == code_cook.kind_name or scripting
self.code_box.layout().set_visible(coding)
# Ramp rows follow the node (an undo) unless one is being dragged.
if coding and not self.workspace.in_transaction():
self.show_ramps()
if coding:
if self.console.text() != node.console:
self.console.set_text(node.console)
self.console.layout().set_visible(node.console != "")
self.header_title.layout().set_visible(not scripting)
self.code_header.editor.layout().set_visible(not scripting)
self.code_title.set_text("Script (runs once per cook, natively; imports any package)" if scripting else "Code (one element; it runs for all in parallel)")
# Completion and hover read the Code node's API, or a script's
# check package (its imports, checked in process; warmed off this
# thread).
self.code_body.script_file = self.checker.prepare(node.texts[script_cook.packages_slot], node.texts[script_cook.lock_slot], self.workspace.network.folder, node.texts[script_cook.code_slot]) if scripting else ""
# A Script's text is checked at a pause before it goes to the node.
self.code_body.on_pause = (func (text: str) -> unit!: self.check_script(text)) if scripting else none
if scripting:
self.code_body.show(node.texts[script_cook.code_slot])
else:
let run_over = int(node.values[code_cook.run_over_slot])
self.code_body.run_over = run_over
self.code_header.run_over = run_over
self.code_body.show(node.texts[code_cook.body_slot])
self.code_header.show(node.texts[code_cook.header_slot])
let message = self.check_failure if scripting and self.check_failure != "" else node.failure
let place = code_node.failure_place(message)
self.code_body.show_error(place[1] if place.length == 3 and place[0] == 0 else 0, place[2] if place.length == 3 else 0, (place[2] if place.length == 3 else 0) + 1, message)
self.code_header.show_error(place[1] if place.length == 3 and place[0] == 1 else 0, place[2] if place.length == 3 else 0, (place[2] if place.length == 3 else 0) + 1, message)
self.delete_button.layout().set_visible(not file)
if changed or not self.name.layout().is_focused():
self.name.set_text(node.name)
let network = self.workspace.network
self.kind.set_text(node.kind + (" · output" if network.is_output(node.id) and not network.on_object_level(node.id) else "") + (" · displayed" if node.visible else "") + ("" if node.enabled else " · bypassed") + (" · frozen" if node.frozen != "" else ""))
# One line: a message from code may hold line breaks or tabs.
self.description.set_text(one_line(node.failure if node.failure != "" else ((node.warning if waiting(node.warning) else "Warning: " + node.warning) if node.warning != "" else node_catalog.description(node.kind))))
self.description.layout().set_visible(not file or node.failure != "" or node.warning != "")
self.parameters.layout().set_enabled(node.enabled or file)
for index in 0..<self.rows.length:
let role = self.roles[index]
let row = self.rows[index]
if role == "value":
for component in 0..<row.components:
self.parameters.set_component(index, component, node.values[row.slot + component])
# Auto says what it chose: "Auto (Cut)".
if row.name == "Operation" and node.kind in ["Extrude", "Revolve"]:
let items = feature_ops.operation_items(node.automatic)
if items != self.operation_items:
self.operation_items = items
self.parameters.set_items(index, items)
# A shader node's linked input takes its link: its value waits.
if is_shader(node.kind):
self.parameters.set_enabled(index, not linked_slot(node, row.slot))
elif role == "text":
# A selection too large to read as text shows as a summary
# (the group itself stays exact); Reselect changes it.
let text = node.texts[row.slot]
let baked = row.name == "Group" and text.byte_count > 16384
self.parameters.set_text(index, f"‹selection of {text.byte_count // 1024} KB›" if baked else text)
self.parameters.set_enabled(index, not baked)
elif role == "info":
self.parameters.set_text(index, row.text)
elif role == "edits":
if self.workspace.holds(node.kind):
let state = "Input changed: Reload Input takes it" if edit_held.input_changed(self.workspace.network, node) else ("holds its result" if node.held != none else "passes its input through")
self.parameters.set_text(index, f"{state} / {self.workspace.selected_entities()} selected")
else:
self.parameters.set_text(index, f"{node.edits.length} edits / {self.workspace.selected_entities()} selected")
elif role.starts_with("pick:"):
if let found = self.pick_of(node.kind, role[5..]):
let (tool, at) = found
self.parameters.set_text(index, summary(tool.picks[at], node))
elif role.starts_with("pick_clear:"):
if let found = self.pick_of(node.kind, role[11..]):
let (tool, at) = found
self.parameters.set_enabled(index, tool_picks.held(node, tool.picks[at], false) != "")
elif role == "clear":
self.parameters.set_enabled(index, node.edits.length > 0 or node.held != none)
elif role == "keep_ids":
self.parameters.set_enabled(index, node.guard != 0)
elif role == "dimension" or role == "angle_dimension":
for d in self.sketch_dimensions(node.texts[0]):
if d.constraint == row.slot:
self.parameters.set_value(index, degrees(d.value) if d.angle else d.value)
self.parameters.set_enabled(index, not d.driven)
if node_catalog.collects_children(node.kind):
let yielded = network.outputs(node.id)
let warning = network.output_warning(node.id)
self.stats.set_text(warning if warning != "" else (f"Output: {yielded[0].name}" if yielded.length == 1 and network.level_of(node.id) == "data" else f"{yielded.length} objects"))
elif self.workspace.compute != none:
self.stats.set_text(node.phase if node.computing else node.summary)
elif let data = node.cache:
self.stats.set_text(data.description())
else:
self.stats.set_text("No evaluated geometry")
## Compose a USD File node's stage when its file, texts or revision
## changed (a failure shows as the node's cook error); the key composed.
func compose(self, texts: list[str], revision: int) -> str:
let key = f"{texts[0].trim()}|{texts[1]}|{texts[2]}|{revision}"
if key != self.stage_key:
self.stage_key = key
self.stage = none
let composed = compose_usd(texts[0].trim(), texts) catch failure:
return key
self.stage = composed
return key
## Sketch text `text`'s dimensions (none when it does not read).
func sketch_dimensions(self, text: str) -> list[SketchDimension]:
if text != self.dimensions_text:
self.dimensions_text = text
self.dimensions = sketch_commands.dimensions(text) catch failure:
recover []
return self.dimensions
## What a Sketch node's dimension rows depend on: which constraints are
## dimensions (their values refresh in place).
func sketch_key(self, kind: str, text: str) -> str:
if kind != sketch_node.kind_name:
return ""
let parts: list[str] = []
for d in self.sketch_dimensions(text):
parts.append(f"{d.constraint}{"a" if d.angle else ""}{"d" if d.driven else ""}")
return parts.join(",")
## The ramp rows show their data: a Code or Script node's ramps, a verb
## node's ramp texts (Volume Visualization's emission color ramp) or
## ramp values (Bevel's Custom profile).
func show_ramps(self) -> unit!:
let node = self.workspace.selected() else return
let coded = node.kind in [code_cook.kind_name, script_cook.kind_name]
let ramps = code_cook.ramps_of(node.texts[code_cook.ramps_slot]) if coded else []
for index in 0..<self.rows.length:
if self.roles[index] != "ramp":
continue
let slot = self.rows[index].slot
if coded and slot >= ramps.length:
continue
var data: list[float] = []
if coded:
data = ramps[slot].data
elif self.rows[index].value_ramp():
data = ramp_numbers(node.values[slot..<slot + self.rows[index].components])
elif not coded:
data = node_catalog.verb_ramp(node.kind, slot, node.texts[slot])
if data.length == 0:
continue
if self.parameters.ramp(index) != data:
self.parameters.set_ramp(index, data)
## A Code editor's text, to the selected Code node.
func code_committed(self, slot: int, text: str) -> unit!:
let node = self.workspace.selected() else return
self.check_failure = ""
if node.kind == code_cook.kind_name:
code_node.set_code(self.workspace, node.id, slot, text)
elif node.kind == script_cook.kind_name and slot == code_cook.body_slot:
script_node.set_code(self.workspace, node.id, text)
## Nanoseconds from `now` until a pause in the code editors' typing is
## due (`due` then), or -1. A Script check's sync and job wake the loop
## themselves when they end (`wake_checks_with`, `poll_checks`).
pub func waits(self, now: int) -> int:
var soon = -1
for left in [self.code_body.waits(now), self.code_header.waits(now)]:
if left >= 0 and (soon < 0 or left < soon): soon = left
return soon
## The waker a Script check's sync and job wake when they end (a notifier
## whose callback polls the panels).
pub func wake_checks_with(self, waker: Waker):
self.checker.waker = waker
## Told when typing in a code editor starts a pause to wait out.
pub func wait_with(self, asked: func() -> unit!):
self.code_body.on_wait = asked
self.code_header.on_wait = asked
## A pause in typing that is due commits its editor's text (or checks it).
pub func due(self) -> unit!:
self.code_body.due()
self.code_header.due()
## The Script check's sync or job ended (its waker), or a check ran at
## once: the set's warming moves on, and a finished check reports.
pub func poll_checks(self) -> unit!:
let reported = self.checker.poll()
self.code_body.set_script_ready(self.checker.ready())
if reported:
# Only an error in the code holds the text back; anything else (a
# package that cannot be found) is the build's to report.
let place = code_node.failure_place(self.checker.failure)
self.check_failure = self.checker.failure if place.length == 3 else ""
if self.check_failure == "":
self.code_body.checked(self.checker.text)
else:
self.code_body.show_error(place[1], place[2], place[2] + 1, self.check_failure)
## Whether the Script editor's package set is warm (captures wait for it).
pub func script_ready(self) -> bool:
return self.checker.ready()
## Check the selected Script node's `text` with its packages.
func check_script(self, text: str) -> unit!:
let node = self.workspace.selected() else return
self.checker.start(text, node.texts[script_cook.packages_slot], node.texts[script_cook.lock_slot], self.workspace.network.folder)
self.poll_checks()
pub func close(self):
self.checker.close()
self.code_body.close()
self.code_header.close()
self.on_browse = none
self.on_render = none
for connection in self.connections:
connection.disconnect()
self.connections.clear()
## Whether the shader input kept in value slot `slot` is linked.
func linked_slot(node: Node, slot: int) -> bool:
let sockets = shader_inputs(node.kind)
for port in 0..<sockets.length:
if sockets[port].slot == slot and port < node.inputs.length and node.inputs[port] >= 0:
return true
return false
## `text` on one line: line breaks and tabs as spaces (a Text holds one).
func one_line(text: str) -> str:
return text.replace("\r", " ").replace("\n", " ").replace("\t", " ")
## What pick `pick` of `node` holds, in words: its own summary, else by
## its kind ("None picked", "2 faces", "An edge", the point).
func summary(pick: Pick, node: Node) -> str!:
if pick.kind == pick_kinds.point:
let v = node.values
return f"{v[pick.slot]:.3f}, {v[pick.slot + 1]:.3f}, {v[pick.slot + 2]:.3f}"
let text = tool_picks.held(node, pick, false).trim()
if let told = pick.summary:
return told(text)
if text == "":
return "None picked"
if pick.kind == pick_kinds.face:
return text
if pick.kind == pick_kinds.edge:
return "An edge"
if pick.kind == pick_kinds.curve_or_edge:
return text if text.starts_with("curve ") else "An edge"
if pick.kind in [pick_kinds.align_input, pick_kinds.align_master]:
let words = text.split(" ")
if words[0] == "isoparm" or words[0] == "isoparm_at":
return "An isoparm"
return f"{words[1]} ({words[0]})" if words.length > 1 else text
let count = text.split(";").length
if pick.kind in [pick_kinds.curves, pick_kinds.words]:
return "1 curve" if count == 1 else f"{count} curves"
if pick.kind == pick_kinds.edges:
return "1 edge" if count == 1 else f"{count} edges"
let noun = "body" if pick.bodies(node.values) else "face"
if count == 1:
return f"1 {noun}"
return f"{count} {"bodies" if noun == "body" else "faces"}"