dymokomi/luce-ui
Source of release 0.19.3
0.19.3 / src / widgets / parameters / paint.lucb
#==============================================================================================
#
# widgets/parameters/paint - Drawing the rows that show
#
#==============================================================================================
extend ParameterPanel:
## Place the rows for the width given, then draw those inside the part of
## the panel the window shows: in a scroll view, a hundred rows cost what
## the dozen showing do.
func paint(target: interop.View[gpu.RenderTarget]) -> !:
var painter = try Painter(target)
defer painter.close()
let size = try target.get().size()
self.arrange(size.width)
let theme = self.box.value().theme()
let bounds = self.box.value().bounds()
let shown = self.box.value().visible_bounds()
var top = shown.y - bounds.y
var bottom = top + shown.height
if shown.height <= 0.0:
top = 0.0
bottom = size.height
for index in 0..<self.total:
let row = self.rows[index]
if not row.shown or row.y + row.height < top or row.y > bottom:
continue
try self.paint_row(&painter, index, theme, size.width)
func paint_row(painter: Painter*, index: usize, theme: Theme, width: f64) -> !:
let row = self.rows[index]
let enabled = self.enabled(index)
let kind = row.kind
if kind == ParameterKind.folder:
try self.paint_folder(painter, index, theme)
return
if kind == ParameterKind.separator:
let middle = row.y + math.floor(row.height * 0.5)
try painter.rectangle(Rect(row.control_x, middle, row.control_width, 1.0), theme.border)
return
let changed = not at_default(row)
let ink = theme.foreground if enabled else theme.muted
# Houdini sets a changed parameter's label in bold; here a tick of the
# accent at the line's edge and the label in full ink.
if changed and row.label_x < 0.0 and kind != ParameterKind.button:
# Just before the label (the box, for a toggle).
let tick = self.row_height() - 10.0
var before = row.control_x - tick_room
if kind != ParameterKind.toggle:
before = self.label_right(width) - math.min(text_width(self.font, row.label.value), self.label_column(width)) - tick_room
try painter.rectangle(Rect(math.max(0.0, before), row.y + 5.0, 2.0, tick), theme.accent if enabled else theme.muted)
if kind != ParameterKind.toggle and kind != ParameterKind.button:
try self.paint_label(painter, row, theme, (changed or index == (usize)self.current) and enabled, width)
if kind == ParameterKind.number or kind == ParameterKind.integer:
try self.paint_number(painter, index, 0, theme, enabled)
if row.slider:
try self.paint_slider(painter, row, theme, enabled)
elif kind == ParameterKind.vector:
for component in 0..<row.components:
try self.paint_number(painter, index, component, theme, enabled)
elif kind == ParameterKind.color:
try self.paint_swatch(painter, index, theme, enabled)
for component in 0..<row.components:
try self.paint_number(painter, index, component, theme, enabled)
elif kind == ParameterKind.toggle:
try self.paint_toggle(painter, index, theme, enabled)
elif kind == ParameterKind.menu:
try self.paint_menu(painter, index, theme, enabled)
elif kind == ParameterKind.text or kind == ParameterKind.path:
try self.paint_text_field(painter, index, theme, enabled)
if kind == ParameterKind.path:
let browse = self.browse_rect(row)
let hot = enabled and self.hot_row == (i64)index and self.hot_part == part_browse
try ParameterPanel.paint_raised(painter, browse, theme, hot, self.press_row == (i64)index and self.press_part == part_browse)
let icon = math.floor(browse.height * 0.62)
try icons.draw_named(painter, "folder", Rect(browse.x + math.floor((browse.width - icon) * 0.5), browse.y + math.floor((browse.height - icon) * 0.5), icon, icon), ink)
elif kind == ParameterKind.button:
let rect = ParameterPanel.span_rect(row)
let hot = enabled and self.hot_row == (i64)index and self.hot_part == part_button
try ParameterPanel.paint_raised(painter, rect, theme, hot, self.press_row == (i64)index and self.press_part == part_button)
let caption = row.label.value
let caption_width = text_width(self.font, caption)
try painter.text(caption, rect.x + math.max(4.0, math.floor((rect.width - caption_width) * 0.5)), self.text_y(row), ink, self.font)
elif kind == ParameterKind.info:
try self.paint_fitted(painter, row.text.value, row.control_x, self.text_y(row), row.control_width, ink)
elif kind == ParameterKind.swatches:
try self.paint_chips(painter, index, theme, enabled)
elif is_ramp(kind):
try self.paint_ramp(painter, index, theme, enabled)
## The label right-aligned against the column's edge (inline for a joined
## row), cut with an ellipsis when the column is narrower.
func paint_label(painter: Painter*, row: Row, theme: Theme, strong: bool, width: f64) -> !:
let label = row.label.value
if label.length == 0:
return
let ink = theme.foreground if strong else theme.muted
let y = self.text_y(row)
if row.label_x >= 0.0:
try painter.text(label, row.label_x, y, ink, self.font)
return
let right = self.label_right(width)
let room = right - self.margin
let wide = text_width(self.font, label)
if wide <= room:
try painter.text(label, right - wide, y, ink, self.font)
return
try self.paint_fitted(painter, label, self.margin, y, room, ink)
## `text` from `x`, cut to `room` with an ellipsis.
func paint_fitted(painter: Painter*, text: str, x: f64, y: f64, room: f64, ink: gpu.Color) -> !:
let advance = self.font.value().advance()
let fits = (usize)math.max(0.0, math.floor(room / advance))
if cell_widths.width(text) <= fits:
try painter.text(text, x, y, ink, self.font)
return
if fits < 2:
return
let kept = cell_widths.prefix(text, fits - 1)
try painter.text(kept, x, y, ink, self.font)
try painter.text("…", x + (f64)(fits - 1) * advance, y, ink, self.font)
func text_y(row: Row) -> f64:
return row.y + math.max(0.0, math.floor((self.row_height() - self.font.value().height()) * 0.5))
## A sunken well with a one-point border: the accent while typed in or
## scrubbed, lighter while hovered.
static func paint_well(painter: Painter*, rect: Rect, theme: Theme, hot: bool, active: bool, current: bool) -> !:
let radius = math.min(theme.control_radius, 3.0)
let border = theme.accent if active else (theme.hover_border() if hot else (theme.active_border if current else theme.border))
try painter.rounded_rectangle(rect, border, radius)
try painter.rounded_rectangle(Rect(rect.x + 1.0, rect.y + 1.0, math.max(0.0, rect.width - 2.0), math.max(0.0, rect.height - 2.0)), theme.sunken, math.max(0.0, radius - 1.0))
## A raised face for buttons and menus.
static func paint_raised(painter: Painter*, rect: Rect, theme: Theme, hot: bool, pressed: bool) -> !:
let radius = math.min(theme.control_radius, 3.0)
try painter.rounded_rectangle(rect, theme.hover_border() if hot else theme.border, radius)
let face = theme.pressed if pressed else (theme.button_hover if hot else theme.button)
try painter.rounded_rectangle(Rect(rect.x + 1.0, rect.y + 1.0, math.max(0.0, rect.width - 2.0), math.max(0.0, rect.height - 2.0)), face, math.max(0.0, radius - 1.0))
## One numeric field: typed text while edited, else the value (as many
## decimals as fit) and its unit, muted.
func paint_number(painter: Painter*, index: usize, component: i64, theme: Theme, enabled: bool) -> !:
let row = self.rows[index]
let rect = self.field_rect(row, component)
let editing = self.edit_row == (i64)index and self.edit_component == component
let scrubbed = (self.scrubbing or self.laddering) and self.press_row == (i64)index and self.press_part != part_curve and (self.press_part == part_label or self.press_component == component)
let hot = enabled and self.hot_row == (i64)index and (self.hot_part == part_field or self.hot_part == part_label) and (self.hot_component == component or self.hot_part == part_label)
let current = self.box.value().is_focused() and self.current == (i64)index and component == 0
try ParameterPanel.paint_well(painter, rect, theme, hot, editing or scrubbed, current)
let inset = math.floor(self.font.value().advance() * 0.6)
let y = self.text_y(row)
if editing:
try self.input.paint(painter, self.font, theme, rect.x + inset, y, rect.width - inset * 2.0)
return
var digits: u8[48]
let room = rect.width - inset * 2.0
# A ramp's position is a bare fraction; its value is the row's.
let position = is_ramp(row.kind) and component == 0
let suffix = "" if position else row.suffix.value
let suffix_width = text_width(self.font, suffix)
var decimals = shown_decimals(row)
let amount = ParameterPanel.ramp_field(row, component) if position else row.units.shown(ParameterPanel.field_number(row, component))
var shown = try format_number(digits, amount, decimals)
while decimals > 0 and text_width(self.font, shown) + suffix_width > room:
decimals -= 1
shown = try format_number(digits, amount, decimals)
let ink = theme.foreground if enabled else theme.muted
try painter.text(shown, rect.x + inset, y, ink, self.font)
if suffix.length > 0 and text_width(self.font, shown) + suffix_width <= room:
try painter.text(suffix, rect.x + inset + text_width(self.font, shown), y, theme.muted, self.font)
## The range a slider spans: the soft range, else a finite hard one.
static func slider_range(row: Row) -> (f64, f64)?:
if row.soft_maximum > row.soft_minimum:
return (row.soft_minimum, row.soft_maximum)
if row.maximum - row.minimum > 0.0 and row.maximum - row.minimum <= 1.0e6:
return (row.minimum, row.maximum)
return none
## A thin track filled to the value in the accent, with a square knob; a
## row with a gradient shows it as a band instead, under the knob.
func paint_slider(painter: Painter*, row: Row, theme: Theme, enabled: bool) -> !:
let rect = self.slider_rect(row)
let range = ParameterPanel.slider_range(row) else return
if rect.width < 12.0:
return
let knob = 6.0
let fraction = math.clamp((row.values[0] - range.0) / (range.1 - range.0), 0.0, 1.0)
let middle = rect.y + math.floor(rect.height * 0.5) - 1.0
let travel = rect.width - knob
if row.stop_count >= 2:
try self.paint_band(painter, row, Rect(rect.x, middle - 2.0, rect.width, 6.0), enabled)
else:
try painter.rectangle(Rect(rect.x, middle, rect.width, 2.0), theme.border)
try painter.rectangle(Rect(rect.x, middle, math.floor(travel * fraction) + knob * 0.5, 2.0), theme.accent if enabled else theme.muted)
let knob_height = math.min(rect.height - 8.0, 12.0)
let hot = self.hot_row >= 0 and self.rows[(usize)self.hot_row].y == row.y and self.hot_part == part_slider
let knob_rect = Rect(rect.x + math.floor(travel * fraction), rect.y + math.floor((rect.height - knob_height) * 0.5), knob, knob_height)
if row.stop_count >= 2:
# On a colored band the knob needs an edge to read.
try painter.rectangle(Rect(knob_rect.x - 1.0, knob_rect.y - 1.0, knob_rect.width + 2.0, knob_rect.height + 2.0), theme.background)
try painter.rectangle(knob_rect, (theme.accent if hot else theme.foreground) if enabled else theme.muted)
## A row's gradient across `band`, its stops evenly spread.
func paint_band(painter: Painter*, row: Row, band: Rect, enabled: bool) -> !:
let segments = row.stop_count - 1
var points: Point[42] = ---
var colors: gpu.Color[42] = ---
for segment in 0..<segments:
let left = band.x + band.width * (f64)segment / (f64)segments
let right = band.x + band.width * (f64)(segment + 1) / (f64)segments
let a = row.stops[segment]
let b = row.stops[segment + 1]
let corners: Point[6] = [Point(left, band.y), Point(right, band.y), Point(right, band.y + band.height),
Point(left, band.y), Point(right, band.y + band.height), Point(left, band.y + band.height)]
let tints: gpu.Color[6] = [a, b, b, a, b, a]
for corner in 0..<(usize)6:
points[segment * 6 + corner] = corners[corner]
colors[segment * 6 + corner] = tints[corner]
try painter.shaded_mesh(points[..<segments * 6], colors[..<segments * 6], 1.0 if enabled else 0.4)
## A swatches row: one chip per item across the span, the chosen one ringed.
func paint_chips(painter: Painter*, index: usize, theme: Theme, enabled: bool) -> !:
let row = self.rows[index]
let count = parameter_text.item_count(row.items.value)
if count == 0:
return
let chosen = (usize)row.values[0]
let radius = math.min(theme.control_radius, 3.0)
for chip in 0..<count:
let rect = self.chip_rect(row, chip, count)
let value = parameter_text.item_label_value(row.items.value, chip)
let color = color_of_hex(value) else theme.muted
if chip == chosen:
try painter.rounded_rectangle(Rect(rect.x - 2.0, rect.y - 2.0, rect.width + 4.0, rect.height + 4.0), theme.accent if enabled else theme.muted, radius + 1.0)
try painter.rounded_rectangle(rect, color, radius, 1.0 if enabled else 0.4)
func paint_toggle(painter: Painter*, index: usize, theme: Theme, enabled: bool) -> !:
let row = self.rows[index]
let well = self.toggle_rect(row)
let on = row.values[0] != 0.0
let hot = enabled and self.hot_row == (i64)index
let radius = math.min(theme.control_radius, 3.0)
let current = self.box.value().is_focused() and self.current == (i64)index
let border = theme.active_border if current else (theme.accent if on else (theme.hover_border() if hot else theme.border))
try painter.rounded_rectangle(well, border if enabled else theme.muted, radius)
let face = theme.accent if on else (theme.hover() if hot else theme.sunken)
try painter.rounded_rectangle(Rect(well.x + 1.0, well.y + 1.0, well.width - 2.0, well.height - 2.0), face if enabled else theme.sunken, math.max(0.0, radius - 1.0))
if on:
let ink = theme.accent_text if enabled else theme.muted
try painter.line(Point(well.x + 3.5, well.y + 7.5), Point(well.x + 6.0, well.y + 10.0), 1.8, ink)
try painter.line(Point(well.x + 6.0, well.y + 10.0), Point(well.x + 10.8, well.y + 4.2), 1.8, ink)
try painter.text(row.label.value, well.x + well.width + math.floor(self.font.value().advance() * 0.75), self.text_y(row),
theme.foreground if enabled else theme.muted, self.font)
## The chosen item on a raised face, a chevron at the right.
func paint_menu(painter: Painter*, index: usize, theme: Theme, enabled: bool) -> !:
let row = self.rows[index]
let rect = ParameterPanel.span_rect(row)
let hot = enabled and self.hot_row == (i64)index
let open = self.popup_mode == popup_items and self.popup_row == (i64)index
try ParameterPanel.paint_raised(painter, rect, theme, hot or open, open)
let chosen = parameter_text.item_of(row.items.value, row.values[0])
let caption = parameter_text.item_label(row.items.value, (usize)chosen) if chosen >= 0 else ""
let inset = math.floor(self.font.value().advance() * 0.6)
try self.paint_fitted(painter, caption, rect.x + inset, self.text_y(row), rect.width - inset * 2.0 - 12.0, theme.foreground if enabled else theme.muted)
let cx = rect.x + rect.width - 10.0
let cy = rect.y + rect.height * 0.5
try painter.triangle(Point(cx - 4.0, cy - 2.0), Point(cx + 4.0, cy - 2.0), Point(cx, cy + 3.0), theme.muted if not hot else theme.foreground)
func paint_text_field(painter: Painter*, index: usize, theme: Theme, enabled: bool) -> !:
let row = self.rows[index]
let rect = self.field_rect(row, 0)
let editing = self.edit_row == (i64)index
let hot = enabled and self.hot_row == (i64)index and self.hot_part == part_field
let current = self.box.value().is_focused() and self.current == (i64)index
try ParameterPanel.paint_well(painter, rect, theme, hot, editing, current)
let inset = math.floor(self.font.value().advance() * 0.6)
let y = self.text_y(row)
if editing:
try self.input.paint(painter, self.font, theme, rect.x + inset, y, rect.width - inset * 2.0)
return
try self.paint_fitted(painter, row.text.value, rect.x + inset, y, rect.width - inset * 2.0, theme.foreground if enabled else theme.muted)
## The color, a checker of the panel behind it when dimmed.
func paint_swatch(painter: Painter*, index: usize, theme: Theme, enabled: bool) -> !:
let row = self.rows[index]
let rect = self.swatch_rect(row)
let hot = enabled and self.hot_row == (i64)index and self.hot_part == part_swatch
let radius = math.min(theme.control_radius, 3.0)
try painter.rounded_rectangle(rect, theme.hover_border() if hot else theme.border, radius)
let shown = gpu.Color(row.values[0], row.values[1], row.values[2]) if row.linear else srgb_decoded(gpu.Color(row.values[0], row.values[1], row.values[2]))
try painter.rounded_rectangle(Rect(rect.x + 1.0, rect.y + 1.0, rect.width - 2.0, rect.height - 2.0), shown, math.max(0.0, radius - 1.0), 1.0 if enabled else 0.4)
## A folder's heading: a chevron, open or closed, and its label.
func paint_folder(painter: Painter*, index: usize, theme: Theme) -> !:
let row = self.rows[index]
let rect = ParameterPanel.span_rect(row)
let hot = self.hot_row == (i64)index
try painter.rounded_rectangle(rect, theme.hover() if hot else theme.raised, math.min(theme.control_radius, 3.0))
let cx = rect.x + 11.0
let cy = rect.y + rect.height * 0.5
let ink = theme.accent if row.open else theme.muted
if row.open:
try painter.triangle(Point(cx - 4.0, cy - 2.0), Point(cx + 4.0, cy - 2.0), Point(cx, cy + 3.0), ink)
else:
try painter.triangle(Point(cx - 2.0, cy - 4.0), Point(cx + 3.0, cy), Point(cx - 2.0, cy + 4.0), ink)
try painter.text(row.label.value, rect.x + 22.0, rect.y + math.floor((rect.height - self.font.value().height()) * 0.5), theme.foreground, self.font)