dymokomi/luce-ui
Source of release 0.19.4
0.19.4 / src / widgets / text_field.lucb
## The TextField widget: a single-line editable text well.
from luce_gpu import gpu
import interop
from luce_std import math
import ownership
import layout
import result
from layout import Widget, Layout, Size, Constraints, Event
from painter import Painter
from text.line_input import LineInput
from luce_window import input
from font import Font, selected_font
## A single-line text field after eleusis: a sunken well whose border thickens in
## the focus color, text inset by one cell, everything selected on focus, and a
## commit on Enter or on losing focus (`on_commit`); Escape puts the committed
## text back. `on_change` fires on every edit. An empty field shows its
## `placeholder` in the muted color. `on_submit` fires on every Enter, changed or
## not, for a field whose Enter is an action (an address bar loads the page again). A `secure` field (a password) shows bullets
## and refuses copy and cut.
pub struct TextField: Widget:
let box: interop.Reference[Layout]
let font: interop.Reference[Font]
var input: LineInput
var committed: interop.Owned[str]
var placeholder: interop.Owned[str]
var cells: f64
let changed: interop.Signal[str]
let submitted: interop.Signal[str]
let entered: interop.Signal[str]
## `cells` is the width the field asks for, in character cells.
pub func init(text: str = "", font: interop.Reference[Font]? = none, placeholder: str = "", cells: f64 = 12.0,
secure: bool = false) -> !:
var selected = try selected_font(font)
errdefer selected.release()
let box = try layout.make_layout()
errdefer box.release()
try box.value().set_shrink(vertical = 0.0)
box.value().set_focusable(true)
box.value().set_text_input(true)
box.value().set_cursor(input.Cursor.text)
var line = try LineInput()
errdefer line.close()
line.masked = secure
try line.set_text(text)
let changed = try interop.Signal[str]()
errdefer changed.release()
let submitted = try interop.Signal[str]()
errdefer submitted.release()
let entered = try interop.Signal[str]()
errdefer entered.release()
self.committed = try interop.copy_text(text)
self.placeholder = try interop.copy_text(placeholder)
self.box = box
self.font = selected
self.input = line
self.cells = math.clamp(cells, 2.0, 120.0)
self.changed = changed
self.submitted = submitted
self.entered = entered
pub func layout() -> interop.Reference[Layout]:
return self.box.clone()
## The text as edited so far.
pub func text() -> interop.Owned[str]!:
return try self.input.text()
## Set the text from code and take it as committed; no signals.
pub func set_text(text: str) -> !:
try self.input.set_text(text)
let replacement = try interop.copy_text(text)
let previous_committed = self.committed
self.committed = replacement
previous_committed.release()
self.box.value().invalidate()
## Select the whole text, as Cmd/Ctrl+A does; an address bar does it on focus so
## typing replaces the address.
pub func select_all() -> !:
try self.input.select_all()
self.box.value().invalidate()
## Called with the whole text after each edit that changes it.
pub func on_change(callback: interop.Callback[str, unit]) -> interop.Reference[interop.Connection]!:
return try self.changed.connect(callback)
## Called with the text on Enter or focus loss, only when it differs from the
## last committed text.
pub func on_commit(callback: interop.Callback[str, unit]) -> interop.Reference[interop.Connection]!:
return try self.submitted.connect(callback)
## Called with the text on every Enter, after `on_commit` (which only fires when
## the text changed): an address field loads its address even when it is the same.
pub func on_submit(callback: interop.Callback[str, unit]) -> interop.Reference[interop.Connection]!:
return try self.entered.connect(callback)
## Enter: commit the text, then submit it.
func submit() -> interop.Outcome[unit]:
let committed = self.commit()
if not committed.is_success():
return committed
committed.release()
let current = self.input.text() catch failure:
return result.failure[unit](failure.code, failure.message)
defer current.release()
return self.entered.emit(current.value)
func commit() -> interop.Outcome[unit]:
let current = self.input.text() catch failure:
return result.failure[unit](failure.code, failure.message)
defer current.release()
if current.value == self.committed.value:
return result.success[unit](())
let replacement = interop.copy_text(current.value) catch failure:
return result.failure[unit](failure.code, failure.message)
let previous_committed = self.committed
self.committed = replacement
previous_committed.release()
self.box.value().invalidate()
return self.submitted.emit(current.value)
func revert() -> interop.Outcome[unit]:
self.input.set_text(self.committed.value) catch failure:
return result.failure[unit](failure.code, failure.message)
self.box.value().invalidate()
return result.success[unit](())
pub func measure(available: Constraints) -> interop.Outcome[Size]:
return result.success[Size](Size(self.font.value().advance() * self.cells, self.box.value().theme().row_height(self.font)))
pub func draw(target: interop.View[gpu.RenderTarget]) -> interop.Outcome[unit]:
self.paint(target) catch failure:
return result.failure[unit](failure.code, failure.message)
return result.success[unit](())
func paint(target: interop.View[gpu.RenderTarget]) -> !:
var painter = try Painter(target)
defer painter.close()
let size = try target.get().size()
let theme = self.box.value().theme()
let focused = self.box.value().is_focused()
let radius = theme.control_radius
let border = theme.active_border if focused else (theme.hover_border() if self.box.value().contains_pointer() else theme.border)
let thickness = 2.0 if focused else 1.0
try painter.rounded_rectangle(gpu.Rect(width = size.width, height = size.height), border, radius)
try painter.rounded_rectangle(gpu.Rect(thickness, thickness, size.width - thickness * 2.0, size.height - thickness * 2.0), theme.sunken, math.max(0.0, radius - thickness))
let inset = self.font.value().advance() * 0.75
let text_y = math.max(0.0, (size.height - self.font.value().height()) * 0.5)
let current = try self.input.text()
defer current.release()
if current.value.length == 0 and not focused and self.placeholder.value.length > 0:
try painter.text(self.placeholder.value, inset, text_y, color = theme.muted, font = self.font)
elif focused:
try self.input.paint(&painter, self.font, theme, inset, text_y, size.width - inset * 2.0)
else:
let shown = try self.input.shown_text()
defer shown.release()
try painter.text(shown.value, inset, text_y, color = theme.foreground if self.box.value().is_enabled() else theme.muted, font = self.font)
pub func event(event: Event) -> interop.Outcome[unit]:
if event.cancelled:
return self.revert()
if not self.box.value().is_enabled():
return result.success[unit](())
let bounds = self.box.value().bounds()
let inset = self.font.value().advance() * 0.75
if event.kind == input.EventKind.pointer_down and event.button == 0 and event.inside:
let was_focused = self.box.value().is_focused()
self.box.value().request_focus()
if not was_focused:
# Focus selects everything, Finder-rename style; a second click places the caret.
let current = self.input.text() catch failure:
return result.failure[unit](failure.code, failure.message)
defer current.release()
self.input.set_text(current.value) catch failure:
return result.failure[unit](failure.code, failure.message)
self.box.value().invalidate()
return result.success[unit](())
if event.kind == input.EventKind.pointer_down or event.kind == input.EventKind.pointer_moved or event.kind == input.EventKind.pointer_up:
self.input.pointer(event, self.font, inset, 0.0, bounds.width - inset * 2.0, bounds.height) catch failure:
return result.failure[unit](failure.code, failure.message)
self.box.value().invalidate()
return result.success[unit](())
if event.kind == input.EventKind.focus_lost:
return self.commit()
if event.kind == input.EventKind.key_down and event.key == input.Key.escape:
return self.revert()
if event.kind == input.EventKind.key_down and event.key == input.Key.enter and not event.repeated:
return self.submit()
if event.kind == input.EventKind.key_down or event.kind == input.EventKind.text_input:
let mutated = self.input.event(event) catch failure:
return result.failure[unit](failure.code, failure.message)
if mutated:
self.box.value().invalidate()
let current = self.input.text() catch failure:
return result.failure[unit](failure.code, failure.message)
defer current.release()
return self.changed.emit(current.value)
return result.success[unit](())
pub func close():
self.font.release()
self.input.close()
self.changed.close()
self.changed.release()
self.submitted.close()
self.submitted.release()
self.entered.close()
self.entered.release()
self.committed.release()
self.placeholder.release()
self.box.release()
func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
self.font.trace(visit, context)
self.box.trace(visit, context)
self.changed.trace(visit, context)
self.submitted.trace(visit, context)
self.entered.trace(visit, context)
self.committed.trace(visit, context)
self.placeholder.trace(visit, context)
pub let text_field_type: interop.Type[TextField] = interop.Type[TextField]("TextField", TextField.close, TextField.trace, closeable = true, main_thread = true)
test "a secure field keeps its text and shows bullets":
var field = try TextField("pässword", secure = true)
defer field.close()
let current = try field.text()
defer current.release()
assert(current.value == "pässword")
let shown = try field.input.shown_text()
defer shown.release()
assert(shown.value == "••••••••")
let part = try field.input.shown(2, 5)
defer part.release()
assert(part.value == "•••")
test "a text field holds, resets and commits text":
var field = try TextField("Layer 2", placeholder = "Name")
defer field.close()
let current = try field.text()
defer current.release()
assert(current.value == "Layer 2")
try field.set_text("Background")
let again = try field.text()
defer again.release()
assert(again.value == "Background")