dymokomi/luce-ui
Source of release 0.19.4
0.19.4 / src / docking / chrome.lucb
## Workspace chrome uses standard GPU regions. Every tab label is clipped away
## from its close button and neighbors; overlay previews do not receive input.
from luce_gpu import gpu
import interop
from luce_std import math
import icons
import docking.strip
from docking.state import State
from painter import Painter
from geometry import Point, Size
from icons import IconKind
pub func draw(state: State*, target: interop.View[gpu.RenderTarget]) -> !:
var painter = try Painter(target)
defer painter.close()
let size = try target.get().size()
let geometry = state.geometry(Size(size.width, size.height))
let model = state.visible_model()
let theme = state.theme()
let box = state.box.get() else return
defer box.release()
let pointer = box.value().pointer_position()
let hovered = box.value().contains_pointer()
let focused = box.value().contains_focus()
let active = state.active()
let active_group = model.tabs[active].group
try painter.rectangle(gpu.Rect(width = size.width, height = size.height), theme.background)
if model.root == 0:
try button(state, &painter, gpu.Rect(math.max(0.0, size.width - state.height()), 0.0, state.height(), state.height()), "+", pointer, hovered)
for group in 1..<model.nodes.length:
let node = model.nodes[group]
if not node.used: continue
if node.first != 0:
let divider = geometry.dividers[group]
if (hovered and strip.contains(divider, pointer.x, pointer.y)) or (focused and state.divider_keyed and state.focused_divider == group):
let line = gpu.Rect(divider.x + (divider.width - 1.0) * 0.5, divider.y, 1.0, divider.height) if node.horizontal else gpu.Rect(divider.x, divider.y + (divider.height - 1.0) * 0.5, divider.width, 1.0)
try painter.rectangle(line, theme.accent)
continue
let bounds = geometry.panes[group]
# Panes sit in the backdrop with no frame of their own; only the focused one shows a border.
let border = theme.active_border if focused and active_group == group else theme.background
try painter.rectangle(bounds, border)
# The tab strip recess, the pane's surface below it, and the one-point rule between.
try painter.rectangle(gpu.Rect(bounds.x + 1.0, bounds.y + 1.0, math.max(0.0, bounds.width - 2.0), state.height()), theme.strip)
try painter.rectangle(gpu.Rect(bounds.x + 1.0, bounds.y + state.height() + 1.0, math.max(0.0, bounds.width - 2.0), math.max(0.0, bounds.height - state.height() - 2.0)), theme.panel)
try painter.rectangle(gpu.Rect(bounds.x + 1.0, bounds.y + state.height(), math.max(0.0, bounds.width - 2.0), 1.0), theme.background)
let header = state.strip(group, bounds)
for order in header.first..<header.first + header.count:
let index = model.at(group, order)
let rectangle = header.tab(order)
if rectangle.width == 0.0: continue
let selected = node.selected == index
# The selected tab is the pane's surface, rounded at the top so tab and
# pane read as one; the others show only a hover wash over the strip.
if selected:
try painter.rounded_rectangle(gpu.Rect(rectangle.x, rectangle.y, rectangle.width, rectangle.height + 1.0), theme.panel, theme.control_radius, corners = 3)
elif hovered and strip.contains(rectangle, pointer.x, pointer.y):
try painter.rounded_rectangle(rectangle, theme.hover(), theme.control_radius, corners = 3)
try tab(state, target, index, rectangle, pointer, hovered)
try button(state, &painter, header.previous, "<", pointer, hovered)
try button(state, &painter, header.next, ">", pointer, hovered)
try button(state, &painter, header.add, "+", pointer, hovered)
if header.count == 1:
let index = model.at(group, header.first)
let panel = try state.panel(index)
defer panel.release()
let detail = panel.value().detail()
defer detail.release()
let x = header.tabs.x + header.width + theme.inset(state.font)
let width = header.add.x - theme.inset(state.font) - x
if detail.value.length > 0 and width > 0.0:
let clipped = try target.get().clipped(gpu.Rect(x, header.tabs.y, width, header.tabs.height))
defer clipped.release()
var labels = try Painter(clipped)
defer labels.close()
try labels.text(detail.value, x, header.tabs.y + (header.tabs.height - state.font.value().height()) * 0.5, theme.muted, state.font)
func tab(state: State*, target: interop.View[gpu.RenderTarget], index: usize, bounds: gpu.Rect, pointer: Point, hovered: bool, closing: bool = true) -> !:
let theme = state.theme()
let font = state.font
let panel = try state.panel(index)
defer panel.release()
let inset = math.ceil(font.value().advance() * theme.header_inset_cells)
let close_width = bounds.height if closing and panel.value().is_closable() else 0.0
let end = math.max(bounds.x, bounds.x + bounds.width - close_width)
let content = try target.get().clipped(gpu.Rect(bounds.x, bounds.y, end - bounds.x, bounds.height))
defer content.release()
var painter = try Painter(content)
defer painter.close()
var x = bounds.x + inset
let y = bounds.y + (bounds.height - font.value().height()) * 0.5
if panel.value().icon() != IconKind.blank:
let extent = font.value().height()
try icons.draw(&painter, panel.value().icon(), gpu.Rect(x, y, extent, extent), theme.foreground)
x += extent + theme.inset(font)
let label = panel.value().text()
defer label.release()
try painter.text(label.value, x, y, theme.foreground, font)
if close_width > 0.0:
var controls = try Painter(target)
defer controls.close()
let rectangle = gpu.Rect(end, bounds.y, close_width, bounds.height)
if hovered and strip.contains(rectangle, pointer.x, pointer.y):
try controls.rectangle(rectangle, theme.hover())
let middle = Point(end + close_width * 0.5, bounds.y + bounds.height * 0.5)
let extent = font.value().advance() * 0.3
try controls.line(Point(middle.x - extent, middle.y - extent), Point(middle.x + extent, middle.y + extent), 1.0, theme.muted)
try controls.line(Point(middle.x - extent, middle.y + extent), Point(middle.x + extent, middle.y - extent), 1.0, theme.muted)
func button(state: State*, painter: Painter*, bounds: gpu.Rect, label: str, pointer: Point, hovered: bool) -> !:
if bounds.width == 0.0 or bounds.height == 0.0: return
let theme = state.theme()
if hovered and strip.contains(bounds, pointer.x, pointer.y):
try painter.rectangle(bounds, theme.hover())
try painter.text(label, bounds.x + (bounds.width - (try state.font.value().measure(label))) * 0.5,
bounds.y + (bounds.height - state.font.value().height()) * 0.5, theme.foreground, state.font)
pub func preview(state: State*, target: interop.View[gpu.RenderTarget]) -> !:
let drop = state.current_drop()
if drop.accepted: try destination(state, target, drop.preview)
if not state.dragging: return
var painter = try Painter(target)
defer painter.close()
# Let go where no pane takes it, the tab becomes a window here.
let floating = state.float_preview()
if floating.width > 0.0:
let color = state.theme().accent
try painter.rectangle(floating, color, 0.10)
try painter.rectangle(gpu.Rect(floating.x, floating.y, floating.width, 1.0), color)
try painter.rectangle(gpu.Rect(floating.x, floating.y + math.max(0.0, floating.height - 1.0), floating.width, 1.0), color)
try painter.rectangle(gpu.Rect(floating.x, floating.y, 1.0, floating.height), color)
try painter.rectangle(gpu.Rect(floating.x + math.max(0.0, floating.width - 1.0), floating.y, 1.0, floating.height), color)
let bounds = state.drag_bounds()
let theme = state.theme()
try painter.rectangle(gpu.Rect(bounds.x + 4.0, bounds.y + 4.0, bounds.width, bounds.height), theme.shadow, theme.shadow_opacity)
try painter.rectangle(bounds, theme.accent)
let title = gpu.Rect(bounds.x + 1.0, bounds.y + 1.0, math.max(0.0, bounds.width - 2.0), math.max(0.0, bounds.height - 2.0))
try painter.rectangle(title, theme.active_border)
try tab(state, target, state.dragged_tab(), title, Point(), false, closing = false)
func destination(state: State*, target: interop.View[gpu.RenderTarget], rectangle: gpu.Rect) -> !:
var painter = try Painter(target)
defer painter.close()
let color = state.theme().accent
try painter.rectangle(rectangle, color, 0.22)
try painter.rectangle(gpu.Rect(rectangle.x, rectangle.y, rectangle.width, 2.0), color)
try painter.rectangle(gpu.Rect(rectangle.x, rectangle.y + math.max(0.0, rectangle.height - 2.0), rectangle.width, 2.0), color)
try painter.rectangle(gpu.Rect(rectangle.x, rectangle.y, 2.0, rectangle.height), color)
try painter.rectangle(gpu.Rect(rectangle.x + math.max(0.0, rectangle.width - 2.0), rectangle.y, 2.0, rectangle.height), color)